@vue/compiler-sfc 3.5.0-rc.1 → 3.5.0

package/dist/compiler-sfc.esm-browser.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.5.0-rc.1
+* @vue/compiler-sfc v3.5.0
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -277,6 +277,13 @@ function escapeHtml(string) {
   }
   return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
 }
+const cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
+function getEscapedCssVarName(key, doubleEscape) {
+  return key.replace(
+    cssVarNameEscapeSymbolsRE,
+    (s) => doubleEscape ? s === '"' ? '\\\\\\"' : `\\\\${s}` : `\\${s}`
+  );
+}
 
 const isRef = (val) => {
   return !!(val && val["__v_isRef"] === true);
@@ -25810,304 +25817,6 @@ var CompilerDOM = /*#__PURE__*/Object.freeze({
   warnDeprecation: warnDeprecation
 });
 
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// resolves . and .. elements in a path array with directory names there
-// must be no slashes, empty elements, or device names (c:\) in the array
-// (so also no leading and trailing slashes - it does not distinguish
-// relative and absolute paths)
-function normalizeArray(parts, allowAboveRoot) {
-  // if the path tries to go above the root, `up` ends up > 0
-  var up = 0;
-  for (var i = parts.length - 1; i >= 0; i--) {
-    var last = parts[i];
-    if (last === '.') {
-      parts.splice(i, 1);
-    } else if (last === '..') {
-      parts.splice(i, 1);
-      up++;
-    } else if (up) {
-      parts.splice(i, 1);
-      up--;
-    }
-  }
-
-  // if the path is allowed to go above the root, restore leading ..s
-  if (allowAboveRoot) {
-    for (; up--; up) {
-      parts.unshift('..');
-    }
-  }
-
-  return parts;
-}
-
-// Split a filename into [root, dir, basename, ext], unix version
-// 'root' is just a slash, or nothing.
-var splitPathRe =
-    /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
-var splitPath = function(filename) {
-  return splitPathRe.exec(filename).slice(1);
-};
-
-// path.resolve([from ...], to)
-// posix version
-function resolve$2() {
-  var resolvedPath = '',
-      resolvedAbsolute = false;
-
-  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-    var path = (i >= 0) ? arguments[i] : '/';
-
-    // Skip empty and invalid entries
-    if (typeof path !== 'string') {
-      throw new TypeError('Arguments to path.resolve must be strings');
-    } else if (!path) {
-      continue;
-    }
-
-    resolvedPath = path + '/' + resolvedPath;
-    resolvedAbsolute = path.charAt(0) === '/';
-  }
-
-  // At this point the path should be resolved to a full absolute path, but
-  // handle relative paths to be safe (might happen when process.cwd() fails)
-
-  // Normalize the path
-  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
-    return !!p;
-  }), !resolvedAbsolute).join('/');
-
-  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
-}
-// path.normalize(path)
-// posix version
-function normalize$1(path) {
-  var isPathAbsolute = isAbsolute$1(path),
-      trailingSlash = substr(path, -1) === '/';
-
-  // Normalize the path
-  path = normalizeArray(filter(path.split('/'), function(p) {
-    return !!p;
-  }), !isPathAbsolute).join('/');
-
-  if (!path && !isPathAbsolute) {
-    path = '.';
-  }
-  if (path && trailingSlash) {
-    path += '/';
-  }
-
-  return (isPathAbsolute ? '/' : '') + path;
-}
-// posix version
-function isAbsolute$1(path) {
-  return path.charAt(0) === '/';
-}
-
-// posix version
-function join$1() {
-  var paths = Array.prototype.slice.call(arguments, 0);
-  return normalize$1(filter(paths, function(p, index) {
-    if (typeof p !== 'string') {
-      throw new TypeError('Arguments to path.join must be strings');
-    }
-    return p;
-  }).join('/'));
-}
-
-
-// path.relative(from, to)
-// posix version
-function relative$1(from, to) {
-  from = resolve$2(from).substr(1);
-  to = resolve$2(to).substr(1);
-
-  function trim(arr) {
-    var start = 0;
-    for (; start < arr.length; start++) {
-      if (arr[start] !== '') break;
-    }
-
-    var end = arr.length - 1;
-    for (; end >= 0; end--) {
-      if (arr[end] !== '') break;
-    }
-
-    if (start > end) return [];
-    return arr.slice(start, end - start + 1);
-  }
-
-  var fromParts = trim(from.split('/'));
-  var toParts = trim(to.split('/'));
-
-  var length = Math.min(fromParts.length, toParts.length);
-  var samePartsLength = length;
-  for (var i = 0; i < length; i++) {
-    if (fromParts[i] !== toParts[i]) {
-      samePartsLength = i;
-      break;
-    }
-  }
-
-  var outputParts = [];
-  for (var i = samePartsLength; i < fromParts.length; i++) {
-    outputParts.push('..');
-  }
-
-  outputParts = outputParts.concat(toParts.slice(samePartsLength));
-
-  return outputParts.join('/');
-}
-
-var sep$1 = '/';
-var delimiter$1 = ':';
-
-function dirname$2(path) {
-  var result = splitPath(path),
-      root = result[0],
-      dir = result[1];
-
-  if (!root && !dir) {
-    // No dirname whatsoever
-    return '.';
-  }
-
-  if (dir) {
-    // It has a dirname, strip trailing slash
-    dir = dir.substr(0, dir.length - 1);
-  }
-
-  return root + dir;
-}
-
-function basename(path, ext) {
-  var f = splitPath(path)[2];
-  // TODO: make this comparison case-insensitive on windows?
-  if (ext && f.substr(-1 * ext.length) === ext) {
-    f = f.substr(0, f.length - ext.length);
-  }
-  return f;
-}
-
-
-function extname(path) {
-  return splitPath(path)[3];
-}
-var path = {
-  extname: extname,
-  basename: basename,
-  dirname: dirname$2,
-  sep: sep$1,
-  delimiter: delimiter$1,
-  relative: relative$1,
-  join: join$1,
-  isAbsolute: isAbsolute$1,
-  normalize: normalize$1,
-  resolve: resolve$2
-};
-function filter (xs, f) {
-    if (xs.filter) return xs.filter(f);
-    var res = [];
-    for (var i = 0; i < xs.length; i++) {
-        if (f(xs[i], i, xs)) res.push(xs[i]);
-    }
-    return res;
-}
-
-// String.prototype.substr - negative index don't work in IE8
-var substr = 'ab'.substr(-1) === 'b' ?
-    function (str, start, len) { return str.substr(start, len) } :
-    function (str, start, len) {
-        if (start < 0) start = str.length + start;
-        return str.substr(start, len);
-    }
-;
-
-var _polyfillNode_path = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  basename: basename,
-  default: path,
-  delimiter: delimiter$1,
-  dirname: dirname$2,
-  extname: extname,
-  isAbsolute: isAbsolute$1,
-  join: join$1,
-  normalize: normalize$1,
-  relative: relative$1,
-  resolve: resolve$2,
-  sep: sep$1
-});
-
-const UNKNOWN_TYPE = "Unknown";
-function resolveObjectKey(node, computed) {
-  switch (node.type) {
-    case "StringLiteral":
-    case "NumericLiteral":
-      return String(node.value);
-    case "Identifier":
-      if (!computed) return node.name;
-  }
-  return void 0;
-}
-function concatStrings(strs) {
-  return strs.filter((s) => !!s).join(", ");
-}
-function isLiteralNode(node) {
-  return node.type.endsWith("Literal");
-}
-function isCallOf(node, test) {
-  return !!(node && test && node.type === "CallExpression" && node.callee.type === "Identifier" && (typeof test === "string" ? node.callee.name === test : test(node.callee.name)));
-}
-function toRuntimeTypeString(types) {
-  return types.length > 1 ? `[${types.join(", ")}]` : types[0];
-}
-function getImportedName(specifier) {
-  if (specifier.type === "ImportSpecifier")
-    return specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
-  else if (specifier.type === "ImportNamespaceSpecifier") return "*";
-  return "default";
-}
-function getId(node) {
-  return node.type === "Identifier" ? node.name : node.type === "StringLiteral" ? node.value : null;
-}
-const normalize = (path.posix || path).normalize;
-const windowsSlashRE = /\\/g;
-function normalizePath(p) {
-  return normalize(p.replace(windowsSlashRE, "/"));
-}
-const joinPaths = (path.posix || path).join;
-const propNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~\-]/;
-function getEscapedPropName(key) {
-  return propNameEscapeSymbolsRE.test(key) ? JSON.stringify(key) : key;
-}
-const cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
-function getEscapedCssVarName(key, doubleEscape) {
-  return key.replace(
-    cssVarNameEscapeSymbolsRE,
-    (s) => doubleEscape ? `\\\\${s}` : `\\${s}`
-  );
-}
-
 function pad$1 (hash, len) {
   while (hash.length < len) {
     hash = '0' + hash;
@@ -26579,7 +26288,7 @@ function resolveTemplateUsedIdentifiers(sfc) {
             } else if (prop.exp) {
               extractIdentifiers(ids, prop.exp);
             } else if (prop.name === "bind" && !prop.exp) {
-              ids.add(prop.arg.content);
+              ids.add(camelize(prop.arg.content));
             }
           }
           if (prop.type === 6 && prop.name === "ref" && ((_a = prop.value) == null ? void 0 : _a.content)) {
@@ -26921,6 +26630,254 @@ function dedent(s) {
   ];
 }
 
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// resolves . and .. elements in a path array with directory names there
+// must be no slashes, empty elements, or device names (c:\) in the array
+// (so also no leading and trailing slashes - it does not distinguish
+// relative and absolute paths)
+function normalizeArray(parts, allowAboveRoot) {
+  // if the path tries to go above the root, `up` ends up > 0
+  var up = 0;
+  for (var i = parts.length - 1; i >= 0; i--) {
+    var last = parts[i];
+    if (last === '.') {
+      parts.splice(i, 1);
+    } else if (last === '..') {
+      parts.splice(i, 1);
+      up++;
+    } else if (up) {
+      parts.splice(i, 1);
+      up--;
+    }
+  }
+
+  // if the path is allowed to go above the root, restore leading ..s
+  if (allowAboveRoot) {
+    for (; up--; up) {
+      parts.unshift('..');
+    }
+  }
+
+  return parts;
+}
+
+// Split a filename into [root, dir, basename, ext], unix version
+// 'root' is just a slash, or nothing.
+var splitPathRe =
+    /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+var splitPath = function(filename) {
+  return splitPathRe.exec(filename).slice(1);
+};
+
+// path.resolve([from ...], to)
+// posix version
+function resolve$2() {
+  var resolvedPath = '',
+      resolvedAbsolute = false;
+
+  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    var path = (i >= 0) ? arguments[i] : '/';
+
+    // Skip empty and invalid entries
+    if (typeof path !== 'string') {
+      throw new TypeError('Arguments to path.resolve must be strings');
+    } else if (!path) {
+      continue;
+    }
+
+    resolvedPath = path + '/' + resolvedPath;
+    resolvedAbsolute = path.charAt(0) === '/';
+  }
+
+  // At this point the path should be resolved to a full absolute path, but
+  // handle relative paths to be safe (might happen when process.cwd() fails)
+
+  // Normalize the path
+  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
+    return !!p;
+  }), !resolvedAbsolute).join('/');
+
+  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+}
+// path.normalize(path)
+// posix version
+function normalize$1(path) {
+  var isPathAbsolute = isAbsolute$1(path),
+      trailingSlash = substr(path, -1) === '/';
+
+  // Normalize the path
+  path = normalizeArray(filter(path.split('/'), function(p) {
+    return !!p;
+  }), !isPathAbsolute).join('/');
+
+  if (!path && !isPathAbsolute) {
+    path = '.';
+  }
+  if (path && trailingSlash) {
+    path += '/';
+  }
+
+  return (isPathAbsolute ? '/' : '') + path;
+}
+// posix version
+function isAbsolute$1(path) {
+  return path.charAt(0) === '/';
+}
+
+// posix version
+function join$1() {
+  var paths = Array.prototype.slice.call(arguments, 0);
+  return normalize$1(filter(paths, function(p, index) {
+    if (typeof p !== 'string') {
+      throw new TypeError('Arguments to path.join must be strings');
+    }
+    return p;
+  }).join('/'));
+}
+
+
+// path.relative(from, to)
+// posix version
+function relative$1(from, to) {
+  from = resolve$2(from).substr(1);
+  to = resolve$2(to).substr(1);
+
+  function trim(arr) {
+    var start = 0;
+    for (; start < arr.length; start++) {
+      if (arr[start] !== '') break;
+    }
+
+    var end = arr.length - 1;
+    for (; end >= 0; end--) {
+      if (arr[end] !== '') break;
+    }
+
+    if (start > end) return [];
+    return arr.slice(start, end - start + 1);
+  }
+
+  var fromParts = trim(from.split('/'));
+  var toParts = trim(to.split('/'));
+
+  var length = Math.min(fromParts.length, toParts.length);
+  var samePartsLength = length;
+  for (var i = 0; i < length; i++) {
+    if (fromParts[i] !== toParts[i]) {
+      samePartsLength = i;
+      break;
+    }
+  }
+
+  var outputParts = [];
+  for (var i = samePartsLength; i < fromParts.length; i++) {
+    outputParts.push('..');
+  }
+
+  outputParts = outputParts.concat(toParts.slice(samePartsLength));
+
+  return outputParts.join('/');
+}
+
+var sep$1 = '/';
+var delimiter$1 = ':';
+
+function dirname$2(path) {
+  var result = splitPath(path),
+      root = result[0],
+      dir = result[1];
+
+  if (!root && !dir) {
+    // No dirname whatsoever
+    return '.';
+  }
+
+  if (dir) {
+    // It has a dirname, strip trailing slash
+    dir = dir.substr(0, dir.length - 1);
+  }
+
+  return root + dir;
+}
+
+function basename(path, ext) {
+  var f = splitPath(path)[2];
+  // TODO: make this comparison case-insensitive on windows?
+  if (ext && f.substr(-1 * ext.length) === ext) {
+    f = f.substr(0, f.length - ext.length);
+  }
+  return f;
+}
+
+
+function extname(path) {
+  return splitPath(path)[3];
+}
+var path = {
+  extname: extname,
+  basename: basename,
+  dirname: dirname$2,
+  sep: sep$1,
+  delimiter: delimiter$1,
+  relative: relative$1,
+  join: join$1,
+  isAbsolute: isAbsolute$1,
+  normalize: normalize$1,
+  resolve: resolve$2
+};
+function filter (xs, f) {
+    if (xs.filter) return xs.filter(f);
+    var res = [];
+    for (var i = 0; i < xs.length; i++) {
+        if (f(xs[i], i, xs)) res.push(xs[i]);
+    }
+    return res;
+}
+
+// String.prototype.substr - negative index don't work in IE8
+var substr = 'ab'.substr(-1) === 'b' ?
+    function (str, start, len) { return str.substr(start, len) } :
+    function (str, start, len) {
+        if (start < 0) start = str.length + start;
+        return str.substr(start, len);
+    }
+;
+
+var _polyfillNode_path = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  basename: basename,
+  default: path,
+  delimiter: delimiter$1,
+  dirname: dirname$2,
+  extname: extname,
+  isAbsolute: isAbsolute$1,
+  join: join$1,
+  normalize: normalize$1,
+  relative: relative$1,
+  resolve: resolve$2,
+  sep: sep$1
+});
+
 /*! https://mths.be/punycode v1.4.1 by @mathias */
 
 
