Ignore:
Timestamp:
12/12/24 17:06:06 (5 weeks ago)
Author:
stefan toskovski <stefantoska84@…>
Branches:
main
Parents:
d565449
Message:

Pred finalna verzija

File:
1 moved

Legend:

Unmodified
Added
Removed
  • imaps-frontend/node_modules/vite/dist/node/chunks/dep-Ba1kN6Mp.js

    rd565449 r0c6b92a  
    1 import { C as commonjsGlobal, B as getDefaultExportFromCjs } from './dep-mCdpKltl.js';
     1import { C as commonjsGlobal, B as getDefaultExportFromCjs } from './dep-CB_7IfJ-.js';
    22import require$$0__default from 'fs';
    33import require$$0 from 'postcss';
     
    13281328
    13291329          root.walkDecls(/^composes$/, (declaration) => {
    1330             const matches = declaration.value.match(matchImports$1);
    1331 
    1332             if (!matches) {
    1333               return;
    1334             }
    1335 
    1336             let tmpSymbols;
    1337             let [
    1338               ,
    1339               /*match*/ symbols,
    1340               doubleQuotePath,
    1341               singleQuotePath,
    1342               global,
    1343             ] = matches;
    1344 
    1345             if (global) {
    1346               // Composing globals simply means changing these classes to wrap them in global(name)
    1347               tmpSymbols = symbols.split(/\s+/).map((s) => `global(${s})`);
    1348             } else {
    1349               const importPath = doubleQuotePath || singleQuotePath;
    1350 
    1351               let parent = declaration.parent;
    1352               let parentIndexes = "";
    1353 
    1354               while (parent.type !== "root") {
    1355                 parentIndexes =
    1356                   parent.parent.index(parent) + "_" + parentIndexes;
    1357                 parent = parent.parent;
     1330            const multiple = declaration.value.split(",");
     1331            const values = [];
     1332
     1333            multiple.forEach((value) => {
     1334              const matches = value.trim().match(matchImports$1);
     1335
     1336              if (!matches) {
     1337                values.push(value);
     1338
     1339                return;
    13581340              }
    13591341
    1360               const { selector } = declaration.parent;
    1361               const parentRule = `_${parentIndexes}${selector}`;
    1362 
    1363               addImportToGraph(importPath, parentRule, graph, visited);
    1364 
    1365               importDecls[importPath] = declaration;
    1366               imports[importPath] = imports[importPath] || {};
    1367 
    1368               tmpSymbols = symbols.split(/\s+/).map((s) => {
    1369                 if (!imports[importPath][s]) {
    1370                   imports[importPath][s] = createImportedName(s, importPath);
     1342              let tmpSymbols;
     1343              let [
     1344                ,
     1345                /*match*/ symbols,
     1346                doubleQuotePath,
     1347                singleQuotePath,
     1348                global,
     1349              ] = matches;
     1350
     1351              if (global) {
     1352                // Composing globals simply means changing these classes to wrap them in global(name)
     1353                tmpSymbols = symbols.split(/\s+/).map((s) => `global(${s})`);
     1354              } else {
     1355                const importPath = doubleQuotePath || singleQuotePath;
     1356
     1357                let parent = declaration.parent;
     1358                let parentIndexes = "";
     1359
     1360                while (parent.type !== "root") {
     1361                  parentIndexes =
     1362                    parent.parent.index(parent) + "_" + parentIndexes;
     1363                  parent = parent.parent;
    13711364                }
    13721365
    1373                 return imports[importPath][s];
    1374               });
    1375             }
    1376 
    1377             declaration.value = tmpSymbols.join(" ");
     1366                const { selector } = declaration.parent;
     1367                const parentRule = `_${parentIndexes}${selector}`;
     1368
     1369                addImportToGraph(importPath, parentRule, graph, visited);
     1370
     1371                importDecls[importPath] = declaration;
     1372                imports[importPath] = imports[importPath] || {};
     1373
     1374                tmpSymbols = symbols.split(/\s+/).map((s) => {
     1375                  if (!imports[importPath][s]) {
     1376                    imports[importPath][s] = createImportedName(s, importPath);
     1377                  }
     1378
     1379                  return imports[importPath][s];
     1380                });
     1381              }
     1382
     1383              values.push(tmpSymbols.join(" "));
     1384            });
     1385
     1386            declaration.value = values.join(", ");
    13781387          });
    13791388
     
    22202229        exports.__esModule = true;
    22212230        exports["default"] = unesc;
    2222 
    22232231        // Many thanks for this post which made this migration much easier.
    22242232        // https://mathiasbynens.be/notes/css-escapes
     
    22332241          var hex = '';
    22342242          var spaceTerminated = false;
    2235 
    22362243          for (var i = 0; i < 6 && lower[i] !== undefined; i++) {
    2237             var code = lower.charCodeAt(i); // check to see if we are dealing with a valid hex char [a-f|0-9]
    2238 
    2239             var valid = code >= 97 && code <= 102 || code >= 48 && code <= 57; // https://drafts.csswg.org/css-syntax/#consume-escaped-code-point
    2240 
     2244            var code = lower.charCodeAt(i);
     2245            // check to see if we are dealing with a valid hex char [a-f|0-9]
     2246            var valid = code >= 97 && code <= 102 || code >= 48 && code <= 57;
     2247            // https://drafts.csswg.org/css-syntax/#consume-escaped-code-point
    22412248            spaceTerminated = code === 32;
    2242 
    22432249            if (!valid) {
    22442250              break;
    22452251            }
    2246 
    22472252            hex += lower[i];
    22482253          }
    2249 
    22502254          if (hex.length === 0) {
    22512255            return undefined;
    22522256          }
    2253 
    22542257          var codePoint = parseInt(hex, 16);
    2255           var isSurrogate = codePoint >= 0xD800 && codePoint <= 0xDFFF; // Add special case for
     2258          var isSurrogate = codePoint >= 0xD800 && codePoint <= 0xDFFF;
     2259          // Add special case for
    22562260          // "If this number is zero, or is for a surrogate, or is greater than the maximum allowed code point"
    22572261          // https://drafts.csswg.org/css-syntax/#maximum-allowed-code-point
    2258 
    22592262          if (isSurrogate || codePoint === 0x0000 || codePoint > 0x10FFFF) {
    22602263            return ["\uFFFD", hex.length + (spaceTerminated ? 1 : 0)];
    22612264          }
    2262 
    22632265          return [String.fromCodePoint(codePoint), hex.length + (spaceTerminated ? 1 : 0)];
    22642266        }
    2265 
    22662267        var CONTAINS_ESCAPE = /\\/;
    2267 
    22682268        function unesc(str) {
    22692269          var needToProcess = CONTAINS_ESCAPE.test(str);
    2270 
    22712270          if (!needToProcess) {
    22722271            return str;
    22732272          }
    2274 
    22752273          var ret = "";
    2276 
    22772274          for (var i = 0; i < str.length; i++) {
    22782275            if (str[i] === "\\") {
    22792276              var gobbled = gobbleHex(str.slice(i + 1, i + 7));
    2280 
    22812277              if (gobbled !== undefined) {
    22822278                ret += gobbled[0];
    22832279                i += gobbled[1];
    22842280                continue;
    2285               } // Retain a pair of \\ if double escaped `\\\\`
     2281              }
     2282
     2283              // Retain a pair of \\ if double escaped `\\\\`
    22862284              // https://github.com/postcss/postcss-selector-parser/commit/268c9a7656fb53f543dc620aa5b73a30ec3ff20e
    2287 
    2288 
    22892285              if (str[i + 1] === "\\") {
    22902286                ret += "\\";
    22912287                i++;
    22922288                continue;
    2293               } // if \\ is at the end of the string retain it
     2289              }
     2290
     2291              // if \\ is at the end of the string retain it
    22942292              // https://github.com/postcss/postcss-selector-parser/commit/01a6b346e3612ce1ab20219acc26abdc259ccefb
    2295 
    2296 
    22972293              if (str.length === i + 1) {
    22982294                ret += str[i];
    22992295              }
    2300 
    23012296              continue;
    23022297            }
    2303 
    23042298            ret += str[i];
    23052299          }
    2306 
    23072300          return ret;
    23082301        }
    2309 
    23102302        module.exports = exports.default;
    23112303} (unesc, unesc.exports));
     
    23192311        exports.__esModule = true;
    23202312        exports["default"] = getProp;
    2321 
    23222313        function getProp(obj) {
    23232314          for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    23242315            props[_key - 1] = arguments[_key];
    23252316          }
    2326 
    23272317          while (props.length > 0) {
    23282318            var prop = props.shift();
    2329 
    23302319            if (!obj[prop]) {
    23312320              return undefined;
    23322321            }
    2333 
    23342322            obj = obj[prop];
    23352323          }
    2336 
    23372324          return obj;
    23382325        }
    2339 
    23402326        module.exports = exports.default;
    23412327} (getProp, getProp.exports));
     
    23492335        exports.__esModule = true;
    23502336        exports["default"] = ensureObject;
    2351 
    23522337        function ensureObject(obj) {
    23532338          for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    23542339            props[_key - 1] = arguments[_key];
    23552340          }
    2356 
    23572341          while (props.length > 0) {
    23582342            var prop = props.shift();
    2359 
    23602343            if (!obj[prop]) {
    23612344              obj[prop] = {};
    23622345            }
    2363 
    23642346            obj = obj[prop];
    23652347          }
    23662348        }
    2367 
    23682349        module.exports = exports.default;
    23692350} (ensureObject, ensureObject.exports));
     
    23772358        exports.__esModule = true;
    23782359        exports["default"] = stripComments;
    2379 
    23802360        function stripComments(str) {
    23812361          var s = "";
    23822362          var commentStart = str.indexOf("/*");
    23832363          var lastEnd = 0;
    2384 
    23852364          while (commentStart >= 0) {
    23862365            s = s + str.slice(lastEnd, commentStart);
    23872366            var commentEnd = str.indexOf("*/", commentStart + 2);
    2388 
    23892367            if (commentEnd < 0) {
    23902368              return s;
    23912369            }
    2392 
    23932370            lastEnd = commentEnd + 2;
    23942371            commentStart = str.indexOf("/*", lastEnd);
    23952372          }
    2396 
    23972373          s = s + str.slice(lastEnd);
    23982374          return s;
    23992375        }
    2400 
    24012376        module.exports = exports.default;
    24022377} (stripComments, stripComments.exports));
     
    24052380
    24062381util.__esModule = true;
    2407 util.stripComments = util.ensureObject = util.getProp = util.unesc = void 0;
    2408 
     2382util.unesc = util.stripComments = util.getProp = util.ensureObject = void 0;
    24092383var _unesc = _interopRequireDefault$3(unescExports);
    2410 
    24112384util.unesc = _unesc["default"];
    2412 
    24132385var _getProp = _interopRequireDefault$3(getPropExports);
    2414 
    24152386util.getProp = _getProp["default"];
    2416 
    24172387var _ensureObject = _interopRequireDefault$3(ensureObjectExports);
    2418 
    24192388util.ensureObject = _ensureObject["default"];
    2420 
    24212389var _stripComments = _interopRequireDefault$3(stripCommentsExports);
    2422 
    24232390util.stripComments = _stripComments["default"];
    2424 
    24252391function _interopRequireDefault$3(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    24262392
     
    24292395        exports.__esModule = true;
    24302396        exports["default"] = void 0;
    2431 
    24322397        var _util = util;
    2433 
    24342398        function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
    2435 
    2436         function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
    2437 
     2399        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
    24382400        var cloneNode = function cloneNode(obj, parent) {
    24392401          if (typeof obj !== 'object' || obj === null) {
    24402402            return obj;
    24412403          }
    2442 
    24432404          var cloned = new obj.constructor();
    2444 
    24452405          for (var i in obj) {
    24462406            if (!obj.hasOwnProperty(i)) {
    24472407              continue;
    24482408            }
    2449 
    24502409            var value = obj[i];
    24512410            var type = typeof value;
    2452 
    24532411            if (i === 'parent' && type === 'object') {
    24542412              if (parent) {
     
    24632421            }
    24642422          }
    2465 
    24662423          return cloned;
    24672424        };
    2468 
    24692425        var Node = /*#__PURE__*/function () {
    24702426          function Node(opts) {
     
    24722428              opts = {};
    24732429            }
    2474 
    24752430            Object.assign(this, opts);
    24762431            this.spaces = this.spaces || {};
     
    24782433            this.spaces.after = this.spaces.after || '';
    24792434          }
    2480 
    24812435          var _proto = Node.prototype;
    2482 
    24832436          _proto.remove = function remove() {
    24842437            if (this.parent) {
    24852438              this.parent.removeChild(this);
    24862439            }
    2487 
    24882440            this.parent = undefined;
    24892441            return this;
    24902442          };
    2491 
    24922443          _proto.replaceWith = function replaceWith() {
    24932444            if (this.parent) {
     
    24952446                this.parent.insertBefore(this, arguments[index]);
    24962447              }
    2497 
    24982448              this.remove();
    24992449            }
    2500 
    25012450            return this;
    25022451          };
    2503 
    25042452          _proto.next = function next() {
    25052453            return this.parent.at(this.parent.index(this) + 1);
    25062454          };
    2507 
    25082455          _proto.prev = function prev() {
    25092456            return this.parent.at(this.parent.index(this) - 1);
    25102457          };
    2511 
    25122458          _proto.clone = function clone(overrides) {
    25132459            if (overrides === void 0) {
    25142460              overrides = {};
    25152461            }
    2516 
    25172462            var cloned = cloneNode(this);
    2518 
    25192463            for (var name in overrides) {
    25202464              cloned[name] = overrides[name];
    25212465            }
    2522 
    25232466            return cloned;
    25242467          }
     2468
    25252469          /**
    25262470           * Some non-standard syntax doesn't follow normal escaping rules for css.
     
    25312475           * @param {any} value the unescaped value of the property
    25322476           * @param {string} valueEscaped optional. the escaped value of the property.
    2533            */
    2534           ;
    2535 
     2477           */;
    25362478          _proto.appendToPropertyAndEscape = function appendToPropertyAndEscape(name, value, valueEscaped) {
    25372479            if (!this.raws) {
    25382480              this.raws = {};
    25392481            }
    2540 
    25412482            var originalValue = this[name];
    25422483            var originalEscaped = this.raws[name];
    25432484            this[name] = originalValue + value; // this may trigger a setter that updates raws, so it has to be set first.
    2544 
    25452485            if (originalEscaped || valueEscaped !== value) {
    25462486              this.raws[name] = (originalEscaped || originalValue) + valueEscaped;
     
    25492489            }
    25502490          }
     2491
    25512492          /**
    25522493           * Some non-standard syntax doesn't follow normal escaping rules for css.
     
    25562497           * @param {any} value the unescaped value of the property
    25572498           * @param {string} valueEscaped the escaped value of the property.
    2558            */
    2559           ;
    2560 
     2499           */;
    25612500          _proto.setPropertyAndEscape = function setPropertyAndEscape(name, value, valueEscaped) {
    25622501            if (!this.raws) {
    25632502              this.raws = {};
    25642503            }
    2565 
    25662504            this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
    2567 
    25682505            this.raws[name] = valueEscaped;
    25692506          }
     2507
    25702508          /**
    25712509           * When you want a value to passed through to CSS directly. This method
     
    25742512           * @param {string} name the property to set.
    25752513           * @param {any} value The value that is both escaped and unescaped.
    2576            */
    2577           ;
    2578 
     2514           */;
    25792515          _proto.setPropertyWithoutEscape = function setPropertyWithoutEscape(name, value) {
    25802516            this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
    2581 
    25822517            if (this.raws) {
    25832518              delete this.raws[name];
    25842519            }
    25852520          }
     2521
    25862522          /**
    25872523           *
    25882524           * @param {number} line The number (starting with 1)
    25892525           * @param {number} column The column number (starting with 1)
    2590            */
    2591           ;
    2592 
     2526           */;
    25932527          _proto.isAtPosition = function isAtPosition(line, column) {
    25942528            if (this.source && this.source.start && this.source.end) {
     
    25962530                return false;
    25972531              }
    2598 
    25992532              if (this.source.end.line < line) {
    26002533                return false;
    26012534              }
    2602 
    26032535              if (this.source.start.line === line && this.source.start.column > column) {
    26042536                return false;
    26052537              }
    2606 
    26072538              if (this.source.end.line === line && this.source.end.column < column) {
    26082539                return false;
    26092540              }
    2610 
    26112541              return true;
    26122542            }
    2613 
    26142543            return undefined;
    26152544          };
    2616 
    26172545          _proto.stringifyProperty = function stringifyProperty(name) {
    26182546            return this.raws && this.raws[name] || this[name];
    26192547          };
    2620 
    26212548          _proto.valueToString = function valueToString() {
    26222549            return String(this.stringifyProperty("value"));
    26232550          };
    2624 
    26252551          _proto.toString = function toString() {
    26262552            return [this.rawSpaceBefore, this.valueToString(), this.rawSpaceAfter].join('');
    26272553          };
    2628 
    26292554          _createClass(Node, [{
    26302555            key: "rawSpaceBefore",
    26312556            get: function get() {
    26322557              var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
    2633 
    26342558              if (rawSpace === undefined) {
    26352559                rawSpace = this.spaces && this.spaces.before;
    26362560              }
    2637 
    26382561              return rawSpace || "";
    26392562            },
     
    26462569            get: function get() {
    26472570              var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
    2648 
    26492571              if (rawSpace === undefined) {
    26502572                rawSpace = this.spaces.after;
    26512573              }
    2652 
    26532574              return rawSpace || "";
    26542575            },
     
    26582579            }
    26592580          }]);
    2660 
    26612581          return Node;
    26622582        }();
    2663 
    26642583        exports["default"] = Node;
    26652584        module.exports = exports.default;
     
    26712590
    26722591types.__esModule = true;
    2673 types.UNIVERSAL = types.ATTRIBUTE = types.CLASS = types.COMBINATOR = types.COMMENT = types.ID = types.NESTING = types.PSEUDO = types.ROOT = types.SELECTOR = types.STRING = types.TAG = void 0;
     2592types.UNIVERSAL = types.TAG = types.STRING = types.SELECTOR = types.ROOT = types.PSEUDO = types.NESTING = types.ID = types.COMMENT = types.COMBINATOR = types.CLASS = types.ATTRIBUTE = void 0;
    26742593var TAG = 'tag';
    26752594types.TAG = TAG;
     
    27012620        exports.__esModule = true;
    27022621        exports["default"] = void 0;
    2703 
    27042622        var _node = _interopRequireDefault(nodeExports);
    2705 
    27062623        var types$1 = _interopRequireWildcard(types);
    2707 
    2708         function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
    2709 
    2710         function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
    2711 
     2624        function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
     2625        function _interopRequireWildcard(obj, nodeInterop) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
    27122626        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    2713 
    2714         function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike  ) { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
    2715 
     2627        function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike) { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
    27162628        function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
    2717 
    27182629        function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
    2719 
    27202630        function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
    2721 
    2722         function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
    2723 
     2631        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
    27242632        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    2725 
    2726         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    2727 
     2633        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    27282634        var Container = /*#__PURE__*/function (_Node) {
    27292635          _inheritsLoose(Container, _Node);
    2730 
    27312636          function Container(opts) {
    27322637            var _this;
    2733 
    27342638            _this = _Node.call(this, opts) || this;
    2735 
    27362639            if (!_this.nodes) {
    27372640              _this.nodes = [];
    27382641            }
    2739 
    27402642            return _this;
    27412643          }
    2742 
    27432644          var _proto = Container.prototype;
    2744 
    27452645          _proto.append = function append(selector) {
    27462646            selector.parent = this;
     
    27482648            return this;
    27492649          };
    2750 
    27512650          _proto.prepend = function prepend(selector) {
    27522651            selector.parent = this;
     
    27542653            return this;
    27552654          };
    2756 
    27572655          _proto.at = function at(index) {
    27582656            return this.nodes[index];
    27592657          };
    2760 
    27612658          _proto.index = function index(child) {
    27622659            if (typeof child === 'number') {
    27632660              return child;
    27642661            }
    2765 
    27662662            return this.nodes.indexOf(child);
    27672663          };
    2768 
    27692664          _proto.removeChild = function removeChild(child) {
    27702665            child = this.index(child);
     
    27722667            this.nodes.splice(child, 1);
    27732668            var index;
    2774 
    27752669            for (var id in this.indexes) {
    27762670              index = this.indexes[id];
    2777 
    27782671              if (index >= child) {
    27792672                this.indexes[id] = index - 1;
    27802673              }
    27812674            }
    2782 
    27832675            return this;
    27842676          };
    2785 
    27862677          _proto.removeAll = function removeAll() {
    27872678            for (var _iterator = _createForOfIteratorHelperLoose(this.nodes), _step; !(_step = _iterator()).done;) {
     
    27892680              node.parent = undefined;
    27902681            }
    2791 
    27922682            this.nodes = [];
    27932683            return this;
    27942684          };
    2795 
    27962685          _proto.empty = function empty() {
    27972686            return this.removeAll();
    27982687          };
    2799 
    28002688          _proto.insertAfter = function insertAfter(oldNode, newNode) {
    28012689            newNode.parent = this;
     
    28042692            newNode.parent = this;
    28052693            var index;
    2806 
    28072694            for (var id in this.indexes) {
    28082695              index = this.indexes[id];
    2809 
    28102696              if (oldIndex <= index) {
    28112697                this.indexes[id] = index + 1;
    28122698              }
    28132699            }
    2814 
    28152700            return this;
    28162701          };
    2817 
    28182702          _proto.insertBefore = function insertBefore(oldNode, newNode) {
    28192703            newNode.parent = this;
     
    28222706            newNode.parent = this;
    28232707            var index;
    2824 
    28252708            for (var id in this.indexes) {
    28262709              index = this.indexes[id];
    2827 
    28282710              if (index <= oldIndex) {
    28292711                this.indexes[id] = index + 1;
    28302712              }
    28312713            }
    2832 
    28332714            return this;
    28342715          };
    2835 
    28362716          _proto._findChildAtPosition = function _findChildAtPosition(line, col) {
    28372717            var found = undefined;
     
    28392719              if (node.atPosition) {
    28402720                var foundChild = node.atPosition(line, col);
    2841 
    28422721                if (foundChild) {
    28432722                  found = foundChild;
     
    28512730            return found;
    28522731          }
     2732
    28532733          /**
    28542734           * Return the most specific node at the line and column number given.
     
    28632743           * @param {number} line The line number of the node to find. (1-based index)
    28642744           * @param {number} col  The column number of the node to find. (1-based index)
    2865            */
    2866           ;
    2867 
     2745           */;
    28682746          _proto.atPosition = function atPosition(line, col) {
    28692747            if (this.isAtPosition(line, col)) {
     
    28732751            }
    28742752          };
    2875 
    28762753          _proto._inferEndPosition = function _inferEndPosition() {
    28772754            if (this.last && this.last.source && this.last.source.end) {
     
    28812758            }
    28822759          };
    2883 
    28842760          _proto.each = function each(callback) {
    28852761            if (!this.lastEach) {
    28862762              this.lastEach = 0;
    28872763            }
    2888 
    28892764            if (!this.indexes) {
    28902765              this.indexes = {};
    28912766            }
    2892 
    28932767            this.lastEach++;
    28942768            var id = this.lastEach;
    28952769            this.indexes[id] = 0;
    2896 
    28972770            if (!this.length) {
    28982771              return undefined;
    28992772            }
    2900 
    29012773            var index, result;
    2902 
    29032774            while (this.indexes[id] < this.length) {
    29042775              index = this.indexes[id];
    29052776              result = callback(this.at(index), index);
    2906 
    29072777              if (result === false) {
    29082778                break;
    29092779              }
    2910 
    29112780              this.indexes[id] += 1;
    29122781            }
    2913 
    29142782            delete this.indexes[id];
    2915 
    29162783            if (result === false) {
    29172784              return false;
    29182785            }
    29192786          };
    2920 
    29212787          _proto.walk = function walk(callback) {
    29222788            return this.each(function (node, i) {
    29232789              var result = callback(node, i);
    2924 
    29252790              if (result !== false && node.length) {
    29262791                result = node.walk(callback);
    29272792              }
    2928 
    29292793              if (result === false) {
    29302794                return false;
     
    29322796            });
    29332797          };
    2934 
    29352798          _proto.walkAttributes = function walkAttributes(callback) {
    29362799            var _this2 = this;
    2937 
    29382800            return this.walk(function (selector) {
    29392801              if (selector.type === types$1.ATTRIBUTE) {
     
    29422804            });
    29432805          };
    2944 
    29452806          _proto.walkClasses = function walkClasses(callback) {
    29462807            var _this3 = this;
    2947 
    29482808            return this.walk(function (selector) {
    29492809              if (selector.type === types$1.CLASS) {
     
    29522812            });
    29532813          };
    2954 
    29552814          _proto.walkCombinators = function walkCombinators(callback) {
    29562815            var _this4 = this;
    2957 
    29582816            return this.walk(function (selector) {
    29592817              if (selector.type === types$1.COMBINATOR) {
     
    29622820            });
    29632821          };
    2964 
    29652822          _proto.walkComments = function walkComments(callback) {
    29662823            var _this5 = this;
    2967 
    29682824            return this.walk(function (selector) {
    29692825              if (selector.type === types$1.COMMENT) {
     
    29722828            });
    29732829          };
    2974 
    29752830          _proto.walkIds = function walkIds(callback) {
    29762831            var _this6 = this;
    2977 
    29782832            return this.walk(function (selector) {
    29792833              if (selector.type === types$1.ID) {
     
    29822836            });
    29832837          };
    2984 
    29852838          _proto.walkNesting = function walkNesting(callback) {
    29862839            var _this7 = this;
    2987 
    29882840            return this.walk(function (selector) {
    29892841              if (selector.type === types$1.NESTING) {
     
    29922844            });
    29932845          };
    2994 
    29952846          _proto.walkPseudos = function walkPseudos(callback) {
    29962847            var _this8 = this;
    2997 
    29982848            return this.walk(function (selector) {
    29992849              if (selector.type === types$1.PSEUDO) {
     
    30022852            });
    30032853          };
    3004 
    30052854          _proto.walkTags = function walkTags(callback) {
    30062855            var _this9 = this;
    3007 
    30082856            return this.walk(function (selector) {
    30092857              if (selector.type === types$1.TAG) {
     
    30122860            });
    30132861          };
    3014 
    30152862          _proto.walkUniversals = function walkUniversals(callback) {
    30162863            var _this10 = this;
    3017 
    30182864            return this.walk(function (selector) {
    30192865              if (selector.type === types$1.UNIVERSAL) {
     
    30222868            });
    30232869          };
    3024 
    30252870          _proto.split = function split(callback) {
    30262871            var _this11 = this;
    3027 
    30282872            var current = [];
    30292873            return this.reduce(function (memo, node, index) {
    30302874              var split = callback.call(_this11, node);
    30312875              current.push(node);
    3032 
    30332876              if (split) {
    30342877                memo.push(current);
     
    30372880                memo.push(current);
    30382881              }
    3039 
    30402882              return memo;
    30412883            }, []);
    30422884          };
    3043 
    30442885          _proto.map = function map(callback) {
    30452886            return this.nodes.map(callback);
    30462887          };
    3047 
    30482888          _proto.reduce = function reduce(callback, memo) {
    30492889            return this.nodes.reduce(callback, memo);
    30502890          };
    3051 
    30522891          _proto.every = function every(callback) {
    30532892            return this.nodes.every(callback);
    30542893          };
    3055 
    30562894          _proto.some = function some(callback) {
    30572895            return this.nodes.some(callback);
    30582896          };
    3059 
    30602897          _proto.filter = function filter(callback) {
    30612898            return this.nodes.filter(callback);
    30622899          };
    3063 
    30642900          _proto.sort = function sort(callback) {
    30652901            return this.nodes.sort(callback);
    30662902          };
    3067 
    30682903          _proto.toString = function toString() {
    30692904            return this.map(String).join('');
    30702905          };
    3071 
    30722906          _createClass(Container, [{
    30732907            key: "first",
     
    30862920            }
    30872921          }]);
    3088 
    30892922          return Container;
    30902923        }(_node["default"]);
    3091 
    30922924        exports["default"] = Container;
    30932925        module.exports = exports.default;
     
    31002932        exports.__esModule = true;
    31012933        exports["default"] = void 0;
    3102 
    31032934        var _container = _interopRequireDefault(containerExports);
    3104 
    31052935        var _types = types;
    3106 
    31072936        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    3108 
    31092937        function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
    3110 
    3111         function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
    3112 
     2938        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
    31132939        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    3114 
    3115         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    3116 
     2940        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    31172941        var Root = /*#__PURE__*/function (_Container) {
    31182942          _inheritsLoose(Root, _Container);
    3119 
    31202943          function Root(opts) {
    31212944            var _this;
    3122 
    31232945            _this = _Container.call(this, opts) || this;
    31242946            _this.type = _types.ROOT;
    31252947            return _this;
    31262948          }
    3127 
    31282949          var _proto = Root.prototype;
    3129 
    31302950          _proto.toString = function toString() {
    31312951            var str = this.reduce(function (memo, selector) {
     
    31352955            return this.trailingComma ? str + ',' : str;
    31362956          };
    3137 
    31382957          _proto.error = function error(message, options) {
    31392958            if (this._error) {
     
    31432962            }
    31442963          };
    3145 
    31462964          _createClass(Root, [{
    31472965            key: "errorGenerator",
     
    31502968            }
    31512969          }]);
    3152 
    31532970          return Root;
    31542971        }(_container["default"]);
    3155 
    31562972        exports["default"] = Root;
    31572973        module.exports = exports.default;
     
    31662982        exports.__esModule = true;
    31672983        exports["default"] = void 0;
    3168 
    31692984        var _container = _interopRequireDefault(containerExports);
    3170 
    31712985        var _types = types;
    3172 
    31732986        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    3174 
    31752987        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    3176 
    3177         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    3178 
     2988        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    31792989        var Selector = /*#__PURE__*/function (_Container) {
    31802990          _inheritsLoose(Selector, _Container);
    3181 
    31822991          function Selector(opts) {
    31832992            var _this;
    3184 
    31852993            _this = _Container.call(this, opts) || this;
    31862994            _this.type = _types.SELECTOR;
    31872995            return _this;
    31882996          }
    3189 
    31902997          return Selector;
    31912998        }(_container["default"]);
    3192 
    31932999        exports["default"] = Selector;
    31943000        module.exports = exports.default;
     
    33123118        exports.__esModule = true;
    33133119        exports["default"] = void 0;
    3314 
    33153120        var _cssesc = _interopRequireDefault(cssesc_1);
    3316 
    33173121        var _util = util;
    3318 
    33193122        var _node = _interopRequireDefault(nodeExports);
    3320 
    33213123        var _types = types;
    3322 
    33233124        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    3324 
    33253125        function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
    3326 
    3327         function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
    3328 
     3126        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
    33293127        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    3330 
    3331         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    3332 
     3128        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    33333129        var ClassName = /*#__PURE__*/function (_Node) {
    33343130          _inheritsLoose(ClassName, _Node);
    3335 
    33363131          function ClassName(opts) {
    33373132            var _this;
    3338 
    33393133            _this = _Node.call(this, opts) || this;
    33403134            _this.type = _types.CLASS;
     
    33423136            return _this;
    33433137          }
    3344 
    33453138          var _proto = ClassName.prototype;
    3346 
    33473139          _proto.valueToString = function valueToString() {
    33483140            return '.' + _Node.prototype.valueToString.call(this);
    33493141          };
    3350 
    33513142          _createClass(ClassName, [{
    33523143            key: "value",
     
    33593150                  isIdentifier: true
    33603151                });
    3361 
    33623152                if (escaped !== v) {
    33633153                  (0, _util.ensureObject)(this, "raws");
     
    33673157                }
    33683158              }
    3369 
    33703159              this._value = v;
    33713160            }
    33723161          }]);
    3373 
    33743162          return ClassName;
    33753163        }(_node["default"]);
    3376 
    33773164        exports["default"] = ClassName;
    33783165        module.exports = exports.default;
     
    33873174        exports.__esModule = true;
    33883175        exports["default"] = void 0;
    3389 
    33903176        var _node = _interopRequireDefault(nodeExports);
    3391 
    33923177        var _types = types;
    3393 
    33943178        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    3395 
    33963179        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    3397 
    3398         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    3399 
     3180        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    34003181        var Comment = /*#__PURE__*/function (_Node) {
    34013182          _inheritsLoose(Comment, _Node);
    3402 
    34033183          function Comment(opts) {
    34043184            var _this;
    3405 
    34063185            _this = _Node.call(this, opts) || this;
    34073186            _this.type = _types.COMMENT;
    34083187            return _this;
    34093188          }
    3410 
    34113189          return Comment;
    34123190        }(_node["default"]);
    3413 
    34143191        exports["default"] = Comment;
    34153192        module.exports = exports.default;
     
    34243201        exports.__esModule = true;
    34253202        exports["default"] = void 0;
    3426 
    34273203        var _node = _interopRequireDefault(nodeExports);
    3428 
    34293204        var _types = types;
    3430 
    34313205        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    3432 
    34333206        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    3434 
    3435         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    3436 
     3207        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    34373208        var ID = /*#__PURE__*/function (_Node) {
    34383209          _inheritsLoose(ID, _Node);
    3439 
    34403210          function ID(opts) {
    34413211            var _this;
    3442 
    34433212            _this = _Node.call(this, opts) || this;
    34443213            _this.type = _types.ID;
    34453214            return _this;
    34463215          }
    3447 
    34483216          var _proto = ID.prototype;
    3449 
    34503217          _proto.valueToString = function valueToString() {
    34513218            return '#' + _Node.prototype.valueToString.call(this);
    34523219          };
    3453 
    34543220          return ID;
    34553221        }(_node["default"]);
    3456 
    34573222        exports["default"] = ID;
    34583223        module.exports = exports.default;
     
    34693234        exports.__esModule = true;
    34703235        exports["default"] = void 0;
    3471 
    34723236        var _cssesc = _interopRequireDefault(cssesc_1);
    3473 
    34743237        var _util = util;
    3475 
    34763238        var _node = _interopRequireDefault(nodeExports);
    3477 
    34783239        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    3479 
    34803240        function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
    3481 
    3482         function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
    3483 
     3241        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
    34843242        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    3485 
    3486         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    3487 
     3243        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    34883244        var Namespace = /*#__PURE__*/function (_Node) {
    34893245          _inheritsLoose(Namespace, _Node);
    3490 
    34913246          function Namespace() {
    34923247            return _Node.apply(this, arguments) || this;
    34933248          }
    3494 
    34953249          var _proto = Namespace.prototype;
    3496 
    34973250          _proto.qualifiedName = function qualifiedName(value) {
    34983251            if (this.namespace) {
     
    35023255            }
    35033256          };
    3504 
    35053257          _proto.valueToString = function valueToString() {
    35063258            return this.qualifiedName(_Node.prototype.valueToString.call(this));
    35073259          };
    3508 
    35093260          _createClass(Namespace, [{
    35103261            key: "namespace",
     
    35153266              if (namespace === true || namespace === "*" || namespace === "&") {
    35163267                this._namespace = namespace;
    3517 
    35183268                if (this.raws) {
    35193269                  delete this.raws.namespace;
    35203270                }
    3521 
    35223271                return;
    35233272              }
    3524 
    35253273              var escaped = (0, _cssesc["default"])(namespace, {
    35263274                isIdentifier: true
    35273275              });
    35283276              this._namespace = namespace;
    3529 
    35303277              if (escaped !== namespace) {
    35313278                (0, _util.ensureObject)(this, "raws");
     
    35483295              if (this.namespace) {
    35493296                var ns = this.stringifyProperty("namespace");
    3550 
    35513297                if (ns === true) {
    35523298                  return '';
     
    35593305            }
    35603306          }]);
    3561 
    35623307          return Namespace;
    35633308        }(_node["default"]);
    3564 
    35653309        exports["default"] = Namespace;
    35663310        module.exports = exports.default;
     
    35733317        exports.__esModule = true;
    35743318        exports["default"] = void 0;
    3575 
    35763319        var _namespace = _interopRequireDefault(namespaceExports);
    3577 
    35783320        var _types = types;
    3579 
    35803321        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    3581 
    35823322        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    3583 
    3584         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    3585 
     3323        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    35863324        var Tag = /*#__PURE__*/function (_Namespace) {
    35873325          _inheritsLoose(Tag, _Namespace);
    3588 
    35893326          function Tag(opts) {
    35903327            var _this;
    3591 
    35923328            _this = _Namespace.call(this, opts) || this;
    35933329            _this.type = _types.TAG;
    35943330            return _this;
    35953331          }
    3596 
    35973332          return Tag;
    35983333        }(_namespace["default"]);
    3599 
    36003334        exports["default"] = Tag;
    36013335        module.exports = exports.default;
     
    36103344        exports.__esModule = true;
    36113345        exports["default"] = void 0;
    3612 
    36133346        var _node = _interopRequireDefault(nodeExports);
    3614 
    36153347        var _types = types;
    3616 
    36173348        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    3618 
    36193349        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    3620 
    3621         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    3622 
     3350        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    36233351        var String = /*#__PURE__*/function (_Node) {
    36243352          _inheritsLoose(String, _Node);
    3625 
    36263353          function String(opts) {
    36273354            var _this;
    3628 
    36293355            _this = _Node.call(this, opts) || this;
    36303356            _this.type = _types.STRING;
    36313357            return _this;
    36323358          }
    3633 
    36343359          return String;
    36353360        }(_node["default"]);
    3636 
    36373361        exports["default"] = String;
    36383362        module.exports = exports.default;
     
    36473371        exports.__esModule = true;
    36483372        exports["default"] = void 0;
    3649 
    36503373        var _container = _interopRequireDefault(containerExports);
    3651 
    36523374        var _types = types;
    3653 
    36543375        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    3655 
    36563376        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    3657 
    3658         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    3659 
     3377        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    36603378        var Pseudo = /*#__PURE__*/function (_Container) {
    36613379          _inheritsLoose(Pseudo, _Container);
    3662 
    36633380          function Pseudo(opts) {
    36643381            var _this;
    3665 
    36663382            _this = _Container.call(this, opts) || this;
    36673383            _this.type = _types.PSEUDO;
    36683384            return _this;
    36693385          }
    3670 
    36713386          var _proto = Pseudo.prototype;
    3672 
    36733387          _proto.toString = function toString() {
    36743388            var params = this.length ? '(' + this.map(String).join(',') + ')' : '';
    36753389            return [this.rawSpaceBefore, this.stringifyProperty("value"), params, this.rawSpaceAfter].join('');
    36763390          };
    3677 
    36783391          return Pseudo;
    36793392        }(_container["default"]);
    3680 
    36813393        exports["default"] = Pseudo;
    36823394        module.exports = exports.default;
     
    36963408
    36973409        exports.__esModule = true;
     3410        exports["default"] = void 0;
    36983411        exports.unescapeValue = unescapeValue;
    3699         exports["default"] = void 0;
    3700 
    37013412        var _cssesc = _interopRequireDefault(cssesc_1);
    3702 
    37033413        var _unesc = _interopRequireDefault(unescExports);
    3704 
    37053414        var _namespace = _interopRequireDefault(namespaceExports);
    3706 
    37073415        var _types = types;
    3708 
    37093416        var _CSSESC_QUOTE_OPTIONS;
    3710 
    37113417        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    3712 
    37133418        function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
    3714 
    3715         function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
    3716 
     3419        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
    37173420        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    3718 
    3719         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    3720 
     3421        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    37213422        var deprecate = node;
    3722 
    37233423        var WRAPPED_IN_QUOTES = /^('|")([^]*)\1$/;
    37243424        var warnOfDeprecatedValueAssignment = deprecate(function () {}, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. " + "Call attribute.setValue() instead.");
    37253425        var warnOfDeprecatedQuotedAssignment = deprecate(function () {}, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.");
    37263426        var warnOfDeprecatedConstructor = deprecate(function () {}, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
    3727 
    37283427        function unescapeValue(value) {
    37293428          var deprecatedUsage = false;
     
    37313430          var unescaped = value;
    37323431          var m = unescaped.match(WRAPPED_IN_QUOTES);
    3733 
    37343432          if (m) {
    37353433            quoteMark = m[1];
    37363434            unescaped = m[2];
    37373435          }
    3738 
    37393436          unescaped = (0, _unesc["default"])(unescaped);
    3740 
    37413437          if (unescaped !== value) {
    37423438            deprecatedUsage = true;
    37433439          }
    3744 
    37453440          return {
    37463441            deprecatedUsage: deprecatedUsage,
     
    37493444          };
    37503445        }
    3751 
    37523446        function handleDeprecatedContructorOpts(opts) {
    37533447          if (opts.quoteMark !== undefined) {
    37543448            return opts;
    37553449          }
    3756 
    37573450          if (opts.value === undefined) {
    37583451            return opts;
    37593452          }
    3760 
    37613453          warnOfDeprecatedConstructor();
    3762 
    37633454          var _unescapeValue = unescapeValue(opts.value),
    3764               quoteMark = _unescapeValue.quoteMark,
    3765               unescaped = _unescapeValue.unescaped;
    3766 
     3455            quoteMark = _unescapeValue.quoteMark,
     3456            unescaped = _unescapeValue.unescaped;
    37673457          if (!opts.raws) {
    37683458            opts.raws = {};
    37693459          }
    3770 
    37713460          if (opts.raws.value === undefined) {
    37723461            opts.raws.value = opts.value;
    37733462          }
    3774 
    37753463          opts.value = unescaped;
    37763464          opts.quoteMark = quoteMark;
    37773465          return opts;
    37783466        }
    3779 
    37803467        var Attribute = /*#__PURE__*/function (_Namespace) {
    37813468          _inheritsLoose(Attribute, _Namespace);
    3782 
    37833469          function Attribute(opts) {
    37843470            var _this;
    3785 
    37863471            if (opts === void 0) {
    37873472              opts = {};
    37883473            }
    3789 
    37903474            _this = _Namespace.call(this, handleDeprecatedContructorOpts(opts)) || this;
    37913475            _this.type = _types.ATTRIBUTE;
     
    38023486            return _this;
    38033487          }
     3488
    38043489          /**
    38053490           * Returns the Attribute's value quoted such that it would be legal to use
     
    38233508           *     method.
    38243509           **/
    3825 
    3826 
    38273510          var _proto = Attribute.prototype;
    3828 
    38293511          _proto.getQuotedValue = function getQuotedValue(options) {
    38303512            if (options === void 0) {
    38313513              options = {};
    38323514            }
    3833 
    38343515            var quoteMark = this._determineQuoteMark(options);
    3835 
    38363516            var cssescopts = CSSESC_QUOTE_OPTIONS[quoteMark];
    38373517            var escaped = (0, _cssesc["default"])(this._value, cssescopts);
    38383518            return escaped;
    38393519          };
    3840 
    38413520          _proto._determineQuoteMark = function _determineQuoteMark(options) {
    38423521            return options.smart ? this.smartQuoteMark(options) : this.preferredQuoteMark(options);
    38433522          }
     3523
    38443524          /**
    38453525           * Set the unescaped value with the specified quotation options. The value
    38463526           * provided must not include any wrapping quote marks -- those quotes will
    38473527           * be interpreted as part of the value and escaped accordingly.
    3848            */
    3849           ;
    3850 
     3528           */;
    38513529          _proto.setValue = function setValue(value, options) {
    38523530            if (options === void 0) {
    38533531              options = {};
    38543532            }
    3855 
    38563533            this._value = value;
    38573534            this._quoteMark = this._determineQuoteMark(options);
    3858 
    38593535            this._syncRawValue();
    38603536          }
     3537
    38613538          /**
    38623539           * Intelligently select a quoteMark value based on the value's contents. If
     
    38703547           * @param options This takes the quoteMark and preferCurrentQuoteMark options
    38713548           * from the quoteValue method.
    3872            */
    3873           ;
    3874 
     3549           */;
    38753550          _proto.smartQuoteMark = function smartQuoteMark(options) {
    38763551            var v = this.value;
    38773552            var numSingleQuotes = v.replace(/[^']/g, '').length;
    38783553            var numDoubleQuotes = v.replace(/[^"]/g, '').length;
    3879 
    38803554            if (numSingleQuotes + numDoubleQuotes === 0) {
    38813555              var escaped = (0, _cssesc["default"])(v, {
    38823556                isIdentifier: true
    38833557              });
    3884 
    38853558              if (escaped === v) {
    38863559                return Attribute.NO_QUOTE;
    38873560              } else {
    38883561                var pref = this.preferredQuoteMark(options);
    3889 
    38903562                if (pref === Attribute.NO_QUOTE) {
    38913563                  // pick a quote mark that isn't none and see if it's smaller
     
    38933565                  var opts = CSSESC_QUOTE_OPTIONS[quote];
    38943566                  var quoteValue = (0, _cssesc["default"])(v, opts);
    3895 
    38963567                  if (quoteValue.length < escaped.length) {
    38973568                    return quote;
    38983569                  }
    38993570                }
    3900 
    39013571                return pref;
    39023572              }
     
    39093579            }
    39103580          }
     3581
    39113582          /**
    39123583           * Selects the preferred quote mark based on the options and the current quote mark value.
    39133584           * If you want the quote mark to depend on the attribute value, call `smartQuoteMark(opts)`
    39143585           * instead.
    3915            */
    3916           ;
    3917 
     3586           */;
    39183587          _proto.preferredQuoteMark = function preferredQuoteMark(options) {
    39193588            var quoteMark = options.preferCurrentQuoteMark ? this.quoteMark : options.quoteMark;
    3920 
    39213589            if (quoteMark === undefined) {
    39223590              quoteMark = options.preferCurrentQuoteMark ? options.quoteMark : this.quoteMark;
    39233591            }
    3924 
    39253592            if (quoteMark === undefined) {
    39263593              quoteMark = Attribute.DOUBLE_QUOTE;
    39273594            }
    3928 
    39293595            return quoteMark;
    39303596          };
    3931 
    39323597          _proto._syncRawValue = function _syncRawValue() {
    39333598            var rawValue = (0, _cssesc["default"])(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
    3934 
    39353599            if (rawValue === this._value) {
    39363600              if (this.raws) {
     
    39413605            }
    39423606          };
    3943 
    39443607          _proto._handleEscapes = function _handleEscapes(prop, value) {
    39453608            if (this._constructed) {
     
    39473610                isIdentifier: true
    39483611              });
    3949 
    39503612              if (escaped !== value) {
    39513613                this.raws[prop] = escaped;
     
    39553617            }
    39563618          };
    3957 
    39583619          _proto._spacesFor = function _spacesFor(name) {
    39593620            var attrSpaces = {
     
    39653626            return Object.assign(attrSpaces, spaces, rawSpaces);
    39663627          };
    3967 
    39683628          _proto._stringFor = function _stringFor(name, spaceName, concat) {
    39693629            if (spaceName === void 0) {
    39703630              spaceName = name;
    39713631            }
    3972 
    39733632            if (concat === void 0) {
    39743633              concat = defaultAttrConcat;
    39753634            }
    3976 
    39773635            var attrSpaces = this._spacesFor(spaceName);
    3978 
    39793636            return concat(this.stringifyProperty(name), attrSpaces);
    39803637          }
     3638
    39813639          /**
    39823640           * returns the offset of the attribute part specified relative to the
     
    39923650           * @param part One of the possible values inside an attribute.
    39933651           * @returns -1 if the name is invalid or the value doesn't exist in this attribute.
    3994            */
    3995           ;
    3996 
     3652           */;
    39973653          _proto.offsetOf = function offsetOf(name) {
    39983654            var count = 1;
    3999 
    40003655            var attributeSpaces = this._spacesFor("attribute");
    4001 
    40023656            count += attributeSpaces.before.length;
    4003 
    40043657            if (name === "namespace" || name === "ns") {
    40053658              return this.namespace ? count : -1;
    40063659            }
    4007 
    40083660            if (name === "attributeNS") {
    40093661              return count;
    40103662            }
    4011 
    40123663            count += this.namespaceString.length;
    4013 
    40143664            if (this.namespace) {
    40153665              count += 1;
    40163666            }
    4017 
    40183667            if (name === "attribute") {
    40193668              return count;
    40203669            }
    4021 
    40223670            count += this.stringifyProperty("attribute").length;
    40233671            count += attributeSpaces.after.length;
    4024 
    40253672            var operatorSpaces = this._spacesFor("operator");
    4026 
    40273673            count += operatorSpaces.before.length;
    40283674            var operator = this.stringifyProperty("operator");
    4029 
    40303675            if (name === "operator") {
    40313676              return operator ? count : -1;
    40323677            }
    4033 
    40343678            count += operator.length;
    40353679            count += operatorSpaces.after.length;
    4036 
    40373680            var valueSpaces = this._spacesFor("value");
    4038 
    40393681            count += valueSpaces.before.length;
    40403682            var value = this.stringifyProperty("value");
    4041 
    40423683            if (name === "value") {
    40433684              return value ? count : -1;
    40443685            }
    4045 
    40463686            count += value.length;
    40473687            count += valueSpaces.after.length;
    4048 
    40493688            var insensitiveSpaces = this._spacesFor("insensitive");
    4050 
    40513689            count += insensitiveSpaces.before.length;
    4052 
    40533690            if (name === "insensitive") {
    40543691              return this.insensitive ? count : -1;
    40553692            }
    4056 
    40573693            return -1;
    40583694          };
    4059 
    40603695          _proto.toString = function toString() {
    40613696            var _this2 = this;
    4062 
    40633697            var selector = [this.rawSpaceBefore, '['];
    40643698            selector.push(this._stringFor('qualifiedAttribute', 'attribute'));
    4065 
    40663699            if (this.operator && (this.value || this.value === '')) {
    40673700              selector.push(this._stringFor('operator'));
     
    40713704                  attrSpaces.before = " ";
    40723705                }
    4073 
    40743706                return defaultAttrConcat(attrValue, attrSpaces);
    40753707              }));
    40763708            }
    4077 
    40783709            selector.push(']');
    40793710            selector.push(this.rawSpaceAfter);
    40803711            return selector.join('');
    40813712          };
    4082 
    40833713          _createClass(Attribute, [{
    40843714            key: "quoted",
     
    40903720              warnOfDeprecatedQuotedAssignment();
    40913721            }
     3722
    40923723            /**
    40933724             * returns a single (`'`) or double (`"`) quote character if the value is quoted.
     
    40963727             * the attribute is constructed without specifying a quote mark.)
    40973728             */
    4098 
    40993729          }, {
    41003730            key: "quoteMark",
     
    41023732              return this._quoteMark;
    41033733            }
     3734
    41043735            /**
    41053736             * Set the quote mark to be used by this attribute's value.
     
    41083739             *
    41093740             * @param {"'" | '"' | null} quoteMark The quote mark or `null` if the value should be unquoted.
    4110              */
    4111             ,
     3741             */,
    41123742            set: function set(quoteMark) {
    41133743              if (!this._constructed) {
     
    41153745                return;
    41163746              }
    4117 
    41183747              if (this._quoteMark !== quoteMark) {
    41193748                this._quoteMark = quoteMark;
    4120 
    41213749                this._syncRawValue();
    41223750              }
     
    41533781              if (this._constructed) {
    41543782                var _unescapeValue2 = unescapeValue(v),
    4155                     deprecatedUsage = _unescapeValue2.deprecatedUsage,
    4156                     unescaped = _unescapeValue2.unescaped,
    4157                     quoteMark = _unescapeValue2.quoteMark;
    4158 
     3783                  deprecatedUsage = _unescapeValue2.deprecatedUsage,
     3784                  unescaped = _unescapeValue2.unescaped,
     3785                  quoteMark = _unescapeValue2.quoteMark;
    41593786                if (deprecatedUsage) {
    41603787                  warnOfDeprecatedValueAssignment();
    41613788                }
    4162 
    41633789                if (unescaped === this._value && quoteMark === this._quoteMark) {
    41643790                  return;
    41653791                }
    4166 
    41673792                this._value = unescaped;
    41683793                this._quoteMark = quoteMark;
    4169 
    41703794                this._syncRawValue();
    41713795              } else {
     
    41783802              return this._insensitive;
    41793803            }
     3804
    41803805            /**
    41813806             * Set the case insensitive flag.
     
    41843809             *
    41853810             * @param {true | false} insensitive true if the attribute should match case-insensitively.
    4186              */
    4187             ,
     3811             */,
    41883812            set: function set(insensitive) {
    41893813              if (!insensitive) {
    4190                 this._insensitive = false; // "i" and "I" can be used in "this.raws.insensitiveFlag" to store the original notation.
     3814                this._insensitive = false;
     3815
     3816                // "i" and "I" can be used in "this.raws.insensitiveFlag" to store the original notation.
    41913817                // When setting `attr.insensitive = false` both should be erased to ensure correct serialization.
    4192 
    41933818                if (this.raws && (this.raws.insensitiveFlag === 'I' || this.raws.insensitiveFlag === 'i')) {
    41943819                  this.raws.insensitiveFlag = undefined;
    41953820                }
    41963821              }
    4197 
    41983822              this._insensitive = insensitive;
    41993823            }
     
    42053829            set: function set(name) {
    42063830              this._handleEscapes("attribute", name);
    4207 
    42083831              this._attribute = name;
    42093832            }
    42103833          }]);
    4211 
    42123834          return Attribute;
    42133835        }(_namespace["default"]);
    4214 
    42153836        exports["default"] = Attribute;
    42163837        Attribute.NO_QUOTE = null;
     
    42293850          isIdentifier: true
    42303851        }, _CSSESC_QUOTE_OPTIONS);
    4231 
    42323852        function defaultAttrConcat(attrValue, attrSpaces) {
    42333853          return "" + attrSpaces.before + attrValue + attrSpaces.after;
     
    42413861        exports.__esModule = true;
    42423862        exports["default"] = void 0;
    4243 
    42443863        var _namespace = _interopRequireDefault(namespaceExports);
    4245 
    42463864        var _types = types;
    4247 
    42483865        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    4249 
    42503866        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    4251 
    4252         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    4253 
     3867        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    42543868        var Universal = /*#__PURE__*/function (_Namespace) {
    42553869          _inheritsLoose(Universal, _Namespace);
    4256 
    42573870          function Universal(opts) {
    42583871            var _this;
    4259 
    42603872            _this = _Namespace.call(this, opts) || this;
    42613873            _this.type = _types.UNIVERSAL;
     
    42633875            return _this;
    42643876          }
    4265 
    42663877          return Universal;
    42673878        }(_namespace["default"]);
    4268 
    42693879        exports["default"] = Universal;
    42703880        module.exports = exports.default;
     
    42793889        exports.__esModule = true;
    42803890        exports["default"] = void 0;
    4281 
    42823891        var _node = _interopRequireDefault(nodeExports);
    4283 
    42843892        var _types = types;
    4285 
    42863893        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    4287 
    42883894        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    4289 
    4290         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    4291 
     3895        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    42923896        var Combinator = /*#__PURE__*/function (_Node) {
    42933897          _inheritsLoose(Combinator, _Node);
    4294 
    42953898          function Combinator(opts) {
    42963899            var _this;
    4297 
    42983900            _this = _Node.call(this, opts) || this;
    42993901            _this.type = _types.COMBINATOR;
    43003902            return _this;
    43013903          }
    4302 
    43033904          return Combinator;
    43043905        }(_node["default"]);
    4305 
    43063906        exports["default"] = Combinator;
    43073907        module.exports = exports.default;
     
    43163916        exports.__esModule = true;
    43173917        exports["default"] = void 0;
    4318 
    43193918        var _node = _interopRequireDefault(nodeExports);
    4320 
    43213919        var _types = types;
    4322 
    43233920        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    4324 
    43253921        function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
    4326 
    4327         function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    4328 
     3922        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
    43293923        var Nesting = /*#__PURE__*/function (_Node) {
    43303924          _inheritsLoose(Nesting, _Node);
    4331 
    43323925          function Nesting(opts) {
    43333926            var _this;
    4334 
    43353927            _this = _Node.call(this, opts) || this;
    43363928            _this.type = _types.NESTING;
     
    43383930            return _this;
    43393931          }
    4340 
    43413932          return Nesting;
    43423933        }(_node["default"]);
    4343 
    43443934        exports["default"] = Nesting;
    43453935        module.exports = exports.default;
     
    43543944        exports.__esModule = true;
    43553945        exports["default"] = sortAscending;
    4356 
    43573946        function sortAscending(list) {
    43583947          return list.sort(function (a, b) {
     
    43703959
    43713960tokenTypes.__esModule = true;
    4372 tokenTypes.combinator = tokenTypes.word = tokenTypes.comment = tokenTypes.str = tokenTypes.tab = tokenTypes.newline = tokenTypes.feed = tokenTypes.cr = tokenTypes.backslash = tokenTypes.bang = tokenTypes.slash = tokenTypes.doubleQuote = tokenTypes.singleQuote = tokenTypes.space = tokenTypes.greaterThan = tokenTypes.pipe = tokenTypes.equals = tokenTypes.plus = tokenTypes.caret = tokenTypes.tilde = tokenTypes.dollar = tokenTypes.closeSquare = tokenTypes.openSquare = tokenTypes.closeParenthesis = tokenTypes.openParenthesis = tokenTypes.semicolon = tokenTypes.colon = tokenTypes.comma = tokenTypes.at = tokenTypes.asterisk = tokenTypes.ampersand = void 0;
     3961tokenTypes.word = tokenTypes.tilde = tokenTypes.tab = tokenTypes.str = tokenTypes.space = tokenTypes.slash = tokenTypes.singleQuote = tokenTypes.semicolon = tokenTypes.plus = tokenTypes.pipe = tokenTypes.openSquare = tokenTypes.openParenthesis = tokenTypes.newline = tokenTypes.greaterThan = tokenTypes.feed = tokenTypes.equals = tokenTypes.doubleQuote = tokenTypes.dollar = tokenTypes.cr = tokenTypes.comment = tokenTypes.comma = tokenTypes.combinator = tokenTypes.colon = tokenTypes.closeSquare = tokenTypes.closeParenthesis = tokenTypes.caret = tokenTypes.bang = tokenTypes.backslash = tokenTypes.at = tokenTypes.asterisk = tokenTypes.ampersand = void 0;
    43733962var ampersand = 38; // `&`.charCodeAt(0);
    4374 
    43753963tokenTypes.ampersand = ampersand;
    43763964var asterisk = 42; // `*`.charCodeAt(0);
    4377 
    43783965tokenTypes.asterisk = asterisk;
    43793966var at = 64; // `@`.charCodeAt(0);
    4380 
    43813967tokenTypes.at = at;
    43823968var comma = 44; // `,`.charCodeAt(0);
    4383 
    43843969tokenTypes.comma = comma;
    43853970var colon = 58; // `:`.charCodeAt(0);
    4386 
    43873971tokenTypes.colon = colon;
    43883972var semicolon = 59; // `;`.charCodeAt(0);
    4389 
    43903973tokenTypes.semicolon = semicolon;
    43913974var openParenthesis = 40; // `(`.charCodeAt(0);
    4392 
    43933975tokenTypes.openParenthesis = openParenthesis;
    43943976var closeParenthesis = 41; // `)`.charCodeAt(0);
    4395 
    43963977tokenTypes.closeParenthesis = closeParenthesis;
    43973978var openSquare = 91; // `[`.charCodeAt(0);
    4398 
    43993979tokenTypes.openSquare = openSquare;
    44003980var closeSquare = 93; // `]`.charCodeAt(0);
    4401 
    44023981tokenTypes.closeSquare = closeSquare;
    44033982var dollar = 36; // `$`.charCodeAt(0);
    4404 
    44053983tokenTypes.dollar = dollar;
    44063984var tilde = 126; // `~`.charCodeAt(0);
    4407 
    44083985tokenTypes.tilde = tilde;
    44093986var caret = 94; // `^`.charCodeAt(0);
    4410 
    44113987tokenTypes.caret = caret;
    44123988var plus = 43; // `+`.charCodeAt(0);
    4413 
    44143989tokenTypes.plus = plus;
    44153990var equals = 61; // `=`.charCodeAt(0);
    4416 
    44173991tokenTypes.equals = equals;
    44183992var pipe = 124; // `|`.charCodeAt(0);
    4419 
    44203993tokenTypes.pipe = pipe;
    44213994var greaterThan = 62; // `>`.charCodeAt(0);
    4422 
    44233995tokenTypes.greaterThan = greaterThan;
    44243996var space = 32; // ` `.charCodeAt(0);
    4425 
    44263997tokenTypes.space = space;
    44273998var singleQuote = 39; // `'`.charCodeAt(0);
    4428 
    44293999tokenTypes.singleQuote = singleQuote;
    44304000var doubleQuote = 34; // `"`.charCodeAt(0);
    4431 
    44324001tokenTypes.doubleQuote = doubleQuote;
    44334002var slash = 47; // `/`.charCodeAt(0);
    4434 
    44354003tokenTypes.slash = slash;
    44364004var bang = 33; // `!`.charCodeAt(0);
    4437 
    44384005tokenTypes.bang = bang;
    44394006var backslash = 92; // '\\'.charCodeAt(0);
    4440 
    44414007tokenTypes.backslash = backslash;
    44424008var cr = 13; // '\r'.charCodeAt(0);
    4443 
    44444009tokenTypes.cr = cr;
    44454010var feed = 12; // '\f'.charCodeAt(0);
    4446 
    44474011tokenTypes.feed = feed;
    44484012var newline = 10; // '\n'.charCodeAt(0);
    4449 
    44504013tokenTypes.newline = newline;
    44514014var tab = 9; // '\t'.charCodeAt(0);
     4015
    44524016// Expose aliases primarily for readability.
    4453 
    44544017tokenTypes.tab = tab;
    4455 var str = singleQuote; // No good single character representation!
    4456 
     4018var str = singleQuote;
     4019
     4020// No good single character representation!
    44574021tokenTypes.str = str;
    44584022var comment$1 = -1;
     
    44664030
    44674031        exports.__esModule = true;
     4032        exports.FIELDS = void 0;
    44684033        exports["default"] = tokenize;
    4469         exports.FIELDS = void 0;
    4470 
    44714034        var t = _interopRequireWildcard(tokenTypes);
    4472 
    44734035        var _unescapable, _wordDelimiters;
    4474 
    4475         function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
    4476 
    4477         function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
    4478 
     4036        function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
     4037        function _interopRequireWildcard(obj, nodeInterop) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
    44794038        var unescapable = (_unescapable = {}, _unescapable[t.tab] = true, _unescapable[t.newline] = true, _unescapable[t.cr] = true, _unescapable[t.feed] = true, _unescapable);
    44804039        var wordDelimiters = (_wordDelimiters = {}, _wordDelimiters[t.space] = true, _wordDelimiters[t.tab] = true, _wordDelimiters[t.newline] = true, _wordDelimiters[t.cr] = true, _wordDelimiters[t.feed] = true, _wordDelimiters[t.ampersand] = true, _wordDelimiters[t.asterisk] = true, _wordDelimiters[t.bang] = true, _wordDelimiters[t.comma] = true, _wordDelimiters[t.colon] = true, _wordDelimiters[t.semicolon] = true, _wordDelimiters[t.openParenthesis] = true, _wordDelimiters[t.closeParenthesis] = true, _wordDelimiters[t.openSquare] = true, _wordDelimiters[t.closeSquare] = true, _wordDelimiters[t.singleQuote] = true, _wordDelimiters[t.doubleQuote] = true, _wordDelimiters[t.plus] = true, _wordDelimiters[t.pipe] = true, _wordDelimiters[t.tilde] = true, _wordDelimiters[t.greaterThan] = true, _wordDelimiters[t.equals] = true, _wordDelimiters[t.dollar] = true, _wordDelimiters[t.caret] = true, _wordDelimiters[t.slash] = true, _wordDelimiters);
    44814040        var hex = {};
    44824041        var hexChars = "0123456789abcdefABCDEF";
    4483 
    44844042        for (var i = 0; i < hexChars.length; i++) {
    44854043          hex[hexChars.charCodeAt(i)] = true;
    44864044        }
     4045
    44874046        /**
    44884047         *  Returns the last index of the bar css word
     
    44904049         * @param {number} start The index into the string where word's first letter occurs
    44914050         */
    4492 
    4493 
    44944051        function consumeWord(css, start) {
    44954052          var next = start;
    44964053          var code;
    4497 
    44984054          do {
    44994055            code = css.charCodeAt(next);
    4500 
    45014056            if (wordDelimiters[code]) {
    45024057              return next - 1;
     
    45084063            }
    45094064          } while (next < css.length);
    4510 
    45114065          return next - 1;
    45124066        }
     4067
    45134068        /**
    45144069         *  Returns the last index of the escape sequence
     
    45164071         * @param {number} start The index into the string where escape character (`\`) occurs.
    45174072         */
    4518 
    4519 
    45204073        function consumeEscape(css, start) {
    45214074          var next = start;
    45224075          var code = css.charCodeAt(next + 1);
    4523 
    45244076          if (unescapable[code]) ; else if (hex[code]) {
    4525             var hexDigits = 0; // consume up to 6 hex chars
    4526 
     4077            var hexDigits = 0;
     4078            // consume up to 6 hex chars
    45274079            do {
    45284080              next++;
    45294081              hexDigits++;
    45304082              code = css.charCodeAt(next + 1);
    4531             } while (hex[code] && hexDigits < 6); // if fewer than 6 hex chars, a trailing space ends the escape
    4532 
    4533 
     4083            } while (hex[code] && hexDigits < 6);
     4084            // if fewer than 6 hex chars, a trailing space ends the escape
    45344085            if (hexDigits < 6 && code === t.space) {
    45354086              next++;
     
    45394090            next++;
    45404091          }
    4541 
    45424092          return next;
    45434093        }
    4544 
    45454094        var FIELDS = {
    45464095          TYPE: 0,
     
    45534102        };
    45544103        exports.FIELDS = FIELDS;
    4555 
    45564104        function tokenize(input) {
    45574105          var tokens = [];
    45584106          var css = input.css.valueOf();
    45594107          var _css = css,
    4560               length = _css.length;
     4108            length = _css.length;
    45614109          var offset = -1;
    45624110          var line = 1;
     
    45644112          var end = 0;
    45654113          var code, content, endColumn, endLine, escaped, escapePos, last, lines, next, nextLine, nextOffset, quote, tokenType;
    4566 
    45674114          function unclosed(what, fix) {
    45684115            if (input.safe) {
     
    45744121            }
    45754122          }
    4576 
    45774123          while (start < length) {
    45784124            code = css.charCodeAt(start);
    4579 
    45804125            if (code === t.newline) {
    45814126              offset = start;
    45824127              line += 1;
    45834128            }
    4584 
    45854129            switch (code) {
    45864130              case t.space:
     
    45904134              case t.feed:
    45914135                next = start;
    4592 
    45934136                do {
    45944137                  next += 1;
    45954138                  code = css.charCodeAt(next);
    4596 
    45974139                  if (code === t.newline) {
    45984140                    offset = next;
     
    46004142                  }
    46014143                } while (code === t.space || code === t.newline || code === t.tab || code === t.cr || code === t.feed);
    4602 
    46034144                tokenType = t.space;
    46044145                endLine = line;
     
    46064147                end = next;
    46074148                break;
    4608 
    46094149              case t.plus:
    46104150              case t.greaterThan:
     
    46124152              case t.pipe:
    46134153                next = start;
    4614 
    46154154                do {
    46164155                  next += 1;
    46174156                  code = css.charCodeAt(next);
    46184157                } while (code === t.plus || code === t.greaterThan || code === t.tilde || code === t.pipe);
    4619 
    46204158                tokenType = t.combinator;
    46214159                endLine = line;
     
    46234161                end = next;
    46244162                break;
     4163
    46254164              // Consume these characters as single tokens.
    4626 
    46274165              case t.asterisk:
    46284166              case t.ampersand:
     
    46444182                end = next + 1;
    46454183                break;
    4646 
    46474184              case t.singleQuote:
    46484185              case t.doubleQuote:
    46494186                quote = code === t.singleQuote ? "'" : '"';
    46504187                next = start;
    4651 
    46524188                do {
    46534189                  escaped = false;
    46544190                  next = css.indexOf(quote, next + 1);
    4655 
    46564191                  if (next === -1) {
    46574192                    unclosed('quote', quote);
    46584193                  }
    4659 
    46604194                  escapePos = next;
    4661 
    46624195                  while (css.charCodeAt(escapePos - 1) === t.backslash) {
    46634196                    escapePos -= 1;
     
    46654198                  }
    46664199                } while (escaped);
    4667 
    46684200                tokenType = t.str;
    46694201                endLine = line;
     
    46714203                end = next + 1;
    46724204                break;
    4673 
    46744205              default:
    46754206                if (code === t.slash && css.charCodeAt(start + 1) === t.asterisk) {
    46764207                  next = css.indexOf('*/', start + 2) + 1;
    4677 
    46784208                  if (next === 0) {
    46794209                    unclosed('comment', '*/');
    46804210                  }
    4681 
    46824211                  content = css.slice(start, next + 1);
    46834212                  lines = content.split('\n');
    46844213                  last = lines.length - 1;
    4685 
    46864214                  if (last > 0) {
    46874215                    nextLine = line + last;
     
    46914219                    nextOffset = offset;
    46924220                  }
    4693 
    46944221                  tokenType = t.comment;
    46954222                  line = nextLine;
     
    47084235                  endColumn = next - offset;
    47094236                }
    4710 
    47114237                end = next + 1;
    47124238                break;
    4713             } // Ensure that the token structure remains consistent
    4714 
    4715 
    4716             tokens.push([tokenType, // [0] Token type
    4717             line, // [1] Starting line
    4718             start - offset, // [2] Starting column
    4719             endLine, // [3] Ending line
    4720             endColumn, // [4] Ending column
    4721             start, // [5] Start position / Source index
     4239            }
     4240
     4241            // Ensure that the token structure remains consistent
     4242            tokens.push([tokenType,
     4243            // [0] Token type
     4244            line,
     4245            // [1] Starting line
     4246            start - offset,
     4247            // [2] Starting column
     4248            endLine,
     4249            // [3] Ending line
     4250            endColumn,
     4251            // [4] Ending column
     4252            start,
     4253            // [5] Start position / Source index
    47224254            end // [6] End position
    4723             ]); // Reset offset for the next token
    4724 
     4255            ]);
     4256
     4257            // Reset offset for the next token
    47254258            if (nextOffset) {
    47264259              offset = nextOffset;
    47274260              nextOffset = null;
    47284261            }
    4729 
    47304262            start = end;
    47314263          }
    4732 
    47334264          return tokens;
    47344265        }
     
    47394270        exports.__esModule = true;
    47404271        exports["default"] = void 0;
    4741 
    47424272        var _root = _interopRequireDefault(rootExports);
    4743 
    47444273        var _selector = _interopRequireDefault(selectorExports);
    4745 
    47464274        var _className = _interopRequireDefault(classNameExports);
    4747 
    47484275        var _comment = _interopRequireDefault(commentExports);
    4749 
    47504276        var _id = _interopRequireDefault(idExports);
    4751 
    47524277        var _tag = _interopRequireDefault(tagExports);
    4753 
    47544278        var _string = _interopRequireDefault(stringExports);
    4755 
    47564279        var _pseudo = _interopRequireDefault(pseudoExports);
    4757 
    47584280        var _attribute = _interopRequireWildcard(attribute$1);
    4759 
    47604281        var _universal = _interopRequireDefault(universalExports);
    4761 
    47624282        var _combinator = _interopRequireDefault(combinatorExports);
    4763 
    47644283        var _nesting = _interopRequireDefault(nestingExports);
    4765 
    47664284        var _sortAscending = _interopRequireDefault(sortAscendingExports);
    4767 
    47684285        var _tokenize = _interopRequireWildcard(tokenize);
    4769 
    47704286        var tokens = _interopRequireWildcard(tokenTypes);
    4771 
    47724287        var types$1 = _interopRequireWildcard(types);
    4773 
    47744288        var _util = util;
    4775 
    47764289        var _WHITESPACE_TOKENS, _Object$assign;
    4777 
    4778         function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
    4779 
    4780         function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
    4781 
     4290        function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
     4291        function _interopRequireWildcard(obj, nodeInterop) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
    47824292        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    4783 
    47844293        function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
    4785 
    4786         function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
    4787 
     4294        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
    47884295        var WHITESPACE_TOKENS = (_WHITESPACE_TOKENS = {}, _WHITESPACE_TOKENS[tokens.space] = true, _WHITESPACE_TOKENS[tokens.cr] = true, _WHITESPACE_TOKENS[tokens.feed] = true, _WHITESPACE_TOKENS[tokens.newline] = true, _WHITESPACE_TOKENS[tokens.tab] = true, _WHITESPACE_TOKENS);
    47894296        var WHITESPACE_EQUIV_TOKENS = Object.assign({}, WHITESPACE_TOKENS, (_Object$assign = {}, _Object$assign[tokens.comment] = true, _Object$assign));
    4790 
    47914297        function tokenStart(token) {
    47924298          return {
     
    47954301          };
    47964302        }
    4797 
    47984303        function tokenEnd(token) {
    47994304          return {
     
    48024307          };
    48034308        }
    4804 
    48054309        function getSource(startLine, startColumn, endLine, endColumn) {
    48064310          return {
     
    48154319          };
    48164320        }
    4817 
    48184321        function getTokenSource(token) {
    48194322          return getSource(token[_tokenize.FIELDS.START_LINE], token[_tokenize.FIELDS.START_COL], token[_tokenize.FIELDS.END_LINE], token[_tokenize.FIELDS.END_COL]);
    48204323        }
    4821 
    48224324        function getTokenSourceSpan(startToken, endToken) {
    48234325          if (!startToken) {
    48244326            return undefined;
    48254327          }
    4826 
    48274328          return getSource(startToken[_tokenize.FIELDS.START_LINE], startToken[_tokenize.FIELDS.START_COL], endToken[_tokenize.FIELDS.END_LINE], endToken[_tokenize.FIELDS.END_COL]);
    48284329        }
    4829 
    48304330        function unescapeProp(node, prop) {
    48314331          var value = node[prop];
    4832 
    48334332          if (typeof value !== "string") {
    48344333            return;
    48354334          }
    4836 
    48374335          if (value.indexOf("\\") !== -1) {
    48384336            (0, _util.ensureObject)(node, 'raws');
    48394337            node[prop] = (0, _util.unesc)(value);
    4840 
    48414338            if (node.raws[prop] === undefined) {
    48424339              node.raws[prop] = value;
    48434340            }
    48444341          }
    4845 
    48464342          return node;
    48474343        }
    4848 
    48494344        function indexesOf(array, item) {
    48504345          var i = -1;
    48514346          var indexes = [];
    4852 
    48534347          while ((i = array.indexOf(item, i + 1)) !== -1) {
    48544348            indexes.push(i);
    48554349          }
    4856 
    48574350          return indexes;
    48584351        }
    4859 
    48604352        function uniqs() {
    48614353          var list = Array.prototype.concat.apply([], arguments);
     
    48644356          });
    48654357        }
    4866 
    48674358        var Parser = /*#__PURE__*/function () {
    48684359          function Parser(rule, options) {
     
    48704361              options = {};
    48714362            }
    4872 
    48734363            this.rule = rule;
    48744364            this.options = Object.assign({
     
    48944384                  column: 1
    48954385                }
    4896               }
     4386              },
     4387              sourceIndex: 0
    48974388            });
    48984389            this.root.append(selector);
     
    49004391            this.loop();
    49014392          }
    4902 
    49034393          var _proto = Parser.prototype;
    4904 
    49054394          _proto._errorGenerator = function _errorGenerator() {
    49064395            var _this = this;
    4907 
    49084396            return function (message, errorOptions) {
    49094397              if (typeof _this.rule === 'string') {
    49104398                return new Error(message);
    49114399              }
    4912 
    49134400              return _this.rule.error(message, errorOptions);
    49144401            };
    49154402          };
    4916 
    49174403          _proto.attribute = function attribute() {
    49184404            var attr = [];
    49194405            var startingToken = this.currToken;
    49204406            this.position++;
    4921 
    49224407            while (this.position < this.tokens.length && this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
    49234408              attr.push(this.currToken);
    49244409              this.position++;
    49254410            }
    4926 
    49274411            if (this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
    49284412              return this.expected('closing square bracket', this.currToken[_tokenize.FIELDS.START_POS]);
    49294413            }
    4930 
    49314414            var len = attr.length;
    49324415            var node = {
     
    49344417              sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
    49354418            };
    4936 
    49374419            if (len === 1 && !~[tokens.word].indexOf(attr[0][_tokenize.FIELDS.TYPE])) {
    49384420              return this.expected('attribute', attr[0][_tokenize.FIELDS.START_POS]);
    49394421            }
    4940 
    49414422            var pos = 0;
    49424423            var spaceBefore = '';
     
    49444425            var lastAdded = null;
    49454426            var spaceAfterMeaningfulToken = false;
    4946 
    49474427            while (pos < len) {
    49484428              var token = attr[pos];
    49494429              var content = this.content(token);
    49504430              var next = attr[pos + 1];
    4951 
    49524431              switch (token[_tokenize.FIELDS.TYPE]) {
    49534432                case tokens.space:
     
    49594438                  // }
    49604439                  spaceAfterMeaningfulToken = true;
    4961 
    49624440                  if (this.options.lossy) {
    49634441                    break;
    49644442                  }
    4965 
    49664443                  if (lastAdded) {
    49674444                    (0, _util.ensureObject)(node, 'spaces', lastAdded);
     
    49694446                    node.spaces[lastAdded].after = prevContent + content;
    49704447                    var existingComment = (0, _util.getProp)(node, 'raws', 'spaces', lastAdded, 'after') || null;
    4971 
    49724448                    if (existingComment) {
    49734449                      node.raws.spaces[lastAdded].after = existingComment + content;
     
    49774453                    commentBefore = commentBefore + content;
    49784454                  }
    4979 
    49804455                  break;
    4981 
    49824456                case tokens.asterisk:
    49834457                  if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
     
    49904464                      spaceBefore = '';
    49914465                    }
    4992 
    49934466                    if (commentBefore) {
    49944467                      (0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute');
     
    49964469                      commentBefore = '';
    49974470                    }
    4998 
    49994471                    node.namespace = (node.namespace || "") + content;
    50004472                    var rawValue = (0, _util.getProp)(node, 'raws', 'namespace') || null;
    5001 
    50024473                    if (rawValue) {
    50034474                      node.raws.namespace += content;
    50044475                    }
    5005 
    50064476                    lastAdded = 'namespace';
    50074477                  }
    5008 
    50094478                  spaceAfterMeaningfulToken = false;
    50104479                  break;
    5011 
    50124480                case tokens.dollar:
    50134481                  if (lastAdded === "value") {
    50144482                    var oldRawValue = (0, _util.getProp)(node, 'raws', 'value');
    50154483                    node.value += "$";
    5016 
    50174484                    if (oldRawValue) {
    50184485                      node.raws.value = oldRawValue + "$";
    50194486                    }
    5020 
    50214487                    break;
    50224488                  }
    5023 
    50244489                // Falls through
    5025 
    50264490                case tokens.caret:
    50274491                  if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
     
    50294493                    lastAdded = 'operator';
    50304494                  }
    5031 
    50324495                  spaceAfterMeaningfulToken = false;
    50334496                  break;
    5034 
    50354497                case tokens.combinator:
    50364498                  if (content === '~' && next[_tokenize.FIELDS.TYPE] === tokens.equals) {
     
    50384500                    lastAdded = 'operator';
    50394501                  }
    5040 
    50414502                  if (content !== '|') {
    50424503                    spaceAfterMeaningfulToken = false;
    50434504                    break;
    50444505                  }
    5045 
    50464506                  if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
    50474507                    node.operator = content;
     
    50504510                    node.namespace = true;
    50514511                  }
    5052 
    50534512                  spaceAfterMeaningfulToken = false;
    50544513                  break;
    5055 
    50564514                case tokens.word:
    5057                   if (next && this.content(next) === '|' && attr[pos + 2] && attr[pos + 2][_tokenize.FIELDS.TYPE] !== tokens.equals && // this look-ahead probably fails with comment nodes involved.
     4515                  if (next && this.content(next) === '|' && attr[pos + 2] && attr[pos + 2][_tokenize.FIELDS.TYPE] !== tokens.equals &&
     4516                  // this look-ahead probably fails with comment nodes involved.
    50584517                  !node.operator && !node.namespace) {
    50594518                    node.namespace = content;
     
    50654524                      spaceBefore = '';
    50664525                    }
    5067 
    50684526                    if (commentBefore) {
    50694527                      (0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute');
     
    50714529                      commentBefore = '';
    50724530                    }
    5073 
    50744531                    node.attribute = (node.attribute || "") + content;
    5075 
    50764532                    var _rawValue = (0, _util.getProp)(node, 'raws', 'attribute') || null;
    5077 
    50784533                    if (_rawValue) {
    50794534                      node.raws.attribute += content;
    50804535                    }
    5081 
    50824536                    lastAdded = 'attribute';
    50834537                  } else if (!node.value && node.value !== "" || lastAdded === "value" && !(spaceAfterMeaningfulToken || node.quoteMark)) {
    50844538                    var _unescaped = (0, _util.unesc)(content);
    5085 
    50864539                    var _oldRawValue = (0, _util.getProp)(node, 'raws', 'value') || '';
    5087 
    50884540                    var oldValue = node.value || '';
    50894541                    node.value = oldValue + _unescaped;
    50904542                    node.quoteMark = null;
    5091 
    50924543                    if (_unescaped !== content || _oldRawValue) {
    50934544                      (0, _util.ensureObject)(node, 'raws');
    50944545                      node.raws.value = (_oldRawValue || oldValue) + content;
    50954546                    }
    5096 
    50974547                    lastAdded = 'value';
    50984548                  } else {
    50994549                    var insensitive = content === 'i' || content === "I";
    5100 
    51014550                    if ((node.value || node.value === '') && (node.quoteMark || spaceAfterMeaningfulToken)) {
    51024551                      node.insensitive = insensitive;
    5103 
    51044552                      if (!insensitive || content === "I") {
    51054553                        (0, _util.ensureObject)(node, 'raws');
    51064554                        node.raws.insensitiveFlag = content;
    51074555                      }
    5108 
    51094556                      lastAdded = 'insensitive';
    5110 
    51114557                      if (spaceBefore) {
    51124558                        (0, _util.ensureObject)(node, 'spaces', 'insensitive');
     
    51144560                        spaceBefore = '';
    51154561                      }
    5116 
    51174562                      if (commentBefore) {
    51184563                        (0, _util.ensureObject)(node, 'raws', 'spaces', 'insensitive');
     
    51234568                      lastAdded = 'value';
    51244569                      node.value += content;
    5125 
    51264570                      if (node.raws.value) {
    51274571                        node.raws.value += content;
     
    51294573                    }
    51304574                  }
    5131 
    51324575                  spaceAfterMeaningfulToken = false;
    51334576                  break;
    5134 
    51354577                case tokens.str:
    51364578                  if (!node.attribute || !node.operator) {
     
    51394581                    });
    51404582                  }
    5141 
    51424583                  var _unescapeValue = (0, _attribute.unescapeValue)(content),
    5143                       unescaped = _unescapeValue.unescaped,
    5144                       quoteMark = _unescapeValue.quoteMark;
    5145 
     4584                    unescaped = _unescapeValue.unescaped,
     4585                    quoteMark = _unescapeValue.quoteMark;
    51464586                  node.value = unescaped;
    51474587                  node.quoteMark = quoteMark;
     
    51514591                  spaceAfterMeaningfulToken = false;
    51524592                  break;
    5153 
    51544593                case tokens.equals:
    51554594                  if (!node.attribute) {
    51564595                    return this.expected('attribute', token[_tokenize.FIELDS.START_POS], content);
    51574596                  }
    5158 
    51594597                  if (node.value) {
    51604598                    return this.error('Unexpected "=" found; an operator was already defined.', {
     
    51624600                    });
    51634601                  }
    5164 
    51654602                  node.operator = node.operator ? node.operator + content : content;
    51664603                  lastAdded = 'operator';
    51674604                  spaceAfterMeaningfulToken = false;
    51684605                  break;
    5169 
    51704606                case tokens.comment:
    51714607                  if (lastAdded) {
     
    51844620                    commentBefore = commentBefore + content;
    51854621                  }
    5186 
    51874622                  break;
    5188 
    51894623                default:
    51904624                  return this.error("Unexpected \"" + content + "\" found.", {
     
    51924626                  });
    51934627              }
    5194 
    51954628              pos++;
    51964629            }
    5197 
    51984630            unescapeProp(node, "attribute");
    51994631            unescapeProp(node, "namespace");
     
    52014633            this.position++;
    52024634          }
     4635
    52034636          /**
    52044637           * return a node containing meaningless garbage up to (but not including) the specified token position.
     
    52124645           *
    52134646           * In lossy mode, this returns only comments.
    5214            */
    5215           ;
    5216 
     4647           */;
    52174648          _proto.parseWhitespaceEquivalentTokens = function parseWhitespaceEquivalentTokens(stopPosition) {
    52184649            if (stopPosition < 0) {
    52194650              stopPosition = this.tokens.length;
    52204651            }
    5221 
    52224652            var startPosition = this.position;
    52234653            var nodes = [];
    52244654            var space = "";
    52254655            var lastComment = undefined;
    5226 
    52274656            do {
    52284657              if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {
     
    52324661              } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.comment) {
    52334662                var spaces = {};
    5234 
    52354663                if (space) {
    52364664                  spaces.before = space;
    52374665                  space = "";
    52384666                }
    5239 
    52404667                lastComment = new _comment["default"]({
    52414668                  value: this.content(),
     
    52474674              }
    52484675            } while (++this.position < stopPosition);
    5249 
    52504676            if (space) {
    52514677              if (lastComment) {
     
    52654691              }
    52664692            }
    5267 
    52684693            return nodes;
    52694694          }
     4695
    52704696          /**
    52714697           *
    52724698           * @param {*} nodes
    5273            */
    5274           ;
    5275 
     4699           */;
    52764700          _proto.convertWhitespaceNodesToSpace = function convertWhitespaceNodesToSpace(nodes, requiredSpace) {
    52774701            var _this2 = this;
    5278 
    52794702            if (requiredSpace === void 0) {
    52804703              requiredSpace = false;
    52814704            }
    5282 
    52834705            var space = "";
    52844706            var rawSpace = "";
    52854707            nodes.forEach(function (n) {
    52864708              var spaceBefore = _this2.lossySpace(n.spaces.before, requiredSpace);
    5287 
    52884709              var rawSpaceBefore = _this2.lossySpace(n.rawSpaceBefore, requiredSpace);
    5289 
    52904710              space += spaceBefore + _this2.lossySpace(n.spaces.after, requiredSpace && spaceBefore.length === 0);
    52914711              rawSpace += spaceBefore + n.value + _this2.lossySpace(n.rawSpaceAfter, requiredSpace && rawSpaceBefore.length === 0);
    52924712            });
    5293 
    52944713            if (rawSpace === space) {
    52954714              rawSpace = undefined;
    52964715            }
    5297 
    52984716            var result = {
    52994717              space: space,
     
    53024720            return result;
    53034721          };
    5304 
    53054722          _proto.isNamedCombinator = function isNamedCombinator(position) {
    53064723            if (position === void 0) {
    53074724              position = this.position;
    53084725            }
    5309 
    53104726            return this.tokens[position + 0] && this.tokens[position + 0][_tokenize.FIELDS.TYPE] === tokens.slash && this.tokens[position + 1] && this.tokens[position + 1][_tokenize.FIELDS.TYPE] === tokens.word && this.tokens[position + 2] && this.tokens[position + 2][_tokenize.FIELDS.TYPE] === tokens.slash;
    53114727          };
    5312 
    53134728          _proto.namedCombinator = function namedCombinator() {
    53144729            if (this.isNamedCombinator()) {
     
    53164731              var name = (0, _util.unesc)(nameRaw).toLowerCase();
    53174732              var raws = {};
    5318 
    53194733              if (name !== nameRaw) {
    53204734                raws.value = "/" + nameRaw + "/";
    53214735              }
    5322 
    53234736              var node = new _combinator["default"]({
    53244737                value: "/" + name + "/",
     
    53334746            }
    53344747          };
    5335 
    53364748          _proto.combinator = function combinator() {
    53374749            var _this3 = this;
    5338 
    53394750            if (this.content() === '|') {
    53404751              return this.namespace();
    5341             } // We need to decide between a space that's a descendant combinator and meaningless whitespace at the end of a selector.
    5342 
    5343 
     4752            }
     4753            // We need to decide between a space that's a descendant combinator and meaningless whitespace at the end of a selector.
    53444754            var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
    5345 
    53464755            if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma) {
    53474756              var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
    5348 
    53494757              if (nodes.length > 0) {
    53504758                var last = this.current.last;
    5351 
    53524759                if (last) {
    53534760                  var _this$convertWhitespa = this.convertWhitespaceNodesToSpace(nodes),
    5354                       space = _this$convertWhitespa.space,
    5355                       rawSpace = _this$convertWhitespa.rawSpace;
    5356 
     4761                    space = _this$convertWhitespa.space,
     4762                    rawSpace = _this$convertWhitespa.rawSpace;
    53574763                  if (rawSpace !== undefined) {
    53584764                    last.rawSpaceAfter += rawSpace;
    53594765                  }
    5360 
    53614766                  last.spaces.after += space;
    53624767                } else {
     
    53664771                }
    53674772              }
    5368 
    53694773              return;
    53704774            }
    5371 
    53724775            var firstToken = this.currToken;
    53734776            var spaceOrDescendantSelectorNodes = undefined;
    5374 
    53754777            if (nextSigTokenPos > this.position) {
    53764778              spaceOrDescendantSelectorNodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
    53774779            }
    5378 
    53794780            var node;
    5380 
    53814781            if (this.isNamedCombinator()) {
    53824782              node = this.namedCombinator();
     
    53914791              this.unexpected();
    53924792            }
    5393 
    53944793            if (node) {
    53954794              if (spaceOrDescendantSelectorNodes) {
    53964795                var _this$convertWhitespa2 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes),
    5397                     _space = _this$convertWhitespa2.space,
    5398                     _rawSpace = _this$convertWhitespa2.rawSpace;
    5399 
     4796                  _space = _this$convertWhitespa2.space,
     4797                  _rawSpace = _this$convertWhitespa2.rawSpace;
    54004798                node.spaces.before = _space;
    54014799                node.rawSpaceBefore = _rawSpace;
     
    54044802              // descendant combinator
    54054803              var _this$convertWhitespa3 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes, true),
    5406                   _space2 = _this$convertWhitespa3.space,
    5407                   _rawSpace2 = _this$convertWhitespa3.rawSpace;
    5408 
     4804                _space2 = _this$convertWhitespa3.space,
     4805                _rawSpace2 = _this$convertWhitespa3.rawSpace;
    54094806              if (!_rawSpace2) {
    54104807                _rawSpace2 = _space2;
    54114808              }
    5412 
    54134809              var spaces = {};
    54144810              var raws = {
    54154811                spaces: {}
    54164812              };
    5417 
    54184813              if (_space2.endsWith(' ') && _rawSpace2.endsWith(' ')) {
    54194814                spaces.before = _space2.slice(0, _space2.length - 1);
     
    54254820                raws.value = _rawSpace2;
    54264821              }
    5427 
    54284822              node = new _combinator["default"]({
    54294823                value: ' ',
     
    54344828              });
    54354829            }
    5436 
    54374830            if (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.space) {
    54384831              node.spaces.after = this.optionalSpace(this.content());
    54394832              this.position++;
    54404833            }
    5441 
    54424834            return this.newNode(node);
    54434835          };
    5444 
    54454836          _proto.comma = function comma() {
    54464837            if (this.position === this.tokens.length - 1) {
     
    54494840              return;
    54504841            }
    5451 
    54524842            this.current._inferEndPosition();
    5453 
    54544843            var selector = new _selector["default"]({
    54554844              source: {
    54564845                start: tokenStart(this.tokens[this.position + 1])
    5457               }
     4846              },
     4847              sourceIndex: this.tokens[this.position + 1][_tokenize.FIELDS.START_POS]
    54584848            });
    54594849            this.current.parent.append(selector);
     
    54614851            this.position++;
    54624852          };
    5463 
    54644853          _proto.comment = function comment() {
    54654854            var current = this.currToken;
     
    54714860            this.position++;
    54724861          };
    5473 
    54744862          _proto.error = function error(message, opts) {
    54754863            throw this.root.error(message, opts);
    54764864          };
    5477 
    54784865          _proto.missingBackslash = function missingBackslash() {
    54794866            return this.error('Expected a backslash preceding the semicolon.', {
     
    54814868            });
    54824869          };
    5483 
    54844870          _proto.missingParenthesis = function missingParenthesis() {
    54854871            return this.expected('opening parenthesis', this.currToken[_tokenize.FIELDS.START_POS]);
    54864872          };
    5487 
    54884873          _proto.missingSquareBracket = function missingSquareBracket() {
    54894874            return this.expected('opening square bracket', this.currToken[_tokenize.FIELDS.START_POS]);
    54904875          };
    5491 
    54924876          _proto.unexpected = function unexpected() {
    54934877            return this.error("Unexpected '" + this.content() + "'. Escaping special characters with \\ may help.", this.currToken[_tokenize.FIELDS.START_POS]);
    54944878          };
    5495 
     4879          _proto.unexpectedPipe = function unexpectedPipe() {
     4880            return this.error("Unexpected '|'.", this.currToken[_tokenize.FIELDS.START_POS]);
     4881          };
    54964882          _proto.namespace = function namespace() {
    54974883            var before = this.prevToken && this.content(this.prevToken) || true;
    5498 
    54994884            if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.word) {
    55004885              this.position++;
     
    55044889              return this.universal(before);
    55054890            }
    5506           };
    5507 
     4891            this.unexpectedPipe();
     4892          };
    55084893          _proto.nesting = function nesting() {
    55094894            if (this.nextToken) {
    55104895              var nextContent = this.content(this.nextToken);
    5511 
    55124896              if (nextContent === "|") {
    55134897                this.position++;
     
    55154899              }
    55164900            }
    5517 
    55184901            var current = this.currToken;
    55194902            this.newNode(new _nesting["default"]({
     
    55244907            this.position++;
    55254908          };
    5526 
    55274909          _proto.parentheses = function parentheses() {
    55284910            var last = this.current.last;
    55294911            var unbalanced = 1;
    55304912            this.position++;
    5531 
    55324913            if (last && last.type === types$1.PSEUDO) {
    55334914              var selector = new _selector["default"]({
    55344915                source: {
    5535                   start: tokenStart(this.tokens[this.position - 1])
    5536                 }
     4916                  start: tokenStart(this.tokens[this.position])
     4917                },
     4918                sourceIndex: this.tokens[this.position][_tokenize.FIELDS.START_POS]
    55374919              });
    55384920              var cache = this.current;
    55394921              last.append(selector);
    55404922              this.current = selector;
    5541 
    55424923              while (this.position < this.tokens.length && unbalanced) {
    55434924                if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
    55444925                  unbalanced++;
    55454926                }
    5546 
    55474927                if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
    55484928                  unbalanced--;
    55494929                }
    5550 
    55514930                if (unbalanced) {
    55524931                  this.parse();
     
    55574936                }
    55584937              }
    5559 
    55604938              this.current = cache;
    55614939            } else {
     
    55654943              var parenValue = "(";
    55664944              var parenEnd;
    5567 
    55684945              while (this.position < this.tokens.length && unbalanced) {
    55694946                if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
    55704947                  unbalanced++;
    55714948                }
    5572 
    55734949                if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
    55744950                  unbalanced--;
    55754951                }
    5576 
    55774952                parenEnd = this.currToken;
    55784953                parenValue += this.parseParenthesisToken(this.currToken);
    55794954                this.position++;
    55804955              }
    5581 
    55824956              if (last) {
    55834957                last.appendToPropertyAndEscape("value", parenValue, parenValue);
     
    55904964              }
    55914965            }
    5592 
    55934966            if (unbalanced) {
    55944967              return this.expected('closing parenthesis', this.currToken[_tokenize.FIELDS.START_POS]);
    55954968            }
    55964969          };
    5597 
    55984970          _proto.pseudo = function pseudo() {
    55994971            var _this4 = this;
    5600 
    56014972            var pseudoStr = '';
    56024973            var startingToken = this.currToken;
    5603 
    56044974            while (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.colon) {
    56054975              pseudoStr += this.content();
    56064976              this.position++;
    56074977            }
    5608 
    56094978            if (!this.currToken) {
    56104979              return this.expected(['pseudo-class', 'pseudo-element'], this.position - 1);
    56114980            }
    5612 
    56134981            if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.word) {
    56144982              this.splitWord(false, function (first, length) {
    56154983                pseudoStr += first;
    5616 
    56174984                _this4.newNode(new _pseudo["default"]({
    56184985                  value: pseudoStr,
     
    56204987                  sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
    56214988                }));
    5622 
    56234989                if (length > 1 && _this4.nextToken && _this4.nextToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
    56244990                  _this4.error('Misplaced parenthesis.', {
     
    56314997            }
    56324998          };
    5633 
    56344999          _proto.space = function space() {
    5635             var content = this.content(); // Handle space before and after the selector
    5636 
     5000            var content = this.content();
     5001            // Handle space before and after the selector
    56375002            if (this.position === 0 || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis || this.current.nodes.every(function (node) {
    56385003              return node.type === 'comment';
     
    56475012            }
    56485013          };
    5649 
    56505014          _proto.string = function string() {
    56515015            var current = this.currToken;
     
    56575021            this.position++;
    56585022          };
    5659 
    56605023          _proto.universal = function universal(namespace) {
    56615024            var nextToken = this.nextToken;
    5662 
    56635025            if (nextToken && this.content(nextToken) === '|') {
    56645026              this.position++;
    56655027              return this.namespace();
    56665028            }
    5667 
    56685029            var current = this.currToken;
    56695030            this.newNode(new _universal["default"]({
     
    56745035            this.position++;
    56755036          };
    5676 
    56775037          _proto.splitWord = function splitWord(namespace, firstCallback) {
    56785038            var _this5 = this;
    5679 
    56805039            var nextToken = this.nextToken;
    56815040            var word = this.content();
    5682 
    56835041            while (nextToken && ~[tokens.dollar, tokens.caret, tokens.equals, tokens.word].indexOf(nextToken[_tokenize.FIELDS.TYPE])) {
    56845042              this.position++;
    56855043              var current = this.content();
    56865044              word += current;
    5687 
    56885045              if (current.lastIndexOf('\\') === current.length - 1) {
    56895046                var next = this.nextToken;
    5690 
    56915047                if (next && next[_tokenize.FIELDS.TYPE] === tokens.space) {
    56925048                  word += this.requiredSpace(this.content(next));
     
    56945050                }
    56955051              }
    5696 
    56975052              nextToken = this.nextToken;
    56985053            }
    5699 
    57005054            var hasClass = indexesOf(word, '.').filter(function (i) {
    57015055              // Allow escaped dot within class name
    5702               var escapedDot = word[i - 1] === '\\'; // Allow decimal numbers percent in @keyframes
    5703 
     5056              var escapedDot = word[i - 1] === '\\';
     5057              // Allow decimal numbers percent in @keyframes
    57045058              var isKeyframesPercent = /^\d+\.\d+%$/.test(word);
    57055059              return !escapedDot && !isKeyframesPercent;
     
    57075061            var hasId = indexesOf(word, '#').filter(function (i) {
    57085062              return word[i - 1] !== '\\';
    5709             }); // Eliminate Sass interpolations from the list of id indexes
    5710 
     5063            });
     5064            // Eliminate Sass interpolations from the list of id indexes
    57115065            var interpolations = indexesOf(word, '#{');
    5712 
    57135066            if (interpolations.length) {
    57145067              hasId = hasId.filter(function (hashIndex) {
     
    57165069              });
    57175070            }
    5718 
    57195071            var indices = (0, _sortAscending["default"])(uniqs([0].concat(hasClass, hasId)));
    57205072            indices.forEach(function (ind, i) {
    57215073              var index = indices[i + 1] || word.length;
    57225074              var value = word.slice(ind, index);
    5723 
    57245075              if (i === 0 && firstCallback) {
    57255076                return firstCallback.call(_this5, value, indices.length);
    57265077              }
    5727 
    57285078              var node;
    57295079              var current = _this5.currToken;
    57305080              var sourceIndex = current[_tokenize.FIELDS.START_POS] + indices[i];
    57315081              var source = getSource(current[1], current[2] + ind, current[3], current[2] + (index - 1));
    5732 
    57335082              if (~hasClass.indexOf(ind)) {
    57345083                var classNameOpts = {
     
    57545103                node = new _tag["default"](tagOpts);
    57555104              }
    5756 
    5757               _this5.newNode(node, namespace); // Ensure that the namespace is used only once
    5758 
    5759 
     5105              _this5.newNode(node, namespace);
     5106              // Ensure that the namespace is used only once
    57605107              namespace = null;
    57615108            });
    57625109            this.position++;
    57635110          };
    5764 
    57655111          _proto.word = function word(namespace) {
    57665112            var nextToken = this.nextToken;
    5767 
    57685113            if (nextToken && this.content(nextToken) === '|') {
    57695114              this.position++;
    57705115              return this.namespace();
    57715116            }
    5772 
    57735117            return this.splitWord(namespace);
    57745118          };
    5775 
    57765119          _proto.loop = function loop() {
    57775120            while (this.position < this.tokens.length) {
    57785121              this.parse(true);
    57795122            }
    5780 
    57815123            this.current._inferEndPosition();
    5782 
    57835124            return this.root;
    57845125          };
    5785 
    57865126          _proto.parse = function parse(throwOnParenthesis) {
    57875127            switch (this.currToken[_tokenize.FIELDS.TYPE]) {
     
    57895129                this.space();
    57905130                break;
    5791 
    57925131              case tokens.comment:
    57935132                this.comment();
    57945133                break;
    5795 
    57965134              case tokens.openParenthesis:
    57975135                this.parentheses();
    57985136                break;
    5799 
    58005137              case tokens.closeParenthesis:
    58015138                if (throwOnParenthesis) {
    58025139                  this.missingParenthesis();
    58035140                }
    5804 
    58055141                break;
    5806 
    58075142              case tokens.openSquare:
    58085143                this.attribute();
    58095144                break;
    5810 
    58115145              case tokens.dollar:
    58125146              case tokens.caret:
     
    58155149                this.word();
    58165150                break;
    5817 
    58185151              case tokens.colon:
    58195152                this.pseudo();
    58205153                break;
    5821 
    58225154              case tokens.comma:
    58235155                this.comma();
    58245156                break;
    5825 
    58265157              case tokens.asterisk:
    58275158                this.universal();
    58285159                break;
    5829 
    58305160              case tokens.ampersand:
    58315161                this.nesting();
    58325162                break;
    5833 
    58345163              case tokens.slash:
    58355164              case tokens.combinator:
    58365165                this.combinator();
    58375166                break;
    5838 
    58395167              case tokens.str:
    58405168                this.string();
    58415169                break;
    58425170              // These cases throw; no break needed.
    5843 
    58445171              case tokens.closeSquare:
    58455172                this.missingSquareBracket();
    5846 
    58475173              case tokens.semicolon:
    58485174                this.missingBackslash();
    5849 
    58505175              default:
    58515176                this.unexpected();
    58525177            }
    58535178          }
     5179
    58545180          /**
    58555181           * Helpers
    5856            */
    5857           ;
    5858 
     5182           */;
    58595183          _proto.expected = function expected(description, index, found) {
    58605184            if (Array.isArray(description)) {
     
    58625186              description = description.join(', ') + " or " + last;
    58635187            }
    5864 
    58655188            var an = /^[aeiou]/.test(description[0]) ? 'an' : 'a';
    5866 
    58675189            if (!found) {
    58685190              return this.error("Expected " + an + " " + description + ".", {
     
    58705192              });
    58715193            }
    5872 
    58735194            return this.error("Expected " + an + " " + description + ", found \"" + found + "\" instead.", {
    58745195              index: index
    58755196            });
    58765197          };
    5877 
    58785198          _proto.requiredSpace = function requiredSpace(space) {
    58795199            return this.options.lossy ? ' ' : space;
    58805200          };
    5881 
    58825201          _proto.optionalSpace = function optionalSpace(space) {
    58835202            return this.options.lossy ? '' : space;
    58845203          };
    5885 
    58865204          _proto.lossySpace = function lossySpace(space, required) {
    58875205            if (this.options.lossy) {
     
    58915209            }
    58925210          };
    5893 
    58945211          _proto.parseParenthesisToken = function parseParenthesisToken(token) {
    58955212            var content = this.content(token);
    5896 
    58975213            if (token[_tokenize.FIELDS.TYPE] === tokens.space) {
    58985214              return this.requiredSpace(content);
     
    59015217            }
    59025218          };
    5903 
    59045219          _proto.newNode = function newNode(node, namespace) {
    59055220            if (namespace) {
     
    59085223                  this.spaces = (this.spaces || '') + namespace;
    59095224                }
    5910 
    59115225                namespace = true;
    59125226              }
    5913 
    59145227              node.namespace = namespace;
    59155228              unescapeProp(node, "namespace");
    59165229            }
    5917 
    59185230            if (this.spaces) {
    59195231              node.spaces.before = this.spaces;
    59205232              this.spaces = '';
    59215233            }
    5922 
    59235234            return this.current.append(node);
    59245235          };
    5925 
    59265236          _proto.content = function content(token) {
    59275237            if (token === void 0) {
    59285238              token = this.currToken;
    59295239            }
    5930 
    59315240            return this.css.slice(token[_tokenize.FIELDS.START_POS], token[_tokenize.FIELDS.END_POS]);
    59325241          };
    5933 
    59345242          /**
    59355243           * returns the index of the next non-whitespace, non-comment token.
     
    59405248              startPosition = this.position + 1;
    59415249            }
    5942 
    59435250            var searchPosition = startPosition;
    5944 
    59455251            while (searchPosition < this.tokens.length) {
    59465252              if (WHITESPACE_EQUIV_TOKENS[this.tokens[searchPosition][_tokenize.FIELDS.TYPE]]) {
     
    59515257              }
    59525258            }
    5953 
    59545259            return -1;
    59555260          };
    5956 
    59575261          _createClass(Parser, [{
    59585262            key: "currToken",
     
    59715275            }
    59725276          }]);
    5973 
    59745277          return Parser;
    59755278        }();
    5976 
    59775279        exports["default"] = Parser;
    59785280        module.exports = exports.default;
     
    59855287        exports.__esModule = true;
    59865288        exports["default"] = void 0;
    5987 
    59885289        var _parser = _interopRequireDefault(parserExports);
    5989 
    59905290        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    5991 
    59925291        var Processor = /*#__PURE__*/function () {
    59935292          function Processor(func, options) {
    59945293            this.func = func || function noop() {};
    5995 
    59965294            this.funcRes = null;
    59975295            this.options = options;
    59985296          }
    5999 
    60005297          var _proto = Processor.prototype;
    6001 
    60025298          _proto._shouldUpdateSelector = function _shouldUpdateSelector(rule, options) {
    60035299            if (options === void 0) {
    60045300              options = {};
    60055301            }
    6006 
    60075302            var merged = Object.assign({}, this.options, options);
    6008 
    60095303            if (merged.updateSelector === false) {
    60105304              return false;
     
    60135307            }
    60145308          };
    6015 
    60165309          _proto._isLossy = function _isLossy(options) {
    60175310            if (options === void 0) {
    60185311              options = {};
    60195312            }
    6020 
    60215313            var merged = Object.assign({}, this.options, options);
    6022 
    60235314            if (merged.lossless === false) {
    60245315              return true;
     
    60275318            }
    60285319          };
    6029 
    60305320          _proto._root = function _root(rule, options) {
    60315321            if (options === void 0) {
    60325322              options = {};
    60335323            }
    6034 
    60355324            var parser = new _parser["default"](rule, this._parseOptions(options));
    60365325            return parser.root;
    60375326          };
    6038 
    60395327          _proto._parseOptions = function _parseOptions(options) {
    60405328            return {
     
    60425330            };
    60435331          };
    6044 
    60455332          _proto._run = function _run(rule, options) {
    60465333            var _this = this;
    6047 
    60485334            if (options === void 0) {
    60495335              options = {};
    60505336            }
    6051 
    60525337            return new Promise(function (resolve, reject) {
    60535338              try {
    60545339                var root = _this._root(rule, options);
    6055 
    60565340                Promise.resolve(_this.func(root)).then(function (transform) {
    60575341                  var string = undefined;
    6058 
    60595342                  if (_this._shouldUpdateSelector(rule, options)) {
    60605343                    string = root.toString();
    60615344                    rule.selector = string;
    60625345                  }
    6063 
    60645346                  return {
    60655347                    transform: transform,
     
    60745356            });
    60755357          };
    6076 
    60775358          _proto._runSync = function _runSync(rule, options) {
    60785359            if (options === void 0) {
    60795360              options = {};
    60805361            }
    6081 
    60825362            var root = this._root(rule, options);
    6083 
    60845363            var transform = this.func(root);
    6085 
    60865364            if (transform && typeof transform.then === "function") {
    60875365              throw new Error("Selector processor returned a promise to a synchronous call.");
    60885366            }
    6089 
    60905367            var string = undefined;
    6091 
    60925368            if (options.updateSelector && typeof rule !== "string") {
    60935369              string = root.toString();
    60945370              rule.selector = string;
    60955371            }
    6096 
    60975372            return {
    60985373              transform: transform,
     
    61015376            };
    61025377          }
     5378
    61035379          /**
    61045380           * Process rule into a selector AST.
     
    61075383           * @param options The options for processing
    61085384           * @returns {Promise<parser.Root>} The AST of the selector after processing it.
    6109            */
    6110           ;
    6111 
     5385           */;
    61125386          _proto.ast = function ast(rule, options) {
    61135387            return this._run(rule, options).then(function (result) {
     
    61155389            });
    61165390          }
     5391
    61175392          /**
    61185393           * Process rule into a selector AST synchronously.
     
    61215396           * @param options The options for processing
    61225397           * @returns {parser.Root} The AST of the selector after processing it.
    6123            */
    6124           ;
    6125 
     5398           */;
    61265399          _proto.astSync = function astSync(rule, options) {
    61275400            return this._runSync(rule, options).root;
    61285401          }
     5402
    61295403          /**
    61305404           * Process a selector into a transformed value asynchronously
     
    61335407           * @param options The options for processing
    61345408           * @returns {Promise<any>} The value returned by the processor.
    6135            */
    6136           ;
    6137 
     5409           */;
    61385410          _proto.transform = function transform(rule, options) {
    61395411            return this._run(rule, options).then(function (result) {
     
    61415413            });
    61425414          }
     5415
    61435416          /**
    61445417           * Process a selector into a transformed value synchronously.
     
    61475420           * @param options The options for processing
    61485421           * @returns {any} The value returned by the processor.
    6149            */
    6150           ;
    6151 
     5422           */;
    61525423          _proto.transformSync = function transformSync(rule, options) {
    61535424            return this._runSync(rule, options).transform;
    61545425          }
     5426
    61555427          /**
    61565428           * Process a selector into a new selector string asynchronously.
     
    61595431           * @param options The options for processing
    61605432           * @returns {string} the selector after processing.
    6161            */
    6162           ;
    6163 
     5433           */;
    61645434          _proto.process = function process(rule, options) {
    61655435            return this._run(rule, options).then(function (result) {
     
    61675437            });
    61685438          }
     5439
    61695440          /**
    61705441           * Process a selector into a new selector string synchronously.
     
    61735444           * @param options The options for processing
    61745445           * @returns {string} the selector after processing.
    6175            */
    6176           ;
    6177 
     5446           */;
    61785447          _proto.processSync = function processSync(rule, options) {
    61795448            var result = this._runSync(rule, options);
    6180 
    61815449            return result.string || result.root.toString();
    61825450          };
    6183 
    61845451          return Processor;
    61855452        }();
    6186 
    61875453        exports["default"] = Processor;
    61885454        module.exports = exports.default;
     
    61975463constructors.__esModule = true;
    61985464constructors.universal = constructors.tag = constructors.string = constructors.selector = constructors.root = constructors.pseudo = constructors.nesting = constructors.id = constructors.comment = constructors.combinator = constructors.className = constructors.attribute = void 0;
    6199 
    62005465var _attribute = _interopRequireDefault$2(attribute$1);
    6201 
    62025466var _className = _interopRequireDefault$2(classNameExports);
    6203 
    62045467var _combinator = _interopRequireDefault$2(combinatorExports);
    6205 
    62065468var _comment = _interopRequireDefault$2(commentExports);
    6207 
    62085469var _id = _interopRequireDefault$2(idExports);
    6209 
    62105470var _nesting = _interopRequireDefault$2(nestingExports);
    6211 
    62125471var _pseudo = _interopRequireDefault$2(pseudoExports);
    6213 
    62145472var _root = _interopRequireDefault$2(rootExports);
    6215 
    62165473var _selector = _interopRequireDefault$2(selectorExports);
    6217 
    62185474var _string = _interopRequireDefault$2(stringExports);
    6219 
    62205475var _tag = _interopRequireDefault$2(tagExports);
    6221 
    62225476var _universal = _interopRequireDefault$2(universalExports);
    6223 
    62245477function _interopRequireDefault$2(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    6225 
    62265478var attribute = function attribute(opts) {
    62275479  return new _attribute["default"](opts);
    62285480};
    6229 
    62305481constructors.attribute = attribute;
    6231 
    62325482var className = function className(opts) {
    62335483  return new _className["default"](opts);
    62345484};
    6235 
    62365485constructors.className = className;
    6237 
    62385486var combinator = function combinator(opts) {
    62395487  return new _combinator["default"](opts);
    62405488};
    6241 
    62425489constructors.combinator = combinator;
    6243 
    62445490var comment = function comment(opts) {
    62455491  return new _comment["default"](opts);
    62465492};
    6247 
    62485493constructors.comment = comment;
    6249 
    62505494var id = function id(opts) {
    62515495  return new _id["default"](opts);
    62525496};
    6253 
    62545497constructors.id = id;
    6255 
    62565498var nesting = function nesting(opts) {
    62575499  return new _nesting["default"](opts);
    62585500};
    6259 
    62605501constructors.nesting = nesting;
    6261 
    62625502var pseudo = function pseudo(opts) {
    62635503  return new _pseudo["default"](opts);
    62645504};
    6265 
    62665505constructors.pseudo = pseudo;
    6267 
    62685506var root = function root(opts) {
    62695507  return new _root["default"](opts);
    62705508};
    6271 
    62725509constructors.root = root;
    6273 
    62745510var selector = function selector(opts) {
    62755511  return new _selector["default"](opts);
    62765512};
    6277 
    62785513constructors.selector = selector;
    6279 
    62805514var string = function string(opts) {
    62815515  return new _string["default"](opts);
    62825516};
    6283 
    62845517constructors.string = string;
    6285 
    62865518var tag = function tag(opts) {
    62875519  return new _tag["default"](opts);
    62885520};
    6289 
    62905521constructors.tag = tag;
    6291 
    62925522var universal = function universal(opts) {
    62935523  return new _universal["default"](opts);
    62945524};
    6295 
    62965525constructors.universal = universal;
    62975526
     
    62995528
    63005529guards.__esModule = true;
     5530guards.isComment = guards.isCombinator = guards.isClassName = guards.isAttribute = void 0;
     5531guards.isContainer = isContainer;
     5532guards.isIdentifier = void 0;
     5533guards.isNamespace = isNamespace;
     5534guards.isNesting = void 0;
    63015535guards.isNode = isNode;
     5536guards.isPseudo = void 0;
     5537guards.isPseudoClass = isPseudoClass;
    63025538guards.isPseudoElement = isPseudoElement;
    6303 guards.isPseudoClass = isPseudoClass;
    6304 guards.isContainer = isContainer;
    6305 guards.isNamespace = isNamespace;
    6306 guards.isUniversal = guards.isTag = guards.isString = guards.isSelector = guards.isRoot = guards.isPseudo = guards.isNesting = guards.isIdentifier = guards.isComment = guards.isCombinator = guards.isClassName = guards.isAttribute = void 0;
    6307 
     5539guards.isUniversal = guards.isTag = guards.isString = guards.isSelector = guards.isRoot = void 0;
    63085540var _types = types;
    6309 
    63105541var _IS_TYPE;
    6311 
    63125542var IS_TYPE = (_IS_TYPE = {}, _IS_TYPE[_types.ATTRIBUTE] = true, _IS_TYPE[_types.CLASS] = true, _IS_TYPE[_types.COMBINATOR] = true, _IS_TYPE[_types.COMMENT] = true, _IS_TYPE[_types.ID] = true, _IS_TYPE[_types.NESTING] = true, _IS_TYPE[_types.PSEUDO] = true, _IS_TYPE[_types.ROOT] = true, _IS_TYPE[_types.SELECTOR] = true, _IS_TYPE[_types.STRING] = true, _IS_TYPE[_types.TAG] = true, _IS_TYPE[_types.UNIVERSAL] = true, _IS_TYPE);
    6313 
    63145543function isNode(node) {
    63155544  return typeof node === "object" && IS_TYPE[node.type];
    63165545}
    6317 
    63185546function isNodeType(type, node) {
    63195547  return isNode(node) && node.type === type;
    63205548}
    6321 
    63225549var isAttribute = isNodeType.bind(null, _types.ATTRIBUTE);
    63235550guards.isAttribute = isAttribute;
     
    63445571var isUniversal = isNodeType.bind(null, _types.UNIVERSAL);
    63455572guards.isUniversal = isUniversal;
    6346 
    63475573function isPseudoElement(node) {
    63485574  return isPseudo(node) && node.value && (node.value.startsWith("::") || node.value.toLowerCase() === ":before" || node.value.toLowerCase() === ":after" || node.value.toLowerCase() === ":first-letter" || node.value.toLowerCase() === ":first-line");
    63495575}
    6350 
    63515576function isPseudoClass(node) {
    63525577  return isPseudo(node) && !isPseudoElement(node);
    63535578}
    6354 
    63555579function isContainer(node) {
    63565580  return !!(isNode(node) && node.walk);
    63575581}
    6358 
    63595582function isNamespace(node) {
    63605583  return isAttribute(node) || isTag(node);
     
    63645587
    63655588        exports.__esModule = true;
    6366 
    63675589        var _types = types;
    6368 
    63695590        Object.keys(_types).forEach(function (key) {
    63705591          if (key === "default" || key === "__esModule") return;
     
    63725593          exports[key] = _types[key];
    63735594        });
    6374 
    63755595        var _constructors = constructors;
    6376 
    63775596        Object.keys(_constructors).forEach(function (key) {
    63785597          if (key === "default" || key === "__esModule") return;
     
    63805599          exports[key] = _constructors[key];
    63815600        });
    6382 
    63835601        var _guards = guards;
    6384 
    63855602        Object.keys(_guards).forEach(function (key) {
    63865603          if (key === "default" || key === "__esModule") return;
     
    63945611        exports.__esModule = true;
    63955612        exports["default"] = void 0;
    6396 
    63975613        var _processor = _interopRequireDefault(processorExports);
    6398 
    63995614        var selectors$1 = _interopRequireWildcard(selectors);
    6400 
    6401         function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
    6402 
    6403         function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
    6404 
     5615        function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
     5616        function _interopRequireWildcard(obj, nodeInterop) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
    64055617        function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
    6406 
    64075618        var parser = function parser(processor) {
    64085619          return new _processor["default"](processor);
    64095620        };
    6410 
    64115621        Object.assign(parser, selectors$1);
    64125622        delete parser.__esModule;
     
    65675777              explicit: context.explicit,
    65685778            };
    6569             newNodes = node.map((childNode) =>
    6570               transform(childNode, childContext)
    6571             );
     5779            newNodes = node.map((childNode) => {
     5780              const newContext = {
     5781                ...childContext,
     5782                enforceNoSpacing: false,
     5783              };
     5784
     5785              const result = transform(childNode, newContext);
     5786
     5787              childContext.global = newContext.global;
     5788              childContext.hasLocals = newContext.hasLocals;
     5789
     5790              return result;
     5791            });
    65725792
    65735793            node = node.clone();
     
    66385858        break;
    66395859      }
     5860      case "nesting": {
     5861        if (node.value === "&") {
     5862          context.hasLocals = true;
     5863        }
     5864      }
    66405865    }
    66415866
     
    67105935}
    67115936
    6712 function isWordAFunctionArgument(wordNode, functionNode) {
    6713   return functionNode
    6714     ? functionNode.nodes.some(
    6715         (functionNodeChild) =>
    6716           functionNodeChild.sourceIndex === wordNode.sourceIndex
    6717       )
    6718     : false;
    6719 }
     5937// `none` is special value, other is global values
     5938const specialKeywords = [
     5939  "none",
     5940  "inherit",
     5941  "initial",
     5942  "revert",
     5943  "revert-layer",
     5944  "unset",
     5945];
    67205946
    67215947function localizeDeclarationValues(localize, declaration, context) {
     
    67235949
    67245950  valueNodes.walk((node, index, nodes) => {
     5951    if (
     5952      node.type === "function" &&
     5953      (node.value.toLowerCase() === "var" || node.value.toLowerCase() === "env")
     5954    ) {
     5955      return false;
     5956    }
     5957
     5958    if (
     5959      node.type === "word" &&
     5960      specialKeywords.includes(node.value.toLowerCase())
     5961    ) {
     5962      return;
     5963    }
     5964
    67255965    const subContext = {
    67265966      options: context.options,
     
    67395979
    67405980  if (isAnimation) {
    6741     const validIdent = /^-?[_a-z][_a-z0-9-]*$/i;
     5981    // letter
     5982    // An uppercase letter or a lowercase letter.
     5983    //
     5984    // ident-start code point
     5985    // A letter, a non-ASCII code point, or U+005F LOW LINE (_).
     5986    //
     5987    // ident code point
     5988    // An ident-start code point, a digit, or U+002D HYPHEN-MINUS (-).
     5989
     5990    // We don't validate `hex digits`, because we don't need it, it is work of linters.
     5991    const validIdent =
     5992      /^-?([a-z\u0080-\uFFFF_]|(\\[^\r\n\f])|-(?![0-9]))((\\[^\r\n\f])|[a-z\u0080-\uFFFF_0-9-])*$/i;
    67425993
    67435994    /*
     
    67465997    a keyword, it is given priority. Only when all the properties that can take a keyword are
    67475998    exhausted can the animation name be set to the keyword. I.e.
    6748  
     5999
    67496000    animation: infinite infinite;
    6750  
     6001
    67516002    The animation will repeat an infinite number of times from the first argument, and will have an
    67526003    animation name of infinite from the second.
    67536004    */
    67546005    const animationKeywords = {
     6006      // animation-direction
     6007      $normal: 1,
     6008      $reverse: 1,
    67556009      $alternate: 1,
    67566010      "$alternate-reverse": 1,
     6011      // animation-fill-mode
     6012      $forwards: 1,
    67576013      $backwards: 1,
    67586014      $both: 1,
     6015      // animation-iteration-count
     6016      $infinite: 1,
     6017      // animation-play-state
     6018      $paused: 1,
     6019      $running: 1,
     6020      // animation-timing-function
    67596021      $ease: 1,
    67606022      "$ease-in": 1,
     6023      "$ease-out": 1,
    67616024      "$ease-in-out": 1,
    6762       "$ease-out": 1,
    6763       $forwards: 1,
    6764       $infinite: 1,
    67656025      $linear: 1,
    6766       $none: Infinity, // No matter how many times you write none, it will never be an animation name
    6767       $normal: 1,
    6768       $paused: 1,
    6769       $reverse: 1,
    6770       $running: 1,
    67716026      "$step-end": 1,
    67726027      "$step-start": 1,
     6028      // Special
     6029      $none: Infinity, // No matter how many times you write none, it will never be an animation name
     6030      // Global values
    67736031      $initial: Infinity,
    67746032      $inherit: Infinity,
    67756033      $unset: Infinity,
     6034      $revert: Infinity,
     6035      "$revert-layer": Infinity,
    67766036    };
    67776037    let parsedAnimationKeywords = {};
    6778     let stepsFunctionNode = null;
    67796038    const valueNodes = valueParser(declaration.value).walk((node) => {
    6780       /* If div-token appeared (represents as comma ','), a possibility of an animation-keywords should be reflesh. */
     6039      // If div-token appeared (represents as comma ','), a possibility of an animation-keywords should be reflesh.
    67816040      if (node.type === "div") {
    67826041        parsedAnimationKeywords = {};
     6042
     6043        return;
    67836044      }
    6784       if (node.type === "function" && node.value.toLowerCase() === "steps") {
    6785         stepsFunctionNode = node;
     6045      // Do not handle nested functions
     6046      else if (node.type === "function") {
     6047        return false;
    67866048      }
    6787       const value =
    6788         node.type === "word" &&
    6789         !isWordAFunctionArgument(node, stepsFunctionNode)
    6790           ? node.value.toLowerCase()
    6791           : null;
     6049      // Ignore all except word
     6050      else if (node.type !== "word") {
     6051        return;
     6052      }
     6053
     6054      const value = node.type === "word" ? node.value.toLowerCase() : null;
    67926055
    67936056      let shouldParseAnimationName = false;
     
    68146077        localAliasMap: context.localAliasMap,
    68156078      };
     6079
    68166080      return localizeDeclNode(node, subContext);
    68176081    });
     
    68886152                atRule.params = localMatch[0];
    68896153                globalKeyframes = false;
    6890               } else if (!globalMode) {
    6891                 if (atRule.params && !localAliasMap.has(atRule.params)) {
    6892                   atRule.params = ":local(" + atRule.params + ")";
    6893                 }
     6154              } else if (
     6155                atRule.params &&
     6156                !globalMode &&
     6157                !localAliasMap.has(atRule.params)
     6158              ) {
     6159                atRule.params = ":local(" + atRule.params + ")";
    68946160              }
    68956161
     
    69006166                  global: globalKeyframes,
    69016167                });
     6168              });
     6169            } else if (/scope$/i.test(atRule.name)) {
     6170              if (atRule.params) {
     6171                atRule.params = atRule.params
     6172                  .split("to")
     6173                  .map((item) => {
     6174                    const selector = item.trim().slice(1, -1).trim();
     6175                    const context = localizeNode(
     6176                      selector,
     6177                      options.mode,
     6178                      localAliasMap
     6179                    );
     6180
     6181                    context.options = options;
     6182                    context.localAliasMap = localAliasMap;
     6183
     6184                    if (pureMode && context.hasPureGlobals) {
     6185                      throw atRule.error(
     6186                        'Selector in at-rule"' +
     6187                          selector +
     6188                          '" is not pure ' +
     6189                          "(pure selectors must contain at least one local class or id)"
     6190                      );
     6191                    }
     6192
     6193                    return `(${context.selector})`;
     6194                  })
     6195                  .join(" to ");
     6196              }
     6197
     6198              atRule.nodes.forEach((declaration) => {
     6199                if (declaration.type === "decl") {
     6200                  localizeDeclaration(declaration, {
     6201                    localAliasMap,
     6202                    options: options,
     6203                    global: globalMode,
     6204                  });
     6205                }
    69026206              });
    69036207            } else if (atRule.nodes) {
     
    69606264const hasOwnProperty = Object.prototype.hasOwnProperty;
    69616265
    6962 function getSingleLocalNamesForComposes(root) {
     6266function isNestedRule(rule) {
     6267  if (!rule.parent || rule.parent.type === "root") {
     6268    return false;
     6269  }
     6270
     6271  if (rule.parent.type === "rule") {
     6272    return true;
     6273  }
     6274
     6275  return isNestedRule(rule.parent);
     6276}
     6277
     6278function getSingleLocalNamesForComposes(root, rule) {
     6279  if (isNestedRule(rule)) {
     6280    throw new Error(`composition is not allowed in nested rule \n\n${rule}`);
     6281  }
     6282
    69636283  return root.nodes.map((node) => {
    69646284    if (node.type !== "selector" || node.nodes.length !== 1) {
     
    70476367      const exports = Object.create(null);
    70486368
    7049       function exportScopedName(name, rawName) {
     6369      function exportScopedName(name, rawName, node) {
    70506370        const scopedName = generateScopedName(
    70516371          rawName ? rawName : name,
    70526372          root.source.input.from,
    7053           root.source.input.css
     6373          root.source.input.css,
     6374          node
    70546375        );
    70556376        const exportEntry = generateExportEntry(
     
    70576378          scopedName,
    70586379          root.source.input.from,
    7059           root.source.input.css
     6380          root.source.input.css,
     6381          node
    70606382        );
    70616383        const { key, value } = exportEntry;
     
    70736395        switch (node.type) {
    70746396          case "selector":
    7075             node.nodes = node.map(localizeNode);
     6397            node.nodes = node.map((item) => localizeNode(item));
    70766398            return node;
    70776399          case "class":
     
    70796401              value: exportScopedName(
    70806402                node.value,
    7081                 node.raws && node.raws.value ? node.raws.value : null
     6403                node.raws && node.raws.value ? node.raws.value : null,
     6404                node
    70826405              ),
    70836406            });
     
    70866409              value: exportScopedName(
    70876410                node.value,
    7088                 node.raws && node.raws.value ? node.raws.value : null
     6411                node.raws && node.raws.value ? node.raws.value : null,
     6412                node
    70896413              ),
    70906414            });
     6415          }
     6416          case "attribute": {
     6417            if (node.attribute === "class" && node.operator === "=") {
     6418              return selectorParser.attribute({
     6419                attribute: node.attribute,
     6420                operator: node.operator,
     6421                quoteMark: "'",
     6422                value: exportScopedName(node.value, null, null),
     6423              });
     6424            }
    70916425          }
    70926426        }
     
    71066440
    71076441              const selector = localizeNode(node.first);
    7108               // move the spaces that were around the psuedo selector to the first
     6442              // move the spaces that were around the pseudo selector to the first
    71096443              // non-container node
    71106444              selector.first.spaces = node.spaces;
     
    71286462          case "root":
    71296463          case "selector": {
    7130             node.each(traverseNode);
     6464            node.each((item) => traverseNode(item));
    71316465            break;
    71326466          }
     
    71566490        rule.selector = traverseNode(parsedSelector.clone()).toString();
    71576491
    7158         rule.walkDecls(/composes|compose-with/i, (decl) => {
    7159           const localNames = getSingleLocalNamesForComposes(parsedSelector);
    7160           const classes = decl.value.split(/\s+/);
    7161 
    7162           classes.forEach((className) => {
    7163             const global = /^global\(([^)]+)\)$/.exec(className);
    7164 
    7165             if (global) {
    7166               localNames.forEach((exportedName) => {
    7167                 exports[exportedName].push(global[1]);
    7168               });
    7169             } else if (hasOwnProperty.call(importedNames, className)) {
    7170               localNames.forEach((exportedName) => {
    7171                 exports[exportedName].push(className);
    7172               });
    7173             } else if (hasOwnProperty.call(exports, className)) {
    7174               localNames.forEach((exportedName) => {
    7175                 exports[className].forEach((item) => {
    7176                   exports[exportedName].push(item);
     6492        rule.walkDecls(/^(composes|compose-with)$/i, (decl) => {
     6493          const localNames = getSingleLocalNamesForComposes(
     6494            parsedSelector,
     6495            decl.parent
     6496          );
     6497          const multiple = decl.value.split(",");
     6498
     6499          multiple.forEach((value) => {
     6500            const classes = value.trim().split(/\s+/);
     6501
     6502            classes.forEach((className) => {
     6503              const global = /^global\(([^)]+)\)$/.exec(className);
     6504
     6505              if (global) {
     6506                localNames.forEach((exportedName) => {
     6507                  exports[exportedName].push(global[1]);
    71776508                });
    7178               });
    7179             } else {
    7180               throw decl.error(
    7181                 `referenced class name "${className}" in ${decl.prop} not found`
    7182               );
    7183             }
     6509              } else if (hasOwnProperty.call(importedNames, className)) {
     6510                localNames.forEach((exportedName) => {
     6511                  exports[exportedName].push(className);
     6512                });
     6513              } else if (hasOwnProperty.call(exports, className)) {
     6514                localNames.forEach((exportedName) => {
     6515                  exports[className].forEach((item) => {
     6516                    exports[exportedName].push(item);
     6517                  });
     6518                });
     6519              } else {
     6520                throw decl.error(
     6521                  `referenced class name "${className}" in ${decl.prop} not found`
     6522                );
     6523              }
     6524            });
    71846525          });
    71856526
     
    72316572
    72326573        atRule.params = exportScopedName(localMatch[1]);
     6574      });
     6575
     6576      root.walkAtRules(/scope$/i, (atRule) => {
     6577        if (atRule.params) {
     6578          atRule.params = atRule.params
     6579            .split("to")
     6580            .map((item) => {
     6581              const selector = item.trim().slice(1, -1).trim();
     6582
     6583              const localMatch = /^\s*:local\s*\((.+?)\)\s*$/.exec(selector);
     6584
     6585              if (!localMatch) {
     6586                return `(${selector})`;
     6587              }
     6588
     6589              let parsedSelector = selectorParser().astSync(selector);
     6590
     6591              return `(${traverseNode(parsedSelector).toString()})`;
     6592            })
     6593            .join(" to ");
     6594        }
    72336595      });
    72346596
Note: See TracChangeset for help on using the changeset viewer.