@everymatrix/general-footer-template 1.28.7 → 1.28.8

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

@@ -4621,7 +4621,7 @@ class CssSyntaxError extends Error {
 
     let mark, aside;
     if (color) {
-      let { bold, gray, red } = picocolors_browser.createColors(true);
+      let { bold, red, gray } = picocolors_browser.createColors(true);
       mark = text => bold(red(text));
       aside = text => gray(text);
     } else {
@@ -4666,17 +4666,17 @@ var symbols = {
 };
 
 const DEFAULT_RAW = {
-  after: '\n',
-  beforeClose: '\n',
-  beforeComment: '\n',
+  colon: ': ',
+  indent: '    ',
   beforeDecl: '\n',
-  beforeOpen: ' ',
   beforeRule: '\n',
-  colon: ': ',
+  beforeOpen: ' ',
+  beforeClose: '\n',
+  beforeComment: '\n',
+  after: '\n',
+  emptyBody: '',
   commentLeft: ' ',
   commentRight: ' ',
-  emptyBody: '',
-  indent: '    ',
   semicolon: false
 };
 
@@ -4689,6 +4689,54 @@ 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') : '';
@@ -4707,51 +4755,6 @@ class Stringifier {
     }
   }
 
-  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 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) {
-    let between = this.raw(node, 'between', 'beforeOpen');
-    this.builder(start + between + '{', node, 'start');
-
-    let after;
-    if (node.nodes && node.nodes.length) {
-      this.body(node);
-      after = this.raw(node, 'after');
-    } else {
-      after = this.raw(node, 'after', 'emptyBody');
-    }
-
-    if (after) this.builder(after);
-    this.builder('}', node, 'end');
-  }
-
   body(node) {
     let last = node.nodes.length - 1;
     while (last > 0) {
@@ -4768,26 +4771,20 @@ class Stringifier {
     }
   }
 
-  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');
+  block(node, start) {
+    let between = this.raw(node, 'between', 'beforeOpen');
+    this.builder(start + between + '{', node, 'start');
 
-    if (node.important) {
-      string += node.raws.important || ' !important';
+    let after;
+    if (node.nodes && node.nodes.length) {
+      this.body(node);
+      after = this.raw(node, 'after');
+    } else {
+      after = this.raw(node, 'after', 'emptyBody');
     }
 
-    if (semicolon) string += ';';
-    this.builder(string, node);
-  }
-
-  document(node) {
-    this.body(node);
+    if (after) this.builder(after);
+    this.builder('}', node, 'end');
   }
 
   raw(node, own, detect) {
@@ -4844,20 +4841,42 @@ class Stringifier {
     return value
   }
 
-  rawBeforeClose(root) {
+  rawSemicolon(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]+$/, '');
-          }
+      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
+    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, '');
           return false
         }
       }
     });
-    if (value) value = value.replace(/\S/g, '');
     return value
   }
 
@@ -4899,17 +4918,6 @@ 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 => {
@@ -4927,53 +4935,71 @@ class Stringifier {
     return value
   }
 
-  rawColon(root) {
+  rawBeforeClose(root) {
     let value;
-    root.walkDecls(i => {
-      if (typeof i.raws.between !== 'undefined') {
-        value = i.raws.between.replace(/[^\s:]/g, '');
-        return false
+    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
+        }
       }
     });
+    if (value) value = value.replace(/\S/g, '');
     return value
   }
 
-  rawEmptyBody(root) {
+  rawBeforeOpen(root) {
     let value;
     root.walk(i => {
-      if (i.nodes && i.nodes.length === 0) {
-        value = i.raws.after;
+      if (i.type !== 'decl') {
+        value = i.raws.between;
         if (typeof value !== 'undefined') return false
       }
     });
     return value
   }
 
-  rawIndent(root) {
-    if (root.raws.indent) return root.raws.indent
+  rawColon(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, '');
-          return false
-        }
+    root.walkDecls(i => {
+      if (typeof i.raws.between !== 'undefined') {
+        value = i.raws.between.replace(/[^\s:]/g, '');
+        return false
       }
     });
     return value
   }
 
-  rawSemicolon(root) {
+  beforeAfter(node, detect) {
     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
+    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;
       }
-    });
+    }
+
     return value
   }
 
@@ -4986,33 +5012,7 @@ class Stringifier {
 
     return value
   }
-
-  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;
@@ -5079,39 +5079,47 @@ class Node {
     }
   }
 