@@ -32883,8 +32840,8 @@ var tokenize$1 = function tokenizer(input, options = {}) {
   let css = input.css.valueOf();
   let ignore = options.ignoreErrors;
 
-  let code, next, quote, content, escape;
-  let escaped, escapePos, prev, n, currentToken;
+  let code, content, escape, next, quote;
+  let currentToken, escaped, escapePos, n, prev;
 
   let length = css.length;
   let pos = 0;
@@ -33240,37 +33197,70 @@ let CssSyntaxError$3 = class CssSyntaxError extends Error {
 
     let css = this.source;
     if (color == null) color = pico.isColorSupported;
-    if (terminalHighlight$1) {
-      if (color) css = terminalHighlight$1(css);
-    }
 
-    let lines = css.split(/\r?\n/);
-    let start = Math.max(this.line - 3, 0);
-    let end = Math.min(this.line + 2, lines.length);
-
-    let maxWidth = String(end).length;
-
-    let mark, aside;
+    let aside = text => text;
+    let mark = text => text;
+    let highlight = text => text;
     if (color) {
       let { bold, gray, red } = pico.createColors(true);
       mark = text => bold(red(text));
       aside = text => gray(text);
-    } else {
-      mark = aside = str => str;
+      if (terminalHighlight$1) {
+        highlight = text => terminalHighlight$1(text);
+      }
     }
 
+    let lines = css.split(/\r?\n/);
+    let start = Math.max(this.line - 3, 0);
+    let end = Math.min(this.line + 2, lines.length);
+    let maxWidth = String(end).length;
+
     return lines
       .slice(start, end)
       .map((line, index) => {
         let number = start + 1 + index;
         let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ';
         if (number === this.line) {
+          if (line.length > 160) {
+            let padding = 20;
+            let subLineStart = Math.max(0, this.column - padding);
+            let subLineEnd = Math.max(
+              this.column + padding,
+              this.endColumn + padding
+            );
+            let subLine = line.slice(subLineStart, subLineEnd);
+
+            let spacing =
+              aside(gutter.replace(/\d/g, ' ')) +
+              line
+                .slice(0, Math.min(this.column - 1, padding - 1))
+                .replace(/[^\t]/g, ' ');
+
+            return (
+              mark('>') +
+              aside(gutter) +
+              highlight(subLine) +
+              '\n ' +
+              spacing +
+              mark('^')
+            )
+          }
+
           let spacing =
             aside(gutter.replace(/\d/g, ' ')) +
             line.slice(0, this.column - 1).replace(/[^\t]/g, ' ');
-          return mark('>') + aside(gutter) + line + '\n ' + spacing + mark('^')
+
+          return (
+            mark('>') +
+            aside(gutter) +
+            highlight(line) +
+            '\n ' +
+            spacing +
+            mark('^')
+          )
         }
-        return ' ' + aside(gutter) + line
+
+        return ' ' + aside(gutter) + highlight(line)
       })
       .join('\n')
   }
@@ -33287,12 +33277,6 @@ let CssSyntaxError$3 = class CssSyntaxError extends Error {
 var cssSyntaxError = CssSyntaxError$3;
 CssSyntaxError$3.default = CssSyntaxError$3;
 
-var symbols = {};
-
-symbols.isClean = Symbol('isClean');
-
-symbols.my = Symbol('my');
-
 const DEFAULT_RAW = {
   after: '\n',
   beforeClose: '\n',
@@ -33655,10 +33639,16 @@ function stringify$4(node, builder) {
 var stringify_1 = stringify$4;
 stringify$4.default = stringify$4;
 
-let { isClean: isClean$2, my: my$2 } = symbols;
+var symbols = {};
+
+symbols.isClean = Symbol('isClean');
+
+symbols.my = Symbol('my');
+
 let CssSyntaxError$2 = cssSyntaxError;
 let Stringifier = stringifier;
 let stringify$3 = stringify_1;
+let { isClean: isClean$2, my: my$2 } = symbols;
 
 function cloneNode(obj, parent) {
   let cloned = new obj.constructor();
@@ -33808,6 +33798,10 @@ let Node$4 = class Node {
     }
   }
 
+  markClean() {
+    this[isClean$2] = true;
+  }
+
   markDirty() {
     if (this[isClean$2]) {
       this[isClean$2] = false;
@@ -34037,7 +34031,19 @@ Node$4.default = Node$4;
 
 let Node$3 = node$2;
 
-let Declaration$4 = class Declaration extends Node$3 {
+let Comment$4 = class Comment extends Node$3 {
+  constructor(defaults) {
+    super(defaults);
+    this.type = 'comment';
+  }
+};
+
+var comment$3 = Comment$4;
+Comment$4.default = Comment$4;
+
+let Node$2 = node$2;
+
+let Declaration$4 = class Declaration extends Node$2 {
   constructor(defaults) {
     if (
       defaults &&
@@ -34058,1537 +34064,1488 @@ let Declaration$4 = class Declaration extends Node$3 {
 var declaration = Declaration$4;
 Declaration$4.default = Declaration$4;
 
-var require$$2 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_url$1);
+let Comment$3 = comment$3;
+let Declaration$3 = declaration;
+let Node$1 = node$2;
+let { isClean: isClean$1, my: my$1 } = symbols;
 
-let urlAlphabet =
-  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
-let customAlphabet = (alphabet, defaultSize = 21) => {
-  return (size = defaultSize) => {
-    let id = '';
-    let i = size;
-    while (i--) {
-      id += alphabet[(Math.random() * alphabet.length) | 0];
-    }
-    return id
-  }
-};
-let nanoid$1 = (size = 21) => {
-  let id = '';
-  let i = size;
-  while (i--) {
-    id += urlAlphabet[(Math.random() * 64) | 0];
-  }
-  return id
-};
-var nonSecure = { nanoid: nanoid$1, customAlphabet };
+let AtRule$4, parse$4, Root$6, Rule$4;
 
-let { SourceMapConsumer: SourceMapConsumer$4, SourceMapGenerator: SourceMapGenerator$5 } = sourceMap$2;
-let { existsSync, readFileSync } = require$$0$2;
-let { dirname: dirname$1, join } = require$$1;
+function cleanSource(nodes) {
+  return nodes.map(i => {
+    if (i.nodes) i.nodes = cleanSource(i.nodes);
+    delete i.source;
+    return i
+  })
+}
 
-function fromBase64(str) {
-  if (Buffer$1) {
-    return Buffer$1.from(str, 'base64').toString()
-  } else {
-    /* c8 ignore next 2 */
-    return window.atob(str)
+function markTreeDirty(node) {
+  node[isClean$1] = false;
+  if (node.proxyOf.nodes) {
+    for (let i of node.proxyOf.nodes) {
+      markTreeDirty(i);
+    }
   }
 }
 
-let PreviousMap$2 = class PreviousMap {
-  constructor(css, opts) {
-    if (opts.map === false) return
-    this.loadAnnotation(css);
-    this.inline = this.startWith(this.annotation, 'data:');
-
-    let prev = opts.map ? opts.map.prev : undefined;
-    let text = this.loadMap(opts.from, prev);
-    if (!this.mapFile && opts.from) {
-      this.mapFile = opts.from;
+let Container$7 = 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);
     }
-    if (this.mapFile) this.root = dirname$1(this.mapFile);
-    if (text) this.text = text;
+
+    this.markDirty();
+
+    return this
   }
 
-  consumer() {
-    if (!this.consumerCache) {
-      this.consumerCache = new SourceMapConsumer$4(this.text);
+  cleanRaws(keepBetween) {
+    super.cleanRaws(keepBetween);
+    if (this.nodes) {
+      for (let node of this.nodes) node.cleanRaws(keepBetween);
     }
-    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,/;
+  each(callback) {
+    if (!this.proxyOf.nodes) return undefined
+    let iterator = this.getIterator();
 
-    let uriMatch = text.match(charsetUri) || text.match(uri);
-    if (uriMatch) {
-      return decodeURIComponent(text.substr(uriMatch[0].length))
-    }
+    let index, result;
+    while (this.indexes[iterator] < this.proxyOf.nodes.length) {
+      index = this.indexes[iterator];
+      result = callback(this.proxyOf.nodes[index], index);
+      if (result === false) break
 
-    let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri);
-    if (baseUriMatch) {
-      return fromBase64(text.substr(baseUriMatch[0].length))
+      this.indexes[iterator] += 1;
     }
 
-    let encoding = text.match(/data:application\/json;([^,]+),/)[1];
-    throw new Error('Unsupported source map encoding ' + encoding)
-  }
-
-  getAnnotationURL(sourceMapString) {
-    return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, '').trim()
+    delete this.indexes[iterator];
+    return result
   }
 
-  isMap(map) {
-    if (typeof map !== 'object') return false
-    return (
-      typeof map.mappings === 'string' ||
-      typeof map._mappings === 'string' ||
-      Array.isArray(map.sections)
-    )
+  every(condition) {
+    return this.nodes.every(condition)
   }
 
-  loadAnnotation(css) {
-    let comments = css.match(/\/\*\s*# sourceMappingURL=/g);
-    if (!comments) return
-
-    // sourceMappingURLs from comments, strings, etc.
-    let start = css.lastIndexOf(comments.pop());
-    let end = css.indexOf('*/', start);
+  getIterator() {
+    if (!this.lastEach) this.lastEach = 0;
+    if (!this.indexes) this.indexes = {};
 
-    if (start > -1 && end > -1) {
-      // Locate the last sourceMappingURL to avoid pickin
-      this.annotation = this.getAnnotationURL(css.substring(start, end));
-    }
-  }
+    this.lastEach += 1;
+    let iterator = this.lastEach;
+    this.indexes[iterator] = 0;
 
-  loadFile(path) {
-    this.root = dirname$1(path);
-    if (existsSync(path)) {
-      this.mapFile = path;
-      return readFileSync(path, 'utf-8').toString().trim()
-    }
+    return iterator
   }
 
-  loadMap(file, prev) {
-    if (prev === false) return false
-
-    if (prev) {
-      if (typeof prev === 'string') {
-        return prev
-      } else if (typeof prev === 'function') {
-        let prevPath = prev(file);
-        if (prevPath) {
-          let map = this.loadFile(prevPath);
-          if (!map) {
-            throw new Error(
-              'Unable to load previous source map: ' + prevPath.toString()
+  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
+                }
+              })
             )
           }
-          return map
+        } 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]
         }
-      } else if (prev instanceof SourceMapConsumer$4) {
-        return SourceMapGenerator$5.fromSourceMap(prev).toString()
-      } else if (prev instanceof SourceMapGenerator$5) {
-        return prev.toString()
-      } else if (this.isMap(prev)) {
-        return JSON.stringify(prev)
-      } else {
-        throw new Error(
-          'Unsupported previous source map format: ' + prev.toString()
-        )
+      },
+
+      set(node, prop, value) {
+        if (node[prop] === value) return true
+        node[prop] = value;
+        if (prop === 'name' || prop === 'params' || prop === 'selector') {
+          node.markDirty();
+        }
+        return true
       }
-    } else if (this.inline) {
-      return this.decodeInline(this.annotation)
-    } else if (this.annotation) {
-      let map = this.annotation;
-      if (file) map = join(dirname$1(file), map);
-      return this.loadFile(map)
     }
   }
 
-  startWith(string, start) {
-    if (!string) return false
-    return string.substr(0, start.length) === start
-  }
-
-  withContent() {
-    return !!(
-      this.consumer().sourcesContent &&
-      this.consumer().sourcesContent.length > 0
-    )
+  index(child) {
+    if (typeof child === 'number') return child
+    if (child.proxyOf) child = child.proxyOf;
+    return this.proxyOf.nodes.indexOf(child)
   }
-};
 
-var previousMap = PreviousMap$2;
-PreviousMap$2.default = PreviousMap$2;
+  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);
 
-let { SourceMapConsumer: SourceMapConsumer$3, SourceMapGenerator: SourceMapGenerator$4 } = sourceMap$2;
-let { fileURLToPath, pathToFileURL: pathToFileURL$1 } = require$$2;
-let { isAbsolute, resolve: resolve$1 } = require$$1;
-let { nanoid } = nonSecure;
+    let index;
+    for (let id in this.indexes) {
+      index = this.indexes[id];
+      if (existIndex < index) {
+        this.indexes[id] = index + nodes.length;
+      }
+    }
 
-let terminalHighlight = terminalHighlight_1;
-let CssSyntaxError$1 = cssSyntaxError;
-let PreviousMap$1 = previousMap;
+    this.markDirty();
 
-let fromOffsetCache = Symbol('fromOffsetCache');
+    return this
+  }
 
-let sourceMapAvailable$1 = Boolean(SourceMapConsumer$3 && SourceMapGenerator$4);
-let pathAvailable$1 = Boolean(resolve$1 && isAbsolute);
+  insertBefore(exist, add) {
+    let existIndex = this.index(exist);
+    let type = existIndex === 0 ? 'prepend' : false;
+    let nodes = this.normalize(
+      add,
+      this.proxyOf.nodes[existIndex],
+      type
+    ).reverse();
+    existIndex = this.index(exist);
+    for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node);
 
-let Input$4 = class Input {
-  constructor(css, opts = {}) {
-    if (
-      css === null ||
-      typeof css === 'undefined' ||
-      (typeof css === 'object' && !css.toString)
-    ) {
-      throw new Error(`PostCSS received ${css} instead of CSS string`)
+    let index;
+    for (let id in this.indexes) {
+      index = this.indexes[id];
+      if (existIndex <= index) {
+        this.indexes[id] = index + nodes.length;
+      }
     }
 
-    this.css = css.toString();
+    this.markDirty();
 
-    if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') {
-      this.hasBOM = true;
-      this.css = this.css.slice(1);
-    } else {
-      this.hasBOM = false;
-    }
+    return this
+  }
 
-    if (opts.from) {
-      if (
-        !pathAvailable$1 ||
-        /^\w+:\/\//.test(opts.from) ||
-        isAbsolute(opts.from)
-      ) {
-        this.file = opts.from;
-      } else {
-        this.file = resolve$1(opts.from);
+  normalize(nodes, sample) {
+    if (typeof nodes === 'string') {
+      nodes = cleanSource(parse$4(nodes).nodes);
+    } else if (typeof nodes === 'undefined') {
+      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$3(nodes)];
+    } else if (nodes.selector || nodes.selectors) {
+      nodes = [new Rule$4(nodes)];
+    } else if (nodes.name) {
+      nodes = [new AtRule$4(nodes)];
+    } else if (nodes.text) {
+      nodes = [new Comment$3(nodes)];
+    } else {
+      throw new Error('Unknown node type in node creation')
     }
 
-    if (pathAvailable$1 && sourceMapAvailable$1) {
-      let map = new PreviousMap$1(this.css, opts);
-      if (map.text) {
-        this.map = map;
-        let file = map.consumer().file;
-        if (!this.file && file) this.file = this.mapResolve(file);
+    let processed = nodes.map(i => {
+      /* c8 ignore next */
+      if (!i[my$1] || !i.markClean) Container.rebuild(i);
+      i = i.proxyOf;
+      if (i.parent) i.parent.removeChild(i);
+      if (i[isClean$1]) markTreeDirty(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
+    });
 
-    if (!this.file) {
-      this.id = '<input css ' + nanoid(6) + '>';
-    }
-    if (this.map) this.map.file = this.from;
+    return processed
   }
 
-  error(message, line, column, opts = {}) {
-    let result, endLine, endColumn;
-
-    if (line && typeof line === 'object') {
-      let start = line;
-      let end = column;
-      if (typeof start.offset === 'number') {
-        let pos = this.fromOffset(start.offset);
-        line = pos.line;
-        column = pos.col;
-      } else {
-        line = start.line;
-        column = start.column;
-      }
-      if (typeof end.offset === 'number') {
-        let pos = this.fromOffset(end.offset);
-        endLine = pos.line;
-        endColumn = pos.col;
-      } else {
-        endLine = end.line;
-        endColumn = end.column;
+  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;
       }
-    } else if (!column) {
-      let pos = this.fromOffset(line);
-      line = pos.line;
-      column = pos.col;
     }
 
-    let origin = this.origin(line, column, endLine, endColumn);
-    if (origin) {
-      result = new CssSyntaxError$1(
-        message,
-        origin.endLine === undefined
-          ? origin.line
-          : { column: origin.column, line: origin.line },
-        origin.endLine === undefined
-          ? origin.column
-          : { column: origin.endColumn, line: origin.endLine },
-        origin.source,
-        origin.file,
-        opts.plugin
-      );
-    } else {
-      result = new CssSyntaxError$1(
-        message,
-        endLine === undefined ? line : { column, line },
-        endLine === undefined ? column : { column: endColumn, line: endLine },
-        this.css,
-        this.file,
-        opts.plugin
-      );
-    }
+    this.markDirty();
 
-    result.input = { column, endColumn, endLine, line, source: this.css };
-    if (this.file) {
-      if (pathToFileURL$1) {
-        result.input.url = pathToFileURL$1(this.file).toString();
-      }
-      result.input.file = this.file;
-    }
+    return this
+  }
 
-    return result
+  push(child) {
+    child.parent = this;
+    this.proxyOf.nodes.push(child);
+    return this
   }
 
-  fromOffset(offset) {
-    let lastLine, lineToIndex;
-    if (!this[fromOffsetCache]) {
-      let lines = this.css.split('\n');
-      lineToIndex = new Array(lines.length);
-      let prevIndex = 0;
+  removeAll() {
+    for (let node of this.proxyOf.nodes) node.parent = undefined;
+    this.proxyOf.nodes = [];
 
-      for (let i = 0, l = lines.length; i < l; i++) {
-        lineToIndex[i] = prevIndex;
-        prevIndex += lines[i].length + 1;
-      }
+    this.markDirty();
 
-      this[fromOffsetCache] = lineToIndex;
-    } else {
-      lineToIndex = this[fromOffsetCache];
-    }
-    lastLine = lineToIndex[lineToIndex.length - 1];
+    return this
+  }
 
-    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
-        }
+  removeChild(child) {
+    child = this.index(child);
+    this.proxyOf.nodes[child].parent = undefined;
+    this.proxyOf.nodes.splice(child, 1);
+
+    let index;
+    for (let id in this.indexes) {
+      index = this.indexes[id];
+      if (index >= child) {
+        this.indexes[id] = index - 1;
       }
     }
-    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)
+    this.markDirty();
+
+    return this
   }
 
-  origin(line, column, endLine, endColumn) {
-    if (!this.map) return false
-    let consumer = this.map.consumer();
+  replaceValues(pattern, opts, callback) {
+    if (!callback) {
+      callback = opts;
+      opts = {};
+    }
 
-    let from = consumer.originalPositionFor({ column, line });
-    if (!from.source) return false
+    this.walkDecls(decl => {
+      if (opts.props && !opts.props.includes(decl.prop)) return
+      if (opts.fast && !decl.value.includes(opts.fast)) return
 
-    let to;
-    if (typeof endLine === 'number') {
-      to = consumer.originalPositionFor({ column: endColumn, line: endLine });
-    }
+      decl.value = decl.value.replace(pattern, callback);
+    });
 
-    let fromUrl;
+    this.markDirty();
 
-    if (isAbsolute(from.source)) {
-      fromUrl = pathToFileURL$1(from.source);
-    } else {
-      fromUrl = new URL(
-        from.source,
-        this.map.consumer().sourceRoot || pathToFileURL$1(this.map.mapFile)
-      );
-    }
+    return this
+  }
 
-    let result = {
-      column: from.column,
-      endColumn: to && to.column,
-      endLine: to && to.line,
-      line: from.line,
-      url: fromUrl.toString()
-    };
+  some(condition) {
+    return this.nodes.some(condition)
+  }
 
-    if (fromUrl.protocol === 'file:') {
-      if (fileURLToPath) {
-        result.file = fileURLToPath(fromUrl);
-      } else {
-        /* c8 ignore next 2 */
-        throw new Error(`file: protocol is not available in this PostCSS build`)
+  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);
       }
-    }
 
-    let source = consumer.sourceContentFor(from.source);
-    if (source) result.source = source;
+      return result
+    })
+  }
 
-    return result
+  walkAtRules(name, callback) {
+    if (!callback) {
+      callback = name;
+      return this.walk((child, i) => {
+        if (child.type === 'atrule') {
+          return callback(child, i)
+        }
+      })
+    }
+    if (name instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === 'atrule' && name.test(child.name)) {
+          return callback(child, i)
+        }
+      })
+    }
+    return this.walk((child, i) => {
+      if (child.type === 'atrule' && child.name === name) {
+        return callback(child, i)
+      }
+    })
   }
 
-  toJSON() {
-    let json = {};
-    for (let name of ['hasBOM', 'css', 'file', 'id']) {
-      if (this[name] != null) {
-        json[name] = this[name];
+  walkComments(callback) {
+    return this.walk((child, i) => {
+      if (child.type === 'comment') {
+        return callback(child, i)
       }
+    })
+  }
+
+  walkDecls(prop, callback) {
+    if (!callback) {
+      callback = prop;
+      return this.walk((child, i) => {
+        if (child.type === 'decl') {
+          return callback(child, i)
+        }
+      })
     }
-    if (this.map) {
-      json.map = { ...this.map };
-      if (json.map.consumerCache) {
-        json.map.consumerCache = undefined;
+    if (prop instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === 'decl' && prop.test(child.prop)) {
+          return callback(child, i)
+        }
+      })
+    }
+    return this.walk((child, i) => {
+      if (child.type === 'decl' && child.prop === prop) {
+        return callback(child, i)
       }
+    })
+  }
+
+  walkRules(selector, callback) {
+    if (!callback) {
+      callback = selector;
+
+      return this.walk((child, i) => {
+        if (child.type === 'rule') {
+          return callback(child, i)
+        }
+      })
     }
-    return json
+    if (selector instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === 'rule' && selector.test(child.selector)) {
+          return callback(child, i)
+        }
+      })
+    }
+    return this.walk((child, i) => {
+      if (child.type === 'rule' && child.selector === selector) {
+        return callback(child, i)
+      }
+    })
   }
 
-  get from() {
-    return this.file || this.id
+  get first() {
+    if (!this.proxyOf.nodes) return undefined
+    return this.proxyOf.nodes[0]
   }
-};
 
-var input = Input$4;
-Input$4.default = Input$4;
+  get last() {
+    if (!this.proxyOf.nodes) return undefined
+    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]
+  }
+};
 
-if (terminalHighlight && terminalHighlight.registerInput) {
-  terminalHighlight.registerInput(Input$4);
-}
+Container$7.registerParse = dependant => {
+  parse$4 = dependant;
+};
 
-let { SourceMapConsumer: SourceMapConsumer$2, SourceMapGenerator: SourceMapGenerator$3 } = sourceMap$2;
-let { dirname, relative, resolve, sep } = require$$1;
-let { pathToFileURL } = require$$2;
+Container$7.registerRule = dependant => {
+  Rule$4 = dependant;
+};
 
-let Input$3 = input;
+Container$7.registerAtRule = dependant => {
+  AtRule$4 = dependant;
+};
 
-let sourceMapAvailable = Boolean(SourceMapConsumer$2 && SourceMapGenerator$3);
-let pathAvailable = Boolean(dirname && resolve && relative && sep);
+Container$7.registerRoot = dependant => {
+  Root$6 = dependant;
+};
 
-let MapGenerator$2 = class MapGenerator {
-  constructor(stringify, root, opts, cssString) {
-    this.stringify = stringify;
-    this.mapOpts = opts.map || {};
-    this.root = root;
-    this.opts = opts;
-    this.css = cssString;
-    this.originalCSS = cssString;
-    this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute;
+var container$1 = Container$7;
+Container$7.default = Container$7;
 
-    this.memoizedFileURLs = new Map();
-    this.memoizedPaths = new Map();
-    this.memoizedURLs = new Map();
+/* c8 ignore start */
+Container$7.rebuild = node => {
+  if (node.type === 'atrule') {
+    Object.setPrototypeOf(node, AtRule$4.prototype);
+  } else if (node.type === 'rule') {
+    Object.setPrototypeOf(node, Rule$4.prototype);
+  } else if (node.type === 'decl') {
+    Object.setPrototypeOf(node, Declaration$3.prototype);
+  } else if (node.type === 'comment') {
+    Object.setPrototypeOf(node, Comment$3.prototype);
+  } else if (node.type === 'root') {
+    Object.setPrototypeOf(node, Root$6.prototype);
   }
 
-  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 {
-      content = this.outputFile() + '.map';
-    }
-    let eol = '\n';
-    if (this.css.includes('\r\n')) eol = '\r\n';
+  node[my$1] = true;
 
-    this.css += eol + '/*# sourceMappingURL=' + content + ' */';
+  if (node.nodes) {
+    node.nodes.forEach(child => {
+      Container$7.rebuild(child);
+    });
   }
+};
 
-  applyPrevMaps() {
-    for (let prev of this.previous()) {
-      let from = this.toUrl(this.path(prev.file));
-      let root = prev.root || dirname(prev.file);
-      let map;
-
-      if (this.mapOpts.sourcesContent === false) {
-        map = new SourceMapConsumer$2(prev.text);
-        if (map.sourcesContent) {
-          map.sourcesContent = null;
-        }
-      } else {
-        map = prev.consumer();
-      }
+let Container$6 = container$1;
 
-      this.map.applySourceMap(map, from, this.toUrl(this.path(root)));
-    }
+let AtRule$3 = class AtRule extends Container$6 {
+  constructor(defaults) {
+    super(defaults);
+    this.type = 'atrule';
   }
 
-  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, '');
-    }
+  append(...children) {
+    if (!this.proxyOf.nodes) this.nodes = [];
+    return super.append(...children)
   }
 
-  generate() {
-    this.clearAnnotation();
-    if (pathAvailable && sourceMapAvailable && this.isMap()) {
-      return this.generateMap()
-    } else {
-      let result = '';
-      this.stringify(this.root, i => {
-        result += i;
-      });
-      return [result]
-    }
+  prepend(...children) {
+    if (!this.proxyOf.nodes) this.nodes = [];
+    return super.prepend(...children)
   }
+};
 
-  generateMap() {
-    if (this.root) {
-      this.generateString();
-    } else if (this.previous().length === 1) {
-      let prev = this.previous()[0].consumer();
-      prev.file = this.outputFile();
-      this.map = SourceMapGenerator$3.fromSourceMap(prev, {
-        ignoreInvalidMapping: true
-      });
-    } else {
-      this.map = new SourceMapGenerator$3({
-        file: this.outputFile(),
-        ignoreInvalidMapping: true
-      });
-      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>'
-      });
-    }
+var atRule = AtRule$3;
+AtRule$3.default = AtRule$3;
 
-    if (this.isSourcesContent()) this.setSourcesContent();
-    if (this.root && this.previous().length > 0) this.applyPrevMaps();
-    if (this.isAnnotation()) this.addAnnotation();
+Container$6.registerAtRule(AtRule$3);
 
-    if (this.isInline()) {
-      return [this.css]
-    } else {
-      return [this.css, this.map]
-    }
-  }
+let Container$5 = container$1;
 
-  generateString() {
-    this.css = '';
-    this.map = new SourceMapGenerator$3({
-      file: this.outputFile(),
-      ignoreInvalidMapping: true
-    });
+let LazyResult$4, Processor$3;
 
-    let line = 1;
-    let column = 1;
+let Document$3 = class Document extends Container$5 {
+  constructor(defaults) {
+    // type needs to be passed to super, otherwise child roots won't be normalized correctly
+    super({ type: 'document', ...defaults });
 
-    let noSource = '<no source>';
-    let mapping = {
-      generated: { column: 0, line: 0 },
-      original: { column: 0, line: 0 },
-      source: ''
-    };
+    if (!this.nodes) {
+      this.nodes = [];
+    }
+  }
 
-    let lines, last;
-    this.stringify(this.root, (str, node, type) => {
-      this.css += str;
+  toResult(opts = {}) {
+    let lazy = new LazyResult$4(new Processor$3(), this, opts);
 
-      if (node && type !== 'end') {
-        mapping.generated.line = line;
-        mapping.generated.column = column - 1;
-        if (node.source && node.source.start) {
-          mapping.source = this.sourcePath(node);
-          mapping.original.line = node.source.start.line;
-          mapping.original.column = node.source.start.column - 1;
-          this.map.addMapping(mapping);
-        } else {
-          mapping.source = noSource;
-          mapping.original.line = 1;
-          mapping.original.column = 0;
-          this.map.addMapping(mapping);
-        }
-      }
+    return lazy.stringify()
+  }
+};
 
-      lines = str.match(/\n/g);
-      if (lines) {
-        line += lines.length;
-        last = str.lastIndexOf('\n');
-        column = str.length - last;
-      } else {
-        column += str.length;
-      }
+Document$3.registerLazyResult = dependant => {
+  LazyResult$4 = dependant;
+};
 
-      if (node && type !== 'start') {
-        let p = node.parent || { raws: {} };
-        let childless =
-          node.type === 'decl' || (node.type === 'atrule' && !node.nodes);
-        if (!childless || node !== p.last || p.raws.semicolon) {
-          if (node.source && node.source.end) {
-            mapping.source = this.sourcePath(node);
-            mapping.original.line = node.source.end.line;
-            mapping.original.column = node.source.end.column - 1;
-            mapping.generated.line = line;
-            mapping.generated.column = column - 2;
-            this.map.addMapping(mapping);
-          } else {
-            mapping.source = noSource;
-            mapping.original.line = 1;
-            mapping.original.column = 0;
-            mapping.generated.line = line;
-            mapping.generated.column = column - 1;
-            this.map.addMapping(mapping);
-          }
-        }
-      }
-    });
-  }
+Document$3.registerProcessor = dependant => {
+  Processor$3 = dependant;
+};
 
-  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)
+var document = Document$3;
+Document$3.default = Document$3;
+
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  return (size = defaultSize) => {
+    let id = '';
+    let i = size;
+    while (i--) {
+      id += alphabet[(Math.random() * alphabet.length) | 0];
     }
-    return true
+    return id
   }
+};
+let nanoid$1 = (size = 21) => {
+  let id = '';
+  let i = size;
+  while (i--) {
+    id += urlAlphabet[(Math.random() * 64) | 0];
+  }
+  return id
+};
+var nonSecure = { nanoid: nanoid$1, customAlphabet };
 
-  isInline() {
-    if (typeof this.mapOpts.inline !== 'undefined') {
-      return this.mapOpts.inline
-    }
+var require$$2 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_url$1);
 
-    let annotation = this.mapOpts.annotation;
-    if (typeof annotation !== 'undefined' && annotation !== true) {
-      return false
-    }
+let { existsSync, readFileSync } = require$$0$2;
+let { dirname: dirname$1, join } = require$$1;
+let { SourceMapConsumer: SourceMapConsumer$4, SourceMapGenerator: SourceMapGenerator$5 } = sourceMap$2;
 
-    if (this.previous().length) {
-      return this.previous().some(i => i.inline)
-    }
-    return true
+function fromBase64(str) {
+  if (Buffer$1) {
+    return Buffer$1.from(str, 'base64').toString()
+  } else {
+    /* c8 ignore next 2 */
+    return window.atob(str)
   }
+}
 
-  isMap() {
-    if (typeof this.opts.map !== 'undefined') {
-      return !!this.opts.map
-    }
-    return this.previous().length > 0
-  }
+let PreviousMap$2 = class PreviousMap {
+  constructor(css, opts) {
+    if (opts.map === false) return
+    this.loadAnnotation(css);
+    this.inline = this.startWith(this.annotation, 'data:');
 
-  isSourcesContent() {
-    if (typeof this.mapOpts.sourcesContent !== 'undefined') {
-      return this.mapOpts.sourcesContent
-    }
-    if (this.previous().length) {
-      return this.previous().some(i => i.withContent())
+    let prev = opts.map ? opts.map.prev : undefined;
+    let text = this.loadMap(opts.from, prev);
+    if (!this.mapFile && opts.from) {
+      this.mapFile = opts.from;
     }
-    return true
+    if (this.mapFile) this.root = dirname$1(this.mapFile);
+    if (text) this.text = text;
   }
 
-  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'
+  consumer() {
+    if (!this.consumerCache) {
+      this.consumerCache = new SourceMapConsumer$4(this.text);
     }
+    return this.consumerCache
   }
 
-  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) : '.';
+  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 (typeof this.mapOpts.annotation === 'string') {
-      from = dirname(resolve(from, this.mapOpts.annotation));
+    let uriMatch = text.match(charsetUri) || text.match(uri);
+    if (uriMatch) {
+      return decodeURIComponent(text.substr(uriMatch[0].length))
     }
 
-    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 = new Input$3(this.originalCSS, this.opts);
-        if (input.map) this.previousMaps.push(input.map);
-      }
+    let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri);
+    if (baseUriMatch) {
+      return fromBase64(text.substr(baseUriMatch[0].length))
     }
 
-    return this.previousMaps
+    let encoding = text.match(/data:application\/json;([^,]+),/)[1];
+    throw new Error('Unsupported source map encoding ' + encoding)
   }
 
-  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);
-    }
+  getAnnotationURL(sourceMapString) {
+    return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, '').trim()
   }
 
