Changeset 0c6b92a for imaps-frontend/node_modules/vite

imaps-frontend/node_modules/vite/LICENSE.md

rd565449	r0c6b92a
4	4	MIT License
5	5
6		Copyright (c) 2019-present, ~~Yuxi (Evan) You~~ and Vite contributors
	6	Copyright (c) 2019-present, VoidZero Inc. and Vite contributors
7	7
8	8	Permission is hereby granted, free of charge, to any person obtaining a copy

imaps-frontend/node_modules/vite/README.md

-              rd565449
+              r0c6b92a
 Vite (French word for "fast", pronounced `/vit/`) is a new breed of frontend build tool that significantly improves the frontend development experience. It consists of two major parts:
 - A dev server that serves your source files over [native ES modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules), with [rich built-in features](https://vitejs.dev/guide/features.html) and astonishingly fast [Hot Module Replacement (HMR)](https://vitejs.dev/guide/features.html#hot-module-replacement).
+- A dev server that serves your source files over [native ES modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules), with [rich built-in features](https://vite.dev/guide/features.html) and astonishingly fast [Hot Module Replacement (HMR)](https://vite.dev/guide/features.html#hot-module-replacement).
 - A [build command](https://vitejs.dev/guide/build.html) that bundles your code with [Rollup](https://rollupjs.org), pre-configured to output highly optimized static assets for production.
+- A [build command](https://vite.dev/guide/build.html) that bundles your code with [Rollup](https://rollupjs.org), pre-configured to output highly optimized static assets for production.
 In addition, Vite is highly extensible via its [Plugin API](https://vitejs.dev/guide/api-plugin.html) and [JavaScript API](https://vitejs.dev/guide/api-javascript.html) with full typing support.
+In addition, Vite is highly extensible via its [Plugin API](https://vite.dev/guide/api-plugin.html) and [JavaScript API](https://vite.dev/guide/api-javascript.html) with full typing support.
 [Read the Docs to Learn More](https://vitejs.dev).
+[Read the Docs to Learn More](https://vite.dev).

imaps-frontend/node_modules/vite/client.d.ts

-              rd565449
+              r0c6b92a
   export default src
+}
+declare interface VitePreloadErrorEvent extends Event {
+  payload: Error
+}
+declare interface WindowEventMap {
+  'vite:preloadError': VitePreloadErrorEvent
+}

imaps-frontend/node_modules/vite/dist/client/client.mjs

-              rd565449
+              r0c6b92a
   (browser) ${currentScriptHost} <--[HTTP]--> ${serverHost} (server)
   (browser) ${socketHost} <--[WebSocket (failing)]--> ${directSocketHost} (server)
 Check out your Vite / network configuration and https://vitejs.dev/config/server-options.html#server-hmr .`
+Check out your Vite / network configuration and https://vite.dev/config/server-options.html#server-hmr .`
         );
       });
 …
         () => {
           console.info(
             "[vite] Direct websocket connection fallback. Check out https://vitejs.dev/config/server-options.html#server-hmr to remove the previous connection error."
+            "[vite] Direct websocket connection fallback. Check out https://vite.dev/config/server-options.html#server-hmr to remove the previous connection error."
           );
         },
 …
+}
 function cleanUrl(pathname) {
   const url = new URL(pathname, "http://vitejs.dev");
+  const url = new URL(pathname, "http://vite.dev");
   url.searchParams.delete("direct");
   return url.pathname + url.search;
 …
+  }
   const pathname = url.replace(/[?#].*$/, "");
   const { search, hash } = new URL(url, "http://vitejs.dev");
+  const { search, hash } = new URL(url, "http://vite.dev");
   return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ""}${hash || ""}`;
+}

imaps-frontend/node_modules/vite/dist/node-cjs/publicUtils.cjs

-              rd565449
+              r0c6b92a
     charToInt[c] = i;
+}
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
+    do {
+        let clamped = delta & 0b011111;
+        delta >>>= 5;
+        if (delta > 0)
+            clamped |= 0b100000;
+        builder.write(intToChar[clamped]);
+    } while (delta > 0);
+    return num;
+}
+const bufLength = 1024 * 16;
 // Provide a fallback for older environments.
 const td = typeof TextDecoder !== 'undefined'
 …
             },
         };
+class StringWriter {
+    constructor() {
+        this.pos = 0;
+        this.out = '';
+        this.buffer = new Uint8Array(bufLength);
+    }
+    write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+        }
+    }
+    flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+}
 function encode(decoded) {
+    const state = new Int32Array(5);
+    const bufLength = 1024 * 16;
+    const subLength = bufLength - 36;
+    const buf = new Uint8Array(bufLength);
+    const sub = buf.subarray(0, subLength);
+    let pos = 0;
+    let out = '';
+    const writer = new StringWriter();
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
     for (let i = 0; i < decoded.length; i++) {
         const line = decoded[i];
+        if (i > 0) {
+            if (pos === bufLength) {
+                out += td.decode(buf);
+                pos = 0;
+            }
+            buf[pos++] = semicolon;
+        }
+        if (i > 0)
+            writer.write(semicolon);
         if (line.length === 0)
             continue;
         state[0] = 0;
+        let genColumn = 0;
         for (let j = 0; j < line.length; j++) {
             const segment = line[j];
-            // We can push up to 5 ints, each int can take at most 7 chars, and we
-            // may push a comma.
-            if (pos > subLength) {
-                out += td.decode(sub);
-                buf.copyWithin(0, subLength, pos);
-                pos -= subLength;
+            }
             if (j > 0)
                 buf[pos++] = comma;
             pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
+                writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
             if (segment.length === 1)
                 continue;
             pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
             pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
             pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
             if (segment.length === 4)
                 continue;
             pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
+        }
+    }
+    return out + td.decode(buf.subarray(0, pos));
+}
+function encodeInteger(buf, pos, state, segment, j) {
+    const next = segment[j];
+    let num = next - state[j];
+    state[j] = next;
+    num = num < 0 ? (-num << 1) | 1 : num << 1;
+    do {
+        let clamped = num & 0b011111;
+        num >>>= 5;
+        if (num > 0)
+            clamped |= 0b100000;
+        buf[pos++] = intToChar[clamped];
+    } while (num > 0);
+    return pos;
+    return writer.flush();
+}
 …
+                        }
+                        let m;
                         // Is webkit? http://stackoverflow.com/a/16459606/376773
                         // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
 …
                                 // Is firefox >= v31?
                                 // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
                                 (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+                                (typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
                                 // Double check webkit in userAgent just in case we are in a worker
                                 (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
 …
       ];
       continue;
+    } else if (key === "server" && rootPath === "server.hmr") {
+      merged[key] = value;
+      continue;
+    }
     if (Array.isArray(existing) || Array.isArray(value)) {
 …
                 if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
+                while (start < 0) start += this.original.length;
+                while (end < 0) end += this.original.length;
+                if (this.original.length !== 0) {
+                        while (start < 0) start += this.original.length;
+                        while (end < 0) end += this.original.length;
+                }
                 if (end > this.original.length) throw new Error('end is out of bounds');
 …
         remove(start, end) {
+                while (start < 0) start += this.original.length;
+                while (end < 0) end += this.original.length;
+                if (this.original.length !== 0) {
+                        while (start < 0) start += this.original.length;
+                        while (end < 0) end += this.original.length;
+                }
                 if (start === end) return this;
 …
         reset(start, end) {
+                while (start < 0) start += this.original.length;
+                while (end < 0) end += this.original.length;
+                if (this.original.length !== 0) {
+                        while (start < 0) start += this.original.length;
+                        while (end < 0) end += this.original.length;
+                }
                 if (start === end) return this;
 …
         slice(start = 0, end = this.original.length) {
+                while (start < 0) start += this.original.length;
+                while (end < 0) end += this.original.length;
+                if (this.original.length !== 0) {
+                        while (start < 0) start += this.original.length;
+                        while (end < 0) end += this.original.length;
+                }
                 let result = '';

imaps-frontend/node_modules/vite/dist/node/chunks/dep-Ba1kN6Mp.js

-              rd565449
+              r0c6b92a
 import { C as commonjsGlobal, B as getDefaultExportFromCjs } from './dep-mCdpKltl.js';
+import { C as commonjsGlobal, B as getDefaultExportFromCjs } from './dep-CB_7IfJ-.js';
 import require$$0__default from 'fs';
 import require$$0 from 'postcss';
 …
           root.walkDecls(/^composes$/, (declaration) => {
+            const matches = declaration.value.match(matchImports$1);
+            if (!matches) {
+              return;
+            }
+            let tmpSymbols;
+            let [
+              ,
+              /*match*/ symbols,
+              doubleQuotePath,
+              singleQuotePath,
+              global,
+            ] = matches;
+            if (global) {
+              // Composing globals simply means changing these classes to wrap them in global(name)
+              tmpSymbols = symbols.split(/\s+/).map((s) => `global(${s})`);
+            } else {
+              const importPath = doubleQuotePath || singleQuotePath;
+              let parent = declaration.parent;
+              let parentIndexes = "";
+              while (parent.type !== "root") {
+                parentIndexes =
+                  parent.parent.index(parent) + "_" + parentIndexes;
+                parent = parent.parent;
+            const multiple = declaration.value.split(",");
+            const values = [];
+            multiple.forEach((value) => {
+              const matches = value.trim().match(matchImports$1);
+              if (!matches) {
+                values.push(value);
+                return;
+              }
+              const { selector } = declaration.parent;
+              const parentRule = `_${parentIndexes}${selector}`;
+              addImportToGraph(importPath, parentRule, graph, visited);
+              importDecls[importPath] = declaration;
+              imports[importPath] = imports[importPath] || {};
+              tmpSymbols = symbols.split(/\s+/).map((s) => {
+                if (!imports[importPath][s]) {
+                  imports[importPath][s] = createImportedName(s, importPath);
+              let tmpSymbols;
+              let [
+                ,
+                /*match*/ symbols,
+                doubleQuotePath,
+                singleQuotePath,
+                global,
+              ] = matches;
+              if (global) {
+                // Composing globals simply means changing these classes to wrap them in global(name)
+                tmpSymbols = symbols.split(/\s+/).map((s) => `global(${s})`);
+              } else {
+                const importPath = doubleQuotePath || singleQuotePath;
+                let parent = declaration.parent;
+                let parentIndexes = "";
+                while (parent.type !== "root") {
+                  parentIndexes =
+                    parent.parent.index(parent) + "_" + parentIndexes;
+                  parent = parent.parent;
+                }
+                return imports[importPath][s];
+              });
+            }
+            declaration.value = tmpSymbols.join(" ");
+                const { selector } = declaration.parent;
+                const parentRule = `_${parentIndexes}${selector}`;
+                addImportToGraph(importPath, parentRule, graph, visited);
+                importDecls[importPath] = declaration;
+                imports[importPath] = imports[importPath] || {};
+                tmpSymbols = symbols.split(/\s+/).map((s) => {
+                  if (!imports[importPath][s]) {
+                    imports[importPath][s] = createImportedName(s, importPath);
+                  }
+                  return imports[importPath][s];
+                });
+              }
+              values.push(tmpSymbols.join(" "));
+            });
+            declaration.value = values.join(", ");
           });
 …
         exports.__esModule = true;
         exports["default"] = unesc;
         // Many thanks for this post which made this migration much easier.
         // https://mathiasbynens.be/notes/css-escapes
 …
           var hex = '';
           var spaceTerminated = false;
           for (var i = 0; i < 6 && lower[i] !== undefined; i++) {
             var code = lower.charCodeAt(i); // check to see if we are dealing with a valid hex char [a-f|0-9]
             var valid = code >= 97 && code <= 102 || code >= 48 && code <= 57; // https://drafts.csswg.org/css-syntax/#consume-escaped-code-point
+            var code = lower.charCodeAt(i);
+            // check to see if we are dealing with a valid hex char [a-f|0-9]
+            var valid = code >= 97 && code <= 102 || code >= 48 && code <= 57;
+            // https://drafts.csswg.org/css-syntax/#consume-escaped-code-point
             spaceTerminated = code === 32;
             if (!valid) {
               break;
+            }
             hex += lower[i];
+          }
           if (hex.length === 0) {
             return undefined;
+          }
           var codePoint = parseInt(hex, 16);
+          var isSurrogate = codePoint >= 0xD800 && codePoint <= 0xDFFF; // Add special case for
+          var isSurrogate = codePoint >= 0xD800 && codePoint <= 0xDFFF;
+          // Add special case for
           // "If this number is zero, or is for a surrogate, or is greater than the maximum allowed code point"
           // https://drafts.csswg.org/css-syntax/#maximum-allowed-code-point
           if (isSurrogate || codePoint === 0x0000 || codePoint > 0x10FFFF) {
             return ["\uFFFD", hex.length + (spaceTerminated ? 1 : 0)];
+          }
           return [String.fromCodePoint(codePoint), hex.length + (spaceTerminated ? 1 : 0)];
+        }
         var CONTAINS_ESCAPE = /\\/;
         function unesc(str) {
           var needToProcess = CONTAINS_ESCAPE.test(str);
           if (!needToProcess) {
             return str;
+          }
           var ret = "";
           for (var i = 0; i < str.length; i++) {
             if (str[i] === "\\") {
               var gobbled = gobbleHex(str.slice(i + 1, i + 7));
               if (gobbled !== undefined) {
                 ret += gobbled[0];
                 i += gobbled[1];
                 continue;
+              } // Retain a pair of \\ if double escaped `\\\\`
+              }
+              // Retain a pair of \\ if double escaped `\\\\`
               // https://github.com/postcss/postcss-selector-parser/commit/268c9a7656fb53f543dc620aa5b73a30ec3ff20e
               if (str[i + 1] === "\\") {
                 ret += "\\";
                 i++;
                 continue;
+              } // if \\ is at the end of the string retain it
+              }
+              // if \\ is at the end of the string retain it
               // https://github.com/postcss/postcss-selector-parser/commit/01a6b346e3612ce1ab20219acc26abdc259ccefb
               if (str.length === i + 1) {
                 ret += str[i];
+              }
               continue;
+            }
             ret += str[i];
+          }
           return ret;
+        }
         module.exports = exports.default;
 } (unesc, unesc.exports));
 …
         exports.__esModule = true;
         exports["default"] = getProp;
         function getProp(obj) {
           for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
             props[_key - 1] = arguments[_key];
+          }
           while (props.length > 0) {
             var prop = props.shift();
             if (!obj[prop]) {
               return undefined;
+            }
             obj = obj[prop];
+          }
           return obj;
+        }
         module.exports = exports.default;
 } (getProp, getProp.exports));
 …
         exports.__esModule = true;
         exports["default"] = ensureObject;
         function ensureObject(obj) {
           for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
             props[_key - 1] = arguments[_key];
+          }
           while (props.length > 0) {
             var prop = props.shift();
             if (!obj[prop]) {
               obj[prop] = {};
+            }
             obj = obj[prop];
+          }
+        }
         module.exports = exports.default;
 } (ensureObject, ensureObject.exports));
 …
         exports.__esModule = true;
         exports["default"] = stripComments;
         function stripComments(str) {
           var s = "";
           var commentStart = str.indexOf("/*");
           var lastEnd = 0;
           while (commentStart >= 0) {
             s = s + str.slice(lastEnd, commentStart);
             var commentEnd = str.indexOf("*/", commentStart + 2);
             if (commentEnd < 0) {
               return s;
+            }
             lastEnd = commentEnd + 2;
             commentStart = str.indexOf("/*", lastEnd);
+          }
           s = s + str.slice(lastEnd);
           return s;
+        }
         module.exports = exports.default;
 } (stripComments, stripComments.exports));
 …
 util.__esModule = true;
+util.stripComments = util.ensureObject = util.getProp = util.unesc = void 0;
+util.unesc = util.stripComments = util.getProp = util.ensureObject = void 0;
 var _unesc = _interopRequireDefault$3(unescExports);
 util.unesc = _unesc["default"];
 var _getProp = _interopRequireDefault$3(getPropExports);
 util.getProp = _getProp["default"];
 var _ensureObject = _interopRequireDefault$3(ensureObjectExports);
 util.ensureObject = _ensureObject["default"];
 var _stripComments = _interopRequireDefault$3(stripCommentsExports);
 util.stripComments = _stripComments["default"];
 function _interopRequireDefault$3(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _util = util;
         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); } }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
         var cloneNode = function cloneNode(obj, parent) {
           if (typeof obj !== 'object' || obj === null) {
             return obj;
+          }
           var cloned = new obj.constructor();
           for (var i in obj) {
             if (!obj.hasOwnProperty(i)) {
               continue;
+            }
             var value = obj[i];
             var type = typeof value;
             if (i === 'parent' && type === 'object') {
               if (parent) {
 …
+            }
+          }
           return cloned;
         };
         var Node = /*#__PURE__*/function () {
           function Node(opts) {
 …
               opts = {};
+            }
             Object.assign(this, opts);
             this.spaces = this.spaces || {};
 …
             this.spaces.after = this.spaces.after || '';
+          }
           var _proto = Node.prototype;
           _proto.remove = function remove() {
             if (this.parent) {
               this.parent.removeChild(this);
+            }
             this.parent = undefined;
             return this;
           };
           _proto.replaceWith = function replaceWith() {
             if (this.parent) {
 …
                 this.parent.insertBefore(this, arguments[index]);
+              }
               this.remove();
+            }
             return this;
           };
           _proto.next = function next() {
             return this.parent.at(this.parent.index(this) + 1);
           };
           _proto.prev = function prev() {
             return this.parent.at(this.parent.index(this) - 1);
           };
           _proto.clone = function clone(overrides) {
             if (overrides === void 0) {
               overrides = {};
+            }
             var cloned = cloneNode(this);
             for (var name in overrides) {
               cloned[name] = overrides[name];
+            }
             return cloned;
+          }
           /**
            * Some non-standard syntax doesn't follow normal escaping rules for css.
 …
            * @param {any} value the unescaped value of the property
            * @param {string} valueEscaped optional. the escaped value of the property.
+           */
+          ;
+           */;
           _proto.appendToPropertyAndEscape = function appendToPropertyAndEscape(name, value, valueEscaped) {
             if (!this.raws) {
               this.raws = {};
+            }
             var originalValue = this[name];
             var originalEscaped = this.raws[name];
             this[name] = originalValue + value; // this may trigger a setter that updates raws, so it has to be set first.
             if (originalEscaped || valueEscaped !== value) {
               this.raws[name] = (originalEscaped || originalValue) + valueEscaped;
 …
+            }
+          }
           /**
            * Some non-standard syntax doesn't follow normal escaping rules for css.
 …
            * @param {any} value the unescaped value of the property
            * @param {string} valueEscaped the escaped value of the property.
+           */
+          ;
+           */;
           _proto.setPropertyAndEscape = function setPropertyAndEscape(name, value, valueEscaped) {
             if (!this.raws) {
               this.raws = {};
+            }
             this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
             this.raws[name] = valueEscaped;
+          }
           /**
            * When you want a value to passed through to CSS directly. This method
 …
            * @param {string} name the property to set.
            * @param {any} value The value that is both escaped and unescaped.
+           */
+          ;
+           */;
           _proto.setPropertyWithoutEscape = function setPropertyWithoutEscape(name, value) {
             this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
             if (this.raws) {
               delete this.raws[name];
+            }
+          }
           /**
+           *
            * @param {number} line The number (starting with 1)
            * @param {number} column The column number (starting with 1)
+           */
+          ;
+           */;
           _proto.isAtPosition = function isAtPosition(line, column) {
             if (this.source && this.source.start && this.source.end) {
 …
                 return false;
+              }
               if (this.source.end.line < line) {
                 return false;
+              }
               if (this.source.start.line === line && this.source.start.column > column) {
                 return false;
+              }
               if (this.source.end.line === line && this.source.end.column < column) {
                 return false;
+              }
               return true;
+            }
             return undefined;
           };
           _proto.stringifyProperty = function stringifyProperty(name) {
             return this.raws && this.raws[name] || this[name];
           };
           _proto.valueToString = function valueToString() {
             return String(this.stringifyProperty("value"));
           };
           _proto.toString = function toString() {
             return [this.rawSpaceBefore, this.valueToString(), this.rawSpaceAfter].join('');
           };
           _createClass(Node, [{
             key: "rawSpaceBefore",
             get: function get() {
               var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
               if (rawSpace === undefined) {
                 rawSpace = this.spaces && this.spaces.before;
+              }
               return rawSpace || "";
             },
 …
             get: function get() {
               var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
               if (rawSpace === undefined) {
                 rawSpace = this.spaces.after;
+              }
               return rawSpace || "";
             },
 …
+            }
           }]);
           return Node;
         }();
         exports["default"] = Node;
         module.exports = exports.default;
 …
 types.__esModule = true;
 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;
+types.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;
 var TAG = 'tag';
 types.TAG = TAG;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _node = _interopRequireDefault(nodeExports);
         var types$1 = _interopRequireWildcard(types);
+        function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+        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; }
+        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); }
+        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; }
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+        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); }
+        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."); }
         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); }
         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; }
         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); } }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var Container = /*#__PURE__*/function (_Node) {
           _inheritsLoose(Container, _Node);
           function Container(opts) {
             var _this;
             _this = _Node.call(this, opts) || this;
             if (!_this.nodes) {
               _this.nodes = [];
+            }
             return _this;
+          }
           var _proto = Container.prototype;
           _proto.append = function append(selector) {
             selector.parent = this;
 …
             return this;
           };
           _proto.prepend = function prepend(selector) {
             selector.parent = this;
 …
             return this;
           };
           _proto.at = function at(index) {
             return this.nodes[index];
           };
           _proto.index = function index(child) {
             if (typeof child === 'number') {
               return child;
+            }
             return this.nodes.indexOf(child);
           };
           _proto.removeChild = function removeChild(child) {
             child = this.index(child);
 …
             this.nodes.splice(child, 1);
             var index;
             for (var id in this.indexes) {
               index = this.indexes[id];
               if (index >= child) {
                 this.indexes[id] = index - 1;
+              }
+            }
             return this;
           };
           _proto.removeAll = function removeAll() {
             for (var _iterator = _createForOfIteratorHelperLoose(this.nodes), _step; !(_step = _iterator()).done;) {
 …
               node.parent = undefined;
+            }
             this.nodes = [];
             return this;
           };
           _proto.empty = function empty() {
             return this.removeAll();
           };
           _proto.insertAfter = function insertAfter(oldNode, newNode) {
             newNode.parent = this;
 …
             newNode.parent = this;
             var index;
             for (var id in this.indexes) {
               index = this.indexes[id];
               if (oldIndex <= index) {
                 this.indexes[id] = index + 1;
+              }
+            }
             return this;
           };
           _proto.insertBefore = function insertBefore(oldNode, newNode) {
             newNode.parent = this;
 …
             newNode.parent = this;
             var index;
             for (var id in this.indexes) {
               index = this.indexes[id];
               if (index <= oldIndex) {
                 this.indexes[id] = index + 1;
+              }
+            }
             return this;
           };
           _proto._findChildAtPosition = function _findChildAtPosition(line, col) {
             var found = undefined;
 …
               if (node.atPosition) {
                 var foundChild = node.atPosition(line, col);
                 if (foundChild) {
                   found = foundChild;
 …
             return found;
+          }
           /**
            * Return the most specific node at the line and column number given.
 …
            * @param {number} line The line number of the node to find. (1-based index)
            * @param {number} col  The column number of the node to find. (1-based index)
+           */
+          ;
+           */;
           _proto.atPosition = function atPosition(line, col) {
             if (this.isAtPosition(line, col)) {
 …
+            }
           };
           _proto._inferEndPosition = function _inferEndPosition() {
             if (this.last && this.last.source && this.last.source.end) {
 …
+            }
           };
           _proto.each = function each(callback) {
             if (!this.lastEach) {
               this.lastEach = 0;
+            }
             if (!this.indexes) {
               this.indexes = {};
+            }
             this.lastEach++;
             var id = this.lastEach;
             this.indexes[id] = 0;
             if (!this.length) {
               return undefined;
+            }
             var index, result;
             while (this.indexes[id] < this.length) {
               index = this.indexes[id];
               result = callback(this.at(index), index);
               if (result === false) {
                 break;
+              }
               this.indexes[id] += 1;
+            }
             delete this.indexes[id];
             if (result === false) {
               return false;
+            }
           };
           _proto.walk = function walk(callback) {
             return this.each(function (node, i) {
               var result = callback(node, i);
               if (result !== false && node.length) {
                 result = node.walk(callback);
+              }
               if (result === false) {
                 return false;
 …
             });
           };
           _proto.walkAttributes = function walkAttributes(callback) {
             var _this2 = this;
             return this.walk(function (selector) {
               if (selector.type === types$1.ATTRIBUTE) {
 …
             });
           };
           _proto.walkClasses = function walkClasses(callback) {
             var _this3 = this;
             return this.walk(function (selector) {
               if (selector.type === types$1.CLASS) {
 …
             });
           };
           _proto.walkCombinators = function walkCombinators(callback) {
             var _this4 = this;
             return this.walk(function (selector) {
               if (selector.type === types$1.COMBINATOR) {
 …
             });
           };
           _proto.walkComments = function walkComments(callback) {
             var _this5 = this;
             return this.walk(function (selector) {
               if (selector.type === types$1.COMMENT) {
 …
             });
           };
           _proto.walkIds = function walkIds(callback) {
             var _this6 = this;
             return this.walk(function (selector) {
               if (selector.type === types$1.ID) {
 …
             });
           };
           _proto.walkNesting = function walkNesting(callback) {
             var _this7 = this;
             return this.walk(function (selector) {
               if (selector.type === types$1.NESTING) {
 …
             });
           };
           _proto.walkPseudos = function walkPseudos(callback) {
             var _this8 = this;
             return this.walk(function (selector) {
               if (selector.type === types$1.PSEUDO) {
 …
             });
           };
           _proto.walkTags = function walkTags(callback) {
             var _this9 = this;
             return this.walk(function (selector) {
               if (selector.type === types$1.TAG) {
 …
             });
           };
           _proto.walkUniversals = function walkUniversals(callback) {
             var _this10 = this;
             return this.walk(function (selector) {
               if (selector.type === types$1.UNIVERSAL) {
 …
             });
           };
           _proto.split = function split(callback) {
             var _this11 = this;
             var current = [];
             return this.reduce(function (memo, node, index) {
               var split = callback.call(_this11, node);
               current.push(node);
               if (split) {
                 memo.push(current);
 …
                 memo.push(current);
+              }
               return memo;
             }, []);
           };
           _proto.map = function map(callback) {
             return this.nodes.map(callback);
           };
           _proto.reduce = function reduce(callback, memo) {
             return this.nodes.reduce(callback, memo);
           };
           _proto.every = function every(callback) {
             return this.nodes.every(callback);
           };
           _proto.some = function some(callback) {
             return this.nodes.some(callback);
           };
           _proto.filter = function filter(callback) {
             return this.nodes.filter(callback);
           };
           _proto.sort = function sort(callback) {
             return this.nodes.sort(callback);
           };
           _proto.toString = function toString() {
             return this.map(String).join('');
           };
           _createClass(Container, [{
             key: "first",
 …
+            }
           }]);
           return Container;
         }(_node["default"]);
         exports["default"] = Container;
         module.exports = exports.default;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _container = _interopRequireDefault(containerExports);
         var _types = types;
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         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); } }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var Root = /*#__PURE__*/function (_Container) {
           _inheritsLoose(Root, _Container);
           function Root(opts) {
             var _this;
             _this = _Container.call(this, opts) || this;
             _this.type = _types.ROOT;
             return _this;
+          }
           var _proto = Root.prototype;
           _proto.toString = function toString() {
             var str = this.reduce(function (memo, selector) {
 …
             return this.trailingComma ? str + ',' : str;
           };
           _proto.error = function error(message, options) {
             if (this._error) {
 …
+            }
           };
           _createClass(Root, [{
             key: "errorGenerator",
 …
+            }
           }]);
           return Root;
         }(_container["default"]);
         exports["default"] = Root;
         module.exports = exports.default;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _container = _interopRequireDefault(containerExports);
         var _types = types;
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var Selector = /*#__PURE__*/function (_Container) {
           _inheritsLoose(Selector, _Container);
           function Selector(opts) {
             var _this;
             _this = _Container.call(this, opts) || this;
             _this.type = _types.SELECTOR;
             return _this;
+          }
           return Selector;
         }(_container["default"]);
         exports["default"] = Selector;
         module.exports = exports.default;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _cssesc = _interopRequireDefault(cssesc_1);
         var _util = util;
         var _node = _interopRequireDefault(nodeExports);
         var _types = types;
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         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); } }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var ClassName = /*#__PURE__*/function (_Node) {
           _inheritsLoose(ClassName, _Node);
           function ClassName(opts) {
             var _this;
             _this = _Node.call(this, opts) || this;
             _this.type = _types.CLASS;
 …
             return _this;
+          }
           var _proto = ClassName.prototype;
           _proto.valueToString = function valueToString() {
             return '.' + _Node.prototype.valueToString.call(this);
           };
           _createClass(ClassName, [{
             key: "value",
 …
                   isIdentifier: true
                 });
                 if (escaped !== v) {
                   (0, _util.ensureObject)(this, "raws");
 …
+                }
+              }
               this._value = v;
+            }
           }]);
           return ClassName;
         }(_node["default"]);
         exports["default"] = ClassName;
         module.exports = exports.default;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _node = _interopRequireDefault(nodeExports);
         var _types = types;
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var Comment = /*#__PURE__*/function (_Node) {
           _inheritsLoose(Comment, _Node);
           function Comment(opts) {
             var _this;
             _this = _Node.call(this, opts) || this;
             _this.type = _types.COMMENT;
             return _this;
+          }
           return Comment;
         }(_node["default"]);
         exports["default"] = Comment;
         module.exports = exports.default;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _node = _interopRequireDefault(nodeExports);
         var _types = types;
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var ID = /*#__PURE__*/function (_Node) {
           _inheritsLoose(ID, _Node);
           function ID(opts) {
             var _this;
             _this = _Node.call(this, opts) || this;
             _this.type = _types.ID;
             return _this;
+          }
           var _proto = ID.prototype;
           _proto.valueToString = function valueToString() {
             return '#' + _Node.prototype.valueToString.call(this);
           };
           return ID;
         }(_node["default"]);
         exports["default"] = ID;
         module.exports = exports.default;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _cssesc = _interopRequireDefault(cssesc_1);
         var _util = util;
         var _node = _interopRequireDefault(nodeExports);
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         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); } }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var Namespace = /*#__PURE__*/function (_Node) {
           _inheritsLoose(Namespace, _Node);
           function Namespace() {
             return _Node.apply(this, arguments) || this;
+          }
           var _proto = Namespace.prototype;
           _proto.qualifiedName = function qualifiedName(value) {
             if (this.namespace) {
 …
+            }
           };
           _proto.valueToString = function valueToString() {
             return this.qualifiedName(_Node.prototype.valueToString.call(this));
           };
           _createClass(Namespace, [{
             key: "namespace",
 …
               if (namespace === true || namespace === "*" || namespace === "&") {
                 this._namespace = namespace;
                 if (this.raws) {
                   delete this.raws.namespace;
+                }
                 return;
+              }
               var escaped = (0, _cssesc["default"])(namespace, {
                 isIdentifier: true
               });
               this._namespace = namespace;
               if (escaped !== namespace) {
                 (0, _util.ensureObject)(this, "raws");
 …
               if (this.namespace) {
                 var ns = this.stringifyProperty("namespace");
                 if (ns === true) {
                   return '';
 …
+            }
           }]);
           return Namespace;
         }(_node["default"]);
         exports["default"] = Namespace;
         module.exports = exports.default;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _namespace = _interopRequireDefault(namespaceExports);
         var _types = types;
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var Tag = /*#__PURE__*/function (_Namespace) {
           _inheritsLoose(Tag, _Namespace);
           function Tag(opts) {
             var _this;
             _this = _Namespace.call(this, opts) || this;
             _this.type = _types.TAG;
             return _this;
+          }
           return Tag;
         }(_namespace["default"]);
         exports["default"] = Tag;
         module.exports = exports.default;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _node = _interopRequireDefault(nodeExports);
         var _types = types;
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var String = /*#__PURE__*/function (_Node) {
           _inheritsLoose(String, _Node);
           function String(opts) {
             var _this;
             _this = _Node.call(this, opts) || this;
             _this.type = _types.STRING;
             return _this;
+          }
           return String;
         }(_node["default"]);
         exports["default"] = String;
         module.exports = exports.default;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _container = _interopRequireDefault(containerExports);
         var _types = types;
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var Pseudo = /*#__PURE__*/function (_Container) {
           _inheritsLoose(Pseudo, _Container);
           function Pseudo(opts) {
             var _this;
             _this = _Container.call(this, opts) || this;
             _this.type = _types.PSEUDO;
             return _this;
+          }
           var _proto = Pseudo.prototype;
           _proto.toString = function toString() {
             var params = this.length ? '(' + this.map(String).join(',') + ')' : '';
             return [this.rawSpaceBefore, this.stringifyProperty("value"), params, this.rawSpaceAfter].join('');
           };
           return Pseudo;
         }(_container["default"]);
         exports["default"] = Pseudo;
         module.exports = exports.default;
 …
         exports.__esModule = true;
+        exports["default"] = void 0;
         exports.unescapeValue = unescapeValue;
-        exports["default"] = void 0;
         var _cssesc = _interopRequireDefault(cssesc_1);
         var _unesc = _interopRequireDefault(unescExports);
         var _namespace = _interopRequireDefault(namespaceExports);
         var _types = types;
         var _CSSESC_QUOTE_OPTIONS;
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         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); } }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var deprecate = node;
         var WRAPPED_IN_QUOTES = /^('|")([^]*)\1$/;
         var warnOfDeprecatedValueAssignment = deprecate(function () {}, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. " + "Call attribute.setValue() instead.");
         var warnOfDeprecatedQuotedAssignment = deprecate(function () {}, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.");
         var warnOfDeprecatedConstructor = deprecate(function () {}, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
         function unescapeValue(value) {
           var deprecatedUsage = false;
 …
           var unescaped = value;
           var m = unescaped.match(WRAPPED_IN_QUOTES);
           if (m) {
             quoteMark = m[1];
             unescaped = m[2];
+          }
           unescaped = (0, _unesc["default"])(unescaped);
           if (unescaped !== value) {
             deprecatedUsage = true;
+          }
           return {
             deprecatedUsage: deprecatedUsage,
 …
           };
+        }
         function handleDeprecatedContructorOpts(opts) {
           if (opts.quoteMark !== undefined) {
             return opts;
+          }
           if (opts.value === undefined) {
             return opts;
+          }
           warnOfDeprecatedConstructor();
           var _unescapeValue = unescapeValue(opts.value),
+              quoteMark = _unescapeValue.quoteMark,
+              unescaped = _unescapeValue.unescaped;
+            quoteMark = _unescapeValue.quoteMark,
+            unescaped = _unescapeValue.unescaped;
           if (!opts.raws) {
             opts.raws = {};
+          }
           if (opts.raws.value === undefined) {
             opts.raws.value = opts.value;
+          }
           opts.value = unescaped;
           opts.quoteMark = quoteMark;
           return opts;
+        }
         var Attribute = /*#__PURE__*/function (_Namespace) {
           _inheritsLoose(Attribute, _Namespace);
           function Attribute(opts) {
             var _this;
             if (opts === void 0) {
               opts = {};
+            }
             _this = _Namespace.call(this, handleDeprecatedContructorOpts(opts)) || this;
             _this.type = _types.ATTRIBUTE;
 …
             return _this;
+          }
           /**
            * Returns the Attribute's value quoted such that it would be legal to use
 …
            *     method.
            **/
           var _proto = Attribute.prototype;
           _proto.getQuotedValue = function getQuotedValue(options) {
             if (options === void 0) {
               options = {};
+            }
             var quoteMark = this._determineQuoteMark(options);
             var cssescopts = CSSESC_QUOTE_OPTIONS[quoteMark];
             var escaped = (0, _cssesc["default"])(this._value, cssescopts);
             return escaped;
           };
           _proto._determineQuoteMark = function _determineQuoteMark(options) {
             return options.smart ? this.smartQuoteMark(options) : this.preferredQuoteMark(options);
+          }
           /**
            * Set the unescaped value with the specified quotation options. The value
            * provided must not include any wrapping quote marks -- those quotes will
            * be interpreted as part of the value and escaped accordingly.
+           */
+          ;
+           */;
           _proto.setValue = function setValue(value, options) {
             if (options === void 0) {
               options = {};
+            }
             this._value = value;
             this._quoteMark = this._determineQuoteMark(options);
             this._syncRawValue();
+          }
           /**
            * Intelligently select a quoteMark value based on the value's contents. If
 …
            * @param options This takes the quoteMark and preferCurrentQuoteMark options
            * from the quoteValue method.
+           */
+          ;
+           */;
           _proto.smartQuoteMark = function smartQuoteMark(options) {
             var v = this.value;
             var numSingleQuotes = v.replace(/[^']/g, '').length;
             var numDoubleQuotes = v.replace(/[^"]/g, '').length;
             if (numSingleQuotes + numDoubleQuotes === 0) {
               var escaped = (0, _cssesc["default"])(v, {
                 isIdentifier: true
               });
               if (escaped === v) {
                 return Attribute.NO_QUOTE;
               } else {
                 var pref = this.preferredQuoteMark(options);
                 if (pref === Attribute.NO_QUOTE) {
                   // pick a quote mark that isn't none and see if it's smaller
 …
                   var opts = CSSESC_QUOTE_OPTIONS[quote];
                   var quoteValue = (0, _cssesc["default"])(v, opts);
                   if (quoteValue.length < escaped.length) {
                     return quote;
+                  }
+                }
                 return pref;
+              }
 …
+            }
+          }
           /**
            * Selects the preferred quote mark based on the options and the current quote mark value.
            * If you want the quote mark to depend on the attribute value, call `smartQuoteMark(opts)`
            * instead.
+           */
+          ;
+           */;
           _proto.preferredQuoteMark = function preferredQuoteMark(options) {
             var quoteMark = options.preferCurrentQuoteMark ? this.quoteMark : options.quoteMark;
             if (quoteMark === undefined) {
               quoteMark = options.preferCurrentQuoteMark ? options.quoteMark : this.quoteMark;
+            }
             if (quoteMark === undefined) {
               quoteMark = Attribute.DOUBLE_QUOTE;
+            }
             return quoteMark;
           };
           _proto._syncRawValue = function _syncRawValue() {
             var rawValue = (0, _cssesc["default"])(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
             if (rawValue === this._value) {
               if (this.raws) {
 …
+            }
           };
           _proto._handleEscapes = function _handleEscapes(prop, value) {
             if (this._constructed) {
 …
                 isIdentifier: true
               });
               if (escaped !== value) {
                 this.raws[prop] = escaped;
 …
+            }
           };
           _proto._spacesFor = function _spacesFor(name) {
             var attrSpaces = {
 …
             return Object.assign(attrSpaces, spaces, rawSpaces);
           };
           _proto._stringFor = function _stringFor(name, spaceName, concat) {
             if (spaceName === void 0) {
               spaceName = name;
+            }
             if (concat === void 0) {
               concat = defaultAttrConcat;
+            }
             var attrSpaces = this._spacesFor(spaceName);
             return concat(this.stringifyProperty(name), attrSpaces);
+          }
           /**
            * returns the offset of the attribute part specified relative to the
 …
            * @param part One of the possible values inside an attribute.
            * @returns -1 if the name is invalid or the value doesn't exist in this attribute.
+           */
+          ;
+           */;
           _proto.offsetOf = function offsetOf(name) {
             var count = 1;
             var attributeSpaces = this._spacesFor("attribute");
             count += attributeSpaces.before.length;
             if (name === "namespace" || name === "ns") {
               return this.namespace ? count : -1;
+            }
             if (name === "attributeNS") {
               return count;
+            }
             count += this.namespaceString.length;
             if (this.namespace) {
               count += 1;
+            }
             if (name === "attribute") {
               return count;
+            }
             count += this.stringifyProperty("attribute").length;
             count += attributeSpaces.after.length;
             var operatorSpaces = this._spacesFor("operator");
             count += operatorSpaces.before.length;
             var operator = this.stringifyProperty("operator");
             if (name === "operator") {
               return operator ? count : -1;
+            }
             count += operator.length;
             count += operatorSpaces.after.length;
             var valueSpaces = this._spacesFor("value");
             count += valueSpaces.before.length;
             var value = this.stringifyProperty("value");
             if (name === "value") {
               return value ? count : -1;
+            }
             count += value.length;
             count += valueSpaces.after.length;
             var insensitiveSpaces = this._spacesFor("insensitive");
             count += insensitiveSpaces.before.length;
             if (name === "insensitive") {
               return this.insensitive ? count : -1;
+            }
             return -1;
           };
           _proto.toString = function toString() {
             var _this2 = this;
             var selector = [this.rawSpaceBefore, '['];
             selector.push(this._stringFor('qualifiedAttribute', 'attribute'));
             if (this.operator && (this.value || this.value === '')) {
               selector.push(this._stringFor('operator'));
 …
                   attrSpaces.before = " ";
+                }
                 return defaultAttrConcat(attrValue, attrSpaces);
               }));
+            }
             selector.push(']');
             selector.push(this.rawSpaceAfter);
             return selector.join('');
           };
           _createClass(Attribute, [{
             key: "quoted",
 …
               warnOfDeprecatedQuotedAssignment();
+            }
             /**
              * returns a single (`'`) or double (`"`) quote character if the value is quoted.
 …
              * the attribute is constructed without specifying a quote mark.)
              */
           }, {
             key: "quoteMark",
 …
               return this._quoteMark;
+            }
             /**
              * Set the quote mark to be used by this attribute's value.
 …
+             *
              * @param {"'" | '"' | null} quoteMark The quote mark or `null` if the value should be unquoted.
+             */
+            ,
+             */,
             set: function set(quoteMark) {
               if (!this._constructed) {
 …
                 return;
+              }
               if (this._quoteMark !== quoteMark) {
                 this._quoteMark = quoteMark;
                 this._syncRawValue();
+              }
 …
               if (this._constructed) {
                 var _unescapeValue2 = unescapeValue(v),
+                    deprecatedUsage = _unescapeValue2.deprecatedUsage,
+                    unescaped = _unescapeValue2.unescaped,
+                    quoteMark = _unescapeValue2.quoteMark;
+                  deprecatedUsage = _unescapeValue2.deprecatedUsage,
+                  unescaped = _unescapeValue2.unescaped,
+                  quoteMark = _unescapeValue2.quoteMark;
                 if (deprecatedUsage) {
                   warnOfDeprecatedValueAssignment();
+                }
                 if (unescaped === this._value && quoteMark === this._quoteMark) {
                   return;
+                }
                 this._value = unescaped;
                 this._quoteMark = quoteMark;
                 this._syncRawValue();
               } else {
 …
               return this._insensitive;
+            }
             /**
              * Set the case insensitive flag.
 …
+             *
              * @param {true | false} insensitive true if the attribute should match case-insensitively.
+             */
+            ,
+             */,
             set: function set(insensitive) {
               if (!insensitive) {
+                this._insensitive = false; // "i" and "I" can be used in "this.raws.insensitiveFlag" to store the original notation.
+                this._insensitive = false;
+                // "i" and "I" can be used in "this.raws.insensitiveFlag" to store the original notation.
                 // When setting `attr.insensitive = false` both should be erased to ensure correct serialization.
                 if (this.raws && (this.raws.insensitiveFlag === 'I' || this.raws.insensitiveFlag === 'i')) {
                   this.raws.insensitiveFlag = undefined;
+                }
+              }
               this._insensitive = insensitive;
+            }
 …
             set: function set(name) {
               this._handleEscapes("attribute", name);
               this._attribute = name;
+            }
           }]);
           return Attribute;
         }(_namespace["default"]);
         exports["default"] = Attribute;
         Attribute.NO_QUOTE = null;
 …
           isIdentifier: true
         }, _CSSESC_QUOTE_OPTIONS);
         function defaultAttrConcat(attrValue, attrSpaces) {
           return "" + attrSpaces.before + attrValue + attrSpaces.after;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _namespace = _interopRequireDefault(namespaceExports);
         var _types = types;
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var Universal = /*#__PURE__*/function (_Namespace) {
           _inheritsLoose(Universal, _Namespace);
           function Universal(opts) {
             var _this;
             _this = _Namespace.call(this, opts) || this;
             _this.type = _types.UNIVERSAL;
 …
             return _this;
+          }
           return Universal;
         }(_namespace["default"]);
         exports["default"] = Universal;
         module.exports = exports.default;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _node = _interopRequireDefault(nodeExports);
         var _types = types;
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var Combinator = /*#__PURE__*/function (_Node) {
           _inheritsLoose(Combinator, _Node);
           function Combinator(opts) {
             var _this;
             _this = _Node.call(this, opts) || this;
             _this.type = _types.COMBINATOR;
             return _this;
+          }
           return Combinator;
         }(_node["default"]);
         exports["default"] = Combinator;
         module.exports = exports.default;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _node = _interopRequireDefault(nodeExports);
         var _types = types;
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+        function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
         var Nesting = /*#__PURE__*/function (_Node) {
           _inheritsLoose(Nesting, _Node);
           function Nesting(opts) {
             var _this;
             _this = _Node.call(this, opts) || this;
             _this.type = _types.NESTING;
 …
             return _this;
+          }
           return Nesting;
         }(_node["default"]);
         exports["default"] = Nesting;
         module.exports = exports.default;
 …
         exports.__esModule = true;
         exports["default"] = sortAscending;
         function sortAscending(list) {
           return list.sort(function (a, b) {
 …
 tokenTypes.__esModule = true;
 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;
+tokenTypes.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;
 var ampersand = 38; // `&`.charCodeAt(0);
 tokenTypes.ampersand = ampersand;
 var asterisk = 42; // `*`.charCodeAt(0);
 tokenTypes.asterisk = asterisk;
 var at = 64; // `@`.charCodeAt(0);
 tokenTypes.at = at;
 var comma = 44; // `,`.charCodeAt(0);
 tokenTypes.comma = comma;
 var colon = 58; // `:`.charCodeAt(0);
 tokenTypes.colon = colon;
 var semicolon = 59; // `;`.charCodeAt(0);
 tokenTypes.semicolon = semicolon;
 var openParenthesis = 40; // `(`.charCodeAt(0);
 tokenTypes.openParenthesis = openParenthesis;
 var closeParenthesis = 41; // `)`.charCodeAt(0);
 tokenTypes.closeParenthesis = closeParenthesis;
 var openSquare = 91; // `[`.charCodeAt(0);
 tokenTypes.openSquare = openSquare;
 var closeSquare = 93; // `]`.charCodeAt(0);
 tokenTypes.closeSquare = closeSquare;
 var dollar = 36; // `$`.charCodeAt(0);
 tokenTypes.dollar = dollar;
 var tilde = 126; // `~`.charCodeAt(0);
 tokenTypes.tilde = tilde;
 var caret = 94; // `^`.charCodeAt(0);
 tokenTypes.caret = caret;
 var plus = 43; // `+`.charCodeAt(0);
 tokenTypes.plus = plus;
 var equals = 61; // `=`.charCodeAt(0);
 tokenTypes.equals = equals;
 var pipe = 124; // `|`.charCodeAt(0);
 tokenTypes.pipe = pipe;
 var greaterThan = 62; // `>`.charCodeAt(0);
 tokenTypes.greaterThan = greaterThan;
 var space = 32; // ` `.charCodeAt(0);
 tokenTypes.space = space;
 var singleQuote = 39; // `'`.charCodeAt(0);
 tokenTypes.singleQuote = singleQuote;
 var doubleQuote = 34; // `"`.charCodeAt(0);
 tokenTypes.doubleQuote = doubleQuote;
 var slash = 47; // `/`.charCodeAt(0);
 tokenTypes.slash = slash;
 var bang = 33; // `!`.charCodeAt(0);
 tokenTypes.bang = bang;
 var backslash = 92; // '\\'.charCodeAt(0);
 tokenTypes.backslash = backslash;
 var cr = 13; // '\r'.charCodeAt(0);
 tokenTypes.cr = cr;
 var feed = 12; // '\f'.charCodeAt(0);
 tokenTypes.feed = feed;
 var newline = 10; // '\n'.charCodeAt(0);
 tokenTypes.newline = newline;
 var tab = 9; // '\t'.charCodeAt(0);
 // Expose aliases primarily for readability.
 tokenTypes.tab = tab;
+var str = singleQuote; // No good single character representation!
+var str = singleQuote;
+// No good single character representation!
 tokenTypes.str = str;
 var comment$1 = -1;
 …
         exports.__esModule = true;
+        exports.FIELDS = void 0;
         exports["default"] = tokenize;
-        exports.FIELDS = void 0;
         var t = _interopRequireWildcard(tokenTypes);
         var _unescapable, _wordDelimiters;
+        function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+        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; }
+        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); }
+        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; }
         var unescapable = (_unescapable = {}, _unescapable[t.tab] = true, _unescapable[t.newline] = true, _unescapable[t.cr] = true, _unescapable[t.feed] = true, _unescapable);
         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);
         var hex = {};
         var hexChars = "0123456789abcdefABCDEF";
         for (var i = 0; i < hexChars.length; i++) {
           hex[hexChars.charCodeAt(i)] = true;
+        }
         /**
          *  Returns the last index of the bar css word
 …
          * @param {number} start The index into the string where word's first letter occurs
          */
         function consumeWord(css, start) {
           var next = start;
           var code;
           do {
             code = css.charCodeAt(next);
             if (wordDelimiters[code]) {
               return next - 1;
 …
+            }
           } while (next < css.length);
           return next - 1;
+        }
         /**
          *  Returns the last index of the escape sequence
 …
          * @param {number} start The index into the string where escape character (`\`) occurs.
          */
         function consumeEscape(css, start) {
           var next = start;
           var code = css.charCodeAt(next + 1);
           if (unescapable[code]) ; else if (hex[code]) {
             var hexDigits = 0; // consume up to 6 hex chars
+            var hexDigits = 0;
+            // consume up to 6 hex chars
             do {
               next++;
               hexDigits++;
               code = css.charCodeAt(next + 1);
+            } while (hex[code] && hexDigits < 6); // if fewer than 6 hex chars, a trailing space ends the escape
+            } while (hex[code] && hexDigits < 6);
+            // if fewer than 6 hex chars, a trailing space ends the escape
             if (hexDigits < 6 && code === t.space) {
               next++;
 …
             next++;
+          }
           return next;
+        }
         var FIELDS = {
           TYPE: 0,
 …
         };
         exports.FIELDS = FIELDS;
         function tokenize(input) {
           var tokens = [];
           var css = input.css.valueOf();
           var _css = css,
               length = _css.length;
+            length = _css.length;
           var offset = -1;
           var line = 1;
 …
           var end = 0;
           var code, content, endColumn, endLine, escaped, escapePos, last, lines, next, nextLine, nextOffset, quote, tokenType;
           function unclosed(what, fix) {
             if (input.safe) {
 …
+            }
+          }
           while (start < length) {
             code = css.charCodeAt(start);
             if (code === t.newline) {
               offset = start;
               line += 1;
+            }
             switch (code) {
               case t.space:
 …
               case t.feed:
                 next = start;
                 do {
                   next += 1;
                   code = css.charCodeAt(next);
                   if (code === t.newline) {
                     offset = next;
 …
+                  }
                 } while (code === t.space || code === t.newline || code === t.tab || code === t.cr || code === t.feed);
                 tokenType = t.space;
                 endLine = line;
 …
                 end = next;
                 break;
               case t.plus:
               case t.greaterThan:
 …
               case t.pipe:
                 next = start;
                 do {
                   next += 1;
                   code = css.charCodeAt(next);
                 } while (code === t.plus || code === t.greaterThan || code === t.tilde || code === t.pipe);
                 tokenType = t.combinator;
                 endLine = line;
 …
                 end = next;
                 break;
               // Consume these characters as single tokens.
               case t.asterisk:
               case t.ampersand:
 …
                 end = next + 1;
                 break;
               case t.singleQuote:
               case t.doubleQuote:
                 quote = code === t.singleQuote ? "'" : '"';
                 next = start;
                 do {
                   escaped = false;
                   next = css.indexOf(quote, next + 1);
                   if (next === -1) {
                     unclosed('quote', quote);
+                  }
                   escapePos = next;
                   while (css.charCodeAt(escapePos - 1) === t.backslash) {
                     escapePos -= 1;
 …
+                  }
                 } while (escaped);
                 tokenType = t.str;
                 endLine = line;
 …
                 end = next + 1;
                 break;
               default:
                 if (code === t.slash && css.charCodeAt(start + 1) === t.asterisk) {
                   next = css.indexOf('*/', start + 2) + 1;
                   if (next === 0) {
                     unclosed('comment', '*/');
+                  }
                   content = css.slice(start, next + 1);
                   lines = content.split('\n');
                   last = lines.length - 1;
                   if (last > 0) {
                     nextLine = line + last;
 …
                     nextOffset = offset;
+                  }
                   tokenType = t.comment;
                   line = nextLine;
 …
                   endColumn = next - offset;
+                }
                 end = next + 1;
                 break;
+            } // Ensure that the token structure remains consistent
+            tokens.push([tokenType, // [0] Token type
+            line, // [1] Starting line
+            start - offset, // [2] Starting column
+            endLine, // [3] Ending line
+            endColumn, // [4] Ending column
+            start, // [5] Start position / Source index
+            }
+            // Ensure that the token structure remains consistent
+            tokens.push([tokenType,
+            // [0] Token type
+            line,
+            // [1] Starting line
+            start - offset,
+            // [2] Starting column
+            endLine,
+            // [3] Ending line
+            endColumn,
+            // [4] Ending column
+            start,
+            // [5] Start position / Source index
             end // [6] End position
+            ]); // Reset offset for the next token
+            ]);
+            // Reset offset for the next token
             if (nextOffset) {
               offset = nextOffset;
               nextOffset = null;
+            }
             start = end;
+          }
           return tokens;