-  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}$&`
-      );
+  error(message, opts = {}) {
+    if (this.source) {
+      let { start, end } = this.rangeBy(opts);
+      return this.source.input.error(
+        message,
+        { line: start.line, column: start.column },
+        { line: end.line, column: end.column },
+        opts
+      )
     }
-    return error
+    return new cssSyntaxError(message)
   }
 
-  after(add) {
-    this.parent.insertAfter(this, add);
-    return this
+  warn(result, text, opts) {
+    let data = { node: this };
+    for (let i in opts) data[i] = opts[i];
+    return result.warn(text, data)
   }
 
-  assign(overrides = {}) {
-    for (let name in overrides) {
-      this[name] = overrides[name];
+  remove() {
+    if (this.parent) {
+      this.parent.removeChild(this);
     }
+    this.parent = undefined;
     return this
   }
 
-  before(add) {
-    this.parent.insertBefore(this, add);
-    return this
+  toString(stringifier = stringify_1) {
+    if (stringifier.stringify) stringifier = stringifier.stringify;
+    let result = '';
+    stringifier(this, i => {
+      result += i;
+    });
+    return result
   }
 
-  cleanRaws(keepBetween) {
-    delete this.raws.before;
-    delete this.raws.after;
-    if (!keepBetween) delete this.raws.between;
+  assign(overrides = {}) {
+    for (let name in overrides) {
+      this[name] = overrides[name];
+    }
+    return this
   }
 
   clone(overrides = {}) {
@@ -5122,70 +5130,39 @@ class Node {
     return cloned
   }
 
-  cloneAfter(overrides = {}) {
-    let cloned = this.clone(overrides);
-    this.parent.insertAfter(this, cloned);
-    return cloned
-  }
-
   cloneBefore(overrides = {}) {
     let cloned = this.clone(overrides);
     this.parent.insertBefore(this, cloned);
     return cloned
   }
 
-  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)
+  cloneAfter(overrides = {}) {
+    let cloned = this.clone(overrides);
+    this.parent.insertAfter(this, cloned);
+    return cloned
   }
 
-  getProxyProcessor() {
-    return {
-      get(node, prop) {
-        if (prop === 'proxyOf') {
-          return node
-        } else if (prop === 'root') {
-          return () => node.root().toProxy()
+  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 {
-          return node[prop]
-        }
-      },
-
-      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();
+          this.parent.insertBefore(bookmark, node);
         }
-        return true
       }
-    }
-  }
 
-  markDirty() {
-    if (this[isClean$2]) {
-      this[isClean$2] = false;
-      let next = this;
-      while ((next = next.parent)) {
-        next[isClean$2] = false;
+      if (!foundSelf) {
+        this.remove();
       }
     }
+
+    return this
   }
 
   next() {
@@ -5194,128 +5171,19 @@ 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]
   }
 
-  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;
+  before(add) {
+    this.parent.insertBefore(this, add);
     return this
   }
 
-  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();
-      }
-    }
-
+  after(add) {
+    this.parent.insertAfter(this, add);
     return this
   }
 
@@ -5327,6 +5195,17 @@ 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;
@@ -5359,9 +5238,9 @@ class Node {
           inputsNextIndex++;
         }
         fixed[name] = {
-          end: value.end,
           inputId,
-          start: value.start
+          start: value.start,
+          end: value.end
         };
       } else {
         fixed[name] = value;
@@ -5375,26 +5254,145 @@ class Node {
     return fixed
   }
 
-  toProxy() {
-    if (!this.proxyCache) {
-      this.proxyCache = new Proxy(this, this.getProxyProcessor());
-    }
-    return this.proxyCache
-  }
+  positionInside(index) {
+    let string = this.toString();
+    let column = this.source.start.column;
+    let line = this.source.start.line;
 
-  toString(stringifier = stringify_1) {
-    if (stringifier.stringify) stringifier = stringifier.stringify;
-    let result = '';
-    stringifier(this, i => {
-      result += i;
-    });
-    return result
+    for (let i = 0; i < index; i++) {
+      if (string[i] === '\n') {
+        column = 1;
+        line += 1;
+      } else {
+        column += 1;
+      }
+    }
+
+    return { line, column }
   }
 
-  warn(result, text, opts) {
-    let data = { node: this };
-    for (let i in opts) data[i] = opts[i];
-    return result.warn(text, data)
+  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
+  }
+
+  markDirty() {
+    if (this[isClean$2]) {
+      this[isClean$2] = false;
+      let next = this;
+      while ((next = next.parent)) {
+        next[isClean$2] = false;
+      }
+    }
   }
 
   get proxyOf() {
@@ -5488,37 +5486,22 @@ class PreviousMap {
     return this.consumerCache
   }
 
-  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))
-    }
+  withContent() {
+    return !!(
+      this.consumer().sourcesContent &&
+      this.consumer().sourcesContent.length > 0
+    )
+  }
 
-    let encoding = text.match(/data:application\/json;([^,]+),/)[1];
-    throw new Error('Unsupported source map encoding ' + encoding)
+  startWith(string, start) {
+    if (!string) return false
+    return string.substr(0, start.length) === start
   }
 
   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
@@ -5533,6 +5516,24 @@ 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)) {
@@ -5578,15 +5579,12 @@ class PreviousMap {
     }
   }
 
-  startWith(string, start) {
-    if (!string) return false
-    return string.substr(0, start.length) === start
-  }
-
-  withContent() {
-    return !!(
-      this.consumer().sourcesContent &&
-      this.consumer().sourcesContent.length > 0
+  isMap(map) {
+    if (typeof map !== 'object') return false
+    return (
+      typeof map.mappings === 'string' ||
+      typeof map._mappings === 'string' ||
+      Array.isArray(map.sections)
     )
   }
 }
@@ -5598,7 +5596,7 @@ const require$$3 = /*@__PURE__*/getAugmentedNamespace(nonSecure);
 
 let { SourceMapConsumer: SourceMapConsumer$1, SourceMapGenerator: SourceMapGenerator$1 } = require$$2;
 let { fileURLToPath, pathToFileURL: pathToFileURL$1 } = require$$2;
-let { isAbsolute, resolve: resolve$1 } = require$$2;
+let { resolve: resolve$1, isAbsolute } = require$$2;
 let { nanoid } = require$$3;
 
 
@@ -5656,6 +5654,48 @@ 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;
 
@@ -5690,10 +5730,10 @@ class Input {
         message,
         origin.endLine === undefined
           ? origin.line
-          : { column: origin.column, line: origin.line },
+          : { line: origin.line, column: origin.column },
         origin.endLine === undefined
           ? origin.column
-          : { column: origin.endColumn, line: origin.endLine },
+          : { line: origin.endLine, column: origin.endColumn },
         origin.source,
         origin.file,
         opts.plugin
@@ -5701,15 +5741,15 @@ class Input {
     } else {
       result = new cssSyntaxError(
         message,
-        endLine === undefined ? line : { column, line },
-        endLine === undefined ? column : { column: endColumn, line: endLine },
+        endLine === undefined ? line : { line, column },
+        endLine === undefined ? column : { line: endLine, column: endColumn },
         this.css,
         this.file,
         opts.plugin
       );
     }
 
-    result.input = { column, endColumn, endLine, line, source: this.css };
+    result.input = { line, column, endLine, endColumn, source: this.css };
     if (this.file) {
       if (pathToFileURL$1) {
         result.input.url = pathToFileURL$1(this.file).toString();
@@ -5720,71 +5760,22 @@ class Input {
     return result
   }
 
-  fromOffset(offset) {
-    let lastLine, lineToIndex;
-    if (!this[fromOffsetCache]) {
-      let lines = this.css.split('\n');
-      lineToIndex = new Array(lines.length);
-      let prevIndex = 0;
+  origin(line, column, endLine, endColumn) {
+    if (!this.map) return false
+    let consumer = this.map.consumer();
 
-      for (let i = 0, l = lines.length; i < l; i++) {
-        lineToIndex[i] = prevIndex;
-        prevIndex += lines[i].length + 1;
-      }
+    let from = consumer.originalPositionFor({ line, column });
+    if (!from.source) return false
 
-      this[fromOffsetCache] = lineToIndex;
-    } else {
-      lineToIndex = this[fromOffsetCache];
+    let to;
+    if (typeof endLine === 'number') {
+      to = consumer.originalPositionFor({ line: endLine, column: endColumn });
     }
-    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 {
-      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);
+    let fromUrl;
+
+    if (isAbsolute(from.source)) {
+      fromUrl = pathToFileURL$1(from.source);
     } else {
       fromUrl = new URL(
         from.source,
@@ -5793,11 +5784,11 @@ class Input {
     }
 
     let result = {
+      url: fromUrl.toString(),
+      line: from.line,
       column: from.column,
-      endColumn: to && to.column,
       endLine: to && to.line,
-      line: from.line,
-      url: fromUrl.toString()
+      endColumn: to && to.column
     };
 
     if (fromUrl.protocol === 'file:') {
@@ -5815,6 +5806,17 @@ 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']) {
@@ -5830,10 +5832,6 @@ class Input {
     }
     return json
   }
-
-  get from() {
-    return this.file || this.id
-  }
 }
 
 var input = Input;
@@ -5844,7 +5842,7 @@ if (require$$2 && require$$2.registerInput) {
 }
 
 let { SourceMapConsumer, SourceMapGenerator } = require$$2;
-let { dirname, relative, resolve, sep } = require$$2;
+let { dirname, resolve, relative, sep } = require$$2;
 let { pathToFileURL } = require$$2;
 
 
@@ -5860,29 +5858,100 @@ class MapGenerator {
     this.opts = opts;
     this.css = cssString;
     this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute;
+  }
 
-    this.memoizedFileURLs = new Map();
-    this.memoizedPaths = new Map();
-    this.memoizedURLs = new Map();
+  isMap() {
+    if (typeof this.opts.map !== 'undefined') {
+      return !!this.opts.map
+    }
+    return this.previous().length > 0
   }
 
-  addAnnotation() {
-    let content;
+  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);
+      }
+    }
 
-    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';
+    return this.previousMaps
+  }
+
+  isInline() {
+    if (typeof this.mapOpts.inline !== 'undefined') {
+      return this.mapOpts.inline
     }
-    let eol = '\n';
-    if (this.css.includes('\r\n')) eol = '\r\n';
 
-    this.css += eol + '/*# sourceMappingURL=' + content + ' */';
+    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
+  }
+
+  clearAnnotation() {
+    if (this.mapOpts.annotation === false) return
+
+    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, '');
+    }
+  }
+
+  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);
+    }
   }
 
   applyPrevMaps() {
@@ -5904,33 +5973,53 @@ class MapGenerator {
     }
   }
 
-  clearAnnotation() {
-    if (this.mapOpts.annotation === false) return
+  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
+  }
 
-    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, '');
+  toBase64(str) {
+    if (Buffer) {
+      return Buffer.from(str).toString('base64')
+    } else {
+      return window.btoa(unescape(encodeURIComponent(str)))
     }
   }
 
-  generate() {
-    this.clearAnnotation();
-    if (pathAvailable && sourceMapAvailable && this.isMap()) {
-      return this.generateMap()
+  addAnnotation() {
+    let content;
+
+    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 {
-      let result = '';
-      this.stringify(this.root, i => {
-        result += i;
-      });
-      return [result]
+      content = this.outputFile() + '.map';
+    }
+    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)
+    } else {
+      return 'to.css'
     }
   }
 
@@ -5944,11 +6033,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>'
+          : '<no source>',
+        generated: { line: 1, column: 0 },
+        original: { line: 1, column: 0 }
       });
     }
 
@@ -5963,6 +6052,48 @@ 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) : '.';
+
+    if (typeof this.mapOpts.annotation === 'string') {
+      from = dirname(resolve(from, this.mapOpts.annotation));
+    }
+
+    file = relative(from, file);
+    return file
+  }
+
+  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() });
@@ -5972,9 +6103,9 @@ class MapGenerator {
 
     let noSource = '<no source>';
     let mapping = {
-      generated: { column: 0, line: 0 },
-      original: { column: 0, line: 0 },
-      source: ''
+      source: '',
+      generated: { line: 0, column: 0 },
+      original: { line: 0, column: 0 }
     };
 
     let lines, last;
@@ -6031,171 +6162,17 @@ 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
-  }
-
-  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)
+  generate() {
+    this.clearAnnotation();
+    if (pathAvailable && sourceMapAvailable && this.isMap()) {
+      return this.generateMap()
     } else {
-      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);
-          }
-        }
+      let result = '';
+      this.stringify(this.root, i => {
+        result += i;
       });
-    } 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, '/');
+      return [result]
     }
-
-    let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
-    this.memoizedURLs.set(path, url);
-
-    return url
   }
 }
 
@@ -6236,24 +6213,12 @@ function markDirtyUp(node) {
 }
 
 class Container extends node_1 {
-  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();
-
+  push(child) {
+    child.parent = this;
+    this.proxyOf.nodes.push(child);
     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();
@@ -6271,88 +6236,118 @@ class Container extends node_1 {
     return result
   }
 
-  every(condition) {
-    return this.nodes.every(condition)
-  }
-
-  getIterator() {
-    if (!this.lastEach) this.lastEach = 0;
-    if (!this.indexes) this.indexes = {};
+  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);
+      }
 
-    this.lastEach += 1;
-    let iterator = this.lastEach;
-    this.indexes[iterator] = 0;
+      return result
+    })
+  }
 
-    return iterator
+  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)
+      }
+    })
   }
 
-  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]
+  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)
+      }
+    })
+  }
 
-      set(node, prop, value) {
-        if (node[prop] === value) return true
-        node[prop] = value;
-        if (prop === 'name' || prop === 'params' || prop === 'selector') {
-          node.markDirty();
+  walkAtRules(name, callback) {
+    if (!callback) {
+      callback = name;
+      return this.walk((child, i) => {
+        if (child.type === 'atrule') {
+          return callback(child, i)
         }
-        return true
-      }
+      })
+    }
+    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)
+      }
+    })
   }
 
-  index(child) {
-    if (typeof child === 'number') return child
-    if (child.proxyOf) child = child.proxyOf;
-    return this.proxyOf.nodes.indexOf(child)
+  walkComments(callback) {
+    return this.walk((child, i) => {
+      if (child.type === 'comment') {
+        return callback(child, i)
+      }
+    })
   }
 
-  insertAfter(exist, add) {
-    let existIndex = this.index(exist);
-    let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse();
-    existIndex = this.index(exist);
-    for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node);
+  append(...children) {
+    for (let child of children) {
+      let nodes = this.normalize(child, this.last);
+      for (let node of nodes) this.proxyOf.nodes.push(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
+  }
+
+  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;
       }
     }
 
@@ -6361,6 +6356,13 @@ class Container extends node_1 {
     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;
@@ -6381,63 +6383,17 @@ class Container extends node_1 {
     return this
   }
 
-  normalize(nodes, sample) {
-    if (typeof nodes === 'string') {
-      nodes = cleanSource(parse$1(nodes).nodes);
-    } else if (Array.isArray(nodes)) {
-      nodes = nodes.slice(0);
-      for (let i of nodes) {
-        if (i.parent) i.parent.removeChild(i, 'ignore');
-      }
-    } else if (nodes.type === 'root' && this.type !== 'document') {
-      nodes = nodes.nodes.slice(0);
-      for (let i of nodes) {
-        if (i.parent) i.parent.removeChild(i, 'ignore');
-      }
-    } else if (nodes.type) {
-      nodes = [nodes];
-    } else if (nodes.prop) {
-      if (typeof nodes.value === 'undefined') {
-        throw new Error('Value field is missed in node creation')
-      } else if (typeof nodes.value !== 'string') {
-        nodes.value = String(nodes.value);
-      }
-      nodes = [new declaration(nodes)];
-    } else if (nodes.selector) {
-      nodes = [new Rule$1(nodes)];
-    } else if (nodes.name) {
-      nodes = [new AtRule$1(nodes)];
-    } else if (nodes.text) {
-      nodes = [new comment(nodes)];
-    } else {
-      throw new Error('Unknown node type in node creation')
-    }
-
-    let processed = nodes.map(i => {
-      /* c8 ignore next */
-      if (!i[my$1]) Container.rebuild(i);
-      i = i.proxyOf;
-      if (i.parent) i.parent.removeChild(i);
-      if (i[isClean$1]) markDirtyUp(i);
-      if (typeof i.raws.before === 'undefined') {
-        if (sample && typeof sample.raws.before !== 'undefined') {
-          i.raws.before = sample.raws.before.replace(/\S/g, '');
-        }
-      }
-      i.parent = this.proxyOf;
-      return i
-    });
-
-    return processed
-  }
+  insertAfter(exist, add) {
+    let existIndex = this.index(exist);
+    let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse();
+    existIndex = this.index(exist);
+    for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node);
 
-  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;
+    let index;
+    for (let id in this.indexes) {
+      index = this.indexes[id];
+      if (existIndex < index) {
+        this.indexes[id] = index + nodes.length;
       }
     }
 
@@ -6446,21 +6402,6 @@ class Container extends node_1 {
     return this
   }
 
-  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;
@@ -6479,6 +6420,15 @@ 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;
@@ -6497,112 +6447,139 @@ class Container extends node_1 {
     return this
   }
 
+  every(condition) {
+    return this.nodes.every(condition)
+  }
+
   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
-    })
+  index(child) {
+    if (typeof child === 'number') return child
+    if (child.proxyOf) child = child.proxyOf;
+    return this.proxyOf.nodes.indexOf(child)
   }
 
-  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)
-      }
-    })
+  get first() {
+    if (!this.proxyOf.nodes) return undefined
+    return this.proxyOf.nodes[0]
   }
 
-  walkComments(callback) {
-    return this.walk((child, i) => {
-      if (child.type === 'comment') {
-        return callback(child, i)
-      }
-    })
+  get last() {
+    if (!this.proxyOf.nodes) return undefined
+    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]
   }
 
-  walkDecls(prop, callback) {
-    if (!callback) {
-      callback = prop;
-      return this.walk((child, i) => {
-        if (child.type === 'decl') {
-          return callback(child, i)
-        }
-      })
+  normalize(nodes, sample) {
+    if (typeof nodes === 'string') {
+      nodes = cleanSource(parse$1(nodes).nodes);
+    } else if (Array.isArray(nodes)) {
+      nodes = nodes.slice(0);
+      for (let i of nodes) {
+        if (i.parent) i.parent.removeChild(i, 'ignore');
+      }
+    } else if (nodes.type === 'root' && this.type !== 'document') {
+      nodes = nodes.nodes.slice(0);
+      for (let i of nodes) {
+        if (i.parent) i.parent.removeChild(i, 'ignore');
+      }
+    } else if (nodes.type) {
+      nodes = [nodes];
+    } else if (nodes.prop) {
+      if (typeof nodes.value === 'undefined') {
+        throw new Error('Value field is missed in node creation')
+      } else if (typeof nodes.value !== 'string') {
+        nodes.value = String(nodes.value);
+      }
+      nodes = [new declaration(nodes)];
+    } else if (nodes.selector) {
+      nodes = [new Rule$1(nodes)];
+    } else if (nodes.name) {
+      nodes = [new AtRule$1(nodes)];
+    } else if (nodes.text) {
+      nodes = [new comment(nodes)];
+    } else {
+      throw new Error('Unknown node type in node creation')
     }
-    if (prop instanceof RegExp) {
-      return this.walk((child, i) => {
-        if (child.type === 'decl' && prop.test(child.prop)) {
-          return callback(child, i)
+
+    let processed = nodes.map(i => {
+      /* c8 ignore next */
+      if (!i[my$1]) Container.rebuild(i);
+      i = i.proxyOf;
+      if (i.parent) i.parent.removeChild(i);
+      if (i[isClean$1]) markDirtyUp(i);
+      if (typeof i.raws.before === 'undefined') {
+        if (sample && typeof sample.raws.before !== 'undefined') {
+          i.raws.before = sample.raws.before.replace(/\S/g, '');
         }
-      })
-    }
-    return this.walk((child, i) => {
-      if (child.type === 'decl' && child.prop === prop) {
-        return callback(child, i)
       }
-    })
-  }
+      i.parent = this.proxyOf;
+      return i
+    });
 
-  walkRules(selector, callback) {
-    if (!callback) {
-      callback = selector;
+    return processed
+  }
 
-      return this.walk((child, i) => {
-        if (child.type === 'rule') {
-          return callback(child, i)
+  getProxyProcessor() {
+    return {
+      set(node, prop, value) {
+        if (node[prop] === value) return true
+        node[prop] = value;
+        if (prop === 'name' || prop === 'params' || prop === 'selector') {
+          node.markDirty();
         }
-      })
-    }
-    if (selector instanceof RegExp) {
-      return this.walk((child, i) => {
-        if (child.type === 'rule' && selector.test(child.selector)) {
-          return callback(child, i)
+        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]
         }
-      })
-    }
-    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]
-  }
+  getIterator() {
+    if (!this.lastEach) this.lastEach = 0;
+    if (!this.indexes) this.indexes = {};
 
-  get last() {
-    if (!this.proxyOf.nodes) return undefined
-    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]
+    this.lastEach += 1;
+    let iterator = this.lastEach;
+    this.indexes[iterator] = 0;
+
+    return iterator
   }
 }
 
@@ -6697,8 +6674,8 @@ class Warning {
   toString() {
     if (this.node) {
       return this.node.error(this.text, {
-        index: this.index,
         plugin: this.plugin,
+        index: this.index,
         word: this.word
       }).message
     }
@@ -6775,7 +6752,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 = /.[\r\n"'(/\\]/;
+const RE_BAD_BRACKET = /.[\n"'(/\\]/;
 const RE_HEX_ESCAPE = /[\da-f]/i;
 
 var tokenize = function tokenizer(input, options = {}) {
@@ -7012,8 +6989,8 @@ var tokenize = function tokenizer(input, options = {}) {
 
   return {
     back,
-    endOfFile,
     nextToken,
+    endOfFile,
     position
   }
 };
@@ -7049,6 +7026,16 @@ 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);
 
@@ -7069,16 +7056,6 @@ 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()
@@ -7099,15 +7076,6 @@ 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 = '';
@@ -7149,6 +7117,15 @@ 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)
   }
 };
 
@@ -7202,150 +7179,55 @@ class Parser {
     this.customProperty = false;
 
     this.createTokenizer();
-    this.root.source = { input, start: { column: 1, line: 1, offset: 0 } };
+    this.root.source = { input, start: { offset: 0, line: 1, column: 1 } };
   }
 
-  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 = [];
+  createTokenizer() {
+    this.tokenizer = tokenize(this.input);
+  }
 
+  parse() {
+    let token;
     while (!this.tokenizer.endOfFile()) {
       token = this.tokenizer.nextToken();
-      type = token[0];
-
-      if (type === '(' || type === '[') {
-        brackets.push(type === '(' ? ')' : ']');
-      } else if (type === '{' && brackets.length > 0) {
-        brackets.push('}');
-      } else if (type === brackets[brackets.length - 1]) {
-        brackets.pop();
-      }
 
-      if (brackets.length === 0) {
-        if (type === ';') {
-          node.source.end = this.getPosition(token[2]);
-          node.source.end.offset++;
-          this.semicolon = true;
+      switch (token[0]) {
+        case 'space':
+          this.spaces += token[1];
           break
-        } else if (type === '{') {
-          open = true;
+
+        case ';':
+          this.freeSemicolon(token);
           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]);
-              node.source.end.offset++;
-            }
-          }
+
+        case '}':
           this.end(token);
           break
-        } else {
-          params.push(token);
-        }
-      } else {
-        params.push(token);
-      }
-
-      if (this.tokenizer.endOfFile()) {
-        last = true;
-        break
-      }
-    }
-
-    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
+        case 'comment':
+          this.comment(token);
+          break
 
-    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]
-    )
-  }
+        case 'at-word':
+          this.atrule(token);
+          break
 
-  colon(tokens) {
-    let brackets = 0;
-    let token, type, prev;
-    for (let [i, element] of tokens.entries()) {
-      token = element;
-      type = token[0];
+        case '{':
+          this.emptyRule(token);
+          break
 
-      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
-        }
+        default:
+          this.other(token);
+          break
       }
-
-      prev = token;
     }
-    return false
+    this.endFile();
   }
 
   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)) {
@@ -7360,8 +7242,86 @@ class Parser {
     }
   }
 
-  createTokenizer() {
-    this.tokenizer = tokenize(this.input);
+  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;
   }
 
   decl(tokens, customProperty) {
@@ -7377,7 +7337,6 @@ 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);
@@ -7469,185 +7428,145 @@ class Parser {
     }
   }
 
-  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;
-  }
-
-  end(token) {
-    if (this.current.nodes && this.current.nodes.length) {
-      this.current.raws.semicolon = this.semicolon;
-    }
-    this.semicolon = false;
-
-    this.current.raws.after = (this.current.raws.after || '') + this.spaces;
-    this.spaces = '';
-
-    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 = '';
-      }
-    }
-  }
-
-  // Helpers
-
-  getPosition(offset) {
-    let pos = this.input.fromOffset(offset);
-    return {
-      column: pos.col,
-      line: pos.line,
-      offset
+  atrule(token) {
+    let node = new atRule();
+    node.name = token[1].slice(1);
+    if (node.name === '') {
+      this.unnamedAtrule(node, token);
     }
-  }
-
-  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;
-  }
+    this.init(node, token[2]);
 
-  other(start) {
-    let end = false;
-    let type = null;
-    let colon = false;
-    let bracket = null;
+    let type;
+    let prev;
+    let shift;
+    let last = false;
+    let open = false;
+    let params = [];
     let brackets = [];
-    let customProperty = start[1].startsWith('--');
 
-    let tokens = [];
-    let token = start;
-    while (token) {
+    while (!this.tokenizer.endOfFile()) {
+      token = this.tokenizer.nextToken();
       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;
+      } else if (type === '{' && brackets.length > 0) {
         brackets.push('}');
-      } else if (brackets.length === 0) {
+      } else if (type === brackets[brackets.length - 1]) {
+        brackets.pop();
+      }
+
+      if (brackets.length === 0) {
         if (type === ';') {
-          if (colon) {
-            this.decl(tokens, customProperty);
-            return
-          } else {
-            break
-          }
+          node.source.end = this.getPosition(token[2]);
+          this.semicolon = true;
+          break
         } else if (type === '{') {
-          this.rule(tokens);
-          return
+          open = true;
+          break
         } else if (type === '}') {
-          this.tokenizer.back(tokens.pop());
-          end = true;
+          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]);
+            }
+          }
+          this.end(token);
           break
-        } else if (type === ':') {
-          colon = true;
+        } else {
+          params.push(token);
         }
-      } else if (type === brackets[brackets.length - 1]) {
-        brackets.pop();
-        if (brackets.length === 0) bracket = null;
+      } else {
+        params.push(token);
       }
 
-      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());
-        }
+      if (this.tokenizer.endOfFile()) {
+        last = true;
+        break
+      }
+    }
+
+    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 = '';
       }
-      this.decl(tokens, customProperty);
     } else {
-      this.unknownWord(tokens);
+      node.raws.afterName = '';
+      node.params = '';
     }
-  }
 
-  parse() {
-    let token;
-    while (!this.tokenizer.endOfFile()) {
-      token = this.tokenizer.nextToken();
+    if (open) {
+      node.nodes = [];
+      this.current = node;
+    }
+  }
 
-      switch (token[0]) {
-        case 'space':
-          this.spaces += token[1];
-          break
+  end(token) {
+    if (this.current.nodes && this.current.nodes.length) {
+      this.current.raws.semicolon = this.semicolon;
+    }
+    this.semicolon = false;
 
-        case ';':
-          this.freeSemicolon(token);
-          break
+    this.current.raws.after = (this.current.raws.after || '') + this.spaces;
+    this.spaces = '';
 
-        case '}':
-          this.end(token);
-          break
+    if (this.current.parent) {
+      this.current.source.end = this.getPosition(token[2]);
+      this.current = this.current.parent;
+    } else {
+      this.unexpectedClose(token);
+    }
+  }
 
-        case 'comment':
-          this.comment(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 'at-word':
-          this.atrule(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 '{':
-          this.emptyRule(token);
-          break
+  // Helpers
 
-        default:
-          this.other(token);
-          break
-      }
+  getPosition(offset) {
+    let pos = this.input.fromOffset(offset);
+    return {
+      offset,
+      line: pos.line,
+      column: pos.col
     }
-    this.endFile();
   }
 
-  precheckMissedSemicolon(/* tokens */) {
-    // Hook for Safe Parser
+  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;
   }
 
   raw(node, prop, tokens, customProperty) {
@@ -7680,22 +7599,11 @@ class Parser {
     }
     if (!clean) {
       let raw = tokens.reduce((all, i) => all + i[1], '');
-      node.raws[prop] = { raw, value };
+      node.raws[prop] = { value, raw };
     }
     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 = '';
@@ -7707,8 +7615,6 @@ class Parser {
     return spaces
   }
 
-  // Errors
-
   spacesAndCommentsFromStart(tokens) {
     let next;
     let spaces = '';
@@ -7740,11 +7646,36 @@ class Parser {
     return result
   }
 
-  unclosedBlock() {
-    let pos = this.current.source.start;
-    throw this.input.error('Unclosed block', pos.line, pos.column)
+  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
   }
 
+  // Errors
+
   unclosedBracket(bracket) {
     throw this.input.error(
       'Unclosed bracket',
@@ -7753,6 +7684,14 @@ 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 }',
@@ -7761,11 +7700,16 @@ class Parser {
     )
   }
 
-  unknownWord(tokens) {
+  unclosedBlock() {
+    let pos = this.current.source.start;
+    throw this.input.error('Unclosed block', pos.line, pos.column)
+  }
+
+  doubleColon(token) {
     throw this.input.error(
-      'Unknown word',
-      { offset: tokens[0][2] },
-      { offset: tokens[0][2] + tokens[0][1].length }
+      'Double colon',
+      { offset: token[2] },
+      { offset: token[2] + token[1].length }
     )
   }
 
@@ -7776,6 +7720,32 @@ 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;
@@ -7808,37 +7778,37 @@ let { isClean, my } = symbols;
 
 
 const TYPE_TO_CLASS_NAME = {
-  atrule: 'AtRule',
-  comment: 'Comment',
-  decl: 'Declaration',
   document: 'Document',
   root: 'Root',
-  rule: 'Rule'
+  atrule: 'AtRule',
+  rule: 'Rule',
+  decl: 'Declaration',
+  comment: 'Comment'
 };
 
 const PLUGIN_PROPS = {
-  AtRule: true,
-  AtRuleExit: true,
-  Comment: true,
-  CommentExit: true,
-  Declaration: true,
-  DeclarationExit: true,
-  Document: true,
-  DocumentExit: true,
-  Once: true,
-  OnceExit: true,
   postcssPlugin: true,
   prepare: true,
+  Once: true,
+  Document: true,
   Root: true,
-  RootExit: true,
+  Declaration: true,
   Rule: true,
-  RuleExit: true
+  AtRule: true,
+  Comment: true,
+  DeclarationExit: true,
+  RuleExit: true,
+  AtRuleExit: true,
+  CommentExit: true,
+  RootExit: true,
+  DocumentExit: true,
+  OnceExit: true
 };
 
 const NOT_VISITORS = {
-  Once: true,
   postcssPlugin: true,
-  prepare: true
+  prepare: true,
+  Once: true
 };
 
 const CHILDREN = 0;
@@ -7884,12 +7854,12 @@ function toStack(node) {
   }
 
   return {
-    eventIndex: 0,
-    events,
-    iterator: 0,
     node,
+    events,
+    eventIndex: 0,
+    visitors: [],
     visitorIndex: 0,
-    visitors: []
+    iterator: 0
   }
 }
 
@@ -7939,24 +7909,59 @@ class LazyResult {
       }
     }
 
-    this.result = new result(processor, root, opts);
-    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) }
-      } else {
-        return plugin
-      }
-    });
+    this.result = new result(processor, root, opts);
+    this.helpers = { ...postcss$1, result: this.result, postcss: postcss$1 };
+    this.plugins = this.processor.plugins.map(plugin => {
+      if (typeof plugin === 'object' && plugin.prepare) {
+        return { ...plugin, ...plugin.prepare(this.result) }
+      } else {
+        return plugin
+      }
+    });
+  }
+
+  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()
   }
 
-  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
+  toString() {
+    return this.css
+  }
+
+  then(onFulfilled, onRejected) {
+    return this.async().then(onFulfilled, onRejected)
   }
 
   catch(onRejected) {
@@ -7967,76 +7972,28 @@ class LazyResult {
     return this.async().then(onFinally, onFinally)
   }
 
-  getAsyncError() {
-    throw new Error('Use process(css).then(cb) to work with async plugins')
-  }
-
-  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);
+  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 error
+    return this.processing
   }
 
-  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]);
-            }
-          }
-        }
-      }
+  sync() {
+    if (this.error) throw this.error
+    if (this.processed) return this.result
+    this.processed = true;
+
+    if (this.processing) {
+      throw this.getAsyncError()
     }
-    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];
+    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()
       }
     }
 
@@ -8045,42 +8002,78 @@ class LazyResult {
       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)
-            }
+        this.walkSync(root);
+      }
+      if (this.listeners.OnceExit) {
+        if (root.type === 'document') {
+          for (let subRoot of root.nodes) {
+            this.visitSync(this.listeners.OnceExit, subRoot);
           }
+        } else {
+          this.visitSync(this.listeners.OnceExit, 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)
-              );
+    return this.result
+  }
 
-              await Promise.all(roots);
-            } else {
-              await visitor(root, this.helpers);
-            }
-          } catch (e) {
-            throw this.handleError(e)
-          }
+  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
+  }
+
+  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
         }
       }
     }
+  }
 
-    this.processed = true;
-    return this.stringify()
+  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()
+      }
+    }
   }
 
   runOnRoot(plugin) {
@@ -8108,40 +8101,38 @@ class LazyResult {
     }
   }
 
-  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
+  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
+  }
 
-    for (let plugin of this.plugins) {
+  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)
+        }
       }
     }
 
@@ -8150,46 +8141,80 @@ class LazyResult {
       let root = this.result.root;
       while (!root[isClean]) {
         root[isClean] = true;
-        this.walkSync(root);
+        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)
+            }
+          }
+        }
       }
+
       if (this.listeners.OnceExit) {
-        if (root.type === 'document') {
-          for (let subRoot of root.nodes) {
-            this.visitSync(this.listeners.OnceExit, subRoot);
+        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)
           }
-        } else {
-          this.visitSync(this.listeners.OnceExit, root);
         }
       }
     }
 
-    return this.result
-  }
-
-  then(onFulfilled, onRejected) {
-    return this.async().then(onFulfilled, onRejected)
-  }
-
-  toString() {
-    return this.css
+    this.processed = true;
+    return this.stringify()
   }
 
-  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()
+  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;
   }
 
   visitTick(stack) {
@@ -8248,61 +8273,6 @@ 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 => {
@@ -8349,42 +8319,23 @@ class NoWorkResult {
     }
   }
 
-  async() {
-    if (this.error) return Promise.reject(this.error)
-    return Promise.resolve(this.result)
-  }
-
-  catch(onRejected) {
-    return this.async().catch(onRejected)
-  }
-
-  finally(onFinally) {
-    return this.async().then(onFinally, onFinally)
-  }
-
-  sync() {
-    if (this.error) throw this.error
-    return this.result
-  }
-
-  then(onFulfilled, onRejected) {
-
-    return this.async().then(onFulfilled, onRejected)
+  get [Symbol.toStringTag]() {
+    return 'NoWorkResult'
   }
 
-  toString() {
-    return this._css
+  get processor() {
+    return this.result.processor
   }
 
-  warnings() {
-    return []
+  get opts() {
+    return this.result.opts
   }
 
-  get content() {
+  get css() {
     return this.result.css
   }
 
-  get css() {
+  get content() {
     return this.result.css
   }
 
@@ -8392,18 +8343,6 @@ class NoWorkResult {
     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
@@ -8426,8 +8365,39 @@ class NoWorkResult {
     }
   }
 
-  get [Symbol.toStringTag]() {
-    return '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
   }
 }
 
@@ -8436,10 +8406,28 @@ NoWorkResult.default = NoWorkResult;
 
 class Processor {
   constructor(plugins = []) {
-    this.version = '8.4.32';
+    this.version = '8.4.24';
     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) {
@@ -8461,24 +8449,6 @@ 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;