@everymatrix/general-footer-template 1.22.0 → 1.22.2

package/dist/cjs/custom-content-section.cjs.entry.js

@@ -4621,7 +4621,7 @@ class CssSyntaxError extends Error {
 
     let mark, aside;
     if (color) {
-      let { bold, red, gray } = picocolors_browser.createColors(true);
+      let { bold, gray, red } = picocolors_browser.createColors(true);
       mark = text => bold(red(text));
       aside = text => gray(text);
     } else {
@@ -4666,17 +4666,17 @@ var symbols = {
 };
 
 const DEFAULT_RAW = {
-  colon: ': ',
-  indent: '    ',
-  beforeDecl: '\n',
-  beforeRule: '\n',
-  beforeOpen: ' ',
+  after: '\n',
   beforeClose: '\n',
   beforeComment: '\n',
-  after: '\n',
-  emptyBody: '',
+  beforeDecl: '\n',
+  beforeOpen: ' ',
+  beforeRule: '\n',
+  colon: ': ',
   commentLeft: ' ',
   commentRight: ' ',
+  emptyBody: '',
+  indent: '    ',
   semicolon: false
 };
 
@@ -4689,54 +4689,6 @@ class Stringifier {
     this.builder = builder;
   }
 
-  stringify(node, semicolon) {
-    /* c8 ignore start */
-    if (!this[node.type]) {
-      throw new Error(
-        'Unknown AST node type ' +
-          node.type +
-          '. ' +
-          'Maybe you need to change PostCSS stringifier.'
-      )
-    }
-    /* c8 ignore stop */
-    this[node.type](node, semicolon);
-  }
-
-  document(node) {
-    this.body(node);
-  }
-
-  root(node) {
-    this.body(node);
-    if (node.raws.after) this.builder(node.raws.after);
-  }
-
-  comment(node) {
-    let left = this.raw(node, 'left', 'commentLeft');
-    let right = this.raw(node, 'right', 'commentRight');
-    this.builder('/*' + left + node.text + right + '*/', node);
-  }
-
-  decl(node, semicolon) {
-    let between = this.raw(node, 'between', 'colon');
-    let string = node.prop + between + this.rawValue(node, 'value');
-
-    if (node.important) {
-      string += node.raws.important || ' !important';
-    }
-
-    if (semicolon) string += ';';
-    this.builder(string, node);
-  }
-
-  rule(node) {
-    this.block(node, this.rawValue(node, 'selector'));
-    if (node.raws.ownSemicolon) {
-      this.builder(node.raws.ownSemicolon, node, 'end');
-    }
-  }
-
   atrule(node, semicolon) {
     let name = '@' + node.name;
     let params = node.params ? this.rawValue(node, 'params') : '';
@@ -4755,20 +4707,33 @@ class Stringifier {
     }
   }
 
-  body(node) {
-    let last = node.nodes.length - 1;
-    while (last > 0) {
-      if (node.nodes[last].type !== 'comment') break
-      last -= 1;
+  beforeAfter(node, detect) {
+    let value;
+    if (node.type === 'decl') {
+      value = this.raw(node, null, 'beforeDecl');
+    } else if (node.type === 'comment') {
+      value = this.raw(node, null, 'beforeComment');
+    } else if (detect === 'before') {
+      value = this.raw(node, null, 'beforeRule');
+    } else {
+      value = this.raw(node, null, 'beforeClose');
     }
 
-    let semicolon = this.raw(node, 'semicolon');
-    for (let i = 0; i < node.nodes.length; i++) {
-      let child = node.nodes[i];
-      let before = this.raw(child, 'before');
-      if (before) this.builder(before);
-      this.stringify(child, last !== i || semicolon);
+    let buf = node.parent;
+    let depth = 0;
+    while (buf && buf.type !== 'root') {
+      depth += 1;
+      buf = buf.parent;
     }
+
+    if (value.includes('\n')) {
+      let indent = this.raw(node, null, 'indent');
+      if (indent.length) {
+        for (let step = 0; step < depth; step++) value += indent;
+      }
+    }
+
+    return value
   }
 
   block(node, start) {
@@ -4787,6 +4752,44 @@ class Stringifier {
     this.builder('}', node, 'end');
   }
 
+  body(node) {
+    let last = node.nodes.length - 1;
+    while (last > 0) {
+      if (node.nodes[last].type !== 'comment') break
+      last -= 1;
+    }
+
+    let semicolon = this.raw(node, 'semicolon');
+    for (let i = 0; i < node.nodes.length; i++) {
+      let child = node.nodes[i];
+      let before = this.raw(child, 'before');
+      if (before) this.builder(before);
+      this.stringify(child, last !== i || semicolon);
+    }
+  }
+
+  comment(node) {
+    let left = this.raw(node, 'left', 'commentLeft');
+    let right = this.raw(node, 'right', 'commentRight');
+    this.builder('/*' + left + node.text + right + '*/', node);
+  }
+
+  decl(node, semicolon) {
+    let between = this.raw(node, 'between', 'colon');
+    let string = node.prop + between + this.rawValue(node, 'value');
+
+    if (node.important) {
+      string += node.raws.important || ' !important';
+    }
+
+    if (semicolon) string += ';';
+    this.builder(string, node);
+  }
+
+  document(node) {
+    this.body(node);
+  }
+
   raw(node, own, detect) {
     let value;
     if (!detect) detect = own;
@@ -4841,42 +4844,20 @@ class Stringifier {
     return value
   }
 
-  rawSemicolon(root) {
-    let value;
-    root.walk(i => {
-      if (i.nodes && i.nodes.length && i.last.type === 'decl') {
-        value = i.raws.semicolon;
-        if (typeof value !== 'undefined') return false
-      }
-    });
-    return value
-  }
-
-  rawEmptyBody(root) {
-    let value;
-    root.walk(i => {
-      if (i.nodes && i.nodes.length === 0) {
-        value = i.raws.after;
-        if (typeof value !== 'undefined') return false
-      }
-    });
-    return value
-  }
-
-  rawIndent(root) {
-    if (root.raws.indent) return root.raws.indent
+  rawBeforeClose(root) {
     let value;
     root.walk(i => {
-      let p = i.parent;
-      if (p && p !== root && p.parent && p.parent === root) {
-        if (typeof i.raws.before !== 'undefined') {
-          let parts = i.raws.before.split('\n');
-          value = parts[parts.length - 1];
-          value = value.replace(/\S/g, '');
+      if (i.nodes && i.nodes.length > 0) {
+        if (typeof i.raws.after !== 'undefined') {
+          value = i.raws.after;
+          if (value.includes('\n')) {
+            value = value.replace(/[^\n]+$/, '');
+          }
           return false
         }
       }
     });
+    if (value) value = value.replace(/\S/g, '');
     return value
   }
 
@@ -4918,6 +4899,17 @@ class Stringifier {
     return value
   }
 
+  rawBeforeOpen(root) {
+    let value;
+    root.walk(i => {
+      if (i.type !== 'decl') {
+        value = i.raws.between;
+        if (typeof value !== 'undefined') return false
+      }
+    });
+    return value
+  }
+
   rawBeforeRule(root) {
     let value;
     root.walk(i => {
@@ -4935,71 +4927,53 @@ class Stringifier {
     return value
   }
 
-  rawBeforeClose(root) {
+  rawColon(root) {
     let value;
-    root.walk(i => {
-      if (i.nodes && i.nodes.length > 0) {
-        if (typeof i.raws.after !== 'undefined') {
-          value = i.raws.after;
-          if (value.includes('\n')) {
-            value = value.replace(/[^\n]+$/, '');
-          }
-          return false
-        }
+    root.walkDecls(i => {
+      if (typeof i.raws.between !== 'undefined') {
+        value = i.raws.between.replace(/[^\s:]/g, '');
+        return false
       }
     });
-    if (value) value = value.replace(/\S/g, '');
     return value
   }
 
-  rawBeforeOpen(root) {
+  rawEmptyBody(root) {
     let value;
     root.walk(i => {
-      if (i.type !== 'decl') {
-        value = i.raws.between;
+      if (i.nodes && i.nodes.length === 0) {
+        value = i.raws.after;
         if (typeof value !== 'undefined') return false
       }
     });
     return value
   }
 
-  rawColon(root) {
+  rawIndent(root) {
+    if (root.raws.indent) return root.raws.indent
     let value;
-    root.walkDecls(i => {
-      if (typeof i.raws.between !== 'undefined') {
-        value = i.raws.between.replace(/[^\s:]/g, '');
-        return false
+    root.walk(i => {
+      let p = i.parent;
+      if (p && p !== root && p.parent && p.parent === root) {
+        if (typeof i.raws.before !== 'undefined') {
+          let parts = i.raws.before.split('\n');
+          value = parts[parts.length - 1];
+          value = value.replace(/\S/g, '');
+          return false
+        }
       }
     });
     return value
   }
 
-  beforeAfter(node, detect) {
+  rawSemicolon(root) {
     let value;
-    if (node.type === 'decl') {
-      value = this.raw(node, null, 'beforeDecl');
-    } else if (node.type === 'comment') {
-      value = this.raw(node, null, 'beforeComment');
-    } else if (detect === 'before') {
-      value = this.raw(node, null, 'beforeRule');
-    } else {
-      value = this.raw(node, null, 'beforeClose');
-    }
-
-    let buf = node.parent;
-    let depth = 0;
-    while (buf && buf.type !== 'root') {
-      depth += 1;
-      buf = buf.parent;
-    }
-
-    if (value.includes('\n')) {
-      let indent = this.raw(node, null, 'indent');
-      if (indent.length) {
-        for (let step = 0; step < depth; step++) value += indent;
+    root.walk(i => {
+      if (i.nodes && i.nodes.length && i.last.type === 'decl') {
+        value = i.raws.semicolon;
+        if (typeof value !== 'undefined') return false
       }
-    }
-
+    });
     return value
   }
 
@@ -5012,10 +4986,36 @@ class Stringifier {
 
     return value
   }
-}
-
-var stringifier = Stringifier;
-Stringifier.default = Stringifier;
+
+  root(node) {
+    this.body(node);
+    if (node.raws.after) this.builder(node.raws.after);
+  }
+
+  rule(node) {
+    this.block(node, this.rawValue(node, 'selector'));
+    if (node.raws.ownSemicolon) {
+      this.builder(node.raws.ownSemicolon, node, 'end');
+    }
+  }
+
+  stringify(node, semicolon) {
+    /* c8 ignore start */
+    if (!this[node.type]) {
+      throw new Error(
+        'Unknown AST node type ' +
+          node.type +
+          '. ' +
+          'Maybe you need to change PostCSS stringifier.'
+      )
+    }
+    /* c8 ignore stop */
+    this[node.type](node, semicolon);
+  }
+}
+
+var stringifier = Stringifier;
+Stringifier.default = Stringifier;
 
 function stringify(node, builder) {
   let str = new stringifier(builder);
@@ -5079,42 +5079,23 @@ class Node {
     }
   }
 
-  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
-      )
+  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 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)
+    return error
   }
 
-  remove() {
-    if (this.parent) {
-      this.parent.removeChild(this);
-    }
-    this.parent = undefined;
+  after(add) {
+    this.parent.insertAfter(this, add);
     return this
   }
 
-  toString(stringifier = stringify_1) {
-    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];
@@ -5122,6 +5103,17 @@ class Node {
     return this
   }
 
+  before(add) {
+    this.parent.insertBefore(this, add);
+    return this
+  }
+
+  cleanRaws(keepBetween) {
+    delete this.raws.before;
+    delete this.raws.after;
+    if (!keepBetween) delete this.raws.between;
+  }
+
   clone(overrides = {}) {
     let cloned = cloneNode(this);
     for (let name in overrides) {
@@ -5130,39 +5122,70 @@ class Node {
     return cloned
   }
 
-  cloneBefore(overrides = {}) {
+  cloneAfter(overrides = {}) {
     let cloned = this.clone(overrides);
-    this.parent.insertBefore(this, cloned);
+    this.parent.insertAfter(this, cloned);
     return cloned
   }
 
-  cloneAfter(overrides = {}) {
+  cloneBefore(overrides = {}) {
     let cloned = this.clone(overrides);
-    this.parent.insertAfter(this, cloned);
+    this.parent.insertBefore(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;
+  error(message, opts = {}) {
+    if (this.source) {
+      let { end, start } = this.rangeBy(opts);
+      return this.source.input.error(
+        message,
+        { column: start.column, line: start.line },
+        { column: end.column, line: end.line },
+        opts
+      )
+    }
+    return new cssSyntaxError(message)
+  }
+
+  getProxyProcessor() {
+    return {
+      get(node, prop) {
+        if (prop === 'proxyOf') {
+          return node
+        } else if (prop === 'root') {
+          return () => node.root().toProxy()
         } else {
-          this.parent.insertBefore(bookmark, node);
+          return node[prop]
         }
-      }
+      },
 
-      if (!foundSelf) {
-        this.remove();
+      set(node, prop, value) {
+        if (node[prop] === value) return true
+        node[prop] = value;
+        if (
+          prop === 'prop' ||
+          prop === 'value' ||
+          prop === 'name' ||
+          prop === 'params' ||
+          prop === 'important' ||
+          /* c8 ignore next */
+          prop === 'text'
+        ) {
+          node.markDirty();
+        }
+        return true
       }
     }
+  }
 
-    return this
+  markDirty() {
+    if (this[isClean$2]) {
+      this[isClean$2] = false;
+      let next = this;
+      while ((next = next.parent)) {
+        next[isClean$2] = false;
+      }
+    }
   }
 
   next() {
@@ -5171,19 +5194,128 @@ class Node {
     return this.parent.nodes[index + 1]
   }
 
+  positionBy(opts, stringRepresentation) {
+    let pos = this.source.start;
+    if (opts.index) {
+      pos = this.positionInside(opts.index, stringRepresentation);
+    } else if (opts.word) {
+      stringRepresentation = this.toString();
+      let index = stringRepresentation.indexOf(opts.word);
+      if (index !== -1) pos = this.positionInside(index, stringRepresentation);
+    }
+    return pos
+  }
+
+  positionInside(index, stringRepresentation) {
+    let string = stringRepresentation || 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 { column, line }
+  }
+
   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);
+  rangeBy(opts) {
+    let start = {
+      column: this.source.start.column,
+      line: this.source.start.line
+    };
+    let end = this.source.end
+      ? {
+        column: this.source.end.column + 1,
+        line: this.source.end.line
+      }
+      : {
+        column: start.column + 1,
+        line: start.line
+      };
+
+    if (opts.word) {
+      let stringRepresentation = this.toString();
+      let index = stringRepresentation.indexOf(opts.word);
+      if (index !== -1) {
+        start = this.positionInside(index, stringRepresentation);
+        end = this.positionInside(index + opts.word.length, stringRepresentation);
+      }
+    } else {
+      if (opts.start) {
+        start = {
+          column: opts.start.column,
+          line: opts.start.line
+        };
+      } else if (opts.index) {
+        start = this.positionInside(opts.index);
+      }
+
+      if (opts.end) {
+        end = {
+          column: opts.end.column,
+          line: opts.end.line
+        };
+      } 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 = { column: start.column + 1, line: start.line };
+    }
+
+    return { end, start }
+  }
+
+  raw(prop, defaultType) {
+    let str = new stringifier();
+    return str.raw(this, prop, defaultType)
+  }
+
+  remove() {
+    if (this.parent) {
+      this.parent.removeChild(this);
+    }
+    this.parent = undefined;
     return this
   }
 
-  after(add) {
-    this.parent.insertAfter(this, add);
+  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
   }
 
@@ -5195,17 +5327,6 @@ class Node {
     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;
@@ -5238,9 +5359,9 @@ class Node {
           inputsNextIndex++;
         }
         fixed[name] = {
+          end: value.end,
           inputId,
-          start: value.start,
-          end: value.end
+          start: value.start
         };
       } else {
         fixed[name] = value;
@@ -5254,145 +5375,26 @@ class Node {
     return fixed
   }
 
-  positionInside(index) {
-    let string = this.toString();
-    let column = this.source.start.column;
-    let line = this.source.start.line;
+  toProxy() {
+    if (!this.proxyCache) {
+      this.proxyCache = new Proxy(this, this.getProxyProcessor());
+    }
+    return this.proxyCache
+  }
 
-    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 = this.source.end
-      ? {
-          line: this.source.end.line,
-          column: this.source.end.column + 1
-        }
-      : {
-          line: start.line,
-          column: start.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' ||
-          /* c8 ignore next */
-          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
+  toString(stringifier = stringify_1) {
+    if (stringifier.stringify) stringifier = stringifier.stringify;
+    let result = '';
+    stringifier(this, i => {
+      result += i;
+    });
+    return result
   }
 
-  markDirty() {
-    if (this[isClean$2]) {
-      this[isClean$2] = false;
-      let next = this;
-      while ((next = next.parent)) {
-        next[isClean$2] = false;
-      }
-    }
+  warn(result, text, opts) {
+    let data = { node: this };
+    for (let i in opts) data[i] = opts[i];
+    return result.warn(text, data)
   }
 
   get proxyOf() {
@@ -5486,22 +5488,37 @@ class PreviousMap {
     return this.consumerCache
   }
 
-  withContent() {
-    return !!(
-      this.consumer().sourcesContent &&
-      this.consumer().sourcesContent.length > 0
-    )
-  }
+  decodeInline(text) {
+    let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
+    let baseUri = /^data:application\/json;base64,/;
+    let charsetUri = /^data:application\/json;charset=utf-?8,/;
+    let uri = /^data:application\/json,/;
 
-  startWith(string, start) {
-    if (!string) return false
-    return string.substr(0, start.length) === start
+    if (charsetUri.test(text) || uri.test(text)) {
+      return decodeURIComponent(text.substr(RegExp.lastMatch.length))
+    }
+
+    if (baseCharsetUri.test(text) || baseUri.test(text)) {
+      return fromBase64(text.substr(RegExp.lastMatch.length))
+    }
+
+    let encoding = text.match(/data:application\/json;([^,]+),/)[1];
+    throw new Error('Unsupported source map encoding ' + encoding)
   }
 
   getAnnotationURL(sourceMapString) {
     return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, '').trim()
   }
 
+  isMap(map) {
+    if (typeof map !== 'object') return false
+    return (
+      typeof map.mappings === 'string' ||
+      typeof map._mappings === 'string' ||
+      Array.isArray(map.sections)
+    )
+  }
+
   loadAnnotation(css) {
     let comments = css.match(/\/\*\s*# sourceMappingURL=/gm);
     if (!comments) return
@@ -5516,24 +5533,6 @@ class PreviousMap {
     }
   }
 
-  decodeInline(text) {
-    let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
-    let baseUri = /^data:application\/json;base64,/;
-    let charsetUri = /^data:application\/json;charset=utf-?8,/;
-    let uri = /^data:application\/json,/;
-
-    if (charsetUri.test(text) || uri.test(text)) {
-      return decodeURIComponent(text.substr(RegExp.lastMatch.length))
-    }
-
-    if (baseCharsetUri.test(text) || baseUri.test(text)) {
-      return fromBase64(text.substr(RegExp.lastMatch.length))
-    }
-
-    let encoding = text.match(/data:application\/json;([^,]+),/)[1];
-    throw new Error('Unsupported source map encoding ' + encoding)
-  }
-
   loadFile(path) {
     this.root = dirname$1(path);
     if (existsSync(path)) {
@@ -5579,12 +5578,15 @@ class PreviousMap {
     }
   }
 
-  isMap(map) {
-    if (typeof map !== 'object') return false
-    return (
-      typeof map.mappings === 'string' ||
-      typeof map._mappings === 'string' ||
-      Array.isArray(map.sections)
+  startWith(string, start) {
+    if (!string) return false
+    return string.substr(0, start.length) === start
+  }
+
+  withContent() {
+    return !!(
+      this.consumer().sourcesContent &&
+      this.consumer().sourcesContent.length > 0
     )
   }
 }
@@ -5596,7 +5598,7 @@ const require$$3 = /*@__PURE__*/getAugmentedNamespace(nonSecure);
 
 let { SourceMapConsumer: SourceMapConsumer$1, SourceMapGenerator: SourceMapGenerator$1 } = require$$2;
 let { fileURLToPath, pathToFileURL: pathToFileURL$1 } = require$$2;
-let { resolve: resolve$1, isAbsolute } = require$$2;
+let { isAbsolute, resolve: resolve$1 } = require$$2;
 let { nanoid } = require$$3;
 
 
@@ -5654,48 +5656,6 @@ class Input {
     if (this.map) this.map.file = this.from;
   }
 
-  fromOffset(offset) {
-    let lastLine, lineToIndex;
-    if (!this[fromOffsetCache]) {
-      let lines = this.css.split('\n');
-      lineToIndex = new Array(lines.length);
-      let prevIndex = 0;
-
-      for (let i = 0, l = lines.length; i < l; i++) {
-        lineToIndex[i] = prevIndex;
-        prevIndex += lines[i].length + 1;
-      }
-
-      this[fromOffsetCache] = lineToIndex;
-    } else {
-      lineToIndex = this[fromOffsetCache];
-    }
-    lastLine = lineToIndex[lineToIndex.length - 1];
-
-    let min = 0;
-    if (offset >= lastLine) {
-      min = lineToIndex.length - 1;
-    } else {
-      let max = lineToIndex.length - 2;
-      let mid;
-      while (min < max) {
-        mid = min + ((max - min) >> 1);
-        if (offset < lineToIndex[mid]) {
-          max = mid - 1;
-        } else if (offset >= lineToIndex[mid + 1]) {
-          min = mid + 1;
-        } else {
-          min = mid;
-          break
-        }
-      }
-    }
-    return {
-      line: min + 1,
-      col: offset - lineToIndex[min] + 1
-    }
-  }
-
   error(message, line, column, opts = {}) {
     let result, endLine, endColumn;
 
@@ -5730,10 +5690,10 @@ class Input {
         message,
         origin.endLine === undefined
           ? origin.line
-          : { line: origin.line, column: origin.column },
+          : { column: origin.column, line: origin.line },
         origin.endLine === undefined
           ? origin.column
-          : { line: origin.endLine, column: origin.endColumn },
+          : { column: origin.endColumn, line: origin.endLine },
         origin.source,
         origin.file,
         opts.plugin
@@ -5741,15 +5701,15 @@ class Input {
     } else {
       result = new cssSyntaxError(
         message,
-        endLine === undefined ? line : { line, column },
-        endLine === undefined ? column : { line: endLine, column: endColumn },
+        endLine === undefined ? line : { column, line },
+        endLine === undefined ? column : { column: endColumn, line: endLine },
         this.css,
         this.file,
         opts.plugin
       );
     }
 
-    result.input = { line, column, endLine, endColumn, source: this.css };
+    result.input = { column, endColumn, endLine, line, source: this.css };
     if (this.file) {
       if (pathToFileURL$1) {
         result.input.url = pathToFileURL$1(this.file).toString();
@@ -5760,22 +5720,71 @@ class Input {
     return result
   }
 
-  origin(line, column, endLine, endColumn) {
-    if (!this.map) return false
-    let consumer = this.map.consumer();
+  fromOffset(offset) {
+    let lastLine, lineToIndex;
+    if (!this[fromOffsetCache]) {
+      let lines = this.css.split('\n');
+      lineToIndex = new Array(lines.length);
+      let prevIndex = 0;
 
-    let from = consumer.originalPositionFor({ line, column });
-    if (!from.source) return false
+      for (let i = 0, l = lines.length; i < l; i++) {
+        lineToIndex[i] = prevIndex;
+        prevIndex += lines[i].length + 1;
+      }
 
-    let to;
-    if (typeof endLine === 'number') {
-      to = consumer.originalPositionFor({ line: endLine, column: endColumn });
+      this[fromOffsetCache] = lineToIndex;
+    } else {
+      lineToIndex = this[fromOffsetCache];
     }
+    lastLine = lineToIndex[lineToIndex.length - 1];
 
-    let fromUrl;
-
-    if (isAbsolute(from.source)) {
-      fromUrl = pathToFileURL$1(from.source);
+    let min = 0;
+    if (offset >= lastLine) {
+      min = lineToIndex.length - 1;
+    } else {
+      let max = lineToIndex.length - 2;
+      let mid;
+      while (min < max) {
+        mid = min + ((max - min) >> 1);
+        if (offset < lineToIndex[mid]) {
+          max = mid - 1;
+        } else if (offset >= lineToIndex[mid + 1]) {
+          min = mid + 1;
+        } else {
+          min = mid;
+          break
+        }
+      }
+    }
+    return {
+      col: offset - lineToIndex[min] + 1,
+      line: min + 1
+    }
+  }
+
+  mapResolve(file) {
+    if (/^\w+:\/\//.test(file)) {
+      return file
+    }
+    return resolve$1(this.map.consumer().sourceRoot || this.map.root || '.', file)
+  }
+
+  origin(line, column, endLine, endColumn) {
+    if (!this.map) return false
+    let consumer = this.map.consumer();
+
+    let from = consumer.originalPositionFor({ column, line });
+    if (!from.source) return false
+
+    let to;
+    if (typeof endLine === 'number') {
+      to = consumer.originalPositionFor({ column: endColumn, line: endLine });
+    }
+
+    let fromUrl;
+
+    if (isAbsolute(from.source)) {
+      fromUrl = pathToFileURL$1(from.source);
     } else {
       fromUrl = new URL(
         from.source,
@@ -5784,11 +5793,11 @@ class Input {
     }
 
     let result = {
-      url: fromUrl.toString(),
-      line: from.line,
       column: from.column,
+      endColumn: to && to.column,
       endLine: to && to.line,
-      endColumn: to && to.column
+      line: from.line,
+      url: fromUrl.toString()
     };
 
     if (fromUrl.protocol === 'file:') {
@@ -5806,17 +5815,6 @@ class Input {
     return result
   }
 
-  mapResolve(file) {
-    if (/^\w+:\/\//.test(file)) {
-      return file
-    }
-    return resolve$1(this.map.consumer().sourceRoot || this.map.root || '.', file)
-  }
-
-  get from() {
-    return this.file || this.id
-  }
-
   toJSON() {
     let json = {};
     for (let name of ['hasBOM', 'css', 'file', 'id']) {
@@ -5832,6 +5830,10 @@ class Input {
     }
     return json
   }
+
+  get from() {
+    return this.file || this.id
+  }
 }
 
 var input = Input;
@@ -5842,7 +5844,7 @@ if (require$$2 && require$$2.registerInput) {
 }
 
 let { SourceMapConsumer, SourceMapGenerator } = require$$2;
-let { dirname, resolve, relative, sep } = require$$2;
+let { dirname, relative, resolve, sep } = require$$2;
 let { pathToFileURL } = require$$2;
 
 
@@ -5858,100 +5860,29 @@ class MapGenerator {
     this.opts = opts;
     this.css = cssString;
     this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute;
-  }
-
-  isMap() {
-    if (typeof this.opts.map !== 'undefined') {
-      return !!this.opts.map
-    }
-    return this.previous().length > 0
-  }
-
-  previous() {
-    if (!this.previousMaps) {
-      this.previousMaps = [];
-      if (this.root) {
-        this.root.walk(node => {
-          if (node.source && node.source.input.map) {
-            let map = node.source.input.map;
-            if (!this.previousMaps.includes(map)) {
-              this.previousMaps.push(map);
-            }
-          }
-        });
-      } else {
-        let input$1 = new input(this.css, this.opts);
-        if (input$1.map) this.previousMaps.push(input$1.map);
-      }
-    }
-
-    return this.previousMaps
-  }
-
-  isInline() {
-    if (typeof this.mapOpts.inline !== 'undefined') {
-      return this.mapOpts.inline
-    }
-
-    let annotation = this.mapOpts.annotation;
-    if (typeof annotation !== 'undefined' && annotation !== true) {
-      return false
-    }
 
-    if (this.previous().length) {
-      return this.previous().some(i => i.inline)
-    }
-    return true
-  }
-
-  isSourcesContent() {
-    if (typeof this.mapOpts.sourcesContent !== 'undefined') {
-      return this.mapOpts.sourcesContent
-    }
-    if (this.previous().length) {
-      return this.previous().some(i => i.withContent())
-    }
-    return true
+    this.memoizedFileURLs = new Map();
+    this.memoizedPaths = new Map();
+    this.memoizedURLs = new Map();
   }
 
-  clearAnnotation() {
-    if (this.mapOpts.annotation === false) return
+  addAnnotation() {
+    let content;
 
-    if (this.root) {
-      let node;
-      for (let i = this.root.nodes.length - 1; i >= 0; i--) {
-        node = this.root.nodes[i];
-        if (node.type !== 'comment') continue
-        if (node.text.indexOf('# sourceMappingURL=') === 0) {
-          this.root.removeChild(i);
-        }
-      }
-    } else if (this.css) {
-      this.css = this.css.replace(/(\n)?\/\*#[\S\s]*?\*\/$/gm, '');
+    if (this.isInline()) {
+      content =
+        'data:application/json;base64,' + this.toBase64(this.map.toString());
+    } else if (typeof this.mapOpts.annotation === 'string') {
+      content = this.mapOpts.annotation;
+    } else if (typeof this.mapOpts.annotation === 'function') {
+      content = this.mapOpts.annotation(this.opts.to, this.root);
+    } else {
+      content = this.outputFile() + '.map';
     }
-  }
+    let eol = '\n';
+    if (this.css.includes('\r\n')) eol = '\r\n';
 
-  setSourcesContent() {
-    let already = {};
-    if (this.root) {
-      this.root.walk(node => {
-        if (node.source) {
-          let from = node.source.input.from;
-          if (from && !already[from]) {
-            already[from] = true;
-            let fromUrl = this.usesFileUrls
-              ? this.toFileUrl(from)
-              : this.toUrl(this.path(from));
-            this.map.setSourceContent(fromUrl, node.source.input.css);
-          }
-        }
-      });
-    } else if (this.css) {
-      let from = this.opts.from
-        ? this.toUrl(this.path(this.opts.from))
-        : '<no source>';
-      this.map.setSourceContent(from, this.css);
-    }
+    this.css += eol + '/*# sourceMappingURL=' + content + ' */';
   }
 
   applyPrevMaps() {
@@ -5973,53 +5904,33 @@ class MapGenerator {
     }
   }
 
-  isAnnotation() {
-    if (this.isInline()) {
-      return true
-    }
-    if (typeof this.mapOpts.annotation !== 'undefined') {
-      return this.mapOpts.annotation
-    }
-    if (this.previous().length) {
-      return this.previous().some(i => i.annotation)
-    }
-    return true
-  }
-
-  toBase64(str) {
-    if (Buffer) {
-      return Buffer.from(str).toString('base64')
-    } else {
-      return window.btoa(unescape(encodeURIComponent(str)))
-    }
-  }
-
-  addAnnotation() {
-    let content;
+  clearAnnotation() {
+    if (this.mapOpts.annotation === false) return
 
-    if (this.isInline()) {
-      content =
-        'data:application/json;base64,' + this.toBase64(this.map.toString());
-    } else if (typeof this.mapOpts.annotation === 'string') {
-      content = this.mapOpts.annotation;
-    } else if (typeof this.mapOpts.annotation === 'function') {
-      content = this.mapOpts.annotation(this.opts.to, this.root);
-    } else {
-      content = this.outputFile() + '.map';
+    if (this.root) {
+      let node;
+      for (let i = this.root.nodes.length - 1; i >= 0; i--) {
+        node = this.root.nodes[i];
+        if (node.type !== 'comment') continue
+        if (node.text.indexOf('# sourceMappingURL=') === 0) {
+          this.root.removeChild(i);
+        }
+      }
+    } else if (this.css) {
+      this.css = this.css.replace(/(\n)?\/\*#[\S\s]*?\*\/$/gm, '');
     }
-    let eol = '\n';
-    if (this.css.includes('\r\n')) eol = '\r\n';
-
-    this.css += eol + '/*# sourceMappingURL=' + content + ' */';
   }
 
-  outputFile() {
-    if (this.opts.to) {
-      return this.path(this.opts.to)
-    } else if (this.opts.from) {
-      return this.path(this.opts.from)
+  generate() {
+    this.clearAnnotation();
+    if (pathAvailable && sourceMapAvailable && this.isMap()) {
+      return this.generateMap()
     } else {
-      return 'to.css'
+      let result = '';
+      this.stringify(this.root, i => {
+        result += i;
+      });
+      return [result]
     }
   }
 
@@ -6033,11 +5944,11 @@ class MapGenerator {
     } else {
       this.map = new SourceMapGenerator({ file: this.outputFile() });
       this.map.addMapping({
+        generated: { column: 0, line: 1 },
+        original: { column: 0, line: 1 },
         source: this.opts.from
           ? this.toUrl(this.path(this.opts.from))
-          : '<no source>',
-        generated: { line: 1, column: 0 },
-        original: { line: 1, column: 0 }
+          : '<no source>'
       });
     }
 
@@ -6052,65 +5963,23 @@ class MapGenerator {
     }
   }
 
-  path(file) {
-    if (file.indexOf('<') === 0) return file
-    if (/^\w+:\/\//.test(file)) return file
-    if (this.mapOpts.absolute) return file
-
-    let from = this.opts.to ? dirname(this.opts.to) : '.';
+  generateString() {
+    this.css = '';
+    this.map = new SourceMapGenerator({ file: this.outputFile() });
 
-    if (typeof this.mapOpts.annotation === 'string') {
-      from = dirname(resolve(from, this.mapOpts.annotation));
-    }
+    let line = 1;
+    let column = 1;
 
-    file = relative(from, file);
-    return file
-  }
+    let noSource = '<no source>';
+    let mapping = {
+      generated: { column: 0, line: 0 },
+      original: { column: 0, line: 0 },
+      source: ''
+    };
 
-  toUrl(path) {
-    if (sep === '\\') {
-      path = path.replace(/\\/g, '/');
-    }
-    return encodeURI(path).replace(/[#?]/g, encodeURIComponent)
-  }
-
-  toFileUrl(path) {
-    if (pathToFileURL) {
-      return pathToFileURL(path).toString()
-    } else {
-      throw new Error(
-        '`map.absolute` option is not available in this PostCSS build'
-      )
-    }
-  }
-
-  sourcePath(node) {
-    if (this.mapOpts.from) {
-      return this.toUrl(this.mapOpts.from)
-    } else if (this.usesFileUrls) {
-      return this.toFileUrl(node.source.input.from)
-    } else {
-      return this.toUrl(this.path(node.source.input.from))
-    }
-  }
-
-  generateString() {
-    this.css = '';
-    this.map = new SourceMapGenerator({ file: this.outputFile() });
-
-    let line = 1;
-    let column = 1;
-
-    let noSource = '<no source>';
-    let mapping = {
-      source: '',
-      generated: { line: 0, column: 0 },
-      original: { line: 0, column: 0 }
-    };
-
-    let lines, last;
-    this.stringify(this.root, (str, node, type) => {
-      this.css += str;
+    let lines, last;
+    this.stringify(this.root, (str, node, type) => {
+      this.css += str;
 
       if (node && type !== 'end') {
         mapping.generated.line = line;
@@ -6162,18 +6031,172 @@ class MapGenerator {
     });
   }
 
-  generate() {
-    this.clearAnnotation();
-    if (pathAvailable && sourceMapAvailable && this.isMap()) {
-      return this.generateMap()
+  isAnnotation() {
+    if (this.isInline()) {
+      return true
+    }
+    if (typeof this.mapOpts.annotation !== 'undefined') {
+      return this.mapOpts.annotation
+    }
+    if (this.previous().length) {
+      return this.previous().some(i => i.annotation)
+    }
+    return true
+  }
+
+  isInline() {
+    if (typeof this.mapOpts.inline !== 'undefined') {
+      return this.mapOpts.inline
+    }
+
+    let annotation = this.mapOpts.annotation;
+    if (typeof annotation !== 'undefined' && annotation !== true) {
+      return false
+    }
+
+    if (this.previous().length) {
+      return this.previous().some(i => i.inline)
+    }
+    return true
+  }
+
+  isMap() {
+    if (typeof this.opts.map !== 'undefined') {
+      return !!this.opts.map
+    }
+    return this.previous().length > 0
+  }
+
+  isSourcesContent() {
+    if (typeof this.mapOpts.sourcesContent !== 'undefined') {
+      return this.mapOpts.sourcesContent
+    }
+    if (this.previous().length) {
+      return this.previous().some(i => i.withContent())
+    }
+    return true
+  }
+
+  outputFile() {
+    if (this.opts.to) {
+      return this.path(this.opts.to)
+    } else if (this.opts.from) {
+      return this.path(this.opts.from)
     } else {
-      let result = '';
-      this.stringify(this.root, i => {
-        result += i;
+      return 'to.css'
+    }
+  }
+
+  path(file) {
+    if (this.mapOpts.absolute) return file
+    if (file.charCodeAt(0) === 60 /* `<` */) return file
+    if (/^\w+:\/\//.test(file)) return file
+    let cached = this.memoizedPaths.get(file);
+    if (cached) return cached
+
+    let from = this.opts.to ? dirname(this.opts.to) : '.';
+
+    if (typeof this.mapOpts.annotation === 'string') {
+      from = dirname(resolve(from, this.mapOpts.annotation));
+    }
+
+    let path = relative(from, file);
+    this.memoizedPaths.set(file, path);
+
+    return path
+  }
+
+  previous() {
+    if (!this.previousMaps) {
+      this.previousMaps = [];
+      if (this.root) {
+        this.root.walk(node => {
+          if (node.source && node.source.input.map) {
+            let map = node.source.input.map;
+            if (!this.previousMaps.includes(map)) {
+              this.previousMaps.push(map);
+            }
+          }
+        });
+      } else {
+        let input$1 = new input(this.css, this.opts);
+        if (input$1.map) this.previousMaps.push(input$1.map);
+      }
+    }
+
+    return this.previousMaps
+  }
+
+  setSourcesContent() {
+    let already = {};
+    if (this.root) {
+      this.root.walk(node => {
+        if (node.source) {
+          let from = node.source.input.from;
+          if (from && !already[from]) {
+            already[from] = true;
+            let fromUrl = this.usesFileUrls
+              ? this.toFileUrl(from)
+              : this.toUrl(this.path(from));
+            this.map.setSourceContent(fromUrl, node.source.input.css);
+          }
+        }
       });
-      return [result]
+    } else if (this.css) {
+      let from = this.opts.from
+        ? this.toUrl(this.path(this.opts.from))
+        : '<no source>';
+      this.map.setSourceContent(from, this.css);
+    }
+  }
+
+  sourcePath(node) {
+    if (this.mapOpts.from) {
+      return this.toUrl(this.mapOpts.from)
+    } else if (this.usesFileUrls) {
+      return this.toFileUrl(node.source.input.from)
+    } else {
+      return this.toUrl(this.path(node.source.input.from))
+    }
+  }
+
+  toBase64(str) {
+    if (Buffer) {
+      return Buffer.from(str).toString('base64')
+    } else {
+      return window.btoa(unescape(encodeURIComponent(str)))
     }
   }
+
+  toFileUrl(path) {
+    let cached = this.memoizedFileURLs.get(path);
+    if (cached) return cached
+
+    if (pathToFileURL) {
+      let fileURL = pathToFileURL(path).toString();
+      this.memoizedFileURLs.set(path, fileURL);
+
+      return fileURL
+    } else {
+      throw new Error(
+        '`map.absolute` option is not available in this PostCSS build'
+      )
+    }
+  }
+
+  toUrl(path) {
+    let cached = this.memoizedURLs.get(path);
+    if (cached) return cached
+
+    if (sep === '\\') {
+      path = path.replace(/\\/g, '/');
+    }
+
+    let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
+    this.memoizedURLs.set(path, url);
+
+    return url
+  }
 }
 
 var mapGenerator = MapGenerator;
@@ -6213,12 +6236,24 @@ function markDirtyUp(node) {
 }
 
 class Container extends node_1 {
-  push(child) {
-    child.parent = this;
-    this.proxyOf.nodes.push(child);
+  append(...children) {
+    for (let child of children) {
+      let nodes = this.normalize(child, this.last);
+      for (let node of nodes) this.proxyOf.nodes.push(node);
+    }
+
+    this.markDirty();
+
     return this
   }
 
+  cleanRaws(keepBetween) {
+    super.cleanRaws(keepBetween);
+    if (this.nodes) {
+      for (let node of this.nodes) node.cleanRaws(keepBetween);
+    }
+  }
+
   each(callback) {
     if (!this.proxyOf.nodes) return undefined
     let iterator = this.getIterator();
@@ -6236,151 +6271,75 @@ class Container extends node_1 {
     return result
   }
 
-  walk(callback) {
-    return this.each((child, i) => {
-      let result;
-      try {
-        result = callback(child, i);
-      } catch (e) {
-        throw child.addToError(e)
-      }
-      if (result !== false && child.walk) {
-        result = child.walk(callback);
-      }
-
-      return result
-    })
+  every(condition) {
+    return this.nodes.every(condition)
   }
 
-  walkDecls(prop, callback) {
-    if (!callback) {
-      callback = prop;
-      return this.walk((child, i) => {
-        if (child.type === 'decl') {
-          return callback(child, i)
-        }
-      })
-    }
-    if (prop instanceof RegExp) {
-      return this.walk((child, i) => {
-        if (child.type === 'decl' && prop.test(child.prop)) {
-          return callback(child, i)
-        }
-      })
-    }
-    return this.walk((child, i) => {
-      if (child.type === 'decl' && child.prop === prop) {
-        return callback(child, i)
-      }
-    })
-  }
+  getIterator() {
+    if (!this.lastEach) this.lastEach = 0;
+    if (!this.indexes) this.indexes = {};
 
-  walkRules(selector, callback) {
-    if (!callback) {
-      callback = selector;
+    this.lastEach += 1;
+    let iterator = this.lastEach;
+    this.indexes[iterator] = 0;
 
-      return this.walk((child, i) => {
-        if (child.type === 'rule') {
-          return callback(child, i)
-        }
-      })
-    }
-    if (selector instanceof RegExp) {
-      return this.walk((child, i) => {
-        if (child.type === 'rule' && selector.test(child.selector)) {
-          return callback(child, i)
-        }
-      })
-    }
-    return this.walk((child, i) => {
-      if (child.type === 'rule' && child.selector === selector) {
-        return callback(child, i)
-      }
-    })
+    return iterator
   }
 
-  walkAtRules(name, callback) {
-    if (!callback) {
-      callback = name;
-      return this.walk((child, i) => {
-        if (child.type === 'atrule') {
-          return callback(child, i)
-        }
-      })
-    }
-    if (name instanceof RegExp) {
-      return this.walk((child, i) => {
-        if (child.type === 'atrule' && name.test(child.name)) {
-          return callback(child, i)
+  getProxyProcessor() {
+    return {
+      get(node, prop) {
+        if (prop === 'proxyOf') {
+          return node
+        } else if (!node[prop]) {
+          return node[prop]
+        } else if (
+          prop === 'each' ||
+          (typeof prop === 'string' && prop.startsWith('walk'))
+        ) {
+          return (...args) => {
+            return node[prop](
+              ...args.map(i => {
+                if (typeof i === 'function') {
+                  return (child, index) => i(child.toProxy(), index)
+                } else {
+                  return i
+                }
+              })
+            )
+          }
+        } else if (prop === 'every' || prop === 'some') {
+          return cb => {
+            return node[prop]((child, ...other) =>
+              cb(child.toProxy(), ...other)
+            )
+          }
+        } else if (prop === 'root') {
+          return () => node.root().toProxy()
+        } else if (prop === 'nodes') {
+          return node.nodes.map(i => i.toProxy())
+        } else if (prop === 'first' || prop === 'last') {
+          return node[prop].toProxy()
+        } else {
+          return node[prop]
         }
-      })
-    }
-    return this.walk((child, i) => {
-      if (child.type === 'atrule' && child.name === name) {
-        return callback(child, i)
-      }
-    })
-  }
-
-  walkComments(callback) {
-    return this.walk((child, i) => {
-      if (child.type === 'comment') {
-        return callback(child, i)
-      }
-    })
-  }
-
-  append(...children) {
-    for (let child of children) {
-      let nodes = this.normalize(child, this.last);
-      for (let node of nodes) this.proxyOf.nodes.push(node);
-    }
-
-    this.markDirty();
-
-    return this
-  }
+      },
 
-  prepend(...children) {
-    children = children.reverse();
-    for (let child of children) {
-      let nodes = this.normalize(child, this.first, 'prepend').reverse();
-      for (let node of nodes) this.proxyOf.nodes.unshift(node);
-      for (let id in this.indexes) {
-        this.indexes[id] = this.indexes[id] + nodes.length;
+      set(node, prop, value) {
+        if (node[prop] === value) return true
+        node[prop] = value;
+        if (prop === 'name' || prop === 'params' || prop === 'selector') {
+          node.markDirty();
+        }
+        return true
       }
     }
-
-    this.markDirty();
-
-    return this
-  }
-
-  cleanRaws(keepBetween) {
-    super.cleanRaws(keepBetween);
-    if (this.nodes) {
-      for (let node of this.nodes) node.cleanRaws(keepBetween);
-    }
   }
 
-  insertBefore(exist, add) {
-    let existIndex = this.index(exist);
-    let type = existIndex === 0 ? 'prepend' : false;
-    let nodes = this.normalize(add, this.proxyOf.nodes[existIndex], type).reverse();
-    existIndex = this.index(exist);
-    for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node);
-
-    let index;
-    for (let id in this.indexes) {
-      index = this.indexes[id];
-      if (existIndex <= index) {
-        this.indexes[id] = index + nodes.length;
-      }
-    }
-
-    this.markDirty();
-
-    return this
+  index(child) {
+    if (typeof child === 'number') return child
+    if (child.proxyOf) child = child.proxyOf;
+    return this.proxyOf.nodes.indexOf(child)
   }
 
   insertAfter(exist, add) {
@@ -6402,16 +6361,18 @@ class Container extends node_1 {
     return this
   }
 
-  removeChild(child) {
-    child = this.index(child);
-    this.proxyOf.nodes[child].parent = undefined;
-    this.proxyOf.nodes.splice(child, 1);
+  insertBefore(exist, add) {
+    let existIndex = this.index(exist);
+    let type = existIndex === 0 ? 'prepend' : false;
+    let nodes = this.normalize(add, this.proxyOf.nodes[existIndex], type).reverse();
+    existIndex = this.index(exist);
+    for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node);
 
     let index;
     for (let id in this.indexes) {
       index = this.indexes[id];
-      if (index >= child) {
-        this.indexes[id] = index - 1;
+      if (existIndex <= index) {
+        this.indexes[id] = index + nodes.length;
       }
     }
 
@@ -6420,57 +6381,6 @@ class Container extends node_1 {
     return this
   }
 
-  removeAll() {
-    for (let node of this.proxyOf.nodes) node.parent = undefined;
-    this.proxyOf.nodes = [];
-
-    this.markDirty();
-
-    return this
-  }
-
-  replaceValues(pattern, opts, callback) {
-    if (!callback) {
-      callback = opts;
-      opts = {};
-    }
-
-    this.walkDecls(decl => {
-      if (opts.props && !opts.props.includes(decl.prop)) return
-      if (opts.fast && !decl.value.includes(opts.fast)) return
-
-      decl.value = decl.value.replace(pattern, callback);
-    });
-
-    this.markDirty();
-
-    return this
-  }
-
-  every(condition) {
-    return this.nodes.every(condition)
-  }
-
-  some(condition) {
-    return this.nodes.some(condition)
-  }
-
-  index(child) {
-    if (typeof child === 'number') return child
-    if (child.proxyOf) child = child.proxyOf;
-    return this.proxyOf.nodes.indexOf(child)
-  }
-
-  get first() {
-    if (!this.proxyOf.nodes) return undefined
-    return this.proxyOf.nodes[0]
-  }
-
-  get last() {
-    if (!this.proxyOf.nodes) return undefined
-    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]
-  }
-
   normalize(nodes, sample) {
     if (typeof nodes === 'string') {
       nodes = cleanSource(parse$1(nodes).nodes);
@@ -6521,65 +6431,178 @@ class Container extends node_1 {
     return processed
   }
 
-  getProxyProcessor() {
-    return {
-      set(node, prop, value) {
-        if (node[prop] === value) return true
-        node[prop] = value;
-        if (prop === 'name' || prop === 'params' || prop === 'selector') {
-          node.markDirty();
-        }
-        return true
-      },
-
-      get(node, prop) {
-        if (prop === 'proxyOf') {
-          return node
-        } else if (!node[prop]) {
-          return node[prop]
-        } else if (
-          prop === 'each' ||
-          (typeof prop === 'string' && prop.startsWith('walk'))
-        ) {
-          return (...args) => {
-            return node[prop](
-              ...args.map(i => {
-                if (typeof i === 'function') {
-                  return (child, index) => i(child.toProxy(), index)
-                } else {
-                  return i
-                }
-              })
-            )
-          }
-        } else if (prop === 'every' || prop === 'some') {
-          return cb => {
-            return node[prop]((child, ...other) =>
-              cb(child.toProxy(), ...other)
-            )
-          }
-        } else if (prop === 'root') {
-          return () => node.root().toProxy()
-        } else if (prop === 'nodes') {
-          return node.nodes.map(i => i.toProxy())
-        } else if (prop === 'first' || prop === 'last') {
-          return node[prop].toProxy()
-        } else {
-          return node[prop]
-        }
+  prepend(...children) {
+    children = children.reverse();
+    for (let child of children) {
+      let nodes = this.normalize(child, this.first, 'prepend').reverse();
+      for (let node of nodes) this.proxyOf.nodes.unshift(node);
+      for (let id in this.indexes) {
+        this.indexes[id] = this.indexes[id] + nodes.length;
       }
     }
-  }
 
-  getIterator() {
-    if (!this.lastEach) this.lastEach = 0;
-    if (!this.indexes) this.indexes = {};
+    this.markDirty();
 
-    this.lastEach += 1;
-    let iterator = this.lastEach;
-    this.indexes[iterator] = 0;
+    return this
+  }
 
-    return iterator
+  push(child) {
+    child.parent = this;
+    this.proxyOf.nodes.push(child);
+    return this
+  }
+
+  removeAll() {
+    for (let node of this.proxyOf.nodes) node.parent = undefined;
+    this.proxyOf.nodes = [];
+
+    this.markDirty();
+
+    return this
+  }
+
+  removeChild(child) {
+    child = this.index(child);
+    this.proxyOf.nodes[child].parent = undefined;
+    this.proxyOf.nodes.splice(child, 1);
+
+    let index;
+    for (let id in this.indexes) {
+      index = this.indexes[id];
+      if (index >= child) {
+        this.indexes[id] = index - 1;
+      }
+    }
+
+    this.markDirty();
+
+    return this
+  }
+
+  replaceValues(pattern, opts, callback) {
+    if (!callback) {
+      callback = opts;
+      opts = {};
+    }
+
+    this.walkDecls(decl => {
+      if (opts.props && !opts.props.includes(decl.prop)) return
+      if (opts.fast && !decl.value.includes(opts.fast)) return
+
+      decl.value = decl.value.replace(pattern, callback);
+    });
+
+    this.markDirty();
+
+    return this
+  }
+
+  some(condition) {
+    return this.nodes.some(condition)
+  }
+
+  walk(callback) {
+    return this.each((child, i) => {
+      let result;
+      try {
+        result = callback(child, i);
+      } catch (e) {
+        throw child.addToError(e)
+      }
+      if (result !== false && child.walk) {
+        result = child.walk(callback);
+      }
+
+      return result
+    })
+  }
+
+  walkAtRules(name, callback) {
+    if (!callback) {
+      callback = name;
+      return this.walk((child, i) => {
+        if (child.type === 'atrule') {
+          return callback(child, i)
+        }
+      })
+    }
+    if (name instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === 'atrule' && name.test(child.name)) {
+          return callback(child, i)
+        }
+      })
+    }
+    return this.walk((child, i) => {
+      if (child.type === 'atrule' && child.name === name) {
+        return callback(child, i)
+      }
+    })
+  }
+
+  walkComments(callback) {
+    return this.walk((child, i) => {
+      if (child.type === 'comment') {
+        return callback(child, i)
+      }
+    })
+  }
+
+  walkDecls(prop, callback) {
+    if (!callback) {
+      callback = prop;
+      return this.walk((child, i) => {
+        if (child.type === 'decl') {
+          return callback(child, i)
+        }
+      })
+    }
+    if (prop instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === 'decl' && prop.test(child.prop)) {
+          return callback(child, i)
+        }
+      })
+    }
+    return this.walk((child, i) => {
+      if (child.type === 'decl' && child.prop === prop) {
+        return callback(child, i)
+      }
+    })
+  }
+
+  walkRules(selector, callback) {
+    if (!callback) {
+      callback = selector;
+
+      return this.walk((child, i) => {
+        if (child.type === 'rule') {
+          return callback(child, i)
+        }
+      })
+    }
+    if (selector instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === 'rule' && selector.test(child.selector)) {
+          return callback(child, i)
+        }
+      })
+    }
+    return this.walk((child, i) => {
+      if (child.type === 'rule' && child.selector === selector) {
+        return callback(child, i)
+      }
+    })
+  }
+
+  get first() {
+    if (!this.proxyOf.nodes) return undefined
+    return this.proxyOf.nodes[0]
+  }
+
+  get last() {
+    if (!this.proxyOf.nodes) return undefined
+    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]
   }
 }
 
@@ -6674,8 +6697,8 @@ class Warning {
   toString() {
     if (this.node) {
       return this.node.error(this.text, {
-        plugin: this.plugin,
         index: this.index,
+        plugin: this.plugin,
         word: this.word
       }).message
     }
@@ -6752,7 +6775,7 @@ const AT = '@'.charCodeAt(0);
 
 const RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g;
 const RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g;
-const RE_BAD_BRACKET = /.[\n"'(/\\]/;
+const RE_BAD_BRACKET = /.[\r\n"'(/\\]/;
 const RE_HEX_ESCAPE = /[\da-f]/i;
 
 var tokenize = function tokenizer(input, options = {}) {
@@ -6989,8 +7012,8 @@ var tokenize = function tokenizer(input, options = {}) {
 
   return {
     back,
-    nextToken,
     endOfFile,
+    nextToken,
     position
   }
 };
@@ -7026,16 +7049,6 @@ class Root extends container {
     if (!this.nodes) this.nodes = [];
   }
 
-  removeChild(child, ignore) {
-    let index = this.index(child);
-
-    if (!ignore && index === 0 && this.nodes.length > 1) {
-      this.nodes[1].raws.before = this.nodes[index].raws.before;
-    }
-
-    return super.removeChild(child)
-  }
-
   normalize(child, sample, type) {
     let nodes = super.normalize(child);
 
@@ -7056,6 +7069,16 @@ class Root extends container {
     return nodes
   }
 
+  removeChild(child, ignore) {
+    let index = this.index(child);
+
+    if (!ignore && index === 0 && this.nodes.length > 1) {
+      this.nodes[1].raws.before = this.nodes[index].raws.before;
+    }
+
+    return super.removeChild(child)
+  }
+
   toResult(opts = {}) {
     let lazy = new LazyResult$1(new Processor$1(), this, opts);
     return lazy.stringify()
@@ -7076,6 +7099,15 @@ Root.default = Root;
 container.registerRoot(Root);
 
 let list = {
+  comma(string) {
+    return list.split(string, [','], true)
+  },
+
+  space(string) {
+    let spaces = [' ', '\n', '\t'];
+    return list.split(string, spaces)
+  },
+
   split(string, separators, last) {
     let array = [];
     let current = '';
@@ -7117,15 +7149,6 @@ let list = {
 
     if (last || current !== '') array.push(current.trim());
     return array
-  },
-
-  space(string) {
-    let spaces = [' ', '\n', '\t'];
-    return list.split(string, spaces)
-  },
-
-  comma(string) {
-    return list.split(string, [','], true)
   }
 };
 
@@ -7179,55 +7202,150 @@ class Parser {
     this.customProperty = false;
 
     this.createTokenizer();
-    this.root.source = { input, start: { offset: 0, line: 1, column: 1 } };
+    this.root.source = { input, start: { column: 1, line: 1, offset: 0 } };
   }
 
-  createTokenizer() {
-    this.tokenizer = tokenize(this.input);
-  }
+  atrule(token) {
+    let node = new atRule();
+    node.name = token[1].slice(1);
+    if (node.name === '') {
+      this.unnamedAtrule(node, token);
+    }
+    this.init(node, token[2]);
+
+    let type;
+    let prev;
+    let shift;
+    let last = false;
+    let open = false;
+    let params = [];
+    let brackets = [];
 
-  parse() {
-    let token;
     while (!this.tokenizer.endOfFile()) {
       token = this.tokenizer.nextToken();
+      type = token[0];
 
-      switch (token[0]) {
-        case 'space':
-          this.spaces += token[1];
-          break
-
-        case ';':
-          this.freeSemicolon(token);
-          break
-
-        case '}':
-          this.end(token);
-          break
+      if (type === '(' || type === '[') {
+        brackets.push(type === '(' ? ')' : ']');
+      } else if (type === '{' && brackets.length > 0) {
+        brackets.push('}');
+      } else if (type === brackets[brackets.length - 1]) {
+        brackets.pop();
+      }
 
-        case 'comment':
-          this.comment(token);
+      if (brackets.length === 0) {
+        if (type === ';') {
+          node.source.end = this.getPosition(token[2]);
+          node.source.end.offset++;
+          this.semicolon = true;
           break
-
-        case 'at-word':
-          this.atrule(token);
+        } else if (type === '{') {
+          open = true;
           break
-
-        case '{':
-          this.emptyRule(token);
+        } else if (type === '}') {
+          if (params.length > 0) {
+            shift = params.length - 1;
+            prev = params[shift];
+            while (prev && prev[0] === 'space') {
+              prev = params[--shift];
+            }
+            if (prev) {
+              node.source.end = this.getPosition(prev[3] || prev[2]);
+              node.source.end.offset++;
+            }
+          }
+          this.end(token);
           break
+        } else {
+          params.push(token);
+        }
+      } else {
+        params.push(token);
+      }
 
-        default:
-          this.other(token);
-          break
+      if (this.tokenizer.endOfFile()) {
+        last = true;
+        break
       }
     }
-    this.endFile();
+
+    node.raws.between = this.spacesAndCommentsFromEnd(params);
+    if (params.length) {
+      node.raws.afterName = this.spacesAndCommentsFromStart(params);
+      this.raw(node, 'params', params);
+      if (last) {
+        token = params[params.length - 1];
+        node.source.end = this.getPosition(token[3] || token[2]);
+        node.source.end.offset++;
+        this.spaces = node.raws.between;
+        node.raws.between = '';
+      }
+    } else {
+      node.raws.afterName = '';
+      node.params = '';
+    }
+
+    if (open) {
+      node.nodes = [];
+      this.current = node;
+    }
+  }
+
+  checkMissedSemicolon(tokens) {
+    let colon = this.colon(tokens);
+    if (colon === false) return
+
+    let founded = 0;
+    let token;
+    for (let j = colon - 1; j >= 0; j--) {
+      token = tokens[j];
+      if (token[0] !== 'space') {
+        founded += 1;
+        if (founded === 2) break
+      }
+    }
+    // If the token is a word, e.g. `!important`, `red` or any other valid property's value.
+    // Then we need to return the colon after that word token. [3] is the "end" colon of that word.
+    // And because we need it after that one we do +1 to get the next one.
+    throw this.input.error(
+      'Missed semicolon',
+      token[0] === 'word' ? token[3] + 1 : token[2]
+    )
+  }
+
+  colon(tokens) {
+    let brackets = 0;
+    let token, type, prev;
+    for (let [i, element] of tokens.entries()) {
+      token = element;
+      type = token[0];
+
+      if (type === '(') {
+        brackets += 1;
+      }
+      if (type === ')') {
+        brackets -= 1;
+      }
+      if (brackets === 0 && type === ':') {
+        if (!prev) {
+          this.doubleColon(token);
+        } else if (prev[0] === 'word' && prev[1] === 'progid') {
+          continue
+        } else {
+          return i
+        }
+      }
+
+      prev = token;
+    }
+    return false
   }
 
   comment(token) {
     let node = new comment();
     this.init(node, token[2]);
     node.source.end = this.getPosition(token[3] || token[2]);
+    node.source.end.offset++;
 
     let text = token[1].slice(2, -2);
     if (/^\s*$/.test(text)) {
@@ -7242,86 +7360,8 @@ class Parser {
     }
   }
 
-  emptyRule(token) {
-    let node = new rule();
-    this.init(node, token[2]);
-    node.selector = '';
-    node.raws.between = '';
-    this.current = node;
-  }
-
-  other(start) {
-    let end = false;
-    let type = null;
-    let colon = false;
-    let bracket = null;
-    let brackets = [];
-    let customProperty = start[1].startsWith('--');
-
-    let tokens = [];
-    let token = start;
-    while (token) {
-      type = token[0];
-      tokens.push(token);
-
-      if (type === '(' || type === '[') {
-        if (!bracket) bracket = token;
-        brackets.push(type === '(' ? ')' : ']');
-      } else if (customProperty && colon && type === '{') {
-        if (!bracket) bracket = token;
-        brackets.push('}');
-      } else if (brackets.length === 0) {
-        if (type === ';') {
-          if (colon) {
-            this.decl(tokens, customProperty);
-            return
-          } else {
-            break
-          }
-        } else if (type === '{') {
-          this.rule(tokens);
-          return
-        } else if (type === '}') {
-          this.tokenizer.back(tokens.pop());
-          end = true;
-          break
-        } else if (type === ':') {
-          colon = true;
-        }
-      } else if (type === brackets[brackets.length - 1]) {
-        brackets.pop();
-        if (brackets.length === 0) bracket = null;
-      }
-
-      token = this.tokenizer.nextToken();
-    }
-
-    if (this.tokenizer.endOfFile()) end = true;
-    if (brackets.length > 0) this.unclosedBracket(bracket);
-
-    if (end && colon) {
-      if (!customProperty) {
-        while (tokens.length) {
-          token = tokens[tokens.length - 1][0];
-          if (token !== 'space' && token !== 'comment') break
-          this.tokenizer.back(tokens.pop());
-        }
-      }
-      this.decl(tokens, customProperty);
-    } else {
-      this.unknownWord(tokens);
-    }
-  }
-
-  rule(tokens) {
-    tokens.pop();
-
-    let node = new rule();
-    this.init(node, tokens[0][2]);
-
-    node.raws.between = this.spacesAndCommentsFromEnd(tokens);
-    this.raw(node, 'selector', tokens);
-    this.current = node;
+  createTokenizer() {
+    this.tokenizer = tokenize(this.input);
   }
 
   decl(tokens, customProperty) {
@@ -7337,6 +7377,7 @@ class Parser {
     node.source.end = this.getPosition(
       last[3] || last[2] || findLastWithPosition(tokens)
     );
+    node.source.end.offset++;
 
     while (tokens[0][0] !== 'word') {
       if (tokens.length === 1) this.unknownWord(tokens);
@@ -7428,145 +7469,185 @@ class Parser {
     }
   }
 
-  atrule(token) {
-    let node = new atRule();
-    node.name = token[1].slice(1);
-    if (node.name === '') {
-      this.unnamedAtrule(node, token);
-    }
+  doubleColon(token) {
+    throw this.input.error(
+      'Double colon',
+      { offset: token[2] },
+      { offset: token[2] + token[1].length }
+    )
+  }
+
+  emptyRule(token) {
+    let node = new rule();
     this.init(node, token[2]);
+    node.selector = '';
+    node.raws.between = '';
+    this.current = node;
+  }
 
-    let type;
-    let prev;
-    let shift;
-    let last = false;
-    let open = false;
-    let params = [];
-    let brackets = [];
+  end(token) {
+    if (this.current.nodes && this.current.nodes.length) {
+      this.current.raws.semicolon = this.semicolon;
+    }
+    this.semicolon = false;
 
-    while (!this.tokenizer.endOfFile()) {
-      token = this.tokenizer.nextToken();
-      type = token[0];
+    this.current.raws.after = (this.current.raws.after || '') + this.spaces;
+    this.spaces = '';
 
-      if (type === '(' || type === '[') {
-        brackets.push(type === '(' ? ')' : ']');
-      } else if (type === '{' && brackets.length > 0) {
-        brackets.push('}');
-      } else if (type === brackets[brackets.length - 1]) {
-        brackets.pop();
+    if (this.current.parent) {
+      this.current.source.end = this.getPosition(token[2]);
+      this.current.source.end.offset++;
+      this.current = this.current.parent;
+    } else {
+      this.unexpectedClose(token);
+    }
+  }
+
+  endFile() {
+    if (this.current.parent) this.unclosedBlock();
+    if (this.current.nodes && this.current.nodes.length) {
+      this.current.raws.semicolon = this.semicolon;
+    }
+    this.current.raws.after = (this.current.raws.after || '') + this.spaces;
+    this.root.source.end = this.getPosition(this.tokenizer.position());
+  }
+
+  freeSemicolon(token) {
+    this.spaces += token[1];
+    if (this.current.nodes) {
+      let prev = this.current.nodes[this.current.nodes.length - 1];
+      if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {
+        prev.raws.ownSemicolon = this.spaces;
+        this.spaces = '';
       }
+    }
+  }
 
-      if (brackets.length === 0) {
-        if (type === ';') {
-          node.source.end = this.getPosition(token[2]);
-          this.semicolon = true;
-          break
-        } else if (type === '{') {
-          open = true;
-          break
-        } else if (type === '}') {
-          if (params.length > 0) {
-            shift = params.length - 1;
-            prev = params[shift];
-            while (prev && prev[0] === 'space') {
-              prev = params[--shift];
-            }
-            if (prev) {
-              node.source.end = this.getPosition(prev[3] || prev[2]);
-            }
+  // Helpers
+
+  getPosition(offset) {
+    let pos = this.input.fromOffset(offset);
+    return {
+      column: pos.col,
+      line: pos.line,
+      offset
+    }
+  }
+
+  init(node, offset) {
+    this.current.push(node);
+    node.source = {
+      input: this.input,
+      start: this.getPosition(offset)
+    };
+    node.raws.before = this.spaces;
+    this.spaces = '';
+    if (node.type !== 'comment') this.semicolon = false;
+  }
+
+  other(start) {
+    let end = false;
+    let type = null;
+    let colon = false;
+    let bracket = null;
+    let brackets = [];
+    let customProperty = start[1].startsWith('--');
+
+    let tokens = [];
+    let token = start;
+    while (token) {
+      type = token[0];
+      tokens.push(token);
+
+      if (type === '(' || type === '[') {
+        if (!bracket) bracket = token;
+        brackets.push(type === '(' ? ')' : ']');
+      } else if (customProperty && colon && type === '{') {
+        if (!bracket) bracket = token;
+        brackets.push('}');
+      } else if (brackets.length === 0) {
+        if (type === ';') {
+          if (colon) {
+            this.decl(tokens, customProperty);
+            return
+          } else {
+            break
           }
-          this.end(token);
+        } else if (type === '{') {
+          this.rule(tokens);
+          return
+        } else if (type === '}') {
+          this.tokenizer.back(tokens.pop());
+          end = true;
           break
-        } else {
-          params.push(token);
+        } else if (type === ':') {
+          colon = true;
         }
-      } else {
-        params.push(token);
+      } else if (type === brackets[brackets.length - 1]) {
+        brackets.pop();
+        if (brackets.length === 0) bracket = null;
       }
 
-      if (this.tokenizer.endOfFile()) {
-        last = true;
-        break
-      }
+      token = this.tokenizer.nextToken();
     }
 
-    node.raws.between = this.spacesAndCommentsFromEnd(params);
-    if (params.length) {
-      node.raws.afterName = this.spacesAndCommentsFromStart(params);
-      this.raw(node, 'params', params);
-      if (last) {
-        token = params[params.length - 1];
-        node.source.end = this.getPosition(token[3] || token[2]);
-        this.spaces = node.raws.between;
-        node.raws.between = '';
+    if (this.tokenizer.endOfFile()) end = true;
+    if (brackets.length > 0) this.unclosedBracket(bracket);
+
+    if (end && colon) {
+      if (!customProperty) {
+        while (tokens.length) {
+          token = tokens[tokens.length - 1][0];
+          if (token !== 'space' && token !== 'comment') break
+          this.tokenizer.back(tokens.pop());
+        }
       }
+      this.decl(tokens, customProperty);
     } else {
-      node.raws.afterName = '';
-      node.params = '';
-    }
-
-    if (open) {
-      node.nodes = [];
-      this.current = node;
+      this.unknownWord(tokens);
     }
   }
 
-  end(token) {
-    if (this.current.nodes && this.current.nodes.length) {
-      this.current.raws.semicolon = this.semicolon;
-    }
-    this.semicolon = false;
+  parse() {
+    let token;
+    while (!this.tokenizer.endOfFile()) {
+      token = this.tokenizer.nextToken();
 
-    this.current.raws.after = (this.current.raws.after || '') + this.spaces;
-    this.spaces = '';
+      switch (token[0]) {
+        case 'space':
+          this.spaces += token[1];
+          break
 
-    if (this.current.parent) {
-      this.current.source.end = this.getPosition(token[2]);
-      this.current = this.current.parent;
-    } else {
-      this.unexpectedClose(token);
-    }
-  }
+        case ';':
+          this.freeSemicolon(token);
+          break
 
-  endFile() {
-    if (this.current.parent) this.unclosedBlock();
-    if (this.current.nodes && this.current.nodes.length) {
-      this.current.raws.semicolon = this.semicolon;
-    }
-    this.current.raws.after = (this.current.raws.after || '') + this.spaces;
-  }
+        case '}':
+          this.end(token);
+          break
 
-  freeSemicolon(token) {
-    this.spaces += token[1];
-    if (this.current.nodes) {
-      let prev = this.current.nodes[this.current.nodes.length - 1];
-      if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {
-        prev.raws.ownSemicolon = this.spaces;
-        this.spaces = '';
-      }
-    }
-  }
+        case 'comment':
+          this.comment(token);
+          break
 
-  // Helpers
+        case 'at-word':
+          this.atrule(token);
+          break
 
-  getPosition(offset) {
-    let pos = this.input.fromOffset(offset);
-    return {
-      offset,
-      line: pos.line,
-      column: pos.col
+        case '{':
+          this.emptyRule(token);
+          break
+
+        default:
+          this.other(token);
+          break
+      }
     }
+    this.endFile();
   }
 
-  init(node, offset) {
-    this.current.push(node);
-    node.source = {
-      start: this.getPosition(offset),
-      input: this.input
-    };
-    node.raws.before = this.spaces;
-    this.spaces = '';
-    if (node.type !== 'comment') this.semicolon = false;
+  precheckMissedSemicolon(/* tokens */) {
+    // Hook for Safe Parser
   }
 
   raw(node, prop, tokens, customProperty) {
@@ -7599,11 +7680,22 @@ class Parser {
     }
     if (!clean) {
       let raw = tokens.reduce((all, i) => all + i[1], '');
-      node.raws[prop] = { value, raw };
+      node.raws[prop] = { raw, value };
     }
     node[prop] = value;
   }
 
+  rule(tokens) {
+    tokens.pop();
+
+    let node = new rule();
+    this.init(node, tokens[0][2]);
+
+    node.raws.between = this.spacesAndCommentsFromEnd(tokens);
+    this.raw(node, 'selector', tokens);
+    this.current = node;
+  }
+
   spacesAndCommentsFromEnd(tokens) {
     let lastTokenType;
     let spaces = '';
@@ -7615,6 +7707,8 @@ class Parser {
     return spaces
   }
 
+  // Errors
+
   spacesAndCommentsFromStart(tokens) {
     let next;
     let spaces = '';
@@ -7646,36 +7740,11 @@ class Parser {
     return result
   }
 
-  colon(tokens) {
-    let brackets = 0;
-    let token, type, prev;
-    for (let [i, element] of tokens.entries()) {
-      token = element;
-      type = token[0];
-
-      if (type === '(') {
-        brackets += 1;
-      }
-      if (type === ')') {
-        brackets -= 1;
-      }
-      if (brackets === 0 && type === ':') {
-        if (!prev) {
-          this.doubleColon(token);
-        } else if (prev[0] === 'word' && prev[1] === 'progid') {
-          continue
-        } else {
-          return i
-        }
-      }
-
-      prev = token;
-    }
-    return false
+  unclosedBlock() {
+    let pos = this.current.source.start;
+    throw this.input.error('Unclosed block', pos.line, pos.column)
   }
 
-  // Errors
-
   unclosedBracket(bracket) {
     throw this.input.error(
       'Unclosed bracket',
@@ -7684,14 +7753,6 @@ class Parser {
     )
   }
 
-  unknownWord(tokens) {
-    throw this.input.error(
-      'Unknown word',
-      { offset: tokens[0][2] },
-      { offset: tokens[0][2] + tokens[0][1].length }
-    )
-  }
-
   unexpectedClose(token) {
     throw this.input.error(
       'Unexpected }',
@@ -7700,16 +7761,11 @@ class Parser {
     )
   }
 
-  unclosedBlock() {
-    let pos = this.current.source.start;
-    throw this.input.error('Unclosed block', pos.line, pos.column)
-  }
-
-  doubleColon(token) {
+  unknownWord(tokens) {
     throw this.input.error(
-      'Double colon',
-      { offset: token[2] },
-      { offset: token[2] + token[1].length }
+      'Unknown word',
+      { offset: tokens[0][2] },
+      { offset: tokens[0][2] + tokens[0][1].length }
     )
   }
 
@@ -7720,43 +7776,17 @@ class Parser {
       { offset: token[2] + token[1].length }
     )
   }
+}
 
-  precheckMissedSemicolon(/* tokens */) {
-    // Hook for Safe Parser
-  }
-
-  checkMissedSemicolon(tokens) {
-    let colon = this.colon(tokens);
-    if (colon === false) return
-
-    let founded = 0;
-    let token;
-    for (let j = colon - 1; j >= 0; j--) {
-      token = tokens[j];
-      if (token[0] !== 'space') {
-        founded += 1;
-        if (founded === 2) break
-      }
-    }
-    // If the token is a word, e.g. `!important`, `red` or any other valid property's value.
-    // Then we need to return the colon after that word token. [3] is the "end" colon of that word.
-    // And because we need it after that one we do +1 to get the next one.
-    throw this.input.error(
-      'Missed semicolon',
-      token[0] === 'word' ? token[3] + 1 : token[2]
-    )
-  }
-}
-
-var parser = Parser;
-
-function parse(css, opts) {
-  let input$1 = new input(css, opts);
-  let parser$1 = new parser(input$1);
-  try {
-    parser$1.parse();
-  } catch (e) {
-    throw e
+var parser = Parser;
+
+function parse(css, opts) {
+  let input$1 = new input(css, opts);
+  let parser$1 = new parser(input$1);
+  try {
+    parser$1.parse();
+  } catch (e) {
+    throw e
   }
 
   return parser$1.root
@@ -7778,37 +7808,37 @@ let { isClean, my } = symbols;
 
 
 const TYPE_TO_CLASS_NAME = {
-  document: 'Document',
-  root: 'Root',
   atrule: 'AtRule',
-  rule: 'Rule',
+  comment: 'Comment',
   decl: 'Declaration',
-  comment: 'Comment'
+  document: 'Document',
+  root: 'Root',
+  rule: 'Rule'
 };
 
 const PLUGIN_PROPS = {
-  postcssPlugin: true,
-  prepare: true,
-  Once: true,
-  Document: true,
-  Root: true,
-  Declaration: true,
-  Rule: true,
   AtRule: true,
-  Comment: true,
-  DeclarationExit: true,
-  RuleExit: true,
   AtRuleExit: true,
+  Comment: true,
   CommentExit: true,
-  RootExit: true,
+  Declaration: true,
+  DeclarationExit: true,
+  Document: true,
   DocumentExit: true,
-  OnceExit: true
+  Once: true,
+  OnceExit: true,
+  postcssPlugin: true,
+  prepare: true,
+  Root: true,
+  RootExit: true,
+  Rule: true,
+  RuleExit: true
 };
 
 const NOT_VISITORS = {
+  Once: true,
   postcssPlugin: true,
-  prepare: true,
-  Once: true
+  prepare: true
 };
 
 const CHILDREN = 0;
@@ -7854,12 +7884,12 @@ function toStack(node) {
   }
 
   return {
-    node,
-    events,
     eventIndex: 0,
-    visitors: [],
+    events,
+    iterator: 0,
+    node,
     visitorIndex: 0,
-    iterator: 0
+    visitors: []
   }
 }
 
@@ -7910,7 +7940,7 @@ class LazyResult {
     }
 
     this.result = new result(processor, root, opts);
-    this.helpers = { ...postcss$1, result: this.result, postcss: postcss$1 };
+    this.helpers = { ...postcss$1, postcss: postcss$1, result: this.result };
     this.plugins = this.processor.plugins.map(plugin => {
       if (typeof plugin === 'object' && plugin.prepare) {
         return { ...plugin, ...plugin.prepare(this.result) }
@@ -7920,48 +7950,13 @@ class LazyResult {
     });
   }
 
-  get [Symbol.toStringTag]() {
-    return 'LazyResult'
-  }
-
-  get processor() {
-    return this.result.processor
-  }
-
-  get opts() {
-    return this.result.opts
-  }
-
-  get css() {
-    return this.stringify().css
-  }
-
-  get content() {
-    return this.stringify().content
-  }
-
-  get map() {
-    return this.stringify().map
-  }
-
-  get root() {
-    return this.sync().root
-  }
-
-  get messages() {
-    return this.sync().messages
-  }
-
-  warnings() {
-    return this.sync().warnings()
-  }
-
-  toString() {
-    return this.css
-  }
-
-  then(onFulfilled, onRejected) {
-    return this.async().then(onFulfilled, onRejected)
+  async() {
+    if (this.error) return Promise.reject(this.error)
+    if (this.processed) return Promise.resolve(this.result)
+    if (!this.processing) {
+      this.processing = this.runAsync();
+    }
+    return this.processing
   }
 
   catch(onRejected) {
@@ -7972,28 +7967,76 @@ class LazyResult {
     return this.async().then(onFinally, onFinally)
   }
 
-  async() {
-    if (this.error) return Promise.reject(this.error)
-    if (this.processed) return Promise.resolve(this.result)
-    if (!this.processing) {
-      this.processing = this.runAsync();
-    }
-    return this.processing
+  getAsyncError() {
+    throw new Error('Use process(css).then(cb) to work with async plugins')
   }
 
-  sync() {
-    if (this.error) throw this.error
-    if (this.processed) return this.result
-    this.processed = true;
-
-    if (this.processing) {
-      throw this.getAsyncError()
+  handleError(error, node) {
+    let plugin = this.result.lastPlugin;
+    try {
+      if (node) node.addToError(error);
+      this.error = error;
+      if (error.name === 'CssSyntaxError' && !error.plugin) {
+        error.plugin = plugin.postcssPlugin;
+        error.setMessage();
+      }
+    } catch (err) {
+      /* c8 ignore next 3 */
+      // eslint-disable-next-line no-console
+      if (console && console.error) console.error(err);
     }
+    return error
+  }
 
+  prepareVisitors() {
+    this.listeners = {};
+    let add = (plugin, type, cb) => {
+      if (!this.listeners[type]) this.listeners[type] = [];
+      this.listeners[type].push([plugin, cb]);
+    };
     for (let plugin of this.plugins) {
+      if (typeof plugin === 'object') {
+        for (let event in plugin) {
+          if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {
+            throw new Error(
+              `Unknown event ${event} in ${plugin.postcssPlugin}. ` +
+                `Try to update PostCSS (${this.processor.version} now).`
+            )
+          }
+          if (!NOT_VISITORS[event]) {
+            if (typeof plugin[event] === 'object') {
+              for (let filter in plugin[event]) {
+                if (filter === '*') {
+                  add(plugin, event, plugin[event][filter]);
+                } else {
+                  add(
+                    plugin,
+                    event + '-' + filter.toLowerCase(),
+                    plugin[event][filter]
+                  );
+                }
+              }
+            } else if (typeof plugin[event] === 'function') {
+              add(plugin, event, plugin[event]);
+            }
+          }
+        }
+      }
+    }
+    this.hasListener = Object.keys(this.listeners).length > 0;
+  }
+
+  async runAsync() {
+    this.plugin = 0;
+    for (let i = 0; i < this.plugins.length; i++) {
+      let plugin = this.plugins[i];
       let promise = this.runOnRoot(plugin);
       if (isPromise(promise)) {
-        throw this.getAsyncError()
+        try {
+          await promise;
+        } catch (error) {
+          throw this.handleError(error)
+        }
       }
     }
 
@@ -8002,78 +8045,42 @@ class LazyResult {
       let root = this.result.root;
       while (!root[isClean]) {
         root[isClean] = true;
-        this.walkSync(root);
-      }
-      if (this.listeners.OnceExit) {
-        if (root.type === 'document') {
-          for (let subRoot of root.nodes) {
-            this.visitSync(this.listeners.OnceExit, subRoot);
+        let stack = [toStack(root)];
+        while (stack.length > 0) {
+          let promise = this.visitTick(stack);
+          if (isPromise(promise)) {
+            try {
+              await promise;
+            } catch (e) {
+              let node = stack[stack.length - 1].node;
+              throw this.handleError(e, node)
+            }
           }
-        } else {
-          this.visitSync(this.listeners.OnceExit, root);
         }
       }
-    }
-
-    return this.result
-  }
-
-  stringify() {
-    if (this.error) throw this.error
-    if (this.stringified) return this.result
-    this.stringified = true;
-
-    this.sync();
 
-    let opts = this.result.opts;
-    let str = stringify_1;
-    if (opts.syntax) str = opts.syntax.stringify;
-    if (opts.stringifier) str = opts.stringifier;
-    if (str.stringify) str = str.stringify;
-
-    let map = new mapGenerator(str, this.result.root, this.result.opts);
-    let data = map.generate();
-    this.result.css = data[0];
-    this.result.map = data[1];
-
-    return this.result
-  }
+      if (this.listeners.OnceExit) {
+        for (let [plugin, visitor] of this.listeners.OnceExit) {
+          this.result.lastPlugin = plugin;
+          try {
+            if (root.type === 'document') {
+              let roots = root.nodes.map(subRoot =>
+                visitor(subRoot, this.helpers)
+              );
 
-  walkSync(node) {
-    node[isClean] = true;
-    let events = getEvents(node);
-    for (let event of events) {
-      if (event === CHILDREN) {
-        if (node.nodes) {
-          node.each(child => {
-            if (!child[isClean]) this.walkSync(child);
-          });
-        }
-      } else {
-        let visitors = this.listeners[event];
-        if (visitors) {
-          if (this.visitSync(visitors, node.toProxy())) return
+              await Promise.all(roots);
+            } else {
+              await visitor(root, this.helpers);
+            }
+          } catch (e) {
+            throw this.handleError(e)
+          }
         }
       }
     }
-  }
 
-  visitSync(visitors, node) {
-    for (let [plugin, visitor] of visitors) {
-      this.result.lastPlugin = plugin;
-      let promise;
-      try {
-        promise = visitor(node, this.helpers);
-      } catch (e) {
-        throw this.handleError(e, node.proxyOf)
-      }
-      if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
-        return true
-      }
-      if (isPromise(promise)) {
-        throw this.getAsyncError()
-      }
-    }
+    this.processed = true;
+    return this.stringify()
   }
 
   runOnRoot(plugin) {
@@ -8101,120 +8108,88 @@ class LazyResult {
     }
   }
 
-  getAsyncError() {
-    throw new Error('Use process(css).then(cb) to work with async plugins')
+  stringify() {
+    if (this.error) throw this.error
+    if (this.stringified) return this.result
+    this.stringified = true;
+
+    this.sync();
+
+    let opts = this.result.opts;
+    let str = stringify_1;
+    if (opts.syntax) str = opts.syntax.stringify;
+    if (opts.stringifier) str = opts.stringifier;
+    if (str.stringify) str = str.stringify;
+
+    let map = new mapGenerator(str, this.result.root, this.result.opts);
+    let data = map.generate();
+    this.result.css = data[0];
+    this.result.map = data[1];
+
+    return this.result
   }
 
-  handleError(error, node) {
-    let plugin = this.result.lastPlugin;
-    try {
-      if (node) node.addToError(error);
-      this.error = error;
-      if (error.name === 'CssSyntaxError' && !error.plugin) {
-        error.plugin = plugin.postcssPlugin;
-        error.setMessage();
-      }
-    } catch (err) {
-      /* c8 ignore next 3 */
-      // eslint-disable-next-line no-console
-      if (console && console.error) console.error(err);
+  sync() {
+    if (this.error) throw this.error
+    if (this.processed) return this.result
+    this.processed = true;
+
+    if (this.processing) {
+      throw this.getAsyncError()
     }
-    return error
-  }
 
-  async runAsync() {
-    this.plugin = 0;
-    for (let i = 0; i < this.plugins.length; i++) {
-      let plugin = this.plugins[i];
+    for (let plugin of this.plugins) {
       let promise = this.runOnRoot(plugin);
       if (isPromise(promise)) {
-        try {
-          await promise;
-        } catch (error) {
-          throw this.handleError(error)
-        }
+        throw this.getAsyncError()
       }
     }
 
     this.prepareVisitors();
     if (this.hasListener) {
-      let root = this.result.root;
-      while (!root[isClean]) {
-        root[isClean] = true;
-        let stack = [toStack(root)];
-        while (stack.length > 0) {
-          let promise = this.visitTick(stack);
-          if (isPromise(promise)) {
-            try {
-              await promise;
-            } catch (e) {
-              let node = stack[stack.length - 1].node;
-              throw this.handleError(e, node)
-            }
-          }
-        }
+      let root = this.result.root;
+      while (!root[isClean]) {
+        root[isClean] = true;
+        this.walkSync(root);
       }
-
       if (this.listeners.OnceExit) {
-        for (let [plugin, visitor] of this.listeners.OnceExit) {
-          this.result.lastPlugin = plugin;
-          try {
-            if (root.type === 'document') {
-              let roots = root.nodes.map(subRoot =>
-                visitor(subRoot, this.helpers)
-              );
-
-              await Promise.all(roots);
-            } else {
-              await visitor(root, this.helpers);
-            }
-          } catch (e) {
-            throw this.handleError(e)
+        if (root.type === 'document') {
+          for (let subRoot of root.nodes) {
+            this.visitSync(this.listeners.OnceExit, subRoot);
           }
+        } else {
+          this.visitSync(this.listeners.OnceExit, root);
         }
       }
     }
 
-    this.processed = true;
-    return this.stringify()
+    return this.result
   }
 
-  prepareVisitors() {
-    this.listeners = {};
-    let add = (plugin, type, cb) => {
-      if (!this.listeners[type]) this.listeners[type] = [];
-      this.listeners[type].push([plugin, cb]);
-    };
-    for (let plugin of this.plugins) {
-      if (typeof plugin === 'object') {
-        for (let event in plugin) {
-          if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {
-            throw new Error(
-              `Unknown event ${event} in ${plugin.postcssPlugin}. ` +
-                `Try to update PostCSS (${this.processor.version} now).`
-            )
-          }
-          if (!NOT_VISITORS[event]) {
-            if (typeof plugin[event] === 'object') {
-              for (let filter in plugin[event]) {
-                if (filter === '*') {
-                  add(plugin, event, plugin[event][filter]);
-                } else {
-                  add(
-                    plugin,
-                    event + '-' + filter.toLowerCase(),
-                    plugin[event][filter]
-                  );
-                }
-              }
-            } else if (typeof plugin[event] === 'function') {
-              add(plugin, event, plugin[event]);
-            }
-          }
-        }
+  then(onFulfilled, onRejected) {
+    return this.async().then(onFulfilled, onRejected)
+  }
+
+  toString() {
+    return this.css
+  }
+
+  visitSync(visitors, node) {
+    for (let [plugin, visitor] of visitors) {
+      this.result.lastPlugin = plugin;
+      let promise;
+      try {
+        promise = visitor(node, this.helpers);
+      } catch (e) {
+        throw this.handleError(e, node.proxyOf)
+      }
+      if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
+        return true
+      }
+      if (isPromise(promise)) {
+        throw this.getAsyncError()
       }
     }
-    this.hasListener = Object.keys(this.listeners).length > 0;
   }
 
   visitTick(stack) {
@@ -8273,6 +8248,61 @@ class LazyResult {
     }
     stack.pop();
   }
+
+  walkSync(node) {
+    node[isClean] = true;
+    let events = getEvents(node);
+    for (let event of events) {
+      if (event === CHILDREN) {
+        if (node.nodes) {
+          node.each(child => {
+            if (!child[isClean]) this.walkSync(child);
+          });
+        }
+      } else {
+        let visitors = this.listeners[event];
+        if (visitors) {
+          if (this.visitSync(visitors, node.toProxy())) return
+        }
+      }
+    }
+  }
+
+  warnings() {
+    return this.sync().warnings()
+  }
+
+  get content() {
+    return this.stringify().content
+  }
+
+  get css() {
+    return this.stringify().css
+  }
+
+  get map() {
+    return this.stringify().map
+  }
+
+  get messages() {
+    return this.sync().messages
+  }
+
+  get opts() {
+    return this.result.opts
+  }
+
+  get processor() {
+    return this.result.processor
+  }
+
+  get root() {
+    return this.sync().root
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'LazyResult'
+  }
 }
 
 LazyResult.registerPostcss = dependant => {
@@ -8319,30 +8349,61 @@ class NoWorkResult {
     }
   }
 
-  get [Symbol.toStringTag]() {
-    return 'NoWorkResult'
+  async() {
+    if (this.error) return Promise.reject(this.error)
+    return Promise.resolve(this.result)
   }
 
-  get processor() {
-    return this.result.processor
+  catch(onRejected) {
+    return this.async().catch(onRejected)
   }
 
-  get opts() {
-    return this.result.opts
+  finally(onFinally) {
+    return this.async().then(onFinally, onFinally)
   }
 
-  get css() {
-    return this.result.css
+  sync() {
+    if (this.error) throw this.error
+    return this.result
+  }
+
+  then(onFulfilled, onRejected) {
+
+    return this.async().then(onFulfilled, onRejected)
+  }
+
+  toString() {
+    return this._css
+  }
+
+  warnings() {
+    return []
   }
 
   get content() {
     return this.result.css
   }
 
+  get css() {
+    return this.result.css
+  }
+
   get map() {
     return this.result.map
   }
 
+  get messages() {
+    return []
+  }
+
+  get opts() {
+    return this.result.opts
+  }
+
+  get processor() {
+    return this.result.processor
+  }
+
   get root() {
     if (this._root) {
       return this._root
@@ -8365,39 +8426,8 @@ class NoWorkResult {
     }
   }
 
-  get messages() {
-    return []
-  }
-
-  warnings() {
-    return []
-  }
-
-  toString() {
-    return this._css
-  }
-
-  then(onFulfilled, onRejected) {
-
-    return this.async().then(onFulfilled, onRejected)
-  }
-
-  catch(onRejected) {
-    return this.async().catch(onRejected)
-  }
-
-  finally(onFinally) {
-    return this.async().then(onFinally, onFinally)
-  }
-
-  async() {
-    if (this.error) return Promise.reject(this.error)
-    return Promise.resolve(this.result)
-  }
-
-  sync() {
-    if (this.error) throw this.error
-    return this.result
+  get [Symbol.toStringTag]() {
+    return 'NoWorkResult'
   }
 }
 
@@ -8406,28 +8436,10 @@ NoWorkResult.default = NoWorkResult;
 
 class Processor {
   constructor(plugins = []) {
-    this.version = '8.4.24';
+    this.version = '8.4.31';
     this.plugins = this.normalize(plugins);
   }
 
-  use(plugin) {
-    this.plugins = this.plugins.concat(this.normalize([plugin]));
-    return this
-  }
-
-  process(css, opts = {}) {
-    if (
-      this.plugins.length === 0 &&
-      typeof opts.parser === 'undefined' &&
-      typeof opts.stringifier === 'undefined' &&
-      typeof opts.syntax === 'undefined'
-    ) {
-      return new noWorkResult(this, css, opts)
-    } else {
-      return new lazyResult(this, css, opts)
-    }
-  }
-
   normalize(plugins) {
     let normalized = [];
     for (let i of plugins) {
@@ -8449,6 +8461,24 @@ class Processor {
     }
     return normalized
   }
+
+  process(css, opts = {}) {
+    if (
+      this.plugins.length === 0 &&
+      typeof opts.parser === 'undefined' &&
+      typeof opts.stringifier === 'undefined' &&
+      typeof opts.syntax === 'undefined'
+    ) {
+      return new noWorkResult(this, css, opts)
+    } else {
+      return new lazyResult(this, css, opts)
+    }
+  }
+
+  use(plugin) {
+    this.plugins = this.plugins.concat(this.normalize([plugin]));
+    return this
+  }
 }
 
 var processor = Processor;