+        }
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _root = _interopRequireDefault(rootExports);
         var _selector = _interopRequireDefault(selectorExports);
         var _className = _interopRequireDefault(classNameExports);
         var _comment = _interopRequireDefault(commentExports);
         var _id = _interopRequireDefault(idExports);
         var _tag = _interopRequireDefault(tagExports);
         var _string = _interopRequireDefault(stringExports);
         var _pseudo = _interopRequireDefault(pseudoExports);
         var _attribute = _interopRequireWildcard(attribute$1);
         var _universal = _interopRequireDefault(universalExports);
         var _combinator = _interopRequireDefault(combinatorExports);
         var _nesting = _interopRequireDefault(nestingExports);
         var _sortAscending = _interopRequireDefault(sortAscendingExports);
         var _tokenize = _interopRequireWildcard(tokenize);
         var tokens = _interopRequireWildcard(tokenTypes);
         var types$1 = _interopRequireWildcard(types);
         var _util = util;
         var _WHITESPACE_TOKENS, _Object$assign;
+        function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+        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; }
+        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); }
+        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; }
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         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); } }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
+        function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
         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);
         var WHITESPACE_EQUIV_TOKENS = Object.assign({}, WHITESPACE_TOKENS, (_Object$assign = {}, _Object$assign[tokens.comment] = true, _Object$assign));
         function tokenStart(token) {
           return {
 …
           };
+        }
         function tokenEnd(token) {
           return {
 …
           };
+        }
         function getSource(startLine, startColumn, endLine, endColumn) {
           return {
 …
           };
+        }
         function getTokenSource(token) {
           return getSource(token[_tokenize.FIELDS.START_LINE], token[_tokenize.FIELDS.START_COL], token[_tokenize.FIELDS.END_LINE], token[_tokenize.FIELDS.END_COL]);
+        }
         function getTokenSourceSpan(startToken, endToken) {
           if (!startToken) {
             return undefined;
+          }
           return getSource(startToken[_tokenize.FIELDS.START_LINE], startToken[_tokenize.FIELDS.START_COL], endToken[_tokenize.FIELDS.END_LINE], endToken[_tokenize.FIELDS.END_COL]);
+        }
         function unescapeProp(node, prop) {
           var value = node[prop];
           if (typeof value !== "string") {
             return;
+          }
           if (value.indexOf("\\") !== -1) {
             (0, _util.ensureObject)(node, 'raws');
             node[prop] = (0, _util.unesc)(value);
             if (node.raws[prop] === undefined) {
               node.raws[prop] = value;
+            }
+          }
           return node;
+        }
         function indexesOf(array, item) {
           var i = -1;
           var indexes = [];
           while ((i = array.indexOf(item, i + 1)) !== -1) {
             indexes.push(i);
+          }
           return indexes;
+        }
         function uniqs() {
           var list = Array.prototype.concat.apply([], arguments);
 …
           });
