hunk.code_window:     let start = {
         line: this.source.start.line,
         column: this.source.start.column
       }
       let end = {
         line: this.source.end.line,
         column: this.source.end.column + 1
       }
       if (opts.word) {
         let index = this.toString().indexOf(opts.word)
         if (index !== -1) {
  
hunk.labels: keep keep keep keep replace replace replace replace keep keep keep keep
hunk.after_edit:     let end = this.source.end
         ? {
             line: this.source.end.line,
             column: this.source.end.column + 1
           }
         : {
             line: start.line,
             column: start.column + 1
           }
  
hunk.file_path: lib/node.js
hunk.type: replace
file: 'use strict'
  
  let { isClean, my } = require('./symbols')
  let CssSyntaxError = require('./css-syntax-error')
  let Stringifier = require('./stringifier')
  let stringify = require('./stringify')
  
  function cloneNode(obj, parent) {
    let cloned = new obj.constructor()
  
    for (let i in obj) {
      if (!Object.prototype.hasOwnProperty.call(obj, i)) {
        // istanbul ignore next
        continue
      }
      if (i === 'proxyCache') continue
      let value = obj[i]
      let type = typeof value
  
      if (i === 'parent' && type === 'object') {
        if (parent) cloned[i] = parent
      } else if (i === 'source') {
        cloned[i] = value
      } else if (Array.isArray(value)) {
        cloned[i] = value.map(j => cloneNode(j, cloned))
      } else {
        if (type === 'object' && value !== null) value = cloneNode(value)
        cloned[i] = value
      }
    }
  
    return cloned
  }
  
  class Node {
    constructor(defaults = {}) {
      this.raws = {}
      this[isClean] = false
      this[my] = true
  
      for (let name in defaults) {
        if (name === 'nodes') {
          this.nodes = []
          for (let node of defaults[name]) {
            if (typeof node.clone === 'function') {
              this.append(node.clone())
            } else {
              this.append(node)
            }
          }
        } else {
          this[name] = defaults[name]
        }
      }
    }
  
    error(message, opts = {}) {
      if (this.source) {
        let { start, end } = this.rangeBy(opts)
        return this.source.input.error(
          message,
          { line: start.line, column: start.column },
          { line: end.line, column: end.column },
          opts
        )
      }
      return new CssSyntaxError(message)
    }
  
    warn(result, text, opts) {
      let data = { node: this }
      for (let i in opts) data[i] = opts[i]
      return result.warn(text, data)
    }
  
    remove() {
      if (this.parent) {
        this.parent.removeChild(this)
      }
      this.parent = undefined
      return this
    }
  
    toString(stringifier = stringify) {
      if (stringifier.stringify) stringifier = stringifier.stringify
      let result = ''
      stringifier(this, i => {
        result += i
      })
      return result
    }
  
    assign(overrides = {}) {
      for (let name in overrides) {
        this[name] = overrides[name]
      }
      return this
    }
  
    clone(overrides = {}) {
      let cloned = cloneNode(this)
      for (let name in overrides) {
        cloned[name] = overrides[name]
      }
      return cloned
    }
  
    cloneBefore(overrides = {}) {
      let cloned = this.clone(overrides)
      this.parent.insertBefore(this, cloned)
      return cloned
    }
  
    cloneAfter(overrides = {}) {
      let cloned = this.clone(overrides)
      this.parent.insertAfter(this, cloned)
      return cloned
    }
  
    replaceWith(...nodes) {
      if (this.parent) {
        let bookmark = this
        let foundSelf = false
        for (let node of nodes) {
          if (node === this) {
            foundSelf = true
          } else if (foundSelf) {
            this.parent.insertAfter(bookmark, node)
            bookmark = node
          } else {
            this.parent.insertBefore(bookmark, node)
          }
        }
  
        if (!foundSelf) {
          this.remove()
        }
      }
  
      return this
    }
  
    next() {
      if (!this.parent) return undefined
      let index = this.parent.index(this)
      return this.parent.nodes[index + 1]
    }
  
    prev() {
      if (!this.parent) return undefined
      let index = this.parent.index(this)
      return this.parent.nodes[index - 1]
    }
  
    before(add) {
      this.parent.insertBefore(this, add)
      return this
    }
  
    after(add) {
      this.parent.insertAfter(this, add)
      return this
    }
  
    root() {
      let result = this
      while (result.parent && result.parent.type !== 'document') {
        result = result.parent
      }
      return result
    }
  
    raw(prop, defaultType) {
      let str = new Stringifier()
      return str.raw(this, prop, defaultType)
    }
  
    cleanRaws(keepBetween) {
      delete this.raws.before
      delete this.raws.after
      if (!keepBetween) delete this.raws.between
    }
  
    toJSON(_, inputs) {
      let fixed = {}
      let emitInputs = inputs == null
      inputs = inputs || new Map()
      let inputsNextIndex = 0
  
      for (let name in this) {
        if (!Object.prototype.hasOwnProperty.call(this, name)) {
          // istanbul ignore next
          continue
        }
        if (name === 'parent' || name === 'proxyCache') continue
        let value = this[name]
  
        if (Array.isArray(value)) {
          fixed[name] = value.map(i => {
            if (typeof i === 'object' && i.toJSON) {
              return i.toJSON(null, inputs)
            } else {
              return i
            }
          })
        } else if (typeof value === 'object' && value.toJSON) {
          fixed[name] = value.toJSON(null, inputs)
        } else if (name === 'source') {
          let inputId = inputs.get(value.input)
          if (inputId == null) {
            inputId = inputsNextIndex
            inputs.set(value.input, inputsNextIndex)
            inputsNextIndex++
          }
          fixed[name] = {
            inputId,
            start: value.start,
            end: value.end
          }
        } else {
          fixed[name] = value
        }
      }
  
      if (emitInputs) {
        fixed.inputs = [...inputs.keys()].map(input => input.toJSON())
      }
  
      return fixed
    }
  
    positionInside(index) {
      let string = this.toString()
      let column = this.source.start.column
      let line = this.source.start.line
  
      for (let i = 0; i < index; i++) {
        if (string[i] === '\n') {
          column = 1
          line += 1
        } else {
          column += 1
        }
      }
  
      return { line, column }
    }
  
    positionBy(opts) {
      let pos = this.source.start
      if (opts.index) {
        pos = this.positionInside(opts.index)
      } else if (opts.word) {
        let index = this.toString().indexOf(opts.word)
        if (index !== -1) pos = this.positionInside(index)
      }
      return pos
    }
  
    rangeBy(opts) {
      let start = {
        line: this.source.start.line,
        column: this.source.start.column
      }
      let end = {
        line: this.source.end.line,
        column: this.source.end.column + 1
      }
  
      if (opts.word) {
        let index = this.toString().indexOf(opts.word)
        if (index !== -1) {
          start = this.positionInside(index)
          end = this.positionInside(index + opts.word.length)
        }
      } else {
        if (opts.start) {
          start = {
            line: opts.start.line,
            column: opts.start.column
          }
        } else if (opts.index) {
          start = this.positionInside(opts.index)
        }
  
        if (opts.end) {
          end = {
            line: opts.end.line,
            column: opts.end.column
          }
        } else if (opts.endIndex) {
          end = this.positionInside(opts.endIndex)
        } else if (opts.index) {
          end = this.positionInside(opts.index + 1)
        }
      }
  
      if (
        end.line < start.line ||
        (end.line === start.line && end.column <= start.column)
      ) {
        end = { line: start.line, column: start.column + 1 }
      }
  
      return { start, end }
    }
  
    getProxyProcessor() {
      return {
        set(node, prop, value) {
          if (node[prop] === value) return true
          node[prop] = value
          if (
            prop === 'prop' ||
            prop === 'value' ||
            prop === 'name' ||
            prop === 'params' ||
            prop === 'important' ||
            prop === 'text'
          ) {
            node.markDirty()
          }
          return true
        },
  
        get(node, prop) {
          if (prop === 'proxyOf') {
            return node
          } else if (prop === 'root') {
            return () => node.root().toProxy()
          } else {
            return node[prop]
          }
        }
      }
    }
  
    toProxy() {
      if (!this.proxyCache) {
        this.proxyCache = new Proxy(this, this.getProxyProcessor())
      }
      return this.proxyCache
    }
  
    addToError(error) {
      error.postcssNode = this
      if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
        let s = this.source
        error.stack = error.stack.replace(
          /\n\s{4}at /,
          `$&${s.input.from}:${s.start.line}:${s.start.column}$&`
        )
      }
      return error
    }
  
    markDirty() {
      if (this[isClean]) {
        this[isClean] = false
        let next = this
        while ((next = next.parent)) {
          next[isClean] = false
        }
      }
    }
  
    get proxyOf() {
      return this
    }
  }
  
  module.exports = Node
  Node.default = Node
  