update

node_modules/postcss-values-parser/lib/node.js

@@ -0,0 +1,214 @@
+'use strict';
+
+let cloneNode = function (obj, parent) {
+  let cloned = new obj.constructor();
+
+  for (let i in obj) {
+    if (!obj.hasOwnProperty(i)) continue;
+
+    let value = obj[i],
+      type  = typeof value;
+
+    if (i === 'parent' && type === 'object') {
+      if (parent) cloned[i] = parent;
+    }
+    else if (i === 'source') {
+      cloned[i] = value;
+    }
+    else if (value instanceof Array) {
+      cloned[i] = value.map(j => cloneNode(j, cloned));
+    }
+    else if (i !== 'before'  && i !== 'after' && i !== 'between' && i !== 'semicolon') {
+      if (type === 'object' && value !== null) value = cloneNode(value);
+      cloned[i] = value;
+    }
+  }
+
+  return cloned;
+};
+
+module.exports = class Node {
+
+  constructor (defaults) {
+    defaults = defaults || {};
+    this.raws = { before: '', after: '' };
+
+    for (let name in defaults) {
+      this[name] = defaults[name];
+    }
+  }
+
+  remove () {
+    if (this.parent) {
+      this.parent.removeChild(this);
+    }
+
+    this.parent = undefined;
+
+    return this;
+  }
+
+  toString () {
+    return [
+      this.raws.before,
+      String(this.value),
+      this.raws.after
+    ].join('');
+  }
+
+  clone (overrides) {
+    overrides = overrides || {};
+
+    let cloned = cloneNode(this);
+
+    for (let name in overrides) {
+      cloned[name] = overrides[name];
+    }
+
+    return cloned;
+  }
+
+  cloneBefore (overrides) {
+    overrides = overrides || {};
+
+    let cloned = this.clone(overrides);
+
+    this.parent.insertBefore(this, cloned);
+    return cloned;
+  }
+
+  cloneAfter (overrides) {
+    overrides = overrides || {};
+
+    let cloned = this.clone(overrides);
+
+    this.parent.insertAfter(this, cloned);
+    return cloned;
+  }
+
+  replaceWith () {
+    let nodes = Array.prototype.slice.call(arguments);
+
+    if (this.parent) {
+      for (let node of nodes) {
+        this.parent.insertBefore(this, node);
+      }
+
+      this.remove();
+    }
+
+    return this;
+  }
+
+  moveTo (container) {
+    this.cleanRaws(this.root() === container.root());
+    this.remove();
+
+    container.append(this);
+
+    return this;
+  }
+
+  moveBefore (node) {
+    this.cleanRaws(this.root() === node.root());
+    this.remove();
+
+    node.parent.insertBefore(node, this);
+
+    return this;
+  }
+
+  moveAfter (node) {
+    this.cleanRaws(this.root() === node.root());
+    this.remove();
+    node.parent.insertAfter(node, this);
+    return this;
+  }
+
+  next () {
+    let index = this.parent.index(this);
+
+    return this.parent.nodes[index + 1];
+  }
+
+  prev () {
+    let index = this.parent.index(this);
+
+    return this.parent.nodes[index - 1];
+  }
+
+  toJSON () {
+    let fixed = { };
+
+    for (let name in this) {
+      if (!this.hasOwnProperty(name)) continue;
+      if (name === 'parent') continue;
+      let value = this[name];
+
+      if (value instanceof Array) {
+        fixed[name] = value.map(i => {
+          if (typeof i === 'object' && i.toJSON) {
+            return i.toJSON();
+          }
+          else {
+            return i;
+          }
+        });
+      }
+      else if (typeof value === 'object' && value.toJSON) {
+        fixed[name] = value.toJSON();
+      }
+      else {
+        fixed[name] = value;
+      }
+    }
+
+    return fixed;
+  }
+
+  root () {
+    let result = this;
+
+    while (result.parent) result = result.parent;
+
+    return result;
+  }
+
+  cleanRaws (keepBetween) {
+    delete this.raws.before;
+    delete this.raws.after;
+    if (!keepBetween) delete this.raws.between;
+  }
+
+  positionInside (index) {
+    let string = this.toString(),
+      column = this.source.start.column,
+      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;
+  }
+};