+        }
         var Parser = /*#__PURE__*/function () {
           function Parser(rule, options) {
 …
               options = {};
+            }
             this.rule = rule;
             this.options = Object.assign({
 …
                   column: 1
+                }
+              }
+              },
+              sourceIndex: 0
             });
             this.root.append(selector);
 …
             this.loop();
+          }
           var _proto = Parser.prototype;
           _proto._errorGenerator = function _errorGenerator() {
             var _this = this;
             return function (message, errorOptions) {
               if (typeof _this.rule === 'string') {
                 return new Error(message);
+              }
               return _this.rule.error(message, errorOptions);
             };
           };
           _proto.attribute = function attribute() {
             var attr = [];
             var startingToken = this.currToken;
             this.position++;
             while (this.position < this.tokens.length && this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
               attr.push(this.currToken);
               this.position++;
+            }
             if (this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
               return this.expected('closing square bracket', this.currToken[_tokenize.FIELDS.START_POS]);
+            }
             var len = attr.length;
             var node = {
 …
               sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
             };
             if (len === 1 && !~[tokens.word].indexOf(attr[0][_tokenize.FIELDS.TYPE])) {
               return this.expected('attribute', attr[0][_tokenize.FIELDS.START_POS]);
+            }
             var pos = 0;
             var spaceBefore = '';
 …
             var lastAdded = null;
             var spaceAfterMeaningfulToken = false;
             while (pos < len) {
               var token = attr[pos];
               var content = this.content(token);
               var next = attr[pos + 1];
               switch (token[_tokenize.FIELDS.TYPE]) {
                 case tokens.space:
 …
                   // }
                   spaceAfterMeaningfulToken = true;
                   if (this.options.lossy) {
                     break;
+                  }
                   if (lastAdded) {
                     (0, _util.ensureObject)(node, 'spaces', lastAdded);
 …
                     node.spaces[lastAdded].after = prevContent + content;
                     var existingComment = (0, _util.getProp)(node, 'raws', 'spaces', lastAdded, 'after') || null;
                     if (existingComment) {
                       node.raws.spaces[lastAdded].after = existingComment + content;
 …
                     commentBefore = commentBefore + content;
+                  }
                   break;
                 case tokens.asterisk:
                   if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
 …
                       spaceBefore = '';
+                    }
                     if (commentBefore) {
                       (0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute');
 …
                       commentBefore = '';
+                    }
                     node.namespace = (node.namespace || "") + content;
                     var rawValue = (0, _util.getProp)(node, 'raws', 'namespace') || null;
                     if (rawValue) {
                       node.raws.namespace += content;
+                    }
                     lastAdded = 'namespace';
+                  }
                   spaceAfterMeaningfulToken = false;
                   break;
                 case tokens.dollar:
                   if (lastAdded === "value") {
                     var oldRawValue = (0, _util.getProp)(node, 'raws', 'value');
                     node.value += "$";
                     if (oldRawValue) {
                       node.raws.value = oldRawValue + "$";
+                    }
                     break;
+                  }
                 // Falls through
                 case tokens.caret:
                   if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
 …
                     lastAdded = 'operator';
+                  }
                   spaceAfterMeaningfulToken = false;
                   break;
                 case tokens.combinator:
                   if (content === '~' && next[_tokenize.FIELDS.TYPE] === tokens.equals) {
 …
                     lastAdded = 'operator';
+                  }
                   if (content !== '|') {
                     spaceAfterMeaningfulToken = false;
                     break;
+                  }
                   if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
                     node.operator = content;
 …
                     node.namespace = true;
+                  }
                   spaceAfterMeaningfulToken = false;
                   break;
                 case tokens.word:
+                  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.
+                  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.
                   !node.operator && !node.namespace) {
                     node.namespace = content;
 …
                       spaceBefore = '';
+                    }
                     if (commentBefore) {
                       (0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute');
 …
                       commentBefore = '';
+                    }
                     node.attribute = (node.attribute || "") + content;
                     var _rawValue = (0, _util.getProp)(node, 'raws', 'attribute') || null;
                     if (_rawValue) {
                       node.raws.attribute += content;
+                    }
                     lastAdded = 'attribute';
                   } else if (!node.value && node.value !== "" || lastAdded === "value" && !(spaceAfterMeaningfulToken || node.quoteMark)) {
                     var _unescaped = (0, _util.unesc)(content);
                     var _oldRawValue = (0, _util.getProp)(node, 'raws', 'value') || '';
                     var oldValue = node.value || '';
                     node.value = oldValue + _unescaped;
                     node.quoteMark = null;
                     if (_unescaped !== content || _oldRawValue) {
                       (0, _util.ensureObject)(node, 'raws');
                       node.raws.value = (_oldRawValue || oldValue) + content;
+                    }
                     lastAdded = 'value';
                   } else {
                     var insensitive = content === 'i' || content === "I";
                     if ((node.value || node.value === '') && (node.quoteMark || spaceAfterMeaningfulToken)) {
                       node.insensitive = insensitive;
                       if (!insensitive || content === "I") {
                         (0, _util.ensureObject)(node, 'raws');
                         node.raws.insensitiveFlag = content;
+                      }
                       lastAdded = 'insensitive';
                       if (spaceBefore) {
                         (0, _util.ensureObject)(node, 'spaces', 'insensitive');
 …
                         spaceBefore = '';
+                      }
                       if (commentBefore) {
                         (0, _util.ensureObject)(node, 'raws', 'spaces', 'insensitive');
 …
                       lastAdded = 'value';
                       node.value += content;
                       if (node.raws.value) {
                         node.raws.value += content;
 …
+                    }
+                  }
                   spaceAfterMeaningfulToken = false;
                   break;
                 case tokens.str:
                   if (!node.attribute || !node.operator) {
 …
                     });
+                  }
                   var _unescapeValue = (0, _attribute.unescapeValue)(content),
+                      unescaped = _unescapeValue.unescaped,
+                      quoteMark = _unescapeValue.quoteMark;
+                    unescaped = _unescapeValue.unescaped,
+                    quoteMark = _unescapeValue.quoteMark;
                   node.value = unescaped;
                   node.quoteMark = quoteMark;
 …
                   spaceAfterMeaningfulToken = false;
                   break;
                 case tokens.equals:
                   if (!node.attribute) {
                     return this.expected('attribute', token[_tokenize.FIELDS.START_POS], content);
+                  }
                   if (node.value) {
                     return this.error('Unexpected "=" found; an operator was already defined.', {
 …
                     });
+                  }
                   node.operator = node.operator ? node.operator + content : content;
                   lastAdded = 'operator';
                   spaceAfterMeaningfulToken = false;
                   break;
                 case tokens.comment:
                   if (lastAdded) {
 …
                     commentBefore = commentBefore + content;
+                  }
                   break;
                 default:
                   return this.error("Unexpected \"" + content + "\" found.", {
 …
                   });
+              }
               pos++;
+            }
             unescapeProp(node, "attribute");
             unescapeProp(node, "namespace");
 …
             this.position++;
+          }
           /**
            * return a node containing meaningless garbage up to (but not including) the specified token position.
 …
+           *
            * In lossy mode, this returns only comments.
+           */
+          ;
+           */;
           _proto.parseWhitespaceEquivalentTokens = function parseWhitespaceEquivalentTokens(stopPosition) {
             if (stopPosition < 0) {
               stopPosition = this.tokens.length;
+            }
             var startPosition = this.position;
             var nodes = [];
             var space = "";
             var lastComment = undefined;
             do {
               if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {
 …
               } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.comment) {
                 var spaces = {};
                 if (space) {
                   spaces.before = space;
                   space = "";
+                }
                 lastComment = new _comment["default"]({
                   value: this.content(),
 …
+              }
             } while (++this.position < stopPosition);
             if (space) {
               if (lastComment) {
 …
+              }
+            }
             return nodes;
+          }
           /**
+           *
            * @param {*} nodes
+           */
+          ;
+           */;
           _proto.convertWhitespaceNodesToSpace = function convertWhitespaceNodesToSpace(nodes, requiredSpace) {
             var _this2 = this;
             if (requiredSpace === void 0) {
               requiredSpace = false;
+            }
             var space = "";
             var rawSpace = "";
             nodes.forEach(function (n) {
               var spaceBefore = _this2.lossySpace(n.spaces.before, requiredSpace);
               var rawSpaceBefore = _this2.lossySpace(n.rawSpaceBefore, requiredSpace);
               space += spaceBefore + _this2.lossySpace(n.spaces.after, requiredSpace && spaceBefore.length === 0);
               rawSpace += spaceBefore + n.value + _this2.lossySpace(n.rawSpaceAfter, requiredSpace && rawSpaceBefore.length === 0);
             });
             if (rawSpace === space) {
               rawSpace = undefined;
+            }
             var result = {
               space: space,
 …
             return result;
           };
           _proto.isNamedCombinator = function isNamedCombinator(position) {
             if (position === void 0) {
               position = this.position;
+            }
             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;
           };
           _proto.namedCombinator = function namedCombinator() {
             if (this.isNamedCombinator()) {
 …
               var name = (0, _util.unesc)(nameRaw).toLowerCase();
               var raws = {};
               if (name !== nameRaw) {
                 raws.value = "/" + nameRaw + "/";
+              }
               var node = new _combinator["default"]({
                 value: "/" + name + "/",
 …
+            }
           };
           _proto.combinator = function combinator() {
             var _this3 = this;
             if (this.content() === '|') {
               return this.namespace();
+            } // We need to decide between a space that's a descendant combinator and meaningless whitespace at the end of a selector.
+            }
+            // We need to decide between a space that's a descendant combinator and meaningless whitespace at the end of a selector.
             var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
             if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma) {
               var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
               if (nodes.length > 0) {
                 var last = this.current.last;
                 if (last) {
                   var _this$convertWhitespa = this.convertWhitespaceNodesToSpace(nodes),
+                      space = _this$convertWhitespa.space,
+                      rawSpace = _this$convertWhitespa.rawSpace;
+                    space = _this$convertWhitespa.space,
+                    rawSpace = _this$convertWhitespa.rawSpace;
                   if (rawSpace !== undefined) {
                     last.rawSpaceAfter += rawSpace;
+                  }
                   last.spaces.after += space;
                 } else {
 …
+                }
+              }
               return;
+            }
             var firstToken = this.currToken;
             var spaceOrDescendantSelectorNodes = undefined;
             if (nextSigTokenPos > this.position) {
               spaceOrDescendantSelectorNodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
+            }
             var node;
             if (this.isNamedCombinator()) {
               node = this.namedCombinator();
 …
               this.unexpected();
+            }
             if (node) {
               if (spaceOrDescendantSelectorNodes) {
                 var _this$convertWhitespa2 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes),
+                    _space = _this$convertWhitespa2.space,
+                    _rawSpace = _this$convertWhitespa2.rawSpace;
+                  _space = _this$convertWhitespa2.space,
+                  _rawSpace = _this$convertWhitespa2.rawSpace;
                 node.spaces.before = _space;
                 node.rawSpaceBefore = _rawSpace;
 …
               // descendant combinator
               var _this$convertWhitespa3 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes, true),
+                  _space2 = _this$convertWhitespa3.space,
+                  _rawSpace2 = _this$convertWhitespa3.rawSpace;
+                _space2 = _this$convertWhitespa3.space,
+                _rawSpace2 = _this$convertWhitespa3.rawSpace;
               if (!_rawSpace2) {
                 _rawSpace2 = _space2;
+              }
               var spaces = {};
               var raws = {
                 spaces: {}
               };
               if (_space2.endsWith(' ') && _rawSpace2.endsWith(' ')) {
                 spaces.before = _space2.slice(0, _space2.length - 1);
 …
                 raws.value = _rawSpace2;
+              }
               node = new _combinator["default"]({
                 value: ' ',
 …
               });
+            }
             if (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.space) {
               node.spaces.after = this.optionalSpace(this.content());
               this.position++;
+            }
             return this.newNode(node);
           };
           _proto.comma = function comma() {
             if (this.position === this.tokens.length - 1) {
 …
               return;
+            }
             this.current._inferEndPosition();
             var selector = new _selector["default"]({
               source: {
                 start: tokenStart(this.tokens[this.position + 1])
+              }
+              },
+              sourceIndex: this.tokens[this.position + 1][_tokenize.FIELDS.START_POS]
             });
             this.current.parent.append(selector);
 …
             this.position++;
           };
           _proto.comment = function comment() {
             var current = this.currToken;
 …
             this.position++;
           };
           _proto.error = function error(message, opts) {
             throw this.root.error(message, opts);
           };
           _proto.missingBackslash = function missingBackslash() {
             return this.error('Expected a backslash preceding the semicolon.', {
 …
             });
           };
           _proto.missingParenthesis = function missingParenthesis() {
             return this.expected('opening parenthesis', this.currToken[_tokenize.FIELDS.START_POS]);
           };
           _proto.missingSquareBracket = function missingSquareBracket() {
             return this.expected('opening square bracket', this.currToken[_tokenize.FIELDS.START_POS]);
           };
           _proto.unexpected = function unexpected() {
             return this.error("Unexpected '" + this.content() + "'. Escaping special characters with \\ may help.", this.currToken[_tokenize.FIELDS.START_POS]);
           };
+          _proto.unexpectedPipe = function unexpectedPipe() {
+            return this.error("Unexpected '|'.", this.currToken[_tokenize.FIELDS.START_POS]);
+          };
           _proto.namespace = function namespace() {
             var before = this.prevToken && this.content(this.prevToken) || true;
             if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.word) {
               this.position++;
 …
               return this.universal(before);
+            }
           };