-  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))
-    }
+  isMap(map) {
+    if (typeof map !== 'object') return false
+    return (
+      typeof map.mappings === 'string' ||
+      typeof map._mappings === 'string' ||
+      Array.isArray(map.sections)
+    )
   }
 
-  toBase64(str) {
-    if (Buffer$1) {
-      return Buffer$1.from(str).toString('base64')
-    } else {
-      return window.btoa(unescape(encodeURIComponent(str)))
-    }
-  }
+  loadAnnotation(css) {
+    let comments = css.match(/\/\*\s*# sourceMappingURL=/g);
+    if (!comments) return
 
-  toFileUrl(path) {
-    let cached = this.memoizedFileURLs.get(path);
-    if (cached) return cached
+    // sourceMappingURLs from comments, strings, etc.
+    let start = css.lastIndexOf(comments.pop());
+    let end = css.indexOf('*/', start);
 
-    if (pathToFileURL) {
-      let fileURL = pathToFileURL(path).toString();
-      this.memoizedFileURLs.set(path, fileURL);
+    if (start > -1 && end > -1) {
+      // Locate the last sourceMappingURL to avoid pickin
+      this.annotation = this.getAnnotationURL(css.substring(start, end));
+    }
+  }
 
-      return fileURL
-    } else {
-      throw new Error(
-        '`map.absolute` option is not available in this PostCSS build'
-      )
+  loadFile(path) {
+    this.root = dirname$1(path);
+    if (existsSync(path)) {
+      this.mapFile = path;
+      return readFileSync(path, 'utf-8').toString().trim()
     }
   }
 
-  toUrl(path) {
-    let cached = this.memoizedURLs.get(path);
-    if (cached) return cached
+  loadMap(file, prev) {
+    if (prev === false) return false
 
-    if (sep === '\\') {
-      path = path.replace(/\\/g, '/');
+    if (prev) {
+      if (typeof prev === 'string') {
+        return prev
+      } else if (typeof prev === 'function') {
+        let prevPath = prev(file);
+        if (prevPath) {
+          let map = this.loadFile(prevPath);
+          if (!map) {
+            throw new Error(
+              'Unable to load previous source map: ' + prevPath.toString()
+            )
+          }
+          return map
+        }
+      } else if (prev instanceof SourceMapConsumer$4) {
+        return SourceMapGenerator$5.fromSourceMap(prev).toString()
+      } else if (prev instanceof SourceMapGenerator$5) {
+        return prev.toString()
+      } else if (this.isMap(prev)) {
+        return JSON.stringify(prev)
+      } else {
+        throw new Error(
+          'Unsupported previous source map format: ' + prev.toString()
+        )
+      }
+    } else if (this.inline) {
+      return this.decodeInline(this.annotation)
+    } else if (this.annotation) {
+      let map = this.annotation;
+      if (file) map = join(dirname$1(file), map);
+      return this.loadFile(map)
     }
+  }
 
-    let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
-    this.memoizedURLs.set(path, url);
+  startWith(string, start) {
+    if (!string) return false
+    return string.substr(0, start.length) === start
+  }
 
-    return url
+  withContent() {
+    return !!(
+      this.consumer().sourcesContent &&
+      this.consumer().sourcesContent.length > 0
+    )
   }
 };
 
-var mapGenerator = MapGenerator$2;
+var previousMap = PreviousMap$2;
+PreviousMap$2.default = PreviousMap$2;
 
-let Node$2 = node$2;
+let { nanoid } = nonSecure;
+let { isAbsolute, resolve: resolve$1 } = require$$1;
+let { SourceMapConsumer: SourceMapConsumer$3, SourceMapGenerator: SourceMapGenerator$4 } = sourceMap$2;
+let { fileURLToPath, pathToFileURL: pathToFileURL$1 } = require$$2;
 
-let Comment$4 = class Comment extends Node$2 {
-  constructor(defaults) {
-    super(defaults);
-    this.type = 'comment';
-  }
-};
+let CssSyntaxError$1 = cssSyntaxError;
+let PreviousMap$1 = previousMap;
+let terminalHighlight = terminalHighlight_1;
 
-var comment$3 = Comment$4;
-Comment$4.default = Comment$4;
+let fromOffsetCache = Symbol('fromOffsetCache');
 
-let { isClean: isClean$1, my: my$1 } = symbols;
-let Declaration$3 = declaration;
-let Comment$3 = comment$3;
-let Node$1 = node$2;
+let sourceMapAvailable$1 = Boolean(SourceMapConsumer$3 && SourceMapGenerator$4);
+let pathAvailable$1 = Boolean(resolve$1 && isAbsolute);
 
-let parse$4, Rule$4, AtRule$4, Root$6;
+let Input$4 = class Input {
+  constructor(css, opts = {}) {
+    if (
+      css === null ||
+      typeof css === 'undefined' ||
+      (typeof css === 'object' && !css.toString)
+    ) {
+      throw new Error(`PostCSS received ${css} instead of CSS string`)
+    }
 
-function cleanSource(nodes) {
-  return nodes.map(i => {
-    if (i.nodes) i.nodes = cleanSource(i.nodes);
-    delete i.source;
-    return i
-  })
-}
+    this.css = css.toString();
 
-function markTreeDirty(node) {
-  node[isClean$1] = false;
-  if (node.proxyOf.nodes) {
-    for (let i of node.proxyOf.nodes) {
-      markTreeDirty(i);
+    if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') {
+      this.hasBOM = true;
+      this.css = this.css.slice(1);
+    } else {
+      this.hasBOM = false;
     }
-  }
-}
 
-let Container$7 = 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);
+    if (opts.from) {
+      if (
+        !pathAvailable$1 ||
+        /^\w+:\/\//.test(opts.from) ||
+        isAbsolute(opts.from)
+      ) {
+        this.file = opts.from;
+      } else {
+        this.file = resolve$1(opts.from);
+      }
     }
 
-    this.markDirty();
-
-    return this
-  }
+    if (pathAvailable$1 && sourceMapAvailable$1) {
+      let map = new PreviousMap$1(this.css, opts);
+      if (map.text) {
+        this.map = map;
+        let file = map.consumer().file;
+        if (!this.file && file) this.file = this.mapResolve(file);
+      }
+    }
 
-  cleanRaws(keepBetween) {
-    super.cleanRaws(keepBetween);
-    if (this.nodes) {
-      for (let node of this.nodes) node.cleanRaws(keepBetween);
+    if (!this.file) {
+      this.id = '<input css ' + nanoid(6) + '>';
     }
+    if (this.map) this.map.file = this.from;
   }
 
-  each(callback) {
-    if (!this.proxyOf.nodes) return undefined
-    let iterator = this.getIterator();
+  error(message, line, column, opts = {}) {
+    let endColumn, endLine, result;
 
-    let index, result;
-    while (this.indexes[iterator] < this.proxyOf.nodes.length) {
-      index = this.indexes[iterator];
-      result = callback(this.proxyOf.nodes[index], index);
-      if (result === false) break
+    if (line && typeof line === 'object') {
+      let start = line;
+      let end = column;
+      if (typeof start.offset === 'number') {
+        let pos = this.fromOffset(start.offset);
+        line = pos.line;
+        column = pos.col;
+      } else {
+        line = start.line;
+        column = start.column;
+      }
+      if (typeof end.offset === 'number') {
+        let pos = this.fromOffset(end.offset);
+        endLine = pos.line;
+        endColumn = pos.col;
+      } else {
+        endLine = end.line;
+        endColumn = end.column;
+      }
+    } else if (!column) {
+      let pos = this.fromOffset(line);
+      line = pos.line;
+      column = pos.col;
+    }
 
-      this.indexes[iterator] += 1;
+    let origin = this.origin(line, column, endLine, endColumn);
+    if (origin) {
+      result = new CssSyntaxError$1(
+        message,
+        origin.endLine === undefined
+          ? origin.line
+          : { column: origin.column, line: origin.line },
+        origin.endLine === undefined
+          ? origin.column
+          : { column: origin.endColumn, line: origin.endLine },
+        origin.source,
+        origin.file,
+        opts.plugin
+      );
+    } else {
+      result = new CssSyntaxError$1(
+        message,
+        endLine === undefined ? line : { column, line },
+        endLine === undefined ? column : { column: endColumn, line: endLine },
+        this.css,
+        this.file,
+        opts.plugin
+      );
     }
 
-    delete this.indexes[iterator];
-    return result
-  }
+    result.input = { column, endColumn, endLine, line, source: this.css };
+    if (this.file) {
+      if (pathToFileURL$1) {
+        result.input.url = pathToFileURL$1(this.file).toString();
+      }
+      result.input.file = this.file;
+    }
 
-  every(condition) {
-    return this.nodes.every(condition)
+    return result
   }
 
-  getIterator() {
-    if (!this.lastEach) this.lastEach = 0;
-    if (!this.indexes) this.indexes = {};
+  fromOffset(offset) {
+    let lastLine, lineToIndex;
+    if (!this[fromOffsetCache]) {
+      let lines = this.css.split('\n');
+      lineToIndex = new Array(lines.length);
+      let prevIndex = 0;
 
-    this.lastEach += 1;
-    let iterator = this.lastEach;
-    this.indexes[iterator] = 0;
+      for (let i = 0, l = lines.length; i < l; i++) {
+        lineToIndex[i] = prevIndex;
+        prevIndex += lines[i].length + 1;
+      }
 
-    return iterator
-  }
+      this[fromOffsetCache] = lineToIndex;
+    } else {
+      lineToIndex = this[fromOffsetCache];
+    }
+    lastLine = lineToIndex[lineToIndex.length - 1];
 
-  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()
+    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 {
-          return node[prop]
-        }
-      },
-
-      set(node, prop, value) {
-        if (node[prop] === value) return true
-        node[prop] = value;
-        if (prop === 'name' || prop === 'params' || prop === 'selector') {
-          node.markDirty();
+          min = mid;
+          break
         }
-        return true
       }
     }
+    return {
+      col: offset - lineToIndex[min] + 1,
+      line: min + 1
+    }
   }
 
-  index(child) {
-    if (typeof child === 'number') return child
-    if (child.proxyOf) child = child.proxyOf;
-    return this.proxyOf.nodes.indexOf(child)
+  mapResolve(file) {
+    if (/^\w+:\/\//.test(file)) {
+      return file
+    }
+    return resolve$1(this.map.consumer().sourceRoot || this.map.root || '.', file)
   }
 
-  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);
+  origin(line, column, endLine, endColumn) {
+    if (!this.map) return false
+    let consumer = this.map.consumer();
 
-    let index;
-    for (let id in this.indexes) {
-      index = this.indexes[id];
-      if (existIndex < index) {
-        this.indexes[id] = index + nodes.length;
-      }
+    let from = consumer.originalPositionFor({ column, line });
+    if (!from.source) return false
+
+    let to;
+    if (typeof endLine === 'number') {
+      to = consumer.originalPositionFor({ column: endColumn, line: endLine });
     }
 
-    this.markDirty();
+    let fromUrl;
 
-    return this
-  }
+    if (isAbsolute(from.source)) {
+      fromUrl = pathToFileURL$1(from.source);
+    } else {
+      fromUrl = new URL(
+        from.source,
+        this.map.consumer().sourceRoot || pathToFileURL$1(this.map.mapFile)
+      );
+    }
 
-  insertBefore(exist, add) {
-    let existIndex = this.index(exist);
-    let type = existIndex === 0 ? 'prepend' : false;
-    let nodes = this.normalize(
-      add,
-      this.proxyOf.nodes[existIndex],
-      type
-    ).reverse();
-    existIndex = this.index(exist);
-    for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node);
+    let result = {
+      column: from.column,
+      endColumn: to && to.column,
+      endLine: to && to.line,
+      line: from.line,
+      url: fromUrl.toString()
+    };
 
-    let index;
-    for (let id in this.indexes) {
-      index = this.indexes[id];
-      if (existIndex <= index) {
-        this.indexes[id] = index + nodes.length;
+    if (fromUrl.protocol === 'file:') {
+      if (fileURLToPath) {
+        result.file = fileURLToPath(fromUrl);
+      } else {
+        /* c8 ignore next 2 */
+        throw new Error(`file: protocol is not available in this PostCSS build`)
       }
     }
 
-    this.markDirty();
+    let source = consumer.sourceContentFor(from.source);
+    if (source) result.source = source;
 
-    return this
+    return result
   }
 
-  normalize(nodes, sample) {
-    if (typeof nodes === 'string') {
-      nodes = cleanSource(parse$4(nodes).nodes);
-    } else if (typeof nodes === 'undefined') {
-      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);
+  toJSON() {
+    let json = {};
+    for (let name of ['hasBOM', 'css', 'file', 'id']) {
+      if (this[name] != null) {
+        json[name] = this[name];
       }
-      nodes = [new Declaration$3(nodes)];
-    } else if (nodes.selector || nodes.selectors) {
-      nodes = [new Rule$4(nodes)];
-    } else if (nodes.name) {
-      nodes = [new AtRule$4(nodes)];
-    } else if (nodes.text) {
-      nodes = [new Comment$3(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]) markTreeDirty(i);
-      if (typeof i.raws.before === 'undefined') {
-        if (sample && typeof sample.raws.before !== 'undefined') {
-          i.raws.before = sample.raws.before.replace(/\S/g, '');
-        }
+    if (this.map) {
+      json.map = { ...this.map };
+      if (json.map.consumerCache) {
+        json.map.consumerCache = undefined;
       }
-      i.parent = this.proxyOf;
-      return i
-    });
+    }
+    return json
+  }
 
-    return processed
+  get from() {
+    return this.file || this.id
   }
+};
 
-  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;
-      }
-    }
+var input = Input$4;
+Input$4.default = Input$4;
 
-    this.markDirty();
+if (terminalHighlight && terminalHighlight.registerInput) {
+  terminalHighlight.registerInput(Input$4);
+}
 
-    return this
-  }
+let Container$4 = container$1;
 
-  push(child) {
-    child.parent = this;
-    this.proxyOf.nodes.push(child);
-    return this
+let LazyResult$3, Processor$2;
+
+let Root$5 = class Root extends Container$4 {
+  constructor(defaults) {
+    super(defaults);
+    this.type = 'root';
+    if (!this.nodes) this.nodes = [];
   }
 
-  removeAll() {
-    for (let node of this.proxyOf.nodes) node.parent = undefined;
-    this.proxyOf.nodes = [];
+  normalize(child, sample, type) {
+    let nodes = super.normalize(child);
 
-    this.markDirty();
+    if (sample) {
+      if (type === 'prepend') {
+        if (this.nodes.length > 1) {
+          sample.raws.before = this.nodes[1].raws.before;
+        } else {
+          delete sample.raws.before;
+        }
+      } else if (this.first !== sample) {
+        for (let node of nodes) {
+          node.raws.before = sample.raws.before;
+        }
+      }
+    }
 
-    return this
+    return nodes
   }
 
-  removeChild(child) {
-    child = this.index(child);
-    this.proxyOf.nodes[child].parent = undefined;
-    this.proxyOf.nodes.splice(child, 1);
+  removeChild(child, ignore) {
+    let index = this.index(child);
 
-    let index;
-    for (let id in this.indexes) {
-      index = this.indexes[id];
-      if (index >= child) {
-        this.indexes[id] = index - 1;
-      }
+    if (!ignore && index === 0 && this.nodes.length > 1) {
+      this.nodes[1].raws.before = this.nodes[index].raws.before;
     }
 
-    this.markDirty();
+    return super.removeChild(child)
+  }
 
-    return this
+  toResult(opts = {}) {
+    let lazy = new LazyResult$3(new Processor$2(), this, opts);
+    return lazy.stringify()
   }
+};
 
-  replaceValues(pattern, opts, callback) {
-    if (!callback) {
-      callback = opts;
-      opts = {};
-    }
+Root$5.registerLazyResult = dependant => {
+  LazyResult$3 = dependant;
+};
 
-    this.walkDecls(decl => {
-      if (opts.props && !opts.props.includes(decl.prop)) return
-      if (opts.fast && !decl.value.includes(opts.fast)) return
+Root$5.registerProcessor = dependant => {
+  Processor$2 = dependant;
+};
 
-      decl.value = decl.value.replace(pattern, callback);
-    });
+var root$2 = Root$5;
+Root$5.default = Root$5;
 
-    this.markDirty();
+Container$4.registerRoot(Root$5);
 
-    return this
-  }
+let list$2 = {
+  comma(string) {
+    return list$2.split(string, [','], true)
+  },
 
-  some(condition) {
-    return this.nodes.some(condition)
-  }
+  space(string) {
+    let spaces = [' ', '\n', '\t'];
+    return list$2.split(string, spaces)
+  },
 
-  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);
-      }
+  split(string, separators, last) {
+    let array = [];
+    let current = '';
+    let split = false;
 
-      return result
-    })
-  }
+    let func = 0;
+    let inQuote = false;
+    let prevQuote = '';
+    let escape = false;
 
-  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)
+    for (let letter of string) {
+      if (escape) {
+        escape = false;
+      } else if (letter === '\\') {
+        escape = true;
+      } else if (inQuote) {
+        if (letter === prevQuote) {
+          inQuote = false;
         }
-      })
-    }
-    return this.walk((child, i) => {
-      if (child.type === 'atrule' && child.name === name) {
-        return callback(child, i)
+      } else if (letter === '"' || letter === "'") {
+        inQuote = true;
+        prevQuote = letter;
+      } else if (letter === '(') {
+        func += 1;
+      } else if (letter === ')') {
+        if (func > 0) func -= 1;
+      } else if (func === 0) {
+        if (separators.includes(letter)) split = true;
       }
-    })
-  }
 
-  walkComments(callback) {
-    return this.walk((child, i) => {
-      if (child.type === 'comment') {
-        return callback(child, i)
+      if (split) {
+        if (current !== '') array.push(current.trim());
+        current = '';
+        split = false;
+      } else {
+        current += letter;
       }
-    })
-  }
-
-  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)
-      }
-    })
+
+    if (last || current !== '') array.push(current.trim());
+    return array
   }
+};
 
-  walkRules(selector, callback) {
-    if (!callback) {
-      callback = selector;
+var list_1 = list$2;
+list$2.default = list$2;
 
-      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)
-      }
-    })
-  }
+let Container$3 = container$1;
+let list$1 = list_1;
 
-  get first() {
-    if (!this.proxyOf.nodes) return undefined
-    return this.proxyOf.nodes[0]
+let Rule$3 = class Rule extends Container$3 {
+  constructor(defaults) {
+    super(defaults);
+    this.type = 'rule';
+    if (!this.nodes) this.nodes = [];
   }
 
-  get last() {
-    if (!this.proxyOf.nodes) return undefined
-    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]
+  get selectors() {
+    return list$1.comma(this.selector)
   }
-};
 
-Container$7.registerParse = dependant => {
-  parse$4 = dependant;
+  set selectors(values) {
+    let match = this.selector ? this.selector.match(/,\s*/) : null;
+    let sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen');
+    this.selector = values.join(sep);
+  }
 };
 
-Container$7.registerRule = dependant => {
-  Rule$4 = dependant;
-};
+var rule = Rule$3;
+Rule$3.default = Rule$3;
 
-Container$7.registerAtRule = dependant => {
-  AtRule$4 = dependant;
-};
+Container$3.registerRule(Rule$3);
 
-Container$7.registerRoot = dependant => {
-  Root$6 = dependant;
-};
+let AtRule$2 = atRule;
+let Comment$2 = comment$3;
+let Declaration$2 = declaration;
+let Input$3 = input;
+let PreviousMap = previousMap;
+let Root$4 = root$2;
+let Rule$2 = rule;
 
-var container$1 = Container$7;
-Container$7.default = Container$7;
+function fromJSON$1(json, inputs) {
+  if (Array.isArray(json)) return json.map(n => fromJSON$1(n))
 
-/* c8 ignore start */
-Container$7.rebuild = node => {
-  if (node.type === 'atrule') {
-    Object.setPrototypeOf(node, AtRule$4.prototype);
-  } else if (node.type === 'rule') {
-    Object.setPrototypeOf(node, Rule$4.prototype);
-  } else if (node.type === 'decl') {
-    Object.setPrototypeOf(node, Declaration$3.prototype);
-  } else if (node.type === 'comment') {
-    Object.setPrototypeOf(node, Comment$3.prototype);
-  } else if (node.type === 'root') {
-    Object.setPrototypeOf(node, Root$6.prototype);
+  let { inputs: ownInputs, ...defaults } = json;
+  if (ownInputs) {
+    inputs = [];
+    for (let input of ownInputs) {
+      let inputHydrated = { ...input, __proto__: Input$3.prototype };
+      if (inputHydrated.map) {
+        inputHydrated.map = {
+          ...inputHydrated.map,
+          __proto__: PreviousMap.prototype
+        };
+      }
+      inputs.push(inputHydrated);
+    }
   }
-
-  node[my$1] = true;
-
-  if (node.nodes) {
-    node.nodes.forEach(child => {
-      Container$7.rebuild(child);
-    });
+  if (defaults.nodes) {
+    defaults.nodes = json.nodes.map(n => fromJSON$1(n, inputs));
   }
-};
+  if (defaults.source) {
+    let { inputId, ...source } = defaults.source;
+    defaults.source = source;
+    if (inputId != null) {
+      defaults.source.input = inputs[inputId];
+    }
+  }
+  if (defaults.type === 'root') {
+    return new Root$4(defaults)
+  } else if (defaults.type === 'decl') {
+    return new Declaration$2(defaults)
+  } else if (defaults.type === 'rule') {
+    return new Rule$2(defaults)
+  } else if (defaults.type === 'comment') {
+    return new Comment$2(defaults)
+  } else if (defaults.type === 'atrule') {
+    return new AtRule$2(defaults)
+  } else {
+    throw new Error('Unknown node type: ' + json.type)
+  }
+}
 
-let Container$6 = container$1;
+var fromJSON_1 = fromJSON$1;
+fromJSON$1.default = fromJSON$1;
 
-let LazyResult$4, Processor$3;
+let { dirname, relative, resolve, sep } = require$$1;
+let { SourceMapConsumer: SourceMapConsumer$2, SourceMapGenerator: SourceMapGenerator$3 } = sourceMap$2;
+let { pathToFileURL } = require$$2;
 
-let Document$3 = class Document extends Container$6 {
-  constructor(defaults) {
-    // type needs to be passed to super, otherwise child roots won't be normalized correctly
-    super({ type: 'document', ...defaults });
+let Input$2 = input;
 
-    if (!this.nodes) {
-      this.nodes = [];
-    }
-  }
+let sourceMapAvailable = Boolean(SourceMapConsumer$2 && SourceMapGenerator$3);
+let pathAvailable = Boolean(dirname && resolve && relative && sep);
 
-  toResult(opts = {}) {
-    let lazy = new LazyResult$4(new Processor$3(), this, opts);
+let MapGenerator$2 = class MapGenerator {
+  constructor(stringify, root, opts, cssString) {
+    this.stringify = stringify;
+    this.mapOpts = opts.map || {};
+    this.root = root;
+    this.opts = opts;
+    this.css = cssString;
+    this.originalCSS = cssString;
+    this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute;
 
-    return lazy.stringify()
+    this.memoizedFileURLs = new Map();
+    this.memoizedPaths = new Map();
+    this.memoizedURLs = new Map();
   }
-};
-
-Document$3.registerLazyResult = dependant => {
-  LazyResult$4 = dependant;
-};
 
-Document$3.registerProcessor = dependant => {
-  Processor$3 = dependant;
-};
+  addAnnotation() {
+    let content;
 
-var document = Document$3;
-Document$3.default = Document$3;
+    if (this.isInline()) {
+      content =
+        'data:application/json;base64,' + this.toBase64(this.map.toString());
+    } else if (typeof this.mapOpts.annotation === 'string') {
+      content = this.mapOpts.annotation;
+    } else if (typeof this.mapOpts.annotation === 'function') {
+      content = this.mapOpts.annotation(this.opts.to, this.root);
+    } else {
+      content = this.outputFile() + '.map';
+    }
+    let eol = '\n';
+    if (this.css.includes('\r\n')) eol = '\r\n';
 
-/* eslint-disable no-console */
+    this.css += eol + '/*# sourceMappingURL=' + content + ' */';
+  }
 
-let printed = {};
+  applyPrevMaps() {
+    for (let prev of this.previous()) {
+      let from = this.toUrl(this.path(prev.file));
+      let root = prev.root || dirname(prev.file);
+      let map;
 
-var warnOnce$2 = function warnOnce(message) {
-  if (printed[message]) return
-  printed[message] = true;
+      if (this.mapOpts.sourcesContent === false) {
+        map = new SourceMapConsumer$2(prev.text);
+        if (map.sourcesContent) {
+          map.sourcesContent = null;
+        }
+      } else {
+        map = prev.consumer();
+      }
 
-  if (typeof console !== 'undefined' && console.warn) {
-    console.warn(message);
+      this.map.applySourceMap(map, from, this.toUrl(this.path(root)));
+    }
   }
-};
 
-let Warning$2 = class Warning {
-  constructor(text, opts = {}) {
-    this.type = 'warning';
-    this.text = text;
+  clearAnnotation() {
+    if (this.mapOpts.annotation === false) return
 
-    if (opts.node && opts.node.source) {
-      let range = opts.node.rangeBy(opts);
-      this.line = range.start.line;
-      this.column = range.start.column;
-      this.endLine = range.end.line;
-      this.endColumn = range.end.column;
+    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.startsWith('# sourceMappingURL=')) {
+          this.root.removeChild(i);
+        }
+      }
+    } else if (this.css) {
+      this.css = this.css.replace(/\n*\/\*#[\S\s]*?\*\/$/gm, '');
     }
-
-    for (let opt in opts) this[opt] = opts[opt];
   }
 
-  toString() {
-    if (this.node) {
-      return this.node.error(this.text, {
-        index: this.index,
-        plugin: this.plugin,
-        word: this.word
-      }).message
+  generate() {
+    this.clearAnnotation();
+    if (pathAvailable && sourceMapAvailable && this.isMap()) {
+      return this.generateMap()
+    } else {
+      let result = '';
+      this.stringify(this.root, i => {
+        result += i;
+      });
+      return [result]
     }
+  }
 
-    if (this.plugin) {
-      return this.plugin + ': ' + this.text
+  generateMap() {
+    if (this.root) {
+      this.generateString();
+    } else if (this.previous().length === 1) {
+      let prev = this.previous()[0].consumer();
+      prev.file = this.outputFile();
+      this.map = SourceMapGenerator$3.fromSourceMap(prev, {
+        ignoreInvalidMapping: true
+      });
+    } else {
+      this.map = new SourceMapGenerator$3({
+        file: this.outputFile(),
+        ignoreInvalidMapping: true
+      });
+      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>'
+      });
     }
 
-    return this.text
+    if (this.isSourcesContent()) this.setSourcesContent();
+    if (this.root && this.previous().length > 0) this.applyPrevMaps();
+    if (this.isAnnotation()) this.addAnnotation();
+
+    if (this.isInline()) {
+      return [this.css]
+    } else {
+      return [this.css, this.map]
+    }
   }
-};
 
-var warning = Warning$2;
-Warning$2.default = Warning$2;
+  generateString() {
+    this.css = '';
+    this.map = new SourceMapGenerator$3({
+      file: this.outputFile(),
+      ignoreInvalidMapping: true
+    });
 
-let Warning$1 = warning;
+    let line = 1;
+    let column = 1;
 
-let Result$3 = class Result {
-  constructor(processor, root, opts) {
-    this.processor = processor;
-    this.messages = [];
-    this.root = root;
-    this.opts = opts;
-    this.css = undefined;
-    this.map = undefined;
-  }
+    let noSource = '<no source>';
+    let mapping = {
+      generated: { column: 0, line: 0 },
+      original: { column: 0, line: 0 },
+      source: ''
+    };
 
-  toString() {
-    return this.css
-  }
+    let last, lines;
+    this.stringify(this.root, (str, node, type) => {
+      this.css += str;
 
-  warn(text, opts = {}) {
-    if (!opts.plugin) {
-      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
-        opts.plugin = this.lastPlugin.postcssPlugin;
+      if (node && type !== 'end') {
+        mapping.generated.line = line;
+        mapping.generated.column = column - 1;
+        if (node.source && node.source.start) {
+          mapping.source = this.sourcePath(node);
+          mapping.original.line = node.source.start.line;
+          mapping.original.column = node.source.start.column - 1;
+          this.map.addMapping(mapping);
+        } else {
+          mapping.source = noSource;
+          mapping.original.line = 1;
+          mapping.original.column = 0;
+          this.map.addMapping(mapping);
+        }
+      }
+
+      lines = str.match(/\n/g);
+      if (lines) {
+        line += lines.length;
+        last = str.lastIndexOf('\n');
+        column = str.length - last;
+      } else {
+        column += str.length;
+      }
+
+      if (node && type !== 'start') {
+        let p = node.parent || { raws: {} };
+        let childless =
+          node.type === 'decl' || (node.type === 'atrule' && !node.nodes);
+        if (!childless || node !== p.last || p.raws.semicolon) {
+          if (node.source && node.source.end) {
+            mapping.source = this.sourcePath(node);
+            mapping.original.line = node.source.end.line;
+            mapping.original.column = node.source.end.column - 1;
+            mapping.generated.line = line;
+            mapping.generated.column = column - 2;
+            this.map.addMapping(mapping);
+          } else {
+            mapping.source = noSource;
+            mapping.original.line = 1;
+            mapping.original.column = 0;
+            mapping.generated.line = line;
+            mapping.generated.column = column - 1;
+            this.map.addMapping(mapping);
+          }
+        }
       }
-    }
-
-    let warning = new Warning$1(text, opts);
-    this.messages.push(warning);
-
-    return warning
+    });
   }
 
-  warnings() {
-    return this.messages.filter(i => i.type === 'warning')
+  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
   }
 
-  get content() {
-    return this.css
-  }
-};
+  isInline() {
+    if (typeof this.mapOpts.inline !== 'undefined') {
+      return this.mapOpts.inline
+    }
 
-var result = Result$3;
-Result$3.default = Result$3;
+    let annotation = this.mapOpts.annotation;
+    if (typeof annotation !== 'undefined' && annotation !== true) {
+      return false
+    }
 
-let Container$5 = container$1;
+    if (this.previous().length) {
+      return this.previous().some(i => i.inline)
+    }
+    return true
+  }
 
-let AtRule$3 = class AtRule extends Container$5 {
-  constructor(defaults) {
-    super(defaults);
-    this.type = 'atrule';
+  isMap() {
+    if (typeof this.opts.map !== 'undefined') {
+      return !!this.opts.map
+    }
+    return this.previous().length > 0
   }
 
-  append(...children) {
-    if (!this.proxyOf.nodes) this.nodes = [];
-    return super.append(...children)
+  isSourcesContent() {
+    if (typeof this.mapOpts.sourcesContent !== 'undefined') {
+      return this.mapOpts.sourcesContent
+    }
+    if (this.previous().length) {
+      return this.previous().some(i => i.withContent())
+    }
+    return true
   }
 
-  prepend(...children) {
-    if (!this.proxyOf.nodes) this.nodes = [];
-    return super.prepend(...children)
+  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'
+    }
   }
-};
 
-var atRule = AtRule$3;
-AtRule$3.default = AtRule$3;
+  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
 
-Container$5.registerAtRule(AtRule$3);
+    let from = this.opts.to ? dirname(this.opts.to) : '.';
 
-let Container$4 = container$1;
+    if (typeof this.mapOpts.annotation === 'string') {
+      from = dirname(resolve(from, this.mapOpts.annotation));
+    }
 
-let LazyResult$3, Processor$2;
+    let path = relative(from, file);
+    this.memoizedPaths.set(file, path);
 
-let Root$5 = class Root extends Container$4 {
-  constructor(defaults) {
-    super(defaults);
-    this.type = 'root';
-    if (!this.nodes) this.nodes = [];
+    return path
   }
 
-  normalize(child, sample, type) {
-    let nodes = super.normalize(child);
-
-    if (sample) {
-      if (type === 'prepend') {
-        if (this.nodes.length > 1) {
-          sample.raws.before = this.nodes[1].raws.before;
-        } else {
-          delete sample.raws.before;
-        }
-      } else if (this.first !== sample) {
-        for (let node of nodes) {
-          node.raws.before = sample.raws.before;
-        }
+  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 = new Input$2(this.originalCSS, this.opts);
+        if (input.map) this.previousMaps.push(input.map);
       }
     }
 
-    return nodes
+    return this.previousMaps
   }
 
-  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;
+  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);
     }
-
-    return super.removeChild(child)
   }
 
-  toResult(opts = {}) {
-    let lazy = new LazyResult$3(new Processor$2(), this, opts);
-    return lazy.stringify()
+  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))
+    }
   }
-};
-
-Root$5.registerLazyResult = dependant => {
-  LazyResult$3 = dependant;
-};
-
-Root$5.registerProcessor = dependant => {
-  Processor$2 = dependant;
-};
-
-var root$2 = Root$5;
-Root$5.default = Root$5;
-
-Container$4.registerRoot(Root$5);
 
-let list$2 = {
-  comma(string) {
-    return list$2.split(string, [','], true)
-  },
-
-  space(string) {
-    let spaces = [' ', '\n', '\t'];
-    return list$2.split(string, spaces)
-  },
-
-  split(string, separators, last) {
-    let array = [];
-    let current = '';
-    let split = false;
+  toBase64(str) {
+    if (Buffer$1) {
+      return Buffer$1.from(str).toString('base64')
+    } else {
+      return window.btoa(unescape(encodeURIComponent(str)))
+    }
+  }
 
-    let func = 0;
-    let inQuote = false;
-    let prevQuote = '';
-    let escape = false;
+  toFileUrl(path) {
+    let cached = this.memoizedFileURLs.get(path);
+    if (cached) return cached
 
-    for (let letter of string) {
-      if (escape) {
-        escape = false;
-      } else if (letter === '\\') {
-        escape = true;
-      } else if (inQuote) {
-        if (letter === prevQuote) {
-          inQuote = false;
-        }
-      } else if (letter === '"' || letter === "'") {
-        inQuote = true;
-        prevQuote = letter;
-      } else if (letter === '(') {
-        func += 1;
-      } else if (letter === ')') {
-        if (func > 0) func -= 1;
-      } else if (func === 0) {
-        if (separators.includes(letter)) split = true;
-      }
+    if (pathToFileURL) {
+      let fileURL = pathToFileURL(path).toString();
+      this.memoizedFileURLs.set(path, fileURL);
 
-      if (split) {
-        if (current !== '') array.push(current.trim());
-        current = '';
-        split = false;
-      } else {
-        current += letter;
-      }
+      return fileURL
+    } else {
+      throw new Error(
+        '`map.absolute` option is not available in this PostCSS build'
+      )
     }
-
-    if (last || current !== '') array.push(current.trim());
-    return array
   }
-};
-
-var list_1 = list$2;
-list$2.default = list$2;
 
-let Container$3 = container$1;
-let list$1 = list_1;
+  toUrl(path) {
+    let cached = this.memoizedURLs.get(path);
+    if (cached) return cached
 
-let Rule$3 = class Rule extends Container$3 {
-  constructor(defaults) {
-    super(defaults);
-    this.type = 'rule';
-    if (!this.nodes) this.nodes = [];
-  }
+    if (sep === '\\') {
+      path = path.replace(/\\/g, '/');
+    }
 
-  get selectors() {
-    return list$1.comma(this.selector)
-  }
+    let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
+    this.memoizedURLs.set(path, url);
 
-  set selectors(values) {
-    let match = this.selector ? this.selector.match(/,\s*/) : null;
-    let sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen');
-    this.selector = values.join(sep);
+    return url
   }
 };
 
-var rule = Rule$3;
-Rule$3.default = Rule$3;
-
-Container$3.registerRule(Rule$3);
+var mapGenerator = MapGenerator$2;
 
-let Declaration$2 = declaration;
+let AtRule$1 = atRule;
+let Comment$1 = comment$3;
+let Declaration$1 = declaration;
+let Root$3 = root$2;
+let Rule$1 = rule;
 let tokenizer = tokenize$1;
-let Comment$2 = comment$3;
-let AtRule$2 = atRule;
-let Root$4 = root$2;
-let Rule$2 = rule;
 
 const SAFE_COMMENT_NEIGHBOR = {
   empty: true,
@@ -35607,7 +35564,7 @@ let Parser$1 = class Parser {
   constructor(input) {
     this.input = input;
 
-    this.root = new Root$4();
+    this.root = new Root$3();
     this.current = this.root;
     this.spaces = '';
     this.semicolon = false;
@@ -35617,7 +35574,7 @@ let Parser$1 = class Parser {
   }
 
   atrule(token) {
-    let node = new AtRule$2();
+    let node = new AtRule$1();
     node.name = token[1].slice(1);
     if (node.name === '') {
       this.unnamedAtrule(node, token);
@@ -35726,7 +35683,7 @@ let Parser$1 = class Parser {
 
   colon(tokens) {
     let brackets = 0;
-    let token, type, prev;
+    let prev, token, type;
     for (let [i, element] of tokens.entries()) {
       token = element;
       type = token[0];
@@ -35753,7 +35710,7 @@ let Parser$1 = class Parser {
   }
 
   comment(token) {
-    let node = new Comment$2();
+    let node = new Comment$1();
     this.init(node, token[2]);
     node.source.end = this.getPosition(token[3] || token[2]);
     node.source.end.offset++;
@@ -35776,7 +35733,7 @@ let Parser$1 = class Parser {
   }
 
   decl(tokens, customProperty) {
-    let node = new Declaration$2();
+    let node = new Declaration$1();
     this.init(node, tokens[0][2]);
 
     let last = tokens[tokens.length - 1];
@@ -35850,12 +35807,12 @@ let Parser$1 = class Parser {
         let str = '';
         for (let j = i; j > 0; j--) {
           let type = cache[j][0];
-          if (str.trim().indexOf('!') === 0 && type !== 'space') {
+          if (str.trim().startsWith('!') && type !== 'space') {
             break
           }
           str = cache.pop()[1] + str;
         }
-        if (str.trim().indexOf('!') === 0) {
+        if (str.trim().startsWith('!')) {
           node.important = true;
           node.raws.important = str;
           tokens = cache;
@@ -35889,7 +35846,7 @@ let Parser$1 = class Parser {
   }
 
   emptyRule(token) {
-    let node = new Rule$2();
+    let node = new Rule$1();
     this.init(node, token[2]);
     node.selector = '';
     node.raws.between = '';
@@ -36099,7 +36056,7 @@ let Parser$1 = class Parser {
   rule(tokens) {
     tokens.pop();
 
-    let node = new Rule$2();
+    let node = new Rule$1();
     this.init(node, tokens[0][2]);
 
     node.raws.between = this.spacesAndCommentsFromEnd(tokens);
@@ -36192,11 +36149,11 @@ let Parser$1 = class Parser {
 var parser$1 = Parser$1;
 
 let Container$2 = container$1;
+let Input$1 = input;
 let Parser = parser$1;
-let Input$2 = input;
 
 function parse$3(css, opts) {
-  let input = new Input$2(css, opts);
+  let input = new Input$1(css, opts);
   let parser = new Parser(input);
   try {
     parser.parse();
@@ -36232,15 +36189,105 @@ parse$3.default = parse$3;
 
 Container$2.registerParse(parse$3);
 
-let { isClean, my } = symbols;
-let MapGenerator$1 = mapGenerator;
-let stringify$2 = stringify_1;
+let Warning$2 = class Warning {
+  constructor(text, opts = {}) {
+    this.type = 'warning';
+    this.text = text;
+
+    if (opts.node && opts.node.source) {
+      let range = opts.node.rangeBy(opts);
+      this.line = range.start.line;
+      this.column = range.start.column;
+      this.endLine = range.end.line;
+      this.endColumn = range.end.column;
+    }
+
+    for (let opt in opts) this[opt] = opts[opt];
+  }
+
+  toString() {
+    if (this.node) {
+      return this.node.error(this.text, {
+        index: this.index,
+        plugin: this.plugin,
+        word: this.word
+      }).message
+    }
+
+    if (this.plugin) {
+      return this.plugin + ': ' + this.text
+    }
+
+    return this.text
+  }
+};
+
+var warning = Warning$2;
+Warning$2.default = Warning$2;
+
+let Warning$1 = warning;
+
+let Result$3 = class Result {
+  constructor(processor, root, opts) {
+    this.processor = processor;
+    this.messages = [];
+    this.root = root;
+    this.opts = opts;
+    this.css = undefined;
+    this.map = undefined;
+  }
+
+  toString() {
+    return this.css
+  }
+
+  warn(text, opts = {}) {
+    if (!opts.plugin) {
+      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
+        opts.plugin = this.lastPlugin.postcssPlugin;
+      }
+    }
+
+    let warning = new Warning$1(text, opts);
+    this.messages.push(warning);
+
+    return warning
+  }
+
+  warnings() {
+    return this.messages.filter(i => i.type === 'warning')
+  }
+
+  get content() {
+    return this.css
+  }
+};
+
+var result = Result$3;
+Result$3.default = Result$3;
+
+/* eslint-disable no-console */
+
+let printed = {};
+
+var warnOnce$2 = function warnOnce(message) {
+  if (printed[message]) return
+  printed[message] = true;
+
+  if (typeof console !== 'undefined' && console.warn) {
+    console.warn(message);
+  }
+};
+
 let Container$1 = container$1;
 let Document$2 = document;
-let warnOnce$1 = warnOnce$2;
-let Result$2 = result;
+let MapGenerator$1 = mapGenerator;
 let parse$2 = parse_1;
-let Root$3 = root$2;
+let Result$2 = result;
+let Root$2 = root$2;
+let stringify$2 = stringify_1;
+let { isClean, my } = symbols;
+let warnOnce$1 = warnOnce$2;
 
 const TYPE_TO_CLASS_NAME = {
   atrule: 'AtRule',
@@ -36778,14 +36825,14 @@ LazyResult$2.registerPostcss = dependant => {
 var lazyResult = LazyResult$2;
 LazyResult$2.default = LazyResult$2;
 
-Root$3.registerLazyResult(LazyResult$2);
+Root$2.registerLazyResult(LazyResult$2);
 Document$2.registerLazyResult(LazyResult$2);
 
 let MapGenerator = mapGenerator;
-let stringify$1 = stringify_1;
-let warnOnce = warnOnce$2;
 let parse$1 = parse_1;
 const Result$1 = result;
+let stringify$1 = stringify_1;
+let warnOnce = warnOnce$2;
 
 let NoWorkResult$1 = class NoWorkResult {
   constructor(processor, css, opts) {
@@ -36918,14 +36965,14 @@ let NoWorkResult$1 = class NoWorkResult {
 var noWorkResult = NoWorkResult$1;
 NoWorkResult$1.default = NoWorkResult$1;
 
-let NoWorkResult = noWorkResult;
-let LazyResult$1 = lazyResult;
 let Document$1 = document;
-let Root$2 = root$2;
+let LazyResult$1 = lazyResult;
+let NoWorkResult = noWorkResult;
+let Root$1 = root$2;
 
 let Processor$1 = class Processor {
   constructor(plugins = []) {
-    this.version = '8.4.41';
+    this.version = '8.4.44';
     this.plugins = this.normalize(plugins);
   }
 
@@ -36981,80 +37028,27 @@ let Processor$1 = class Processor {
 var processor$1 = Processor$1;
 Processor$1.default = Processor$1;
 
-Root$2.registerProcessor(Processor$1);
+Root$1.registerProcessor(Processor$1);
 Document$1.registerProcessor(Processor$1);
 
-let Declaration$1 = declaration;
-let PreviousMap = previousMap;
-let Comment$1 = comment$3;
-let AtRule$1 = atRule;
-let Input$1 = input;
-let Root$1 = root$2;
-let Rule$1 = rule;
-
-function fromJSON$1(json, inputs) {
-  if (Array.isArray(json)) return json.map(n => fromJSON$1(n))
-
-  let { inputs: ownInputs, ...defaults } = json;
-  if (ownInputs) {
-    inputs = [];
-    for (let input of ownInputs) {
-      let inputHydrated = { ...input, __proto__: Input$1.prototype };
-      if (inputHydrated.map) {
-        inputHydrated.map = {
-          ...inputHydrated.map,
-          __proto__: PreviousMap.prototype
-        };
-      }
-      inputs.push(inputHydrated);
-    }
-  }
-  if (defaults.nodes) {
-    defaults.nodes = json.nodes.map(n => fromJSON$1(n, inputs));
-  }
-  if (defaults.source) {
-    let { inputId, ...source } = defaults.source;
-    defaults.source = source;
-    if (inputId != null) {
-      defaults.source.input = inputs[inputId];
-    }
-  }
-  if (defaults.type === 'root') {
-    return new Root$1(defaults)
-  } else if (defaults.type === 'decl') {
-    return new Declaration$1(defaults)
-  } else if (defaults.type === 'rule') {
-    return new Rule$1(defaults)
-  } else if (defaults.type === 'comment') {
-    return new Comment$1(defaults)
-  } else if (defaults.type === 'atrule') {
-    return new AtRule$1(defaults)
-  } else {
-    throw new Error('Unknown node type: ' + json.type)
-  }
-}
-
-var fromJSON_1 = fromJSON$1;
-fromJSON$1.default = fromJSON$1;
-
+let AtRule = atRule;
+let Comment = comment$3;
+let Container = container$1;
 let CssSyntaxError = cssSyntaxError;
 let Declaration = declaration;
-let LazyResult = lazyResult;
-let Container = container$1;
-let Processor = processor$1;
-let stringify = stringify_1;
-let fromJSON = fromJSON_1;
 let Document = document;
-let Warning = warning;
-let Comment = comment$3;
-let AtRule = atRule;
-let Result = result;
+let fromJSON = fromJSON_1;
 let Input = input;
-let parse = parse_1;
+let LazyResult = lazyResult;
 let list = list_1;
-let Rule = rule;
-let Root = root$2;
 let Node = node$2;
+let parse = parse_1;
+let Processor = processor$1;
+let Result = result;
+let Root = root$2;
+let Rule = rule;
+let stringify = stringify_1;
+let Warning = warning;
 
 function postcss(...plugins) {
   if (plugins.length === 1 && Array.isArray(plugins[0])) {
@@ -44259,6 +44253,49 @@ function preprocess(options, preprocessor) {
   );
 }
 
+const UNKNOWN_TYPE = "Unknown";
+function resolveObjectKey(node, computed) {
+  switch (node.type) {
+    case "StringLiteral":
+    case "NumericLiteral":
+      return String(node.value);
+    case "Identifier":
+      if (!computed) return node.name;
+  }
+  return void 0;
+}
+function concatStrings(strs) {
+  return strs.filter((s) => !!s).join(", ");
+}
+function isLiteralNode(node) {
+  return node.type.endsWith("Literal");
+}
+function isCallOf(node, test) {
+  return !!(node && test && node.type === "CallExpression" && node.callee.type === "Identifier" && (typeof test === "string" ? node.callee.name === test : test(node.callee.name)));
+}
+function toRuntimeTypeString(types) {
+  return types.length > 1 ? `[${types.join(", ")}]` : types[0];
+}
+function getImportedName(specifier) {
+  if (specifier.type === "ImportSpecifier")
+    return specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+  else if (specifier.type === "ImportNamespaceSpecifier") return "*";
+  return "default";
+}
+function getId(node) {
+  return node.type === "Identifier" ? node.name : node.type === "StringLiteral" ? node.value : null;
+}
+const normalize = (path.posix || path).normalize;
+const windowsSlashRE = /\\/g;
+function normalizePath(p) {
+  return normalize(p.replace(windowsSlashRE, "/"));
+}
+const joinPaths = (path.posix || path).join;
+const propNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~\-]/;
+function getEscapedPropName(key) {
+  return propNameEscapeSymbolsRE.test(key) ? JSON.stringify(key) : key;
+}
+
 function analyzeScriptBindings(ast) {
   for (const node of ast) {
     if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "ObjectExpression") {
@@ -48853,7 +48890,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const version = "3.5.0-rc.1";
+const version = "3.5.0";
 const parseCache = parseCache$1;
 const errorMessages = __spreadValues(__spreadValues({}, errorMessages$1), DOMErrorMessages);
 const walk = walk$2;