+            this.unexpectedPipe();
+          };
           _proto.nesting = function nesting() {
             if (this.nextToken) {
               var nextContent = this.content(this.nextToken);
               if (nextContent === "|") {
                 this.position++;
 …
+              }
+            }
             var current = this.currToken;
             this.newNode(new _nesting["default"]({
 …
             this.position++;
           };
           _proto.parentheses = function parentheses() {
             var last = this.current.last;
             var unbalanced = 1;
             this.position++;
             if (last && last.type === types$1.PSEUDO) {
               var selector = new _selector["default"]({
                 source: {
+                  start: tokenStart(this.tokens[this.position - 1])
+                }
+                  start: tokenStart(this.tokens[this.position])
+                },
+                sourceIndex: this.tokens[this.position][_tokenize.FIELDS.START_POS]
               });
               var cache = this.current;
               last.append(selector);
               this.current = selector;
               while (this.position < this.tokens.length && unbalanced) {
                 if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
                   unbalanced++;
+                }
                 if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
                   unbalanced--;
+                }
                 if (unbalanced) {
                   this.parse();
 …
+                }
+              }
               this.current = cache;
             } else {
 …
               var parenValue = "(";
               var parenEnd;
               while (this.position < this.tokens.length && unbalanced) {
                 if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
                   unbalanced++;
+                }
                 if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
                   unbalanced--;
+                }
                 parenEnd = this.currToken;
                 parenValue += this.parseParenthesisToken(this.currToken);
                 this.position++;
+              }
               if (last) {
                 last.appendToPropertyAndEscape("value", parenValue, parenValue);
 …
+              }
+            }
             if (unbalanced) {
               return this.expected('closing parenthesis', this.currToken[_tokenize.FIELDS.START_POS]);
+            }
           };
           _proto.pseudo = function pseudo() {
             var _this4 = this;
             var pseudoStr = '';
             var startingToken = this.currToken;
             while (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.colon) {
               pseudoStr += this.content();
               this.position++;
+            }
             if (!this.currToken) {
               return this.expected(['pseudo-class', 'pseudo-element'], this.position - 1);
+            }
             if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.word) {
               this.splitWord(false, function (first, length) {
                 pseudoStr += first;
                 _this4.newNode(new _pseudo["default"]({
                   value: pseudoStr,
 …
                   sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
                 }));
                 if (length > 1 && _this4.nextToken && _this4.nextToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
                   _this4.error('Misplaced parenthesis.', {
 …
+            }
           };
           _proto.space = function space() {
             var content = this.content(); // Handle space before and after the selector
+            var content = this.content();
+            // Handle space before and after the selector
             if (this.position === 0 || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis || this.current.nodes.every(function (node) {
               return node.type === 'comment';
 …
+            }
           };
           _proto.string = function string() {
             var current = this.currToken;
 …
             this.position++;
           };
           _proto.universal = function universal(namespace) {
             var nextToken = this.nextToken;
             if (nextToken && this.content(nextToken) === '|') {
               this.position++;
               return this.namespace();
+            }
             var current = this.currToken;
             this.newNode(new _universal["default"]({
 …
             this.position++;
           };
           _proto.splitWord = function splitWord(namespace, firstCallback) {
             var _this5 = this;
             var nextToken = this.nextToken;
             var word = this.content();
             while (nextToken && ~[tokens.dollar, tokens.caret, tokens.equals, tokens.word].indexOf(nextToken[_tokenize.FIELDS.TYPE])) {
               this.position++;
               var current = this.content();
               word += current;
               if (current.lastIndexOf('\\') === current.length - 1) {
                 var next = this.nextToken;
                 if (next && next[_tokenize.FIELDS.TYPE] === tokens.space) {
                   word += this.requiredSpace(this.content(next));
 …
+                }
+              }
               nextToken = this.nextToken;
+            }
             var hasClass = indexesOf(word, '.').filter(function (i) {
               // Allow escaped dot within class name
               var escapedDot = word[i - 1] === '\\'; // Allow decimal numbers percent in @keyframes
+              var escapedDot = word[i - 1] === '\\';
+              // Allow decimal numbers percent in @keyframes
               var isKeyframesPercent = /^\d+\.\d+%$/.test(word);
               return !escapedDot && !isKeyframesPercent;
 …
             var hasId = indexesOf(word, '#').filter(function (i) {
               return word[i - 1] !== '\\';
             }); // Eliminate Sass interpolations from the list of id indexes
+            });
+            // Eliminate Sass interpolations from the list of id indexes
             var interpolations = indexesOf(word, '#{');
             if (interpolations.length) {
               hasId = hasId.filter(function (hashIndex) {
 …
               });
+            }
             var indices = (0, _sortAscending["default"])(uniqs([0].concat(hasClass, hasId)));
             indices.forEach(function (ind, i) {
               var index = indices[i + 1] || word.length;
               var value = word.slice(ind, index);
               if (i === 0 && firstCallback) {
                 return firstCallback.call(_this5, value, indices.length);
+              }
               var node;
               var current = _this5.currToken;
               var sourceIndex = current[_tokenize.FIELDS.START_POS] + indices[i];
               var source = getSource(current[1], current[2] + ind, current[3], current[2] + (index - 1));
               if (~hasClass.indexOf(ind)) {
                 var classNameOpts = {
 …
                 node = new _tag["default"](tagOpts);
+              }
+              _this5.newNode(node, namespace); // Ensure that the namespace is used only once
+              _this5.newNode(node, namespace);
+              // Ensure that the namespace is used only once
               namespace = null;
             });
             this.position++;
           };
           _proto.word = function word(namespace) {
             var nextToken = this.nextToken;
             if (nextToken && this.content(nextToken) === '|') {
               this.position++;
               return this.namespace();
+            }
             return this.splitWord(namespace);
           };
           _proto.loop = function loop() {
             while (this.position < this.tokens.length) {
               this.parse(true);
+            }
             this.current._inferEndPosition();
             return this.root;
           };
           _proto.parse = function parse(throwOnParenthesis) {
             switch (this.currToken[_tokenize.FIELDS.TYPE]) {
 …
                 this.space();
                 break;
               case tokens.comment:
                 this.comment();
                 break;
               case tokens.openParenthesis:
                 this.parentheses();
                 break;
               case tokens.closeParenthesis:
                 if (throwOnParenthesis) {
                   this.missingParenthesis();
+                }
                 break;
               case tokens.openSquare:
                 this.attribute();
                 break;
               case tokens.dollar:
               case tokens.caret:
 …
                 this.word();
                 break;
               case tokens.colon:
                 this.pseudo();
                 break;
               case tokens.comma:
                 this.comma();
                 break;
               case tokens.asterisk:
                 this.universal();
                 break;
               case tokens.ampersand:
                 this.nesting();
                 break;
               case tokens.slash:
               case tokens.combinator:
                 this.combinator();
                 break;
               case tokens.str:
                 this.string();
                 break;
               // These cases throw; no break needed.
               case tokens.closeSquare:
                 this.missingSquareBracket();
               case tokens.semicolon:
                 this.missingBackslash();
               default:
                 this.unexpected();
+            }
+          }
           /**
            * Helpers
+           */
+          ;
+           */;
           _proto.expected = function expected(description, index, found) {
             if (Array.isArray(description)) {
 …
               description = description.join(', ') + " or " + last;
+            }
             var an = /^[aeiou]/.test(description[0]) ? 'an' : 'a';
             if (!found) {
               return this.error("Expected " + an + " " + description + ".", {
 …
               });
+            }
             return this.error("Expected " + an + " " + description + ", found \"" + found + "\" instead.", {
               index: index
             });
           };
           _proto.requiredSpace = function requiredSpace(space) {
             return this.options.lossy ? ' ' : space;
           };
           _proto.optionalSpace = function optionalSpace(space) {
             return this.options.lossy ? '' : space;
           };
           _proto.lossySpace = function lossySpace(space, required) {
             if (this.options.lossy) {
 …
+            }
           };
           _proto.parseParenthesisToken = function parseParenthesisToken(token) {
             var content = this.content(token);
             if (token[_tokenize.FIELDS.TYPE] === tokens.space) {
               return this.requiredSpace(content);
 …
+            }
           };
           _proto.newNode = function newNode(node, namespace) {
             if (namespace) {
 …
                   this.spaces = (this.spaces || '') + namespace;
+                }
                 namespace = true;
+              }
               node.namespace = namespace;
               unescapeProp(node, "namespace");
+            }
             if (this.spaces) {
               node.spaces.before = this.spaces;
               this.spaces = '';
+            }
             return this.current.append(node);
           };
           _proto.content = function content(token) {
             if (token === void 0) {
               token = this.currToken;
+            }
             return this.css.slice(token[_tokenize.FIELDS.START_POS], token[_tokenize.FIELDS.END_POS]);
           };
           /**
            * returns the index of the next non-whitespace, non-comment token.
 …
               startPosition = this.position + 1;
+            }
             var searchPosition = startPosition;
             while (searchPosition < this.tokens.length) {
               if (WHITESPACE_EQUIV_TOKENS[this.tokens[searchPosition][_tokenize.FIELDS.TYPE]]) {
 …
+              }
+            }
             return -1;
           };
           _createClass(Parser, [{
             key: "currToken",
 …
+            }
           }]);
           return Parser;
         }();
         exports["default"] = Parser;
         module.exports = exports.default;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _parser = _interopRequireDefault(parserExports);
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         var Processor = /*#__PURE__*/function () {
           function Processor(func, options) {
             this.func = func || function noop() {};
             this.funcRes = null;
             this.options = options;
+          }
           var _proto = Processor.prototype;
           _proto._shouldUpdateSelector = function _shouldUpdateSelector(rule, options) {
             if (options === void 0) {
               options = {};
+            }
             var merged = Object.assign({}, this.options, options);
             if (merged.updateSelector === false) {
               return false;
 …
+            }
           };
           _proto._isLossy = function _isLossy(options) {
             if (options === void 0) {
               options = {};
+            }
             var merged = Object.assign({}, this.options, options);
             if (merged.lossless === false) {
               return true;
 …
+            }
           };
           _proto._root = function _root(rule, options) {
             if (options === void 0) {
               options = {};
+            }
             var parser = new _parser["default"](rule, this._parseOptions(options));
             return parser.root;
           };
           _proto._parseOptions = function _parseOptions(options) {
             return {
 …
             };
           };
           _proto._run = function _run(rule, options) {
             var _this = this;
             if (options === void 0) {
               options = {};
+            }
             return new Promise(function (resolve, reject) {
               try {
                 var root = _this._root(rule, options);
                 Promise.resolve(_this.func(root)).then(function (transform) {
                   var string = undefined;
                   if (_this._shouldUpdateSelector(rule, options)) {
                     string = root.toString();
                     rule.selector = string;
+                  }
                   return {
                     transform: transform,
 …
             });
           };
           _proto._runSync = function _runSync(rule, options) {
             if (options === void 0) {
               options = {};
+            }
             var root = this._root(rule, options);
             var transform = this.func(root);
             if (transform && typeof transform.then === "function") {
               throw new Error("Selector processor returned a promise to a synchronous call.");
+            }
             var string = undefined;
             if (options.updateSelector && typeof rule !== "string") {
               string = root.toString();
               rule.selector = string;
+            }
             return {
               transform: transform,
 …
             };
+          }
           /**
            * Process rule into a selector AST.
 …
            * @param options The options for processing
            * @returns {Promise<parser.Root>} The AST of the selector after processing it.
+           */
+          ;
+           */;
           _proto.ast = function ast(rule, options) {
             return this._run(rule, options).then(function (result) {
 …
             });
+          }
           /**
            * Process rule into a selector AST synchronously.
 …
            * @param options The options for processing
            * @returns {parser.Root} The AST of the selector after processing it.
+           */
+          ;
+           */;
           _proto.astSync = function astSync(rule, options) {
             return this._runSync(rule, options).root;
+          }
           /**
            * Process a selector into a transformed value asynchronously
 …
            * @param options The options for processing
            * @returns {Promise<any>} The value returned by the processor.
+           */
+          ;
+           */;
           _proto.transform = function transform(rule, options) {
             return this._run(rule, options).then(function (result) {
 …
             });
+          }
           /**
            * Process a selector into a transformed value synchronously.
 …
            * @param options The options for processing
            * @returns {any} The value returned by the processor.
+           */
+          ;
+           */;
           _proto.transformSync = function transformSync(rule, options) {
             return this._runSync(rule, options).transform;
+          }
           /**
            * Process a selector into a new selector string asynchronously.
 …
            * @param options The options for processing
            * @returns {string} the selector after processing.
+           */
+          ;
+           */;
           _proto.process = function process(rule, options) {
             return this._run(rule, options).then(function (result) {
 …
             });
+          }
           /**
            * Process a selector into a new selector string synchronously.
 …
            * @param options The options for processing
            * @returns {string} the selector after processing.
+           */
+          ;
+           */;
           _proto.processSync = function processSync(rule, options) {
             var result = this._runSync(rule, options);
             return result.string || result.root.toString();
           };
           return Processor;
         }();
         exports["default"] = Processor;
         module.exports = exports.default;
 …
 constructors.__esModule = true;
 constructors.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;
 var _attribute = _interopRequireDefault$2(attribute$1);
 var _className = _interopRequireDefault$2(classNameExports);
 var _combinator = _interopRequireDefault$2(combinatorExports);
 var _comment = _interopRequireDefault$2(commentExports);
 var _id = _interopRequireDefault$2(idExports);
 var _nesting = _interopRequireDefault$2(nestingExports);
 var _pseudo = _interopRequireDefault$2(pseudoExports);
 var _root = _interopRequireDefault$2(rootExports);
 var _selector = _interopRequireDefault$2(selectorExports);
 var _string = _interopRequireDefault$2(stringExports);
 var _tag = _interopRequireDefault$2(tagExports);
 var _universal = _interopRequireDefault$2(universalExports);
 function _interopRequireDefault$2(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 var attribute = function attribute(opts) {
   return new _attribute["default"](opts);
 };
 constructors.attribute = attribute;
 var className = function className(opts) {
   return new _className["default"](opts);
 };
 constructors.className = className;
 var combinator = function combinator(opts) {
   return new _combinator["default"](opts);
 };
 constructors.combinator = combinator;
 var comment = function comment(opts) {
   return new _comment["default"](opts);
 };
 constructors.comment = comment;
 var id = function id(opts) {
   return new _id["default"](opts);
 };
 constructors.id = id;
 var nesting = function nesting(opts) {
   return new _nesting["default"](opts);
 };
 constructors.nesting = nesting;
 var pseudo = function pseudo(opts) {
   return new _pseudo["default"](opts);
 };
 constructors.pseudo = pseudo;
 var root = function root(opts) {
   return new _root["default"](opts);
 };
 constructors.root = root;
 var selector = function selector(opts) {
   return new _selector["default"](opts);
 };
 constructors.selector = selector;
 var string = function string(opts) {
   return new _string["default"](opts);
 };
 constructors.string = string;
 var tag = function tag(opts) {
   return new _tag["default"](opts);
 };
 constructors.tag = tag;
 var universal = function universal(opts) {
   return new _universal["default"](opts);
 };
 constructors.universal = universal;
 …
 guards.__esModule = true;
+guards.isComment = guards.isCombinator = guards.isClassName = guards.isAttribute = void 0;
+guards.isContainer = isContainer;
+guards.isIdentifier = void 0;
+guards.isNamespace = isNamespace;
+guards.isNesting = void 0;
 guards.isNode = isNode;
+guards.isPseudo = void 0;
+guards.isPseudoClass = isPseudoClass;
 guards.isPseudoElement = isPseudoElement;
+guards.isPseudoClass = isPseudoClass;
+guards.isContainer = isContainer;
+guards.isNamespace = isNamespace;
+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;
+guards.isUniversal = guards.isTag = guards.isString = guards.isSelector = guards.isRoot = void 0;
 var _types = types;
 var _IS_TYPE;
 var 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);
 function isNode(node) {
   return typeof node === "object" && IS_TYPE[node.type];
+}
 function isNodeType(type, node) {
   return isNode(node) && node.type === type;
+}
 var isAttribute = isNodeType.bind(null, _types.ATTRIBUTE);
 guards.isAttribute = isAttribute;
 …
 var isUniversal = isNodeType.bind(null, _types.UNIVERSAL);
 guards.isUniversal = isUniversal;
 function isPseudoElement(node) {
   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");
+}
 function isPseudoClass(node) {
   return isPseudo(node) && !isPseudoElement(node);
+}
 function isContainer(node) {
   return !!(isNode(node) && node.walk);
+}
 function isNamespace(node) {
   return isAttribute(node) || isTag(node);
 …
         exports.__esModule = true;
         var _types = types;
         Object.keys(_types).forEach(function (key) {
           if (key === "default" || key === "__esModule") return;
 …
           exports[key] = _types[key];
         });
         var _constructors = constructors;
         Object.keys(_constructors).forEach(function (key) {
           if (key === "default" || key === "__esModule") return;
 …
           exports[key] = _constructors[key];
         });
         var _guards = guards;
         Object.keys(_guards).forEach(function (key) {
           if (key === "default" || key === "__esModule") return;
 …
         exports.__esModule = true;
         exports["default"] = void 0;
         var _processor = _interopRequireDefault(processorExports);
         var selectors$1 = _interopRequireWildcard(selectors);
+        function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+        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; }
+        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); }
+        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; }
         function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
         var parser = function parser(processor) {
           return new _processor["default"](processor);
         };
         Object.assign(parser, selectors$1);
         delete parser.__esModule;
 …
               explicit: context.explicit,
             };
+            newNodes = node.map((childNode) =>
+              transform(childNode, childContext)
+            );
+            newNodes = node.map((childNode) => {
+              const newContext = {
+                ...childContext,
+                enforceNoSpacing: false,
+              };
+              const result = transform(childNode, newContext);
+              childContext.global = newContext.global;
+              childContext.hasLocals = newContext.hasLocals;
+              return result;
+            });
             node = node.clone();
 …
         break;
+      }
+      case "nesting": {
+        if (node.value === "&") {
+          context.hasLocals = true;
+        }
+      }
+    }
 …
+}
+function isWordAFunctionArgument(wordNode, functionNode) {
+  return functionNode
+    ? functionNode.nodes.some(
+        (functionNodeChild) =>
+          functionNodeChild.sourceIndex === wordNode.sourceIndex
+      )
+    : false;
+}
+// `none` is special value, other is global values
+const specialKeywords = [
+  "none",
+  "inherit",
+  "initial",
+  "revert",
+  "revert-layer",
+  "unset",
+];
 function localizeDeclarationValues(localize, declaration, context) {
 …
   valueNodes.walk((node, index, nodes) => {
+    if (
+      node.type === "function" &&
+      (node.value.toLowerCase() === "var" || node.value.toLowerCase() === "env")
+    ) {
+      return false;
+    }
+    if (
+      node.type === "word" &&
+      specialKeywords.includes(node.value.toLowerCase())
+    ) {
+      return;
+    }
     const subContext = {
       options: context.options,
 …
   if (isAnimation) {
+    const validIdent = /^-?[_a-z][_a-z0-9-]*$/i;
+    // letter
+    // An uppercase letter or a lowercase letter.
+    //
+    // ident-start code point
+    // A letter, a non-ASCII code point, or U+005F LOW LINE (_).
+    //
+    // ident code point
+    // An ident-start code point, a digit, or U+002D HYPHEN-MINUS (-).
+    // We don't validate `hex digits`, because we don't need it, it is work of linters.
+    const validIdent =
+      /^-?([a-z\u0080-\uFFFF_]|(\\[^\r\n\f])|-(?![0-9]))((\\[^\r\n\f])|[a-z\u0080-\uFFFF_0-9-])*$/i;
     /*
 …
     a keyword, it is given priority. Only when all the properties that can take a keyword are
     exhausted can the animation name be set to the keyword. I.e.
     animation: infinite infinite;
     The animation will repeat an infinite number of times from the first argument, and will have an
     animation name of infinite from the second.
     */
     const animationKeywords = {
+      // animation-direction
+      $normal: 1,
+      $reverse: 1,
       $alternate: 1,
       "$alternate-reverse": 1,
+      // animation-fill-mode
+      $forwards: 1,
       $backwards: 1,
       $both: 1,
+      // animation-iteration-count
+      $infinite: 1,
+      // animation-play-state
+      $paused: 1,
+      $running: 1,
+      // animation-timing-function
       $ease: 1,
       "$ease-in": 1,
+      "$ease-out": 1,
       "$ease-in-out": 1,
-      "$ease-out": 1,
-      $forwards: 1,
-      $infinite: 1,
       $linear: 1,
-      $none: Infinity, // No matter how many times you write none, it will never be an animation name
-      $normal: 1,
-      $paused: 1,
-      $reverse: 1,
-      $running: 1,
       "$step-end": 1,
       "$step-start": 1,
+      // Special
+      $none: Infinity, // No matter how many times you write none, it will never be an animation name
+      // Global values
       $initial: Infinity,
       $inherit: Infinity,
       $unset: Infinity,
+      $revert: Infinity,
+      "$revert-layer": Infinity,
     };
     let parsedAnimationKeywords = {};
-    let stepsFunctionNode = null;
     const valueNodes = valueParser(declaration.value).walk((node) => {
       /* If div-token appeared (represents as comma ','), a possibility of an animation-keywords should be reflesh. */
+      // If div-token appeared (represents as comma ','), a possibility of an animation-keywords should be reflesh.
       if (node.type === "div") {
         parsedAnimationKeywords = {};
+        return;
+      }
+      if (node.type === "function" && node.value.toLowerCase() === "steps") {
+        stepsFunctionNode = node;
+      // Do not handle nested functions
+      else if (node.type === "function") {
+        return false;
+      }
+      const value =
+        node.type === "word" &&
+        !isWordAFunctionArgument(node, stepsFunctionNode)
+          ? node.value.toLowerCase()
+          : null;
+      // Ignore all except word
+      else if (node.type !== "word") {
+        return;
+      }
+      const value = node.type === "word" ? node.value.toLowerCase() : null;
       let shouldParseAnimationName = false;
 …
         localAliasMap: context.localAliasMap,
       };
       return localizeDeclNode(node, subContext);
     });
 …
                 atRule.params = localMatch[0];
                 globalKeyframes = false;
+              } else if (!globalMode) {
+                if (atRule.params && !localAliasMap.has(atRule.params)) {
+                  atRule.params = ":local(" + atRule.params + ")";
+                }
+              } else if (
+                atRule.params &&
+                !globalMode &&
+                !localAliasMap.has(atRule.params)
+              ) {
+                atRule.params = ":local(" + atRule.params + ")";
+              }
 …
                   global: globalKeyframes,
                 });
+              });
+            } else if (/scope$/i.test(atRule.name)) {
+              if (atRule.params) {
+                atRule.params = atRule.params
+                  .split("to")
+                  .map((item) => {
+                    const selector = item.trim().slice(1, -1).trim();
+                    const context = localizeNode(
+                      selector,
+                      options.mode,
+                      localAliasMap
+                    );
+                    context.options = options;
+                    context.localAliasMap = localAliasMap;
+                    if (pureMode && context.hasPureGlobals) {
+                      throw atRule.error(
+                        'Selector in at-rule"' +
+                          selector +
+                          '" is not pure ' +
+                          "(pure selectors must contain at least one local class or id)"
+                      );
+                    }
+                    return `(${context.selector})`;
+                  })
+                  .join(" to ");
+              }
+              atRule.nodes.forEach((declaration) => {
+                if (declaration.type === "decl") {
+                  localizeDeclaration(declaration, {
+                    localAliasMap,
+                    options: options,
+                    global: globalMode,
+                  });
+                }
               });
             } else if (atRule.nodes) {
 …
 const hasOwnProperty = Object.prototype.hasOwnProperty;
+function getSingleLocalNamesForComposes(root) {
+function isNestedRule(rule) {
+  if (!rule.parent || rule.parent.type === "root") {
+    return false;
+  }
+  if (rule.parent.type === "rule") {
+    return true;
+  }
+  return isNestedRule(rule.parent);
+}
+function getSingleLocalNamesForComposes(root, rule) {
+  if (isNestedRule(rule)) {
+    throw new Error(`composition is not allowed in nested rule \n\n${rule}`);
+  }
   return root.nodes.map((node) => {
     if (node.type !== "selector" || node.nodes.length !== 1) {
 …
       const exports = Object.create(null);
       function exportScopedName(name, rawName) {
+      function exportScopedName(name, rawName, node) {
         const scopedName = generateScopedName(
           rawName ? rawName : name,
           root.source.input.from,
+          root.source.input.css
+          root.source.input.css,
+          node
         );
         const exportEntry = generateExportEntry(
 …
           scopedName,
           root.source.input.from,
+          root.source.input.css
+          root.source.input.css,
+          node
         );
         const { key, value } = exportEntry;
 …
         switch (node.type) {
           case "selector":
             node.nodes = node.map(localizeNode);
+            node.nodes = node.map((item) => localizeNode(item));
             return node;
           case "class":
 …
               value: exportScopedName(
                 node.value,
+                node.raws && node.raws.value ? node.raws.value : null
+                node.raws && node.raws.value ? node.raws.value : null,
+                node
               ),
             });
 …
               value: exportScopedName(
                 node.value,
+                node.raws && node.raws.value ? node.raws.value : null
+                node.raws && node.raws.value ? node.raws.value : null,
+                node
               ),
             });
+          }
+          case "attribute": {
+            if (node.attribute === "class" && node.operator === "=") {
+              return selectorParser.attribute({
+                attribute: node.attribute,
+                operator: node.operator,
+                quoteMark: "'",
+                value: exportScopedName(node.value, null, null),
+              });
+            }
+          }
+        }
 …
               const selector = localizeNode(node.first);
               // move the spaces that were around the psuedo selector to the first
+              // move the spaces that were around the pseudo selector to the first
               // non-container node
               selector.first.spaces = node.spaces;
 …
           case "root":
           case "selector": {
             node.each(traverseNode);
+            node.each((item) => traverseNode(item));
             break;
+          }
 …
         rule.selector = traverseNode(parsedSelector.clone()).toString();
+        rule.walkDecls(/composes|compose-with/i, (decl) => {
+          const localNames = getSingleLocalNamesForComposes(parsedSelector);
+          const classes = decl.value.split(/\s+/);
+          classes.forEach((className) => {
+            const global = /^global\(([^)]+)\)$/.exec(className);
+            if (global) {
+              localNames.forEach((exportedName) => {
+                exports[exportedName].push(global[1]);
+              });
+            } else if (hasOwnProperty.call(importedNames, className)) {
+              localNames.forEach((exportedName) => {
+                exports[exportedName].push(className);
+              });
+            } else if (hasOwnProperty.call(exports, className)) {
+              localNames.forEach((exportedName) => {
+                exports[className].forEach((item) => {
+                  exports[exportedName].push(item);
+        rule.walkDecls(/^(composes|compose-with)$/i, (decl) => {
+          const localNames = getSingleLocalNamesForComposes(
+            parsedSelector,
+            decl.parent
+          );
+          const multiple = decl.value.split(",");
+          multiple.forEach((value) => {
+            const classes = value.trim().split(/\s+/);
+            classes.forEach((className) => {
+              const global = /^global\(([^)]+)\)$/.exec(className);
+              if (global) {
+                localNames.forEach((exportedName) => {
+                  exports[exportedName].push(global[1]);
                 });
+              });
+            } else {
+              throw decl.error(
+                `referenced class name "${className}" in ${decl.prop} not found`
+              );
+            }
+              } else if (hasOwnProperty.call(importedNames, className)) {
+                localNames.forEach((exportedName) => {
+                  exports[exportedName].push(className);
+                });
+              } else if (hasOwnProperty.call(exports, className)) {
+                localNames.forEach((exportedName) => {
+                  exports[className].forEach((item) => {
+                    exports[exportedName].push(item);
+                  });
+                });
+              } else {
+                throw decl.error(
+                  `referenced class name "${className}" in ${decl.prop} not found`
+                );
+              }
+            });
           });
 …
         atRule.params = exportScopedName(localMatch[1]);
+      });
+      root.walkAtRules(/scope$/i, (atRule) => {
+        if (atRule.params) {
+          atRule.params = atRule.params
+            .split("to")
+            .map((item) => {
+              const selector = item.trim().slice(1, -1).trim();
+              const localMatch = /^\s*:local\s*\((.+?)\)\s*$/.exec(selector);
+              if (!localMatch) {
+                return `(${selector})`;
+              }
+              let parsedSelector = selectorParser().astSync(selector);
+              return `(${traverseNode(parsedSelector).toString()})`;
+            })
+            .join(" to ");
+        }
       });

imaps-frontend/node_modules/vite/dist/node/chunks/dep-C6EFp3uH.js

rd565449	r0c6b92a
1		import { B as getDefaultExportFromCjs } from './dep-~~mCdpKltl~~.js';
	1	import { B as getDefaultExportFromCjs } from './dep-CB_7IfJ-.js';
2	2	import require$$0 from 'path';
3	3	import require$$0__default from 'fs';

imaps-frontend/node_modules/vite/dist/node/chunks/dep-CB_7IfJ-.js

-              rd565449
+              r0c6b92a
     charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+    let value = 0;
+    let shift = 0;
+    let integer = 0;
+    do {
+        const c = reader.next();
+        integer = charToInt[c];
+        value |= (integer & 31) << shift;
+        shift += 5;
+    } while (integer & 32);
+    const shouldNegate = value & 1;
+    value >>>= 1;
+    if (shouldNegate) {
+        value = -0x80000000 | -value;
+    }
+    return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
+    do {
+        let clamped = delta & 0b011111;
+        delta >>>= 5;
+        if (delta > 0)
+            clamped |= 0b100000;
+        builder.write(intToChar[clamped]);
+    } while (delta > 0);
+    return num;
+}
+function hasMoreVlq(reader, max) {
+    if (reader.pos >= max)
+        return false;
+    return reader.peek() !== comma;
+}
+const bufLength = 1024 * 16;
 // Provide a fallback for older environments.
 const td = typeof TextDecoder !== 'undefined'
 …
             },
         };
+class StringWriter {
+    constructor() {
+        this.pos = 0;
+        this.out = '';
+        this.buffer = new Uint8Array(bufLength);
+    }
+    write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+        }
+    }
+    flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+}
+class StringReader {
+    constructor(buffer) {
+        this.pos = 0;
+        this.buffer = buffer;
+    }
+    next() {
+        return this.buffer.charCodeAt(this.pos++);
+    }
+    peek() {
+        return this.buffer.charCodeAt(this.pos);
+    }
+    indexOf(char) {
+        const { buffer, pos } = this;
+        const idx = buffer.indexOf(char, pos);
+        return idx === -1 ? buffer.length : idx;
+    }
+}
 function decode(mappings) {
+    const state = new Int32Array(5);
+    const { length } = mappings;
+    const reader = new StringReader(mappings);
     const decoded = [];
+    let index = 0;
+    let genColumn = 0;
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
     do {
         const semi = indexOf(mappings, index);
+        const semi = reader.indexOf(';');
         const line = [];
         let sorted = true;
         let lastCol = 0;
         state[0] = 0;
         for (let i = index; i < semi; i++) {
+        genColumn = 0;
+        while (reader.pos < semi) {
             let seg;
+            i = decodeInteger(mappings, i, state, 0); // genColumn
+            const col = state[0];
+            if (col < lastCol)
+            genColumn = decodeInteger(reader, genColumn);
+            if (genColumn < lastCol)
                 sorted = false;
             lastCol = col;
             if (hasMoreVlq(mappings, i, semi)) {
                 i = decodeInteger(mappings, i, state, 1); // sourcesIndex
                 i = decodeInteger(mappings, i, state, 2); // sourceLine
                 i = decodeInteger(mappings, i, state, 3); // sourceColumn
                 if (hasMoreVlq(mappings, i, semi)) {
                     i = decodeInteger(mappings, i, state, 4); // namesIndex
                     seg = [col, state[1], state[2], state[3], state[4]];
+            lastCol = genColumn;
+            if (hasMoreVlq(reader, semi)) {
+                sourcesIndex = decodeInteger(reader, sourcesIndex);
+                sourceLine = decodeInteger(reader, sourceLine);
+                sourceColumn = decodeInteger(reader, sourceColumn);
+                if (hasMoreVlq(reader, semi)) {
+                    namesIndex = decodeInteger(reader, namesIndex);
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+                }
                 else {
                     seg = [col, state[1], state[2], state[3]];
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+                }
+            }
             else {
                 seg = [col];
+                seg = [genColumn];
+            }
             line.push(seg);
+            reader.pos++;
+        }
         if (!sorted)
             sort(line);
         decoded.push(line);
         index = semi + 1;
     } while (index <= mappings.length);
+        reader.pos = semi + 1;
+    } while (reader.pos <= length);
     return decoded;
+}
-function indexOf(mappings, index) {
-    const idx = mappings.indexOf(';', index);
-    return idx === -1 ? mappings.length : idx;
+}
-function decodeInteger(mappings, pos, state, j) {
-    let value = 0;
-    let shift = 0;
-    let integer = 0;
-    do {
-        const c = mappings.charCodeAt(pos++);
-        integer = charToInt[c];
-        value |= (integer & 31) << shift;
-        shift += 5;
-    } while (integer & 32);
-    const shouldNegate = value & 1;
-    value >>>= 1;
-    if (shouldNegate) {
-        value = -0x80000000 | -value;
+    }
-    state[j] += value;
-    return pos;
+}
-function hasMoreVlq(mappings, i, length) {
-    if (i >= length)
-        return false;
-    return mappings.charCodeAt(i) !== comma;
+}
 function sort(line) {
 …
+}
 function encode$1(decoded) {
+    const state = new Int32Array(5);
+    const bufLength = 1024 * 16;
+    const subLength = bufLength - 36;
+    const buf = new Uint8Array(bufLength);
+    const sub = buf.subarray(0, subLength);
+    let pos = 0;
+    let out = '';
+    const writer = new StringWriter();
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
     for (let i = 0; i < decoded.length; i++) {
         const line = decoded[i];
+        if (i > 0) {
+            if (pos === bufLength) {
+                out += td.decode(buf);
+                pos = 0;
+            }
+            buf[pos++] = semicolon;
+        }
+        if (i > 0)
+            writer.write(semicolon);
         if (line.length === 0)
             continue;
         state[0] = 0;
+        let genColumn = 0;
         for (let j = 0; j < line.length; j++) {
             const segment = line[j];
-            // We can push up to 5 ints, each int can take at most 7 chars, and we
-            // may push a comma.
-            if (pos > subLength) {
-                out += td.decode(sub);
-                buf.copyWithin(0, subLength, pos);
-                pos -= subLength;
+            }
             if (j > 0)
                 buf[pos++] = comma;
             pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
+                writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
             if (segment.length === 1)
                 continue;
             pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
             pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
             pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
             if (segment.length === 4)
                 continue;
+            pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
+        }
+    }
+    return out + td.decode(buf.subarray(0, pos));
+}
+function encodeInteger(buf, pos, state, segment, j) {
+    const next = segment[j];
+    let num = next - state[j];
+    state[j] = next;
+    num = num < 0 ? (-num << 1) | 1 : num << 1;
+    do {
+        let clamped = num & 0b011111;
+        num >>>= 5;
+        if (num > 0)
+            clamped |= 0b100000;
+        buf[pos++] = intToChar[clamped];
+    } while (num > 0);
+    return pos;
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
+        }
+    }
+    return writer.flush();
+}
 …
                 if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
+                while (start < 0) start += this.original.length;
+                while (end < 0) end += this.original.length;
+                if (this.original.length !== 0) {
+                        while (start < 0) start += this.original.length;
+                        while (end < 0) end += this.original.length;
+                }
                 if (end > this.original.length) throw new Error('end is out of bounds');
 …
         remove(start, end) {
+                while (start < 0) start += this.original.length;
+                while (end < 0) end += this.original.length;
+                if (this.original.length !== 0) {
+                        while (start < 0) start += this.original.length;
+                        while (end < 0) end += this.original.length;
+                }
                 if (start === end) return this;
 …
         reset(start, end) {
+                while (start < 0) start += this.original.length;
+                while (end < 0) end += this.original.length;
+                if (this.original.length !== 0) {
+                        while (start < 0) start += this.original.length;
+                        while (end < 0) end += this.original.length;
+                }
                 if (start === end) return this;
 …
         slice(start = 0, end = this.original.length) {
+                while (start < 0) start += this.original.length;
+                while (end < 0) end += this.original.length;
+                if (this.original.length !== 0) {
+                        while (start < 0) start += this.original.length;
+                        while (end < 0) end += this.original.length;
+                }
                 let result = '';
 …
+                        }
+                        let m;
                         // Is webkit? http://stackoverflow.com/a/16459606/376773
                         // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
 …
                                 // Is firefox >= v31?
                                 // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
                                 (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+                                (typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
                                 // Double check webkit in userAgent just in case we are in a worker
                                 (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
 …
         invalidatePackageData(packageCache, path$n.normalize(id));
+      }
-    },
-    handleHotUpdate({ file }) {
-      if (file.endsWith("/package.json")) {
-        invalidatePackageData(packageCache, path$n.normalize(file));
+      }
+    }
   };
 …
 const replaceSlashOrColonRE = /[/:]/g;
 const replaceDotRE = /\./g;
 const replaceNestedIdRE = /(\s*>\s*)/g;
+const replaceNestedIdRE = /\s*>\s*/g;
 const replaceHashRE = /#/g;
 const flattenId = (id) => {
 …
     for (const file of skip) {
       if (path$n.dirname(file) !== ".") {
         const matched = file.match(splitFirstDirRE);
+        const matched = splitFirstDirRE.exec(file);
         if (matched) {
           nested ??= /* @__PURE__ */ new Map();
 …
   return realPath;
+}
 const parseNetUseRE = /^(\w+)? +(\w:) +([^ ]+)\s/;
+const parseNetUseRE = /^\w* +(\w:) +([^ ]+)\s/;
 let firstSafeRealPathSyncRun = false;
 function windowsSafeRealPathSync(path2) {
 …
     const lines = stdout.split("\n");
     for (const line of lines) {
       const m = line.match(parseNetUseRE);
       if (m) windowsNetworkMap.set(m[3], m[2]);
+      const m = parseNetUseRE.exec(line);
+      if (m) windowsNetworkMap.set(m[2], m[1]);
+    }
     if (windowsNetworkMap.size === 0) {
 …
+  }
+}
 const escapedSpaceCharacters = /( |\\t|\\n|\\f|\\r)+/g;
+const escapedSpaceCharacters = /(?: |\\t|\\n|\\f|\\r)+/g;
 const imageSetUrlRE = /^(?:[\w\-]+\(.*?\)|'.*?'|".*?"|\S*)/;
 function joinSrcset(ret) {
 …
         ...backwardCompatibleWorkerPlugins(value)
       ];
+      continue;
+    } else if (key === "server" && rootPath === "server.hmr") {
+      merged[key] = value;
       continue;
+    }
 …
                 let lastWildcardIndex = pattern.length;
                 let hasWildcard = false;
+                let hasExtension = false;
+                let hasSlash = false;
+                let lastSlashIndex = -1;
                 for (let i = pattern.length - 1; i > -1; i--) {
+                        if (pattern[i] === '*' || pattern[i] === '?') {
+                                lastWildcardIndex = i;
+                                hasWildcard = true;
+                        const c = pattern[i];
+                        if (!hasWildcard) {
+                                if (c === '*' || c === '?') {
+                                        lastWildcardIndex = i;
+                                        hasWildcard = true;
+                                }
+                        }
+                        if (!hasSlash) {
+                                if (c === '.') {
+                                        hasExtension = true;
+                                } else if (c === '/') {
+                                        lastSlashIndex = i;
+                                        hasSlash = true;
+                                }
+                        }
+                        if (hasWildcard && hasSlash) {
                                 break;
+                        }
+                }
+                if (!hasExtension && (!hasWildcard || lastWildcardIndex < lastSlashIndex)) {
+                        // add implicit glob
+                        pattern += `${pattern.endsWith('/') ? '' : '/'}${GLOB_ALL_PATTERN}`;
+                        lastWildcardIndex = pattern.length - 1;
+                        hasWildcard = true;
+                }
 …
+                }
-                // if no wildcard in pattern, filename must be equal to resolved pattern
                 if (!hasWildcard) {
+                        //  no wildcard in pattern, filename must be equal to resolved pattern
                         return filename === resolvedPattern;
+                } else if (
+                        firstWildcardIndex + GLOB_ALL_PATTERN.length ===
+                                resolvedPattern.length - (pattern.length - 1 - lastWildcardIndex) &&
+                        resolvedPattern.slice(firstWildcardIndex, firstWildcardIndex + GLOB_ALL_PATTERN.length) ===
+                                GLOB_ALL_PATTERN
+                ) {
+                        // singular glob-all pattern and we already validated prefix and suffix matches
+                        return true;
+                }
                 // complex pattern, use regex to check it
                 if (PATTERN_REGEX_CACHE.has(resolvedPattern)) {
 …
         return JSON.parse(
                 JSON.stringify(tsconfig)
                         // replace ${configDir}, accounting for rebaseRelative emitted ../${configDir}
                         .replaceAll(/"(?:\.\.\/)*\${configDir}/g, `"${native2posix(configDir)}`)
+                        // replace ${configDir}
+                        .replaceAll(/"\${configDir}/g, `"${native2posix(configDir)}`)
         );
+}
 …
  */
 function rebasePath(value, prependPath) {
         if (path$n.isAbsolute(value)) {
+        if (path$n.isAbsolute(value) || value.startsWith('${configDir}')) {
                 return value;
         } else {
 …
 const debug$h = createDebugger("vite:esbuild");
 const IIFE_BEGIN_RE = /(const|var)\s+\S+\s*=\s*function\([^()]*\)\s*\{\s*"use strict";/;
+const IIFE_BEGIN_RE = /(?:const|var)\s+\S+\s*=\s*function\([^()]*\)\s*\{\s*"use strict";/;
 const validExtensionRE = /\.\w+$/;
 const jsxExtensionsRE = /\.(?:j|t)sx\b/;
 …
         // Force rollup to keep this module from being shared between other entry points if it's an entrypoint.
         // If the resulting chunk is empty, it will be removed in generateBundle.
+        moduleSideEffects: config.command === "build" && this.getModuleInfo(id)?.isEntry ? "no-treeshake" : false
+        moduleSideEffects: config.command === "build" && this.getModuleInfo(id)?.isEntry ? "no-treeshake" : false,
+        meta: config.command === "build" ? { "vite:asset": true } : void 0
       };
     },
 …
       for (const file in bundle) {
         const chunk = bundle[file];
         if (chunk.type === "chunk" && chunk.isEntry && chunk.moduleIds.length === 1 && config.assetsInclude(chunk.moduleIds[0])) {
+        if (chunk.type === "chunk" && chunk.isEntry && chunk.moduleIds.length === 1 && config.assetsInclude(chunk.moduleIds[0]) && this.getModuleInfo(chunk.moduleIds[0])?.meta["vite:asset"]) {
           delete bundle[file];
+        }
 …
+  }
+}
 function fileToDevUrl(id, config) {
+function fileToDevUrl(id, config, skipBase = false) {
   let rtn;
   if (checkPublicFile(id, config)) {
 …
     rtn = path$n.posix.join(FS_PREFIX, id);
+  }
+  const base = joinUrlSegments(config.server?.origin ?? "", config.base);
+  if (skipBase) {
+    return rtn;
+  }
+  const base = joinUrlSegments(config.server?.origin ?? "", config.decodedBase);
   return joinUrlSegments(base, removeLeadingSlash(rtn));
+}
 …
 function publicFileToBuiltUrl(url, config) {
   if (config.command !== "build") {
     return joinUrlSegments(config.base, url);
+    return joinUrlSegments(config.decodedBase, url);
+  }
   const hash = getHash(url);
 …
     const { search, hash } = parse$h(id);
     const postfix = (search || "") + (hash || "");
+    const originalFileName = normalizePath$3(path$n.relative(config.root, file));
     const referenceId = pluginContext.emitFile({
+      type: "asset",
       // Ignore directory structure for asset file names
       name: path$n.basename(file),
       type: "asset",
+      originalFileName,
       source: content
     });
+    const originalName = normalizePath$3(path$n.relative(config.root, file));
+    generatedAssets.get(config).set(referenceId, { originalName });
+    generatedAssets.get(config).set(referenceId, { originalFileName });
     url = `__VITE_ASSET__${referenceId}__${postfix ? `$_${postfix}__` : ``}`;
+  }
 …
         return manifestChunk;
+      }
-      const fileNameToAssetMeta = /* @__PURE__ */ new Map();
       const assets = generatedAssets.get(config);
+      assets.forEach((asset, referenceId) => {
+        try {
+          const fileName = this.getFileName(referenceId);
+          fileNameToAssetMeta.set(fileName, asset);
+        } catch (error) {
+          assets.delete(referenceId);
+        }
+      });
+      const entryCssAssetFileNames = /* @__PURE__ */ new Set();
+      for (const [id, asset] of assets.entries()) {
+        if (asset.isEntry) {
+          try {
+            const fileName = this.getFileName(id);
+            entryCssAssetFileNames.add(fileName);
+          } catch (error) {
+            assets.delete(id);
+          }
+        }
+      }
       const fileNameToAsset = /* @__PURE__ */ new Map();
       for (const file in bundle) {
 …
           manifest[getChunkName(chunk)] = createChunk(chunk);
         } else if (chunk.type === "asset" && typeof chunk.name === "string") {
           const assetMeta = fileNameToAssetMeta.get(chunk.fileName);
           const src = assetMeta?.originalName ?? chunk.name;
           const asset = createAsset(chunk, src, assetMeta?.isEntry);
+          const src = chunk.originalFileName ?? chunk.name;
+          const isEntry = entryCssAssetFileNames.has(chunk.fileName);
+          const asset = createAsset(chunk, src, isEntry);
           const file2 = manifest[src]?.file;
           if (file2 && endsWithJSRE.test(file2)) continue;
 …
+        }
+      }
       assets.forEach(({ originalName }, referenceId) => {
         if (!manifest[originalName]) {
+      for (const [referenceId, { originalFileName }] of assets.entries()) {
+        if (!manifest[originalFileName]) {
           const fileName = this.getFileName(referenceId);
           const asset = fileNameToAsset.get(fileName);
           if (asset) {
             manifest[originalName] = asset;
+            manifest[originalFileName] = asset;
+          }
+        }
       });
+      }
       outputCount++;
       const output = config.build.rollupOptions?.output;
 …
     },
     resolveId(id) {
       if (!dataUriRE.test(id)) {
+      if (!id.trimStart().startsWith("data:")) {
         return;
+      }
 …
         return;
+      }
       const match = uri.pathname.match(dataUriRE);
+      const match = dataUriRE.exec(uri.pathname);
       if (!match) {
         return;
 …
 const picomatch$2 = picomatch$3;
 const utils$b = utils$k;
+const isEmptyString = val => val === '' || val === './';
+const isEmptyString = v => v === '' || v === './';
+const hasBraces = v => {
+  const index = v.indexOf('{');
+  return index > -1 && v.indexOf('}', index) > -1;
+};
 /**
 …
 micromatch$1.braces = (pattern, options) => {
   if (typeof pattern !== 'string') throw new TypeError('Expected a string');
   if ((options && options.nobrace === true) || !/\{.*\}/.test(pattern)) {
+  if ((options && options.nobrace === true) || !hasBraces(pattern)) {
     return [pattern];
+  }
 …
  */
+// exposed for tests
+micromatch$1.hasBraces = hasBraces;
 var micromatch_1 = micromatch$1;
 …
+    }
+}
-Collection.maxFlowStringSingleLineLength = 60;
 /**
 …
     if (!lineWidth || lineWidth < 0)
         return text;
+    if (lineWidth < minContentWidth)
+        minContentWidth = 0;
     const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);
     if (text.length <= endStep)
 …
     let commentSep = '';
     let hasNewline = false;
-    let hasNewlineAfterProp = false;
     let reqSpace = false;
     let tab = null;
     let anchor = null;
     let tag = null;
+    let newlineAfterProp = null;
     let comma = null;
     let found = null;
 …
                 hasNewline = true;
                 if (anchor || tag)
                     hasNewlineAfterProp = true;
+                    newlineAfterProp = token;
                 hasSpace = true;
                 break;
 …
         comment,
         hasNewline,
-        hasNewlineAfterProp,
         anchor,
         tag,
+        newlineAfterProp,
         end,
         start: start ?? end
 …
                 continue;
+            }
             if (keyProps.hasNewlineAfterProp || containsNewline(key)) {
+            if (keyProps.newlineAfterProp || containsNewline(key)) {
                 onError(key ?? start[start.length - 1], 'MULTILINE_IMPLICIT_KEY', 'Implicit keys need to be on a single line');
+            }
 …
     return coll;
+}
+function composeCollection(CN, ctx, token, tagToken, onError) {
+function composeCollection(CN, ctx, token, props, onError) {
+    const tagToken = props.tag;
     const tagName = !tagToken
         ? null
         : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    if (token.type === 'block-seq') {
+        const { anchor, newlineAfterProp: nl } = props;
+        const lastProp = anchor && tagToken
+            ? anchor.offset > tagToken.offset
+                ? anchor
+                : tagToken
+            : (anchor ?? tagToken);
+        if (lastProp && (!nl || nl.offset < lastProp.offset)) {
+            const message = 'Missing newline after block sequence props';
+            onError(lastProp, 'MISSING_CHAR', message);
+        }
+    }
     const expType = token.type === 'block-map'
         ? 'map'
 …
         tagName === '!' ||
         (tagName === YAMLMap.tagName && expType === 'map') ||
+        (tagName === YAMLSeq.tagName && expType === 'seq') ||
+        !expType) {
+        (tagName === YAMLSeq.tagName && expType === 'seq')) {
         return resolveCollection(CN, ctx, token, onError, tagName);
+    }
 …
         case 'block-seq':
         case 'flow-collection':
             node = composeCollection(CN, ctx, token, tag, onError);
+            node = composeCollection(CN, ctx, token, props, onError);
             if (anchor)
                 node.anchor = anchor.source.substring(1);
 …
                 return this.setNext('line-start');
             const s = this.peek(3);
             if (s === '---' && isEmpty(this.charAt(3))) {
+            if ((s === '---' || s === '...') && isEmpty(this.charAt(3))) {
                 yield* this.pushCount(3);
                 this.indentValue = 0;
                 this.indentNext = 0;
+                return 'doc';
+            }
+            else if (s === '...' && isEmpty(this.charAt(3))) {
+                yield* this.pushCount(3);
+                return 'stream';
+                return s === '---' ? 'doc' : 'stream';
+            }
+        }
 …
                 break loop;
+        }
+    }
-    while (prev[++i]?.type === 'space') {
-        /* loop */
+    }
     return prev.splice(i, prev.length);
 …
+}
 const htmlProxyRE$1 = /\?html-proxy=?(?:&inline-css)?(?:&style-attr)?&index=(\d+)\.(js|css)$/;
+const htmlProxyRE$1 = /\?html-proxy=?(?:&inline-css)?(?:&style-attr)?&index=(\d+)\.(?:js|css)$/;
 const isHtmlProxyRE = /\?html-proxy\b/;
 const inlineCSSRE$1 = /__VITE_INLINE_CSS__([a-z\d]{8}_\d+)__/g;
 …
     },
     load(id) {
       const proxyMatch = id.match(htmlProxyRE$1);
+      const proxyMatch = htmlProxyRE$1.exec(id);
       if (proxyMatch) {
         const index = Number(proxyMatch[1]);
 …
+}
 function traverseNodes(node, visitor) {
+  if (node.nodeName === "template") {
+    node = node.content;
+  }
   visitor(node);
   if (nodeIsElement(node) || node.nodeName === "#document" || node.nodeName === "#document-fragment") {
 …
     sourceCodeLocation.endOffset
   );
   const valueStart = srcString.match(attrValueStartRE);
+  const valueStart = attrValueStartRE.exec(srcString);
   if (!valueStart) {
     throw new Error(
 …
       if (id.endsWith(".html")) {
         id = normalizePath$3(id);
         const relativeUrlPath = path$n.posix.relative(config.root, id);
+        const relativeUrlPath = normalizePath$3(path$n.relative(config.root, id));
         const publicPath = `/${relativeUrlPath}`;
         const publicBase = getBaseInHTML(relativeUrlPath, config);
 …
       };
       for (const [normalizedId, html] of processedHtml) {
+        const relativeUrlPath = path$n.posix.relative(config.root, normalizedId);
+        const relativeUrlPath = normalizePath$3(
+          path$n.relative(config.root, normalizedId)
+        );
         const assetsBase = getBaseInHTML(relativeUrlPath, config);
         const toOutputFilePath = (filename, type) => {
 …
         this.emitFile({
           type: "asset",
+          originalFileName: normalizedId,
           fileName: shortEmitName,
           source: result
 …
   return html;
+}
 const importRE = /\bimport\s*("[^"]*[^\\]"|'[^']*[^\\]');*/g;
+const importRE = /\bimport\s*(?:"[^"]*[^\\]"|'[^']*[^\\]');*/g;
 const commentRE$1 = /\/\*[\s\S]*?\*\/|\/\/.*$/gm;
 function isEntirelyImport(code) {
 …
 const functionCallRE = /^[A-Z_][\w-]*\(/i;
 const transformOnlyRE = /[?&]transform-only\b/;
 const nonEscapedDoubleQuoteRe = /(?<!\\)(")/g;
+const nonEscapedDoubleQuoteRe = /(?<!\\)"/g;
 const cssBundleName = "style.css";
 const isCSSRequest = (request) => CSS_LANGS_RE.test(request);
 …
       return path$n.dirname(
         assetFileNames({
+          type: "asset",
           name: cssAssetName,
           type: "asset",
+          originalFileName: null,
           source: "/* vite internal call, ignore */"
         })
 …
         const cssAssetDirname = encodedPublicUrls || relative ? slash$1(getCssAssetDirname(cssAssetName)) : void 0;
         const toRelative = (filename) => {
+          const relativePath = path$n.posix.relative(cssAssetDirname, filename);
+          const relativePath = normalizePath$3(
+            path$n.relative(cssAssetDirname, filename)
+          );
           return relativePath[0] === "." ? relativePath : "./" + relativePath;
         };
 …
         });
         if (encodedPublicUrls) {
+          const relativePathToPublicFromCSS = path$n.posix.relative(
+            cssAssetDirname,
+            ""
+          const relativePathToPublicFromCSS = normalizePath$3(
+            path$n.relative(cssAssetDirname, "")
           );
           chunkCSS2 = chunkCSS2.replace(publicAssetUrlRE, (_, hash) => {
 …
           const [full, idHex] = match;
           const id = Buffer.from(idHex, "hex").toString();
           const originalFilename = cleanUrl(id);
+          const originalFileName = cleanUrl(id);
           const cssAssetName = ensureFileExt(
             path$n.basename(originalFilename),
+            path$n.basename(originalFileName),
             ".css"
           );
 …
           urlEmitTasks.push({
             cssAssetName,
             originalFilename,
+            originalFileName,
             content: cssContent,
             start: match.index,
 …
         for (const {
           cssAssetName,
           originalFilename,
+          originalFileName,
           content,
           start,
 …
         } of urlEmitTasks) {
           const referenceId = this.emitFile({
+            type: "asset",
             name: cssAssetName,
             type: "asset",
+            originalFileName,
             source: content
           });
           generatedAssets.get(config).set(referenceId, { originalName: originalFilename });
+          generatedAssets.get(config).set(referenceId, { originalFileName });
           const filename = this.getFileName(referenceId);
           chunk.viteMetadata.importedAssets.add(cleanUrl(filename));
 …
             const cssFullAssetName = ensureFileExt(chunk.name, ".css");
             const cssAssetName = chunk.isEntry && (!chunk.facadeModuleId || !isCSSRequest(chunk.facadeModuleId)) ? path$n.basename(cssFullAssetName) : cssFullAssetName;
             const originalFilename = getChunkOriginalFileName(
+            const originalFileName = getChunkOriginalFileName(
               chunk,
               config.root,
 …
             });
             const referenceId = this.emitFile({
+              type: "asset",
               name: cssAssetName,
               type: "asset",
+              originalFileName,
               source: chunkCSS
             });
             generatedAssets.get(config).set(referenceId, { originalName: originalFilename, isEntry });
+            generatedAssets.get(config).set(referenceId, { originalFileName, isEntry });
             chunk.viteMetadata.importedCss.add(this.getFileName(referenceId));
           } else if (!config.build.ssr) {
 …
         });
+      }
+      const cssAssets = Object.values(bundle).filter(
+        (asset) => asset.type === "asset" && asset.fileName.endsWith(".css")
+      );
+      for (const cssAsset of cssAssets) {
+        if (typeof cssAsset.source === "string") {
+          cssAsset.source = cssAsset.source.replace(viteHashUpdateMarkerRE, "");
+        }
+      }
+    }
   };
 …
         if (pluginImports) {
           const depModules = /* @__PURE__ */ new Set();
-          const devBase = config.base;
           for (const file of pluginImports) {
             depModules.add(
               isCSSRequest(file) ? moduleGraph.createFileOnlyEntry(file) : await moduleGraph.ensureEntryFromUrl(
+                stripBase(
+                  await fileToUrl$1(file, config, this),
+                  (config.server?.origin ?? "") + devBase
+                fileToDevUrl(
+                  file,
+                  config,
+                  /* skipBase */
+                  true
                 ),
                 ssr
 …
     },
     get sass() {
+      return sassResolve || (sassResolve = config.createResolver({
+        extensions: [".scss", ".sass", ".css"],
+        mainFields: ["sass", "style"],
+        conditions: ["sass", "style"],
+        tryIndex: true,
+        tryPrefix: "_",
+        preferRelative: true
+      }));
+      if (!sassResolve) {
+        const resolver = config.createResolver({
+          extensions: [".scss", ".sass", ".css"],
+          mainFields: ["sass", "style"],
+          conditions: ["sass", "style"],
+          tryIndex: true,
+          tryPrefix: "_",
+          preferRelative: true
+        });
+        sassResolve = async (...args) => {
+          if (args[0].startsWith("file://")) {
+            args[0] = fileURLToPath(args[0]);
+          }
+          return resolver(...args);
+        };
+      }
+      return sassResolve;
     },
     get less() {
 …
   const needInlineImport = code.includes("@import");
   const hasUrl = cssUrlRE.test(code) || cssImageSetRE.test(code);
   const lang = id.match(CSS_LANGS_RE)?.[1];
+  const lang = CSS_LANGS_RE.exec(id)?.[1];
   const postcssConfig = await resolvePostcssConfig(config);
   if (lang === "css" && !postcssConfig && !isModule && !needInlineImport && !hasUrl) {
 …
         async load(id2) {
           const code2 = await fs__default.promises.readFile(id2, "utf-8");
           const lang2 = id2.match(CSS_LANGS_RE)?.[1];
+          const lang2 = CSS_LANGS_RE.exec(id2)?.[1];
           if (isPreProcessor(lang2)) {
             const result = await compileCSSPreprocessors(
 …
   };
+}
 const importPostcssImport = createCachedImport(() => import('./dep-VqAwxVIc.js').then(function (n) { return n.i; }));
 const importPostcssModules = createCachedImport(() => import('./dep-CjZz522d.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-C6EFp3uH.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-Ba1kN6Mp.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 const preprocessorWorkerControllerCache = /* @__PURE__ */ new WeakMap();
 …
   ]) : map1;
+}
+const viteHashUpdateMarker = "/*$vite$:1*/";
+const viteHashUpdateMarkerRE = /\/\*\$vite\$:\d+\*\//;
 async function finalizeCss(css, minify, config) {
   if (css.includes("@import") || css.includes("@charset")) {
 …
     css = await minifyCSS(css, config, false);
+  }
+  css += viteHashUpdateMarker;
   return css;
+}
 …
+  }
+}
+function loadSassPackage(root) {
+  try {
+    const path2 = loadPreprocessorPath("sass-embedded", root);
+    return { name: "sass-embedded", path: path2 };
+  } catch (e1) {
+    try {
+      const path2 = loadPreprocessorPath("sass" /* sass */, root);
+      return { name: "sass", path: path2 };
+    } catch (e2) {
+      throw e1;
+    }
+  }
+}
 let cachedSss;
 function loadSss(root) {
 …
   return data;
+}
 const makeScssWorker = (resolvers, alias, maxWorkers) => {
+const makeScssWorker = (resolvers, alias, maxWorkers, packageName) => {
   const internalImporter = async (url, importer, filename) => {
     importer = cleanScssBugUrl(importer);
 …
           resolvers.sass
         );
+        if (packageName === "sass-embedded") {
+          return data;
+        }
         return fixScssBugImportValue(data);
       } catch (data) {
 …
   return worker;
 };
+const makeModernScssWorker = (resolvers, alias, maxWorkers) => {
+  const internalCanonicalize = async (url, importer) => {
+    importer = cleanScssBugUrl(importer);
+    const resolved = await resolvers.sass(url, importer);
+    return resolved ?? null;
+  };
+  const internalLoad = async (file, rootFile) => {
+    const result = await rebaseUrls(file, rootFile, alias, "$", resolvers.sass);
+    if (result.contents) {
+      return result.contents;
+    }
+    return await fsp.readFile(result.file, "utf-8");
+  };
+  const worker = new WorkerWithFallback(
+    () => async (sassPath, data, options) => {
+      const sass = require(sassPath);
+      const path2 = require("node:path");
+      const { fileURLToPath: fileURLToPath2, pathToFileURL: pathToFileURL2 } = (
+        // eslint-disable-next-line no-restricted-globals
+        require("node:url")
+      );
+      const sassOptions = { ...options };
+      sassOptions.url = pathToFileURL2(options.filename);
+      sassOptions.sourceMap = options.enableSourcemap;
+      const internalImporter = {
+        async canonicalize(url, context) {
+          const importer = context.containingUrl ? fileURLToPath2(context.containingUrl) : options.filename;
+          const resolved = await internalCanonicalize(url, importer);
+          return resolved ? pathToFileURL2(resolved) : null;
+        },
+        async load(canonicalUrl) {
+          const ext = path2.extname(canonicalUrl.pathname);
+          let syntax = "scss";
+          if (ext === ".sass") {
+            syntax = "indented";
+          } else if (ext === ".css") {
+            syntax = "css";
+          }
+          const contents = await internalLoad(
+            fileURLToPath2(canonicalUrl),
+            options.filename
+          );
+          return { contents, syntax, sourceMapUrl: canonicalUrl };
+        }
+      };
+      sassOptions.importers = [
+        ...sassOptions.importers ?? [],
+        internalImporter
+      ];
+      const result = await sass.compileStringAsync(data, sassOptions);
+      return {
+        css: result.css,
+        map: result.sourceMap ? JSON.stringify(result.sourceMap) : void 0,
+        stats: {
+          includedFiles: result.loadedUrls.filter((url) => url.protocol === "file:").map((url) => fileURLToPath2(url))
+        }
+      };
+    },
+    {
+      parentFunctions: {
+        internalCanonicalize,
+        internalLoad
+      },
+      shouldUseFake(_sassPath, _data, options) {
+        return !!(options.functions && Object.keys(options.functions).length > 0 || options.importers && (!Array.isArray(options.importers) || options.importers.length > 0));
+      },
+      max: maxWorkers
+    }
+  );
+  return worker;
+};
+const makeModernCompilerScssWorker = (resolvers, alias, _maxWorkers) => {
+  let compilerPromise;
+  const worker = {
+    async run(sassPath, data, options) {
+      const sass = (await import(pathToFileURL(sassPath).href)).default;
+      compilerPromise ??= sass.initAsyncCompiler();
+      const compiler = await compilerPromise;
+      const sassOptions = { ...options };
+      sassOptions.url = pathToFileURL(options.filename);
+      sassOptions.sourceMap = options.enableSourcemap;
+      const internalImporter = {
+        async canonicalize(url, context) {
+          const importer = context.containingUrl ? fileURLToPath(context.containingUrl) : options.filename;
+          const resolved = await resolvers.sass(url, cleanScssBugUrl(importer));
+          return resolved ? pathToFileURL(resolved) : null;
+        },
+        async load(canonicalUrl) {
+          const ext = path$n.extname(canonicalUrl.pathname);
+          let syntax = "scss";
+          if (ext === ".sass") {
+            syntax = "indented";
+          } else if (ext === ".css") {
+            syntax = "css";
+          }
+          const result2 = await rebaseUrls(
+            fileURLToPath(canonicalUrl),
+            options.filename,
+            alias,
+            "$",
+            resolvers.sass
+          );
+          const contents = result2.contents ?? await fsp.readFile(result2.file, "utf-8");
+          return { contents, syntax, sourceMapUrl: canonicalUrl };
+        }
+      };
+      sassOptions.importers = [
+        ...sassOptions.importers ?? [],
+        internalImporter
+      ];
+      const result = await compiler.compileStringAsync(data, sassOptions);
+      return {
+        css: result.css,
+        map: result.sourceMap ? JSON.stringify(result.sourceMap) : void 0,
+        stats: {
+          includedFiles: result.loadedUrls.filter((url) => url.protocol === "file:").map((url) => fileURLToPath(url))
+        }
+      };
+    },
+    async stop() {
+      (await compilerPromise)?.dispose();
+      compilerPromise = void 0;
+    }
+  };
+  return worker;
+};
 const scssProcessor = (maxWorkers) => {
   const workerMap = /* @__PURE__ */ new Map();
 …
     },
     async process(source, root, options, resolvers) {
+      const sassPath = loadPreprocessorPath("sass" /* sass */, root);
+      const sassPackage = loadSassPackage(root);
+      const api = options.api ?? "legacy";
       if (!workerMap.has(options.alias)) {
         workerMap.set(
           options.alias,
+          makeScssWorker(resolvers, options.alias, maxWorkers)
+          api === "modern-compiler" ? makeModernCompilerScssWorker(resolvers, options.alias) : api === "modern" ? makeModernScssWorker(resolvers, options.alias, maxWorkers) : makeScssWorker(
+            resolvers,
+            options.alias,
+            maxWorkers,
+            sassPackage.name
+          )
         );
+      }
 …
       try {
         const result = await worker.run(
           sassPath,
+          sassPackage.path,
           data,
           optionsWithoutAdditionalData
 …
         const deps = result.stats.includedFiles.map((f) => cleanScssBugUrl(f));
         const map2 = result.map ? JSON.parse(result.map.toString()) : void 0;
+        if (map2) {
+          map2.sources = map2.sources.map(
+            (url) => url.startsWith("file://") ? normalizePath$3(fileURLToPath(url)) : url
+          );
+        }
         return {
           code: result.css.toString(),
 …
       source,
       root,
       { ...options, indentedSyntax: true },
+      { ...options, indentedSyntax: true, syntax: "indented" },
       resolvers
     );
 …
         deps.add(dep.url);
         if (urlReplacer) {
+          const replaceUrl = await urlReplacer(dep.url, id);
+          const replaceUrl = await urlReplacer(
+            dep.url,
+            toAbsolute(dep.loc.filePath)
+          );
           css = css.replace(dep.placeholder, () => replaceUrl);
         } else {
 …
   const targets = {};
   const entriesWithoutES = arraify(esbuildTarget).flatMap((e) => {
     const match = e.match(esRE);
+    const match = esRE.exec(e);
     if (!match) return e;
     const year = Number(match[1]);
 …
   emacs: 'emacs',
   gvim: 'gvim',
+  idea: 'idea',
   'idea.sh': 'idea',
+  phpstorm: 'phpstorm',
   'phpstorm.sh': 'phpstorm',
+  pycharm: 'pycharm',
   'pycharm.sh': 'pycharm',
+  rubymine: 'rubymine',
   'rubymine.sh': 'rubymine',
   sublime_text: 'subl',
   vim: 'vim',
+  webstorm: 'webstorm',
   'webstorm.sh': 'webstorm',
+  goland: 'goland',
   'goland.sh': 'goland',
+  rider: 'rider',
   'rider.sh': 'rider'
 };
 …
+  }
-  // cmd.exe on Windows is vulnerable to RCE attacks given a file name of the
-  // form "C:\Users\myusername\Downloads\& curl 172.21.93.52". Use a safe file
-  // name pattern to validate user-provided file names. This doesn't cover the
-  // entire range of valid file names but should cover almost all of them in practice.
-  // (Backport of
-  // https://github.com/facebook/create-react-app/pull/4866
-  // and
-  // https://github.com/facebook/create-react-app/pull/5431)
-  // Allows alphanumeric characters, periods, dashes, slashes, and underscores.
-  const WINDOWS_CMD_SAFE_FILE_NAME_PATTERN = /^([A-Za-z]:[/\\])?[\p{L}0-9/.\-_\\]+$/u;
-  if (
-    process.platform === 'win32' &&
-    !WINDOWS_CMD_SAFE_FILE_NAME_PATTERN.test(fileName.trim())
-  ) {
-    console.log();
-    console.log(
-      colors.red('Could not open ' + path$5.basename(fileName) + ' in the editor.')
-    );
-    console.log();
-    console.log(
-      'When running on Windows, file names are checked against a safe file name ' +
-        'pattern to protect against remote code execution attacks. File names ' +
-        'may consist only of alphanumeric characters (all languages), periods, ' +
-        'dashes, slashes, and underscores.'
-    );
-    console.log();
-    return
+  }
   if (lineNumber) {
     const extraArgs = getArgumentsForPosition(editor, fileName, lineNumber, columnNumber);
 …
   if (process.platform === 'win32') {
+    // On Windows, launch the editor in a shell because spawn can only
+    // launch .exe files.
+    _childProcess = childProcess$1.spawn(
+      'cmd.exe',
+      ['/C', editor].concat(args),
+      { stdio: 'inherit' }
+    );
+    // On Windows, we need to use `exec` with the `shell: true` option,
+    // and some more sanitization is required.
+    // However, CMD.exe on Windows is vulnerable to RCE attacks given a file name of the
+    // form "C:\Users\myusername\Downloads\& curl 172.21.93.52".
+    // `create-react-app` used a safe file name pattern to validate user-provided file names:
+    // - https://github.com/facebook/create-react-app/pull/4866
+    // - https://github.com/facebook/create-react-app/pull/5431
+    // But that's not a viable solution for this package because
+    // it's depended on by so many meta frameworks that heavily rely on
+    // special characters in file names for filesystem-based routing.
+    // We need to at least:
+    // - Support `+` because it's used in SvelteKit and Vike
+    // - Support `$` because it's used in Remix
+    // - Support `(` and `)` because they are used in Analog, SolidStart, and Vike
+    // - Support `@` because it's used in Vike
+    // - Support `[` and `]` because they are widely used for [slug]
+    // So here we choose to use `^` to escape special characters instead.
+    // According to https://ss64.com/nt/syntax-esc.html,
+    // we can use `^` to escape `&`, `<`, `>`, `|`, `%`, and `^`
+    // I'm not sure if we have to escape all of these, but let's do it anyway
+    function escapeCmdArgs (cmdArgs) {
+      return cmdArgs.replace(/([&|<>,;=^])/g, '^$1')
+    }
+    // Need to double quote the editor path in case it contains spaces;
+    // If the fileName contains spaces, we also need to double quote it in the arguments
+    // However, there's a case that it's concatenated with line number and column number
+    // which is separated by `:`. We need to double quote the whole string in this case.
+    // Also, if the string contains the escape character `^`, it needs to be quoted, too.
+    function doubleQuoteIfNeeded(str) {
+      if (str.includes('^')) {
+        // If a string includes an escaped character, not only does it need to be quoted,
+        // but the quotes need to be escaped too.
+        return `^"${str}^"`
+      } else if (str.includes(' ')) {
+        return `"${str}"`
+      }
+      return str
+    }
+    const launchCommand = [editor, ...args.map(escapeCmdArgs)]
+      .map(doubleQuoteIfNeeded)
+      .join(' ');
+    _childProcess = childProcess$1.exec(launchCommand, {
+      stdio: 'inherit',
+      shell: true
+    });
   } else {
     _childProcess = childProcess$1.spawn(editor, args, { stdio: 'inherit' });
 …
       logger.warn(
         colors$1.yellow(
           "Server responded with status code 431. See https://vitejs.dev/guide/troubleshooting.html#_431-request-header-fields-too-large."
+          "Server responded with status code 431. See https://vite.dev/guide/troubleshooting.html#_431-request-header-fields-too-large."
+        )
       );
 …
   let fsUtils = cachedFsUtilsMap.get(config);
   if (!fsUtils) {
     if (config.command !== "serve" || config.server.fs.cachedChecks === false || config.server.watch?.ignored || process.versions.pnp) {
+    if (config.command !== "serve" || config.server.fs.cachedChecks !== true || config.server.watch?.ignored || process.versions.pnp) {
       fsUtils = commonFsUtils;
     } else if (!config.resolve.preserveSymlinks && config.root !== getRealPath(config.root)) {
 …
             } else if (isProduction) {
               this.warn(
                 `Module "${id}" has been externalized for browser compatibility, imported by "${importer}". See https://vitejs.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`
+                `Module "${id}" has been externalized for browser compatibility, imported by "${importer}". See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`
               );
+            }
 …
           return `export default new Proxy({}, {
   get(_, key) {
     throw new Error(\`Module "${id}" has been externalized for browser compatibility. Cannot access "${id}.\${key}" in client code.  See https://vitejs.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.\`)
+    throw new Error(\`Module "${id}" has been externalized for browser compatibility. Cannot access "${id}.\${key}" in client code.  See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.\`)
+  }
 })`;
 …
 function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = false, externalize, allowLinkedExternal = true) {
   const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
   const deepMatch = id.match(deepImportRE);
+  const deepMatch = deepImportRE.exec(id);
   const pkgId = deepMatch ? deepMatch[1] || deepMatch[2] : cleanUrl(id);
   let basedir;
 …
       key !== 'splice'
     ) {
       console.warn(\`Module "${path2}" has been externalized for browser compatibility. Cannot access "${path2}.\${key}" in client code. See https://vitejs.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.\`)
+      console.warn(\`Module "${path2}" has been externalized for browser compatibility. Cannot access "${path2}.\${key}" in client code. See https://vite.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.\`)
+    }
+  }
 …
         const metadata = depsOptimizer.metadata;
         const file = cleanUrl(id);
         const versionMatch = id.match(DEP_VERSION_RE);
+        const versionMatch = DEP_VERSION_RE.exec(file);
         const browserHash = versionMatch ? versionMatch[1].split("=")[1] : void 0;
         const info = optimizedDepInfoFromFile(metadata, file);
 …
 const nonJsRe = /\.json(?:$|\?)/;
 const isNonJsRequest = (request) => nonJsRe.test(request);
+const importMetaEnvMarker = "__vite_import_meta_env__";
+const importMetaEnvKeyReCache = /* @__PURE__ */ new Map();
 function definePlugin(config) {
   const isBuild = config.command === "build";
 …
+    }
     if ("import.meta.env" in define) {
+      define["import.meta.env"] = serializeDefine({
+        ...importMetaEnvKeys,
+        SSR: ssr + "",
+        ...userDefineEnv
+      });
+    }
+      define["import.meta.env"] = importMetaEnvMarker;
+    }
+    const importMetaEnvVal = serializeDefine({
+      ...importMetaEnvKeys,
+      SSR: ssr + "",
+      ...userDefineEnv
+    });
     const patternKeys = Object.keys(userDefine);
     if (replaceProcessEnv && Object.keys(processEnv).length) {
 …
+    }
     const pattern = patternKeys.length ? new RegExp(patternKeys.map(escapeRegex).join("|")) : null;
     return [define, pattern];
+    return [define, pattern, importMetaEnvVal];
+  }
   const defaultPattern = generatePattern(false);
 …
         return;
+      }
       const [define, pattern] = ssr ? ssrPattern : defaultPattern;
+      let [define, pattern, importMetaEnvVal] = ssr ? ssrPattern : defaultPattern;
       if (!pattern) return;
       pattern.lastIndex = 0;
       if (!pattern.test(code)) return;
+      return await replaceDefine(code, id, define, config);
+      const hasDefineImportMetaEnv = "import.meta.env" in define;
+      let marker = importMetaEnvMarker;
+      if (hasDefineImportMetaEnv && code.includes(marker)) {
+        let i = 1;
+        do {
+          marker = importMetaEnvMarker + i++;
+        } while (code.includes(marker));
+        if (marker !== importMetaEnvMarker) {
+          define = { ...define, "import.meta.env": marker };
+        }
+      }
+      const result = await replaceDefine(code, id, define, config);
+      if (hasDefineImportMetaEnv) {
+        result.code = result.code.replaceAll(
+          getImportMetaEnvKeyRe(marker),
+          (m) => "undefined".padEnd(m.length)
+        );
+        if (result.code.includes(marker)) {
+          result.code = `const ${marker} = ${importMetaEnvVal};
+` + result.code;
+          if (result.map) {
+            const map = JSON.parse(result.map);
+            map.mappings = ";" + map.mappings;
+            result.map = map;
+          }
+        }
+      }
+      return result;
+    }
   };
+}
 async function replaceDefine(code, id, define, config) {
-  const replacementMarkers = {};
-  const env = define["import.meta.env"];
-  if (env && !canJsonParse(env)) {
-    const marker = `_${getHash(env, env.length - 2)}_`;
-    replacementMarkers[marker] = env;
-    define = { ...define, "import.meta.env": marker };
+  }
   const esbuildOptions = config.esbuild || {};
   const result = await transform$1(code, {
 …
+    }
+  }
-  for (const marker in replacementMarkers) {
-    result.code = result.code.replaceAll(marker, replacementMarkers[marker]);
+  }
   return {
     code: result.code,
 …
   return JSON.stringify(value);
+}
 function canJsonParse(value) {
   try {
     JSON.parse(value);
     return true;
   } catch {
     return false;
+  }
+function getImportMetaEnvKeyRe(marker) {
+  let re = importMetaEnvKeyReCache.get(marker);
+  if (!re) {
+    re = new RegExp(`${marker}\\..+?\\b`, "g");
+    importMetaEnvKeyReCache.set(marker, re);
+  }
+  return re;
+}
 …
+      }
       throw new Error(
         '"ESM integration proposal for Wasm" is not supported currently. Use vite-plugin-wasm or other community plugins to handle this. Alternatively, you can use `.wasm?init` or `.wasm?url`. See https://vitejs.dev/guide/features.html#webassembly for more details.'
+        '"ESM integration proposal for Wasm" is not supported currently. Use vite-plugin-wasm or other community plugins to handle this. Alternatively, you can use `.wasm?init` or `.wasm?url`. See https://vite.dev/guide/features.html#webassembly for more details.'
       );
+    }
 …
         saveEmitWorkerAsset(config, {
           fileName: outputChunk2.fileName,
+          originalFileName: null,
           source: outputChunk2.code
         });
 …
       saveEmitWorkerAsset(config, {
         fileName: mapFileName,
+        originalFileName: null,
         source: data
       });
 …
     saveEmitWorkerAsset(config, {
       fileName,
+      originalFileName: null,
       source: outputChunk.code
     });
 …
         if (injectEnv) {
           const s = new MagicString(raw);
           s.prepend(injectEnv);
+          s.prepend(injectEnv + ";\n");
           return {
             code: s.toString(),
 …
       let urlCode;
       if (isBuild) {
         if (isWorker && this.getModuleInfo(cleanUrl(id))?.isEntry) {
+        if (isWorker && config.bundleChain.at(-1) === cleanUrl(id)) {
           urlCode = "self.location.href";
         } else if (inlineRE.test(id)) {
 …
           type: "asset",
           fileName: asset.fileName,
+          originalFileName: asset.originalFileName,
           source: asset.source
         });
 …
             file ??= url[0] === "/" ? slash$1(path$n.join(config.publicDir, url)) : slash$1(path$n.resolve(path$n.dirname(id), url));
+          }
           if (isBuild && config.isWorker && this.getModuleInfo(cleanUrl(file))?.isEntry) {
+          if (isBuild && config.isWorker && config.bundleChain.at(-1) === cleanUrl(file)) {
             s.update(expStart, expEnd, "self.location.href");
           } else {
 …
+}
 function cleanStack(stack) {
   return stack.split(/\n/g).filter((l) => /^\s*at/.test(l)).join("\n");
+  return stack.split(/\n/).filter((l) => /^\s*at/.test(l)).join("\n");
+}
 function logError(server, err) {
 …
 const typeRE = /\btype\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
 const langRE = /\blang\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
+const contextRE = /\bcontext\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
+const svelteScriptModuleRE = /\bcontext\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
+const svelteModuleRE = /\smodule\b/i;
 function esbuildScanPlugin(config, container, depImports, missing, entries) {
   const seen = /* @__PURE__ */ new Map();
 …
         const matches = raw.matchAll(scriptRE);
         for (const [, openTag, content] of matches) {
           const typeMatch = openTag.match(typeRE);
+          const typeMatch = typeRE.exec(openTag);
           const type = typeMatch && (typeMatch[1] || typeMatch[2] || typeMatch[3]);
           const langMatch = openTag.match(langRE);
+          const langMatch = langRE.exec(openTag);
           const lang = langMatch && (langMatch[1] || langMatch[2] || langMatch[3]);
           if (isHtml && type !== "module") {
 …
             loader = "ts";
+          }
           const srcMatch = openTag.match(srcRE);
+          const srcMatch = srcRE.exec(openTag);
           if (srcMatch) {
             const src = srcMatch[1] || srcMatch[2] || srcMatch[3];
 …
+            }
             const virtualModulePath = JSON.stringify(virtualModulePrefix + key);
+            const contextMatch = openTag.match(contextRE);
+            const context = contextMatch && (contextMatch[1] || contextMatch[2] || contextMatch[3]);
+            if (p.endsWith(".svelte") && context !== "module") {
+              js += `import ${virtualModulePath}
+            let addedImport = false;
+            if (p.endsWith(".svelte")) {
+              let isModule = svelteModuleRE.test(openTag);
+              if (!isModule) {
+                const contextMatch = svelteScriptModuleRE.exec(openTag);
+                const context = contextMatch && (contextMatch[1] || contextMatch[2] || contextMatch[3]);
+                isModule = context === "module";
+              }
+              if (!isModule) {
+                addedImport = true;
+                js += `import ${virtualModulePath}
 `;
+            } else {
+              }
+            }
+            if (!addedImport) {
               js += `export * from ${virtualModulePath}
 `;
 …
                 filePath = "./" + filePath;
+              }
               const matched2 = slash$1(filePath).match(exportsValueGlobRe);
+              const matched2 = exportsValueGlobRe.exec(slash$1(filePath));
               if (matched2) {
                 let allGlobSame = matched2.length === 2;
 …
   const logNewlyDiscoveredDeps = () => {
     if (newDepsToLog.length) {
       config.logger.info(
+      logger.info(
         colors$1.green(
           `\u2728 new dependencies optimized: ${depsLogString(newDepsToLog)}`
 …
   const logDiscoveredDepsWhileScanning = () => {
     if (discoveredDepsWhileScanning.length) {
       config.logger.info(
+      logger.info(
         colors$1.green(
           `\u2728 discovered while scanning: ${depsLogString(
 …
             if (warnAboutMissedDependencies) {
               logDiscoveredDepsWhileScanning();
               config.logger.info(
+              logger.info(
                 colors$1.magenta(
                   `\u2757 add these dependencies to optimizeDeps.include to speed up cold start`
 …
             if (warnAboutMissedDependencies) {
               logDiscoveredDepsWhileScanning();
               config.logger.info(
+              logger.info(
                 colors$1.magenta(
                   `\u2757 add these dependencies to optimizeDeps.include to avoid a full page reload during cold start`
 …
           );
           if (needsInteropMismatch.length > 0) {
             config.logger.warn(
+            logger.warn(
               `Mixed ESM and CJS detected in ${colors$1.yellow(
                 needsInteropMismatch.join(", ")
 …
   };
   return function viteServePublicMiddleware(req, res, next) {
+    if (publicFiles && !publicFiles.has(toFilePath(req.url)) || isImportRequest(req.url) || isInternalRequest(req.url)) {
+    if (publicFiles && !publicFiles.has(toFilePath(req.url)) || isImportRequest(req.url) || isInternalRequest(req.url) || // for `/public-file.js?url` to be transformed
+    urlRE.test(req.url)) {
       return next();
+    }
 …
 ${server.config.server.fs.allow.map((i) => `- ${i}`).join("\n")}
 Refer to docs https://vitejs.dev/config/server-options.html#server-fs-allow for configurations and more details.`;
+Refer to docs https://vite.dev/config/server-options.html#server-fs-allow for configurations and more details.`;
     server.config.logger.error(urlMessage);
     server.config.logger.warnOnce(hintMessage + "\n");
 …
   const idToImportMap = /* @__PURE__ */ new Map();
   const declaredConst = /* @__PURE__ */ new Set();
   const hoistIndex = code.match(hashbangRE)?.[0].length ?? 0;
+  const hoistIndex = hashbangRE.exec(code)?.[0].length ?? 0;
   function defineImport(index, source, metadata) {
     deps.add(source);
 …
     );
+  }
+  const imports = [];
+  const exports = [];
   for (const node of ast.body) {
     if (node.type === "ImportDeclaration") {
+      const importId = defineImport(hoistIndex, node.source.value, {
+        importedNames: node.specifiers.map((s2) => {
+          if (s2.type === "ImportSpecifier")
+            return s2.imported.type === "Identifier" ? s2.imported.name : (
+              // @ts-expect-error TODO: Estree types don't consider arbitrary module namespace specifiers yet
+              s2.imported.value
+            );
+          else if (s2.type === "ImportDefaultSpecifier") return "default";
+        }).filter(isDefined)
+      });
+      s.remove(node.start, node.end);
+      for (const spec of node.specifiers) {
+        if (spec.type === "ImportSpecifier") {
+          if (spec.imported.type === "Identifier") {
+            idToImportMap.set(
+              spec.local.name,
+              `${importId}.${spec.imported.name}`
+            );
+          } else {
+            idToImportMap.set(
+              spec.local.name,
+              `${importId}[${// @ts-expect-error TODO: Estree types don't consider arbitrary module namespace specifiers yet
+              JSON.stringify(spec.imported.value)}]`
+            );
+          }
+        } else if (spec.type === "ImportDefaultSpecifier") {
+          idToImportMap.set(spec.local.name, `${importId}.default`);
+      imports.push(node);
+    } else if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration") {
+      exports.push(node);
+    }
+  }
+  for (const node of imports) {
+    const importId = defineImport(hoistIndex, node.source.value, {
+      importedNames: node.specifiers.map((s2) => {
+        if (s2.type === "ImportSpecifier")
+          return s2.imported.type === "Identifier" ? s2.imported.name : (
+            // @ts-expect-error TODO: Estree types don't consider arbitrary module namespace specifiers yet
+            s2.imported.value
+          );
+        else if (s2.type === "ImportDefaultSpecifier") return "default";
+      }).filter(isDefined)
+    });
+    s.remove(node.start, node.end);
+    for (const spec of node.specifiers) {
+      if (spec.type === "ImportSpecifier") {
+        if (spec.imported.type === "Identifier") {
+          idToImportMap.set(
+            spec.local.name,
+            `${importId}.${spec.imported.name}`
+          );
         } else {
+          idToImportMap.set(spec.local.name, importId);
+        }
+      }
+    }
+  }
+  for (const node of ast.body) {
+          idToImportMap.set(
+            spec.local.name,
+            `${importId}[${// @ts-expect-error TODO: Estree types don't consider arbitrary module namespace specifiers yet
+            JSON.stringify(spec.imported.value)}]`
+          );
+        }
+      } else if (spec.type === "ImportDefaultSpecifier") {
+        idToImportMap.set(spec.local.name, `${importId}.default`);
+      } else {
+        idToImportMap.set(spec.local.name, importId);
+      }
+    }
+  }
+  for (const node of exports) {
     if (node.type === "ExportNamedDeclaration") {
       if (node.declaration) {
 …
   });
   let map = s.generateMap({ hires: "boundary" });
+  map.sources = [path$n.basename(url)];
+  map.sourcesContent = [originalCode];
   if (inMap && inMap.mappings && "sources" in inMap && inMap.sources.length > 0) {
     map = combineSourcemaps(url, [
+      {
+        ...map,
+        sources: inMap.sources,
+        sourcesContent: inMap.sourcesContent
+      },
+      map,
       inMap
     ]);
-  } else {
-    map.sources = [path$n.basename(url)];
-    map.sourcesContent = [originalCode];
+  }
   return {
 …
 const pendingModuleDependencyGraph = /* @__PURE__ */ new Map();
 const importErrors = /* @__PURE__ */ new WeakMap();
 async function ssrLoadModule(url, server, context = { global }, fixStacktrace) {
+async function ssrLoadModule(url, server, fixStacktrace) {
   url = unwrapId$1(url);
   const pending = pendingModules.get(url);
 …
     return pending;
+  }
   const modulePromise = instantiateModule(url, server, context, fixStacktrace);
+  const modulePromise = instantiateModule(url, server, fixStacktrace);
   pendingModules.set(url, modulePromise);
   modulePromise.catch(() => {
 …
   return modulePromise;
+}
 async function instantiateModule(url, server, context = { global }, fixStacktrace) {
+async function instantiateModule(url, server, fixStacktrace) {
   const { moduleGraph } = server;
   const mod = await moduleGraph.ensureEntryFromUrl(url, true);
 …
+        }
+      }
       return ssrLoadModule(dep, server, context, fixStacktrace);
+      return ssrLoadModule(dep, server, fixStacktrace);
     } catch (err) {
       importErrors.set(err, { importee: dep });
 …
   try {
     const initModule = new AsyncFunction(
-      `global`,
       ssrModuleExportsKey,
       ssrImportMetaKey,
 …
     );
     await initModule(
-      context.global,
       ssrModule,
       ssrImportMeta,
 …
     if (!normalizePath$3(outDir).startsWith(withTrailingSlash(root))) {
       logger?.warn(
         picocolorsExports.yellow(
+        colors$1.yellow(
+          `
 ${picocolorsExports.bold(`(!)`)} outDir ${picocolorsExports.white(
             picocolorsExports.dim(outDir)
+${colors$1.bold(`(!)`)} outDir ${colors$1.white(
+            colors$1.dim(outDir)
           )} is not inside project root and will not be emptied.
 Use --emptyOutDir to override.
 …
   return true;
+}
 function resolveChokidarOptions(config, options, resolvedOutDirs, emptyOutDir) {
+function resolveChokidarOptions(options, resolvedOutDirs, emptyOutDir, cacheDir) {
   const { ignored: ignoredList, ...otherOptions } = options ?? {};
   const ignored = [
 …
     "**/test-results/**",
     // Playwright
     glob.escapePath(config.cacheDir) + "/**",
+    glob.escapePath(cacheDir) + "/**",
     ...arraify(ignoredList || [])
   ];
 …
     if (ifNoneMatch) {
       const moduleByEtag = server.moduleGraph.getModuleByEtag(ifNoneMatch);
       if (moduleByEtag?.transformResult?.etag === ifNoneMatch) {
+      if (moduleByEtag?.transformResult?.etag === ifNoneMatch && moduleByEtag?.url === req.url) {
         const maybeMixedEtag = isCSSRequest(req.url);
         if (!maybeMixedEtag) {
 …
         warnAboutExplicitPublicPathInUrl(url);
+      }
+      if ((rawRE.test(url) || urlRE.test(url)) && !ensureServingAccess(url, server, res, next)) {
+        return;
+      }
       if (isJSRequest(url) || isImportRequest(url) || isCSSRequest(url) || isHTMLProxy(url)) {
         url = removeImportQuery(url);
 …
+      }
       if (preTransformUrl) {
+        preTransformRequest(server, preTransformUrl, config.base);
+        try {
+          preTransformUrl = decodeURI(preTransformUrl);
+        } catch (err) {
+          return url2;
+        }
+        preTransformRequest(server, preTransformUrl, config.decodedBase);
+      }
+    }
 …
   const { config, moduleGraph, watcher } = server;
   const base = config.base || "/";
+  const decodedBase = config.decodedBase || "/";
   let proxyModulePath;
   let proxyModuleUrl;
 …
     proxyModuleUrl = wrapId$1(proxyModulePath);
+  }
   proxyModuleUrl = joinUrlSegments(base, proxyModuleUrl);
+  proxyModuleUrl = joinUrlSegments(decodedBase, proxyModuleUrl);
   const s = new MagicString(html);
   let inlineModuleIndex = -1;
 …
       `<script type="module" src="${modulePath}"><\/script>`
     );
     preTransformRequest(server, modulePath, base);
+    preTransformRequest(server, modulePath, decodedBase);
   };
   await traverseHtml(html, filename, (node) => {
 …
   };
+}
 function preTransformRequest(server, url, base) {
+function preTransformRequest(server, decodedUrl, decodedBase) {
   if (!server.config.server.preTransformRequests) return;
+  try {
+    url = unwrapId$1(stripBase(decodeURI(url), base));
+  } catch {
+    return;
+  }
+  server.warmupRequest(url);
+  decodedUrl = unwrapId$1(stripBase(decodedUrl, decodedBase));
+  server.warmupRequest(decodedUrl);
+}
 …
     mod.importers.forEach((importer) => {
       if (!importer.acceptedHmrDeps.has(mod)) {
         const shouldSoftInvalidateImporter = importer.staticImportedUrls?.has(mod.url) || softInvalidate;
+        const shouldSoftInvalidateImporter = (importer.staticImportedUrls?.has(mod.url) || softInvalidate) && importer.type !== "css";
         this.invalidateModule(
           importer,
 …
   );
   const resolvedWatchOptions = resolveChokidarOptions(
-    config,
+    {
       disableGlobbing: true,
 …
     },
     resolvedOutDirs,
+    emptyOutDir
+    emptyOutDir,
+    config.cacheDir
   );
   const middlewares = connect$1();
 …
     },
     async ssrLoadModule(url, opts) {
       return ssrLoadModule(url, server, void 0, opts?.fixStacktrace);
+      return ssrLoadModule(url, server, opts?.fixStacktrace);
     },
     async ssrFetchModule(url, importer) {
 …
       seenIds.add(ignoredId);
       markIdAsDone(ignoredId);
+    } else {
+      checkIfCrawlEndAfterTimeout();
+    }
     return onCrawlEndPromiseWithResolvers.promise;
+  }
   function markIdAsDone(id) {
+    if (registeredIds.has(id)) {
+      registeredIds.delete(id);
+      checkIfCrawlEndAfterTimeout();
+    }
+    registeredIds.delete(id);
+    checkIfCrawlEndAfterTimeout();
+  }
   function checkIfCrawlEndAfterTimeout() {
 …
             url = injectQuery(url, "import");
           } else if ((isRelative || isSelfImport) && !DEP_VERSION_RE.test(url)) {
             const versionMatch = importer.match(DEP_VERSION_RE);
+            const versionMatch = DEP_VERSION_RE.exec(importer);
             if (versionMatch) {
               url = injectQuery(url, versionMatch[1]);
 …
+  }
   const pathname = url.replace(/[?#].*$/, "");
   const { search, hash } = new URL(url, "http://vitejs.dev");
+  const { search, hash } = new URL(url, "http://vite.dev");
   return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ""}${hash || ""}`;
+}
 …
     );
     const cspNonce = cspNonceMeta?.nonce || cspNonceMeta?.getAttribute("nonce");
     promise = Promise.all(
+    promise = Promise.allSettled(
       deps.map((dep) => {
         dep = assetsURL(dep, importerUrl);
 …
         if (!isCss) {
           link.as = "script";
           link.crossOrigin = "";
+        }
+        }
+        link.crossOrigin = "";
         link.href = dep;
         if (cspNonce) {
 …
     );
+  }
+  return promise.then(() => baseModule()).catch((err) => {
+    const e = new Event("vite:preloadError", { cancelable: true });
+  function handlePreloadError(err) {
+    const e = new Event("vite:preloadError", {
+      cancelable: true
+    });
     e.payload = err;
     window.dispatchEvent(e);
 …
       throw err;
+    }
+  }
+  return promise.then((res) => {
+    for (const item of res || []) {
+      if (item.status !== "rejected") continue;
+      handlePreloadError(item.reason);
+    }
+    return baseModule().catch(handlePreloadError);
   });
+}
 …
   const isWorker = config.isWorker;
   const insertPreload = !(ssr || !!config.build.lib || isWorker);
-  const resolveModulePreloadDependencies = config.build.modulePreload && config.build.modulePreload.resolveDependencies;
   const renderBuiltUrl = config.experimental.renderBuiltUrl;
-  const customModulePreloadPaths = !!(resolveModulePreloadDependencies || renderBuiltUrl);
   const isRelativeBase = config.base === "./" || config.base === "";
-  const optimizeModulePreloadRelativePaths = isRelativeBase && !customModulePreloadPaths;
   const { modulePreload } = config.build;
   const scriptRel2 = modulePreload && modulePreload.polyfill ? `'modulepreload'` : `(${detectScriptRel.toString()})()`;
+  const assetsURL2 = customModulePreloadPaths ? (
+    // If `experimental.renderBuiltUrl` or `build.modulePreload.resolveDependencies` are used
+    // the dependencies are already resolved. To avoid the need for `new URL(dep, import.meta.url)`
+    // a helper `__vitePreloadRelativeDep` is used to resolve from relative paths which can be minimized.
+    `function(dep, importerUrl) { return dep[0] === '.' ? new URL(dep, importerUrl).href : dep }`
+  ) : optimizeModulePreloadRelativePaths ? (
+    // If there isn't custom resolvers affecting the deps list, deps in the list are relative
+    // to the current chunk and are resolved to absolute URL by the __vitePreload helper itself.
+  const assetsURL2 = renderBuiltUrl || isRelativeBase ? (
+    // If `experimental.renderBuiltUrl` is used, the dependencies might be relative to the current chunk.
+    // If relative base is used, the dependencies are relative to the current chunk.
     // The importerUrl is passed as third parameter to __vitePreload in this case
     `function(dep, importerUrl) { return new URL(dep, importerUrl).href }`
 …
+          }
           if (match[3]) {
             let names2 = match[4].match(/\.([^.?]+)/)?.[1] || "";
+            let names2 = /\.([^.?]+)/.exec(match[4])?.[1] || "";
             if (names2 === "default") {
               names2 = "default: __vite_default__";
 …
           str().appendRight(
             expEnd,
             `,${isModernFlag}?${preloadMarker}:void 0${optimizeModulePreloadRelativePaths || customModulePreloadPaths ? ",import.meta.url" : ""})`
+            `,${isModernFlag}?${preloadMarker}:void 0${renderBuiltUrl || isRelativeBase ? ",import.meta.url" : ""})`
           );
+        }
 …
+              }
               if (markerStartPos2 > 0) {
                 const depsArray = deps.size > 1 || // main chunk is removed
+                let depsArray = deps.size > 1 || // main chunk is removed
                 hasRemovedPureCssChunk && deps.size > 0 ? modulePreload === false ? (
                   // CSS deps use the same mechanism as module preloads, so even if disabled,
 …
                   [...deps].filter((d) => d.endsWith(".css"))
                 ) : [...deps] : [];
+                const resolveDependencies = modulePreload ? modulePreload.resolveDependencies : void 0;
+                if (resolveDependencies && normalizedFile) {
+                  const cssDeps = [];
+                  const otherDeps = [];
+                  for (const dep of depsArray) {
+                    (dep.endsWith(".css") ? cssDeps : otherDeps).push(dep);
+                  }
+                  depsArray = [
+                    ...resolveDependencies(normalizedFile, otherDeps, {
+                      hostId: file,
+                      hostType: "js"
+                    }),
+                    ...cssDeps
+                  ];
+                }
                 let renderedDeps;
+                if (normalizedFile && customModulePreloadPaths) {
+                  const { modulePreload: modulePreload2 } = config.build;
+                  const resolveDependencies = modulePreload2 ? modulePreload2.resolveDependencies : void 0;
+                  let resolvedDeps;
+                  if (resolveDependencies) {
+                    const cssDeps = [];
+                    const otherDeps = [];
+                    for (const dep of depsArray) {
+                      (dep.endsWith(".css") ? cssDeps : otherDeps).push(dep);
+                    }
+                    resolvedDeps = [
+                      ...resolveDependencies(normalizedFile, otherDeps, {
+                        hostId: file,
+                        hostType: "js"
+                      }),
+                      ...cssDeps
+                    ];
+                  } else {
+                    resolvedDeps = depsArray;
+                  }
+                  renderedDeps = resolvedDeps.map((dep) => {
+                if (renderBuiltUrl) {
+                  renderedDeps = depsArray.map((dep) => {
                     const replacement = toOutputFilePathInJS(
                       dep,
 …
                       // Don't include the assets dir if the default asset file names
                       // are used, the path will be reconstructed by the import preload helper
                       optimizeModulePreloadRelativePaths ? addFileDep(toRelativePath(d, file)) : addFileDep(d)
+                      isRelativeBase ? addFileDep(toRelativePath(d, file)) : addFileDep(d)
+                    )
                   );
 …
   );
   const options = config.build;
+  const { root, logger, packageCache } = config;
   const ssr = !!options.ssr;
   const libOptions = options.lib;
   config.logger.info(
+  logger.info(
     colors$1.cyan(
       `vite v${VERSION} ${colors$1.green(
 …
+    )
   );
   const resolve = (p) => path$n.resolve(config.root, p);
+  const resolve = (p) => path$n.resolve(root, p);
   const input = libOptions ? options.rollupOptions?.input || (typeof libOptions.entry === "string" ? resolve(libOptions.entry) : Array.isArray(libOptions.entry) ? libOptions.entry.map(resolve) : Object.fromEntries(
     Object.entries(libOptions.entry).map(([alias, file]) => [
 …
     enhanceRollupError(e);
     clearLine();
     config.logger.error(e.message, { error: e });
+    logger.error(e.message, { error: e });
   };
   let bundle;
 …
     const buildOutputOptions = (output = {}) => {
       if (output.output) {
         config.logger.warn(
+        logger.warn(
           `You've set "rollupOptions.output.output" in your config. This is deprecated and will override all Vite.js default output options. Please use "rollupOptions.output" instead.`
         );
 …
+      }
       if (output.sourcemap) {
         config.logger.warnOnce(
+        logger.warnOnce(
           colors$1.yellow(
             `Vite does not support "rollupOptions.output.sourcemap". Please use "build.sourcemap" instead.`
 …
       const jsExt = ssrNodeBuild || libOptions ? resolveOutputJsExtension(
         format,
         findNearestPackageData(config.root, config.packageCache)?.data.type
+        findNearestPackageData(root, packageCache)?.data.type
       ) : "js";
       return {
 …
           format,
           name,
           config.root,
+          root,
           jsExt,
           config.packageCache
+          packageCache
         ) : path$n.posix.join(options.assetsDir, `[name]-[hash].${jsExt}`),
         chunkFileNames: libOptions ? `[name]-[hash].${jsExt}` : path$n.posix.join(options.assetsDir, `[name]-[hash].${jsExt}`),
 …
       options.rollupOptions?.output,
       libOptions,
       config.logger
+      logger
     );
     const normalizedOutputs = [];
 …
+    }
     const resolvedOutDirs = getResolvedOutDirs(
       config.root,
+      root,
       options.outDir,
       options.rollupOptions?.output
 …
     const emptyOutDir = resolveEmptyOutDir(
       options.emptyOutDir,
       config.root,
+      root,
       resolvedOutDirs,
       config.logger
+      logger
     );
     if (config.build.watch) {
       config.logger.info(colors$1.cyan(`
+      logger.info(colors$1.cyan(`
 watching for file changes...`));
       const resolvedChokidarOptions = resolveChokidarOptions(
-        config,
         config.build.watch.chokidar,
         resolvedOutDirs,
+        emptyOutDir
+        emptyOutDir,
+        config.cacheDir
       );
       const { watch } = await import('rollup');
 …
       watcher.on("event", (event) => {
         if (event.code === "BUNDLE_START") {
           config.logger.info(colors$1.cyan(`
+          logger.info(colors$1.cyan(`
 build started...`));
           if (options.write) {
 …
         } else if (event.code === "BUNDLE_END") {
           event.result.close();
           config.logger.info(colors$1.cyan(`built in ${event.duration}ms.`));
+          logger.info(colors$1.cyan(`built in ${event.duration}ms.`));
         } else if (event.code === "ERROR") {
           outputBuildError(event.error);
 …
       res.push(await bundle[options.write ? "write" : "generate"](output));
+    }
     config.logger.info(
+    logger.info(
       `${colors$1.green(`\u2713 built in ${displayTime(Date.now() - startTime)}`)}`
     );
 …
     clearLine();
     if (startTime) {
       config.logger.error(
+      logger.error(
         `${colors$1.red("x")} Build failed in ${displayTime(Date.now() - startTime)}`
       );
 …
 const getResolveUrl = (path2, URL = "URL") => `new ${URL}(${path2}).href`;
 const getRelativeUrlFromDocument = (relativePath, umd = false) => getResolveUrl(
   `'${escapeId(partialEncodeURIPath(relativePath))}', ${umd ? `typeof document === 'undefined' ? location.href : ` : ""}document.currentScript && document.currentScript.src || document.baseURI`
+  `'${escapeId(partialEncodeURIPath(relativePath))}', ${umd ? `typeof document === 'undefined' ? location.href : ` : ""}document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || document.baseURI`
 );
 const getFileUrlFromFullPath = (path2) => `require('u' + 'rl').pathToFileURL(${path2}).href`;
 …
     return toRelative(filename, hostId);
+  }
   return joinUrlSegments(config.base, filename);
+  return joinUrlSegments(config.decodedBase, filename);
+}
 function createToImportMetaURLBasedRelativeRuntime(format, isWorker) {
 …
     return toRelative(filename, hostId);
   } else {
     return joinUrlSegments(config.base, filename);
+    return joinUrlSegments(config.decodedBase, filename);
+  }
+}
 …
     rollupOptions: config.worker?.rollupOptions || {}
   };
+  const base = withTrailingSlash(resolvedBase);
   resolved = {
     configFile: configFile ? normalizePath$3(configFile) : void 0,
 …
     inlineConfig,
     root: resolvedRoot,
+    base: withTrailingSlash(resolvedBase),
+    base,
+    decodedBase: decodeURI(base),
     rawBase: resolvedBase,
     resolve: resolveOptions,
 …
+  }
   if (!isBuild || !isExternal) {
     base = new URL(base, "http://vitejs.dev").pathname;
+    base = new URL(base, "http://vite.dev").pathname;
     if (base[0] !== "/") {
       base = "/" + base;
 …
     return null;
+  }
   const isESM = isFilePathESM(resolvedPath);
+  const isESM = typeof process.versions.deno === "string" || isFilePathESM(resolvedPath);
   try {
     const bundled = await bundleConfigFile(resolvedPath, isESM);
 …
     entryPoints: [fileName],
     write: false,
     target: ["node18"],
+    target: [`node${process.versions.node}`],
     platform: "node",
     bundle: true,
 …
                       `Failed to resolve ${JSON.stringify(
                         id
                       )}. This package is ESM only but it was tried to load by \`require\`. See https://vitejs.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`
+                      )}. This package is ESM only but it was tried to load by \`require\`. See https://vite.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`
                     );
+                  }
 …
                   `${JSON.stringify(
                     id
                   )} resolved to an ESM file. ESM file cannot be loaded by \`require\`. See https://vitejs.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`
+                  )} resolved to an ESM file. ESM file cannot be loaded by \`require\`. See https://vite.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`
                 );
+              }

imaps-frontend/node_modules/vite/dist/node/cli.js

-              rd565449
+              r0c6b92a
 import { performance } from 'node:perf_hooks';
 import { EventEmitter } from 'events';
 import { A as colors, v as createLogger, r as resolveConfig } from './chunks/dep-mCdpKltl.js';
+import { A as colors, v as createLogger, r as resolveConfig } from './chunks/dep-CB_7IfJ-.js';
 import { VERSION } from './constants.js';
 import 'node:fs/promises';
 …
 ).action(async (root, options) => {
   filterDuplicateOptions(options);
   const { createServer } = await import('./chunks/dep-mCdpKltl.js').then(function (n) { return n.E; });
+  const { createServer } = await import('./chunks/dep-CB_7IfJ-.js').then(function (n) { return n.E; });
   try {
     const server = await createServer({
 …
 ).option("-w, --watch", `[boolean] rebuilds when modules have changed on disk`).action(async (root, options) => {
   filterDuplicateOptions(options);
   const { build } = await import('./chunks/dep-mCdpKltl.js').then(function (n) { return n.F; });
+  const { build } = await import('./chunks/dep-CB_7IfJ-.js').then(function (n) { return n.F; });
   const buildOptions = cleanOptions(options);
   try {
 …
   async (root, options) => {
     filterDuplicateOptions(options);
     const { optimizeDeps } = await import('./chunks/dep-mCdpKltl.js').then(function (n) { return n.D; });
+    const { optimizeDeps } = await import('./chunks/dep-CB_7IfJ-.js').then(function (n) { return n.D; });
     try {
       const config = await resolveConfig(
 …
   async (root, options) => {
     filterDuplicateOptions(options);
     const { preview } = await import('./chunks/dep-mCdpKltl.js').then(function (n) { return n.G; });
+    const { preview } = await import('./chunks/dep-CB_7IfJ-.js').then(function (n) { return n.G; });
     try {
       const server = await preview({

imaps-frontend/node_modules/vite/dist/node/index.d.ts

-              rd565449
+              r0c6b92a
  */
 interface CorsOptions {
     origin?: CorsOrigin | ((origin: string, cb: (err: Error, origins: CorsOrigin) => void) => void);
+    origin?: CorsOrigin | ((origin: string | undefined, cb: (err: Error, origins: CorsOrigin) => void) => void);
     methods?: string | string[];
     allowedHeaders?: string | string[];
 …
 declare const WebSocketAlias: typeof WebSocket
 interface WebSocketAlias extends WebSocket {}
 // WebSocket socket.
 declare class WebSocket extends EventEmitter {
 …
   ): this
+}
- // tslint:disable-line no-empty-interface
 declare namespace WebSocket {
 …
   const WebSocketServer: typeof Server
   interface WebSocketServer extends Server {} // tslint:disable-line no-empty-interface
+  interface WebSocketServer extends Server {}
   const WebSocket: typeof WebSocketAlias
   interface WebSocket extends WebSocketAlias {} // tslint:disable-line no-empty-interface
+  interface WebSocket extends WebSocketAlias {}
   // WebSocket stream

imaps-frontend/node_modules/vite/dist/node/index.js

-              rd565449
+              r0c6b92a
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
 import { i as isInNodeModules, a as arraify } from './chunks/dep-mCdpKltl.js';
 export { b as build, g as buildErrorMessage, k as createFilter, v as createLogger, c as createServer, d as defineConfig, h as fetchModule, f as formatPostcssSourceMap, x as isFileServingAllowed, l as loadConfigFromFile, y as loadEnv, j as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, e as preprocessCSS, p as preview, r as resolveConfig, z as resolveEnvPrefix, q as rollupVersion, w as searchForWorkspaceRoot, u as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-mCdpKltl.js';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-CB_7IfJ-.js';
+export { b as build, g as buildErrorMessage, k as createFilter, v as createLogger, c as createServer, d as defineConfig, h as fetchModule, f as formatPostcssSourceMap, x as isFileServingAllowed, l as loadConfigFromFile, y as loadEnv, j as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, e as preprocessCSS, p as preview, r as resolveConfig, z as resolveEnvPrefix, q as rollupVersion, w as searchForWorkspaceRoot, u as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-CB_7IfJ-.js';
 export { VERSION as version } from './constants.js';
 export { version as esbuildVersion } from 'esbuild';

imaps-frontend/node_modules/vite/dist/node/runtime.js

-              rd565449
+              r0c6b92a
   intToChar[i] = c, charToInt[c] = i;
+}
+function decode(mappings) {
+  const state = new Int32Array(5), decoded = [];
+  let index = 0;
+  do {
+    const semi = indexOf(mappings, index), line = [];
+    let sorted = !0, lastCol = 0;
+    state[0] = 0;
+    for (let i = index; i < semi; i++) {
+      let seg;
+      i = decodeInteger(mappings, i, state, 0);
+      const col = state[0];
+      col < lastCol && (sorted = !1), lastCol = col, hasMoreVlq(mappings, i, semi) ? (i = decodeInteger(mappings, i, state, 1), i = decodeInteger(mappings, i, state, 2), i = decodeInteger(mappings, i, state, 3), hasMoreVlq(mappings, i, semi) ? (i = decodeInteger(mappings, i, state, 4), seg = [col, state[1], state[2], state[3], state[4]]) : seg = [col, state[1], state[2], state[3]]) : seg = [col], line.push(seg);
+    }
+    sorted || sort(line), decoded.push(line), index = semi + 1;
+  } while (index <= mappings.length);
+  return decoded;
+}
+function indexOf(mappings, index) {
+  const idx = mappings.indexOf(";", index);
+  return idx === -1 ? mappings.length : idx;
+}
+function decodeInteger(mappings, pos, state, j) {
+function decodeInteger(reader, relative) {
   let value = 0, shift = 0, integer = 0;
   do {
     const c = mappings.charCodeAt(pos++);
+    const c = reader.next();
     integer = charToInt[c], value |= (integer & 31) << shift, shift += 5;
   } while (integer & 32);
   const shouldNegate = value & 1;
+  return value >>>= 1, shouldNegate && (value = -2147483648 | -value), state[j] += value, pos;
+}
+function hasMoreVlq(mappings, i, length) {
+  return i >= length ? !1 : mappings.charCodeAt(i) !== comma;
+  return value >>>= 1, shouldNegate && (value = -2147483648 | -value), relative + value;
+}
+function hasMoreVlq(reader, max) {
+  return reader.pos >= max ? !1 : reader.peek() !== comma;
+}
+class StringReader {
+  constructor(buffer) {
+    this.pos = 0, this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this, idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+}
+function decode(mappings) {
+  const { length } = mappings, reader = new StringReader(mappings), decoded = [];
+  let genColumn = 0, sourcesIndex = 0, sourceLine = 0, sourceColumn = 0, namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";"), line = [];
+    let sorted = !0, lastCol = 0;
+    for (genColumn = 0; reader.pos < semi; ) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn), genColumn < lastCol && (sorted = !1), lastCol = genColumn, hasMoreVlq(reader, semi) ? (sourcesIndex = decodeInteger(reader, sourcesIndex), sourceLine = decodeInteger(reader, sourceLine), sourceColumn = decodeInteger(reader, sourceColumn), hasMoreVlq(reader, semi) ? (namesIndex = decodeInteger(reader, namesIndex), seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]) : seg = [genColumn, sourcesIndex, sourceLine, sourceColumn]) : seg = [genColumn], line.push(seg), reader.pos++;
+    }
+    sorted || sort(line), decoded.push(line), reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
 function sort(line) {
 …
     if (mod.map) return mod.map;
     if (!mod.meta || !("code" in mod.meta)) return null;
+    const mapString = mod.meta.code.match(
+      VITE_RUNTIME_SOURCEMAPPING_REGEXP
+    )?.[1];
+    const mapString = VITE_RUNTIME_SOURCEMAPPING_REGEXP.exec(mod.meta.code)?.[1];
     if (!mapString) return null;
     const baseFile = mod.meta.file || moduleId.split("?")[0];

imaps-frontend/node_modules/vite/index.cjs

-              rd565449
+              r0c6b92a
-/* eslint-disable no-restricted-globals */
 warnCjsUsage()
 …
 // proxy cjs utils (sync functions)
-// eslint-disable-next-line n/no-missing-require -- will be generated by build
 Object.assign(module.exports, require('./dist/node-cjs/publicUtils.cjs'))
 …
 function warnCjsUsage() {
   if (process.env.VITE_CJS_IGNORE_WARNING) return
+  const logLevelIndex = process.argv.findIndex((arg) =>
+    /^(?:-l|--logLevel)/.test(arg),
+  )
+  if (logLevelIndex > 0) {
+    const logLevelValue = process.argv[logLevelIndex + 1]
+    if (logLevelValue === 'silent' || logLevelValue === 'error') {
+      return
+    }
+    if (/silent|error/.test(process.argv[logLevelIndex])) {
+      return
+    }
+  }
   const yellow = (str) => `\u001b[33m${str}\u001b[39m`
+  const log = process.env.VITE_CJS_TRACE ? console.trace : console.warn
+  log(
+  console.warn(
     yellow(
       `The CJS build of Vite's Node API is deprecated. See https://vitejs.dev/guide/troubleshooting.html#vite-cjs-node-api-deprecated for more details.`,
+      `The CJS build of Vite's Node API is deprecated. See https://vite.dev/guide/troubleshooting.html#vite-cjs-node-api-deprecated for more details.`,
     ),
+  )
+  if (process.env.VITE_CJS_TRACE) {
+    const e = {}
+    const stackTraceLimit = Error.stackTraceLimit
+    Error.stackTraceLimit = 100
+    Error.captureStackTrace(e)
+    Error.stackTraceLimit = stackTraceLimit
+    console.log(
+      e.stack
+        .split('\n')
+        .slice(1)
+        .filter((line) => !line.includes('(node:'))
+        .join('\n'),
+    )
+  }
+}

imaps-frontend/node_modules/vite/index.d.cts

rd565449	r0c6b92a
1	1	/**
2		* @deprecated The CJS build of Vite's Node API is deprecated. See https://vitejs.dev/guide/troubleshooting.html#vite-cjs-node-api-deprecated for more details.
	2	* @deprecated The CJS build of Vite's Node API is deprecated. See https://vite.dev/guide/troubleshooting.html#vite-cjs-node-api-deprecated for more details.
3	3	*/
4	4	declare const module: any

imaps-frontend/node_modules/vite/package.json

-              rd565449
+              r0c6b92a
+{
   "name": "vite",
   "version": "5.3.5",
+  "version": "5.4.11",
   "type": "module",
   "license": "MIT",
 …
     "url": "https://github.com/vitejs/vite/issues"
   },
   "homepage": "https://vitejs.dev",
+  "homepage": "https://vite.dev",
   "funding": "https://github.com/vitejs/vite?sponsor=1",
   "//": "READ CONTRIBUTING.md to understand what to put under deps vs. devDeps!",
   "dependencies": {
     "esbuild": "^0.21.3",
     "postcss": "^8.4.39",
     "rollup": "^4.13.0"
+    "postcss": "^8.4.43",
+    "rollup": "^4.20.0"
   },
   "optionalDependencies": {
 …
   "devDependencies": {
     "@ampproject/remapping": "^2.3.0",
     "@babel/parser": "^7.24.8",
+    "@babel/parser": "^7.25.6",
     "@jridgewell/trace-mapping": "^0.3.25",
     "@polka/compression": "^1.0.0-next.25",
 …
     "cors": "^2.8.5",
     "cross-spawn": "^7.0.3",
     "debug": "^4.3.5",
+    "debug": "^4.3.6",
     "dep-types": "link:./src/types",
     "dotenv": "^16.4.5",
 …
     "fast-glob": "^3.3.2",
     "http-proxy": "^1.18.1",
     "launch-editor-middleware": "^2.8.0",
     "lightningcss": "^1.25.1",
     "magic-string": "^0.30.10",
     "micromatch": "^4.0.7",
+    "launch-editor-middleware": "^2.9.1",
+    "lightningcss": "^1.26.0",
+    "magic-string": "^0.30.11",
+    "micromatch": "^4.0.8",
     "mlly": "^1.7.1",
     "mrmime": "^2.0.0",
 …
     "rollup-plugin-license": "^3.5.2",
     "sass": "^1.77.8",
+    "sass-embedded": "^1.77.8",
     "sirv": "^2.0.4",
     "source-map-support": "^0.5.21",
     "strip-ansi": "^7.1.0",
     "strip-literal": "^2.1.0",
     "tsconfck": "^3.1.1",
     "tslib": "^2.6.3",
+    "tsconfck": "^3.1.4",
+    "tslib": "^2.7.0",
     "types": "link:./types",
     "ufo": "^1.5.4",
 …
     "lightningcss": "^1.21.0",
     "sass": "*",
+    "sass-embedded": "*",
     "stylus": "*",
     "sugarss": "*",
 …
     },
     "sass": {
+      "optional": true
+    },
+    "sass-embedded": {
       "optional": true
     },

Context Navigation

Legend:

imaps-frontend/node_modules/vite/LICENSE.md

imaps-frontend/node_modules/vite/README.md

imaps-frontend/node_modules/vite/client.d.ts

imaps-frontend/node_modules/vite/dist/client/client.mjs

imaps-frontend/node_modules/vite/dist/node-cjs/publicUtils.cjs

imaps-frontend/node_modules/vite/dist/node/chunks/dep-Ba1kN6Mp.js

imaps-frontend/node_modules/vite/dist/node/chunks/dep-C6EFp3uH.js

imaps-frontend/node_modules/vite/dist/node/chunks/dep-CB_7IfJ-.js

imaps-frontend/node_modules/vite/dist/node/cli.js

imaps-frontend/node_modules/vite/dist/node/index.d.ts

imaps-frontend/node_modules/vite/dist/node/index.js

imaps-frontend/node_modules/vite/dist/node/runtime.js

imaps-frontend/node_modules/vite/index.cjs

imaps-frontend/node_modules/vite/index.d.cts

imaps-frontend/node_modules/vite/package.json

Download in other formats: