Base UI

node_modules/postcss-selector-parser/dist/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var processor_1 = __importDefault(require("./processor"));
+var selectors = __importStar(require("./selectors"));
+var parser = function (processor) { return new processor_1.default(processor); };
+Object.assign(parser, selectors);
+delete parser.__esModule;
+module.exports = parser;
+//# sourceMappingURL=index.js.map

node_modules/postcss-selector-parser/dist/processor.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var parser_1 = __importDefault(require("./parser"));
+var Processor = /** @class */ (function () {
+    function Processor(func, options) {
+        this.func = func || function noop() { };
+        this.funcRes = null;
+        this.options = options;
+    }
+    Processor.prototype._shouldUpdateSelector = function (rule, options) {
+        if (options === void 0) { options = {}; }
+        var merged = Object.assign({}, this.options, options);
+        if (merged.updateSelector === false) {
+            return false;
+        }
+        else {
+            return typeof rule !== "string";
+        }
+    };
+    Processor.prototype._isLossy = function (options) {
+        if (options === void 0) { options = {}; }
+        var merged = Object.assign({}, this.options, options);
+        if (merged.lossless === false) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    };
+    Processor.prototype._root = function (rule, options) {
+        if (options === void 0) { options = {}; }
+        var parser = new parser_1.default(rule, this._parseOptions(options));
+        return parser.root;
+    };
+    Processor.prototype._parseOptions = function (options) {
+        var merged = Object.assign({}, this.options, options);
+        return {
+            lossy: this._isLossy(merged),
+            maxNestingDepth: merged.maxNestingDepth,
+        };
+    };
+    Processor.prototype._stringifyOptions = function (options) {
+        var merged = Object.assign({}, this.options, options);
+        return {
+            maxNestingDepth: merged.maxNestingDepth,
+        };
+    };
+    Processor.prototype._run = function (rule, options) {
+        var _this = this;
+        if (options === void 0) { options = {}; }
+        return new Promise(function (resolve, reject) {
+            try {
+                var root_1 = _this._root(rule, options);
+                Promise.resolve(_this.func(root_1))
+                    .then(function (transform) {
+                    var string = undefined;
+                    if (_this._shouldUpdateSelector(rule, options)) {
+                        string = root_1.toString(_this._stringifyOptions(options));
+                        rule.selector = string;
+                    }
+                    return { transform: transform, root: root_1, string: string };
+                })
+                    .then(resolve, reject);
+            }
+            catch (e) {
+                reject(e);
+                return;
+            }
+        });
+    };
+    Processor.prototype._runSync = function (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(this._stringifyOptions(options));
+            rule.selector = string;
+        }
+        return { transform: transform, root: root, string: string };
+    };
+    /**
+     * Process rule into a selector AST.
+     *
+     * @param rule {postcss.Rule | string} The css selector to be processed
+     * @param options The options for processing
+     * @returns {Promise<parser.Root>} The AST of the selector after processing it.
+     */
+    Processor.prototype.ast = function (rule, options) {
+        return this._run(rule, options).then(function (result) { return result.root; });
+    };
+    /**
+     * Process rule into a selector AST synchronously.
+     *
+     * @param rule {postcss.Rule | string} The css selector to be processed
+     * @param options The options for processing
+     * @returns {parser.Root} The AST of the selector after processing it.
+     */
+    Processor.prototype.astSync = function (rule, options) {
+        return this._runSync(rule, options).root;
+    };
+    /**
+     * Process a selector into a transformed value asynchronously
+     *
+     * @param rule {postcss.Rule | string} The css selector to be processed
+     * @param options The options for processing
+     * @returns {Promise<any>} The value returned by the processor.
+     */
+    Processor.prototype.transform = function (rule, options) {
+        return this._run(rule, options).then(function (result) { return result.transform; });
+    };
+    /**
+     * Process a selector into a transformed value synchronously.
+     *
+     * @param rule {postcss.Rule | string} The css selector to be processed
+     * @param options The options for processing
+     * @returns {any} The value returned by the processor.
+     */
+    Processor.prototype.transformSync = function (rule, options) {
+        return this._runSync(rule, options).transform;
+    };
+    /**
+     * Process a selector into a new selector string asynchronously.
+     *
+     * @param rule {postcss.Rule | string} The css selector to be processed
+     * @param options The options for processing
+     * @returns {string} the selector after processing.
+     */
+    Processor.prototype.process = function (rule, options) {
+        var _this = this;
+        return this._run(rule, options).then(function (result) { return result.string || result.root.toString(_this._stringifyOptions(options)); });
+    };
+    /**
+     * Process a selector into a new selector string synchronously.
+     *
+     * @param rule {postcss.Rule | string} The css selector to be processed
+     * @param options The options for processing
+     * @returns {string} the selector after processing.
+     */
+    Processor.prototype.processSync = function (rule, options) {
+        var result = this._runSync(rule, options);
+        return result.string || result.root.toString(this._stringifyOptions(options));
+    };
+    return Processor;
+}());
+exports.default = Processor;
+//# sourceMappingURL=processor.js.map

node_modules/postcss-selector-parser/dist/selectors/attribute.js

@@ -0,0 +1,440 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unescapeValue = unescapeValue;
+var cssesc_1 = __importDefault(require("cssesc"));
+var unesc_1 = __importDefault(require("../util/unesc"));
+var namespace_1 = __importDefault(require("./namespace"));
+var types_1 = require("./types");
+var deprecate = require("util-deprecate");
+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 quoteMark = null;
+    var unescaped = value;
+    var m = unescaped.match(WRAPPED_IN_QUOTES);
+    if (m) {
+        quoteMark = m[1];
+        unescaped = m[2];
+    }
+    unescaped = (0, unesc_1.default)(unescaped);
+    if (unescaped !== value) {
+        deprecatedUsage = true;
+    }
+    return {
+        deprecatedUsage: deprecatedUsage,
+        unescaped: unescaped,
+        quoteMark: quoteMark,
+    };
+}
+function handleDeprecatedContructorOpts(opts) {
+    if (opts.quoteMark !== undefined) {
+        return opts;
+    }
+    if (opts.value === undefined) {
+        return opts;
+    }
+    warnOfDeprecatedConstructor();
+    var _a = unescapeValue(opts.value), quoteMark = _a.quoteMark, unescaped = _a.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 = /** @class */ (function (_super) {
+    __extends(Attribute, _super);
+    function Attribute(opts) {
+        if (opts === void 0) { opts = {}; }
+        var _this = _super.call(this, handleDeprecatedContructorOpts(opts)) || this;
+        _this.type = types_1.ATTRIBUTE;
+        _this.raws = _this.raws || {};
+        Object.defineProperty(_this.raws, "unquoted", {
+            get: deprecate(function () { return _this.value; }, "attr.raws.unquoted is deprecated. Call attr.value instead."),
+            set: deprecate(function () { return _this.value; }, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now."),
+        });
+        _this._constructed = true;
+        return _this;
+    }
+    /**
+     * Returns the Attribute's value quoted such that it would be legal to use
+     * in the value of a css file. The original value's quotation setting
+     * used for stringification is left unchanged. See `setValue(value, options)`
+     * if you want to control the quote settings of a new value for the attribute.
+     *
+     * You can also change the quotation used for the current value by setting quoteMark.
+     *
+     * Options:
+     *   * quoteMark {'"' | "'" | null} - Use this value to quote the value. If this
+     *     option is not set, the original value for quoteMark will be used. If
+     *     indeterminate, a double quote is used. The legal values are:
+     *     * `null` - the value will be unquoted and characters will be escaped as necessary.
+     *     * `'` - the value will be quoted with a single quote and single quotes are escaped.
+     *     * `"` - the value will be quoted with a double quote and double quotes are escaped.
+     *   * preferCurrentQuoteMark {boolean} - if true, prefer the source quote mark
+     *     over the quoteMark option value.
+     *   * smart {boolean} - if true, will select a quote mark based on the value
+     *     and the other options specified here. See the `smartQuoteMark()`
+     *     method.
+     **/
+    Attribute.prototype.getQuotedValue = function (options) {
+        if (options === void 0) { options = {}; }
+        var quoteMark = this._determineQuoteMark(options);
+        var cssescopts = CSSESC_QUOTE_OPTIONS[quoteMark];
+        var escaped = (0, cssesc_1.default)(this._value, cssescopts);
+        return escaped;
+    };
+    Attribute.prototype._determineQuoteMark = function (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.
+     */
+    Attribute.prototype.setValue = function (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
+     * the value is a legal CSS ident, it will not be quoted. Otherwise a quote
+     * mark will be picked that minimizes the number of escapes.
+     *
+     * If there's no clear winner, the quote mark from these options is used,
+     * then the source quote mark (this is inverted if `preferCurrentQuoteMark` is
+     * true). If the quoteMark is unspecified, a double quote is used.
+     *
+     * @param options This takes the quoteMark and preferCurrentQuoteMark options
+     * from the quoteValue method.
+     */
+    Attribute.prototype.smartQuoteMark = function (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_1.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 quote = this.quoteMark || options.quoteMark || Attribute.DOUBLE_QUOTE;
+                    var opts = CSSESC_QUOTE_OPTIONS[quote];
+                    var quoteValue = (0, cssesc_1.default)(v, opts);
+                    if (quoteValue.length < escaped.length) {
+                        return quote;
+                    }
+                }
+                return pref;
+            }
+        }
+        else if (numDoubleQuotes === numSingleQuotes) {
+            return this.preferredQuoteMark(options);
+        }
+        else if (numDoubleQuotes < numSingleQuotes) {
+            return Attribute.DOUBLE_QUOTE;
+        }
+        else {
+            return Attribute.SINGLE_QUOTE;
+        }
+    };
+    /**
+     * 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.
+     */
+    Attribute.prototype.preferredQuoteMark = function (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;
+    };
+    Object.defineProperty(Attribute.prototype, "quoted", {
+        get: function () {
+            var qm = this.quoteMark;
+            return qm === "'" || qm === '"';
+        },
+        set: function (value) {
+            warnOfDeprecatedQuotedAssignment();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Attribute.prototype, "quoteMark", {
+        /**
+         * returns a single (`'`) or double (`"`) quote character if the value is quoted.
+         * returns `null` if the value is not quoted.
+         * returns `undefined` if the quotation state is unknown (this can happen when
+         * the attribute is constructed without specifying a quote mark.)
+         */
+        get: function () {
+            return this._quoteMark;
+        },
+        /**
+         * Set the quote mark to be used by this attribute's value.
+         * If the quote mark changes, the raw (escaped) value at `attr.raws.value` of the attribute
+         * value is updated accordingly.
+         *
+         * @param {"'" | '"' | null} quoteMark The quote mark or `null` if the value should be unquoted.
+         */
+        set: function (quoteMark) {
+            if (!this._constructed) {
+                this._quoteMark = quoteMark;
+                return;
+            }
+            if (this._quoteMark !== quoteMark) {
+                this._quoteMark = quoteMark;
+                this._syncRawValue();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Attribute.prototype._syncRawValue = function () {
+        var rawValue = (0, cssesc_1.default)(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
+        if (rawValue === this._value) {
+            if (this.raws) {
+                delete this.raws.value;
+            }
+        }
+        else {
+            this.raws.value = rawValue;
+        }
+    };
+    Object.defineProperty(Attribute.prototype, "qualifiedAttribute", {
+        get: function () {
+            return this.qualifiedName(this.raws.attribute || this.attribute);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Attribute.prototype, "insensitiveFlag", {
+        get: function () {
+            return this.insensitive ? "i" : "";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Attribute.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        /**
+         * Before 3.0, the value had to be set to an escaped value including any wrapped
+         * quote marks. In 3.0, the semantics of `Attribute.value` changed so that the value
+         * is unescaped during parsing and any quote marks are removed.
+         *
+         * Because the ambiguity of this semantic change, if you set `attr.value = newValue`,
+         * a deprecation warning is raised when the new value contains any characters that would
+         * require escaping (including if it contains wrapped quotes).
+         *
+         * Instead, you should call `attr.setValue(newValue, opts)` and pass options that describe
+         * how the new value is quoted.
+         */
+        set: function (v) {
+            if (this._constructed) {
+                var _a = unescapeValue(v), deprecatedUsage = _a.deprecatedUsage, unescaped = _a.unescaped, quoteMark = _a.quoteMark;
+                if (deprecatedUsage) {
+                    warnOfDeprecatedValueAssignment();
+                }
+                if (unescaped === this._value && quoteMark === this._quoteMark) {
+                    return;
+                }
+                this._value = unescaped;
+                this._quoteMark = quoteMark;
+                this._syncRawValue();
+            }
+            else {
+                this._value = v;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Attribute.prototype, "insensitive", {
+        get: function () {
+            return this._insensitive;
+        },
+        /**
+         * Set the case insensitive flag.
+         * If the case insensitive flag changes, the raw (escaped) value at `attr.raws.insensitiveFlag`
+         * of the attribute is updated accordingly.
+         *
+         * @param {true | false} insensitive true if the attribute should match case-insensitively.
+         */
+        set: function (insensitive) {
+            if (!insensitive) {
+                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;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Attribute.prototype, "attribute", {
+        get: function () {
+            return this._attribute;
+        },
+        set: function (name) {
+            this._handleEscapes("attribute", name);
+            this._attribute = name;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Attribute.prototype._handleEscapes = function (prop, value) {
+        if (this._constructed) {
+            var escaped = (0, cssesc_1.default)(value, { isIdentifier: true });
+            if (escaped !== value) {
+                this.raws[prop] = escaped;
+            }
+            else {
+                delete this.raws[prop];
+            }
+        }
+    };
+    Attribute.prototype._spacesFor = function (name) {
+        var attrSpaces = { before: "", after: "" };
+        var spaces = this.spaces[name] || {};
+        var rawSpaces = (this.raws.spaces && this.raws.spaces[name]) || {};
+        return Object.assign(attrSpaces, spaces, rawSpaces);
+    };
+    Attribute.prototype._stringFor = function (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
+     * start of the node of the output string.
+     *
+     * * "ns" - alias for "namespace"
+     * * "namespace" - the namespace if it exists.
+     * * "attribute" - the attribute name
+     * * "attributeNS" - the start of the attribute or its namespace
+     * * "operator" - the match operator of the attribute
+     * * "value" - The value (string or identifier)
+     * * "insensitive" - the case insensitivity flag;
+     * @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.
+     */
+    Attribute.prototype.offsetOf = function (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;
+    };
+    Attribute.prototype.toString = function () {
+        var _this = this;
+        var selector = [this.rawSpaceBefore, "["];
+        selector.push(this._stringFor("qualifiedAttribute", "attribute"));
+        if (this.operator && (this.value || this.value === "")) {
+            selector.push(this._stringFor("operator"));
+            selector.push(this._stringFor("value"));
+            selector.push(this._stringFor("insensitiveFlag", "insensitive", function (attrValue, attrSpaces) {
+                if (attrValue.length > 0 &&
+                    !_this.quoted &&
+                    attrSpaces.before.length === 0 &&
+                    !(_this.spaces.value && _this.spaces.value.after)) {
+                    attrSpaces.before = " ";
+                }
+                return defaultAttrConcat(attrValue, attrSpaces);
+            }));
+        }
+        selector.push("]");
+        selector.push(this.rawSpaceAfter);
+        return selector.join("");
+    };
+    Attribute.NO_QUOTE = null;
+    Attribute.SINGLE_QUOTE = "'";
+    Attribute.DOUBLE_QUOTE = '"';
+    return Attribute;
+}(namespace_1.default));
+exports.default = Attribute;
+var CSSESC_QUOTE_OPTIONS = (_a = {
+        "'": { quotes: "single", wrap: true },
+        '"': { quotes: "double", wrap: true }
+    },
+    _a[null] = { isIdentifier: true },
+    _a);
+function defaultAttrConcat(attrValue, attrSpaces) {
+    return "".concat(attrSpaces.before).concat(attrValue).concat(attrSpaces.after);
+}
+//# sourceMappingURL=attribute.js.map

node_modules/postcss-selector-parser/dist/selectors/className.js

@@ -0,0 +1,59 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var cssesc_1 = __importDefault(require("cssesc"));
+var util_1 = require("../util");
+var node_1 = __importDefault(require("./node"));
+var types_1 = require("./types");
+var ClassName = /** @class */ (function (_super) {
+    __extends(ClassName, _super);
+    function ClassName(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.CLASS;
+        _this._constructed = true;
+        return _this;
+    }
+    Object.defineProperty(ClassName.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        set: function (v) {
+            if (this._constructed) {
+                var escaped = (0, cssesc_1.default)(v, { isIdentifier: true });
+                if (escaped !== v) {
+                    (0, util_1.ensureObject)(this, "raws");
+                    this.raws.value = escaped;
+                }
+                else if (this.raws) {
+                    delete this.raws.value;
+                }
+            }
+            this._value = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ClassName.prototype.valueToString = function () {
+        return "." + _super.prototype.valueToString.call(this);
+    };
+    return ClassName;
+}(node_1.default));
+exports.default = ClassName;
+//# sourceMappingURL=className.js.map

node_modules/postcss-selector-parser/dist/selectors/combinator.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var node_1 = __importDefault(require("./node"));
+var types_1 = require("./types");
+var Combinator = /** @class */ (function (_super) {
+    __extends(Combinator, _super);
+    function Combinator(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.COMBINATOR;
+        return _this;
+    }
+    return Combinator;
+}(node_1.default));
+exports.default = Combinator;
+//# sourceMappingURL=combinator.js.map

node_modules/postcss-selector-parser/dist/selectors/comment.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var node_1 = __importDefault(require("./node"));
+var types_1 = require("./types");
+var Comment = /** @class */ (function (_super) {
+    __extends(Comment, _super);
+    function Comment(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.COMMENT;
+        return _this;
+    }
+    return Comment;
+}(node_1.default));
+exports.default = Comment;
+//# sourceMappingURL=comment.js.map

node_modules/postcss-selector-parser/dist/selectors/constructors.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.universal = exports.tag = exports.string = exports.selector = exports.root = exports.pseudo = exports.nesting = exports.id = exports.comment = exports.combinator = exports.className = exports.attribute = void 0;
+var attribute_1 = __importDefault(require("./attribute"));
+var className_1 = __importDefault(require("./className"));
+var combinator_1 = __importDefault(require("./combinator"));
+var comment_1 = __importDefault(require("./comment"));
+var id_1 = __importDefault(require("./id"));
+var nesting_1 = __importDefault(require("./nesting"));
+var pseudo_1 = __importDefault(require("./pseudo"));
+var root_1 = __importDefault(require("./root"));
+var selector_1 = __importDefault(require("./selector"));
+var string_1 = __importDefault(require("./string"));
+var tag_1 = __importDefault(require("./tag"));
+var universal_1 = __importDefault(require("./universal"));
+var attribute = function (opts) { return new attribute_1.default(opts); };
+exports.attribute = attribute;
+var className = function (opts) { return new className_1.default(opts); };
+exports.className = className;
+var combinator = function (opts) { return new combinator_1.default(opts); };
+exports.combinator = combinator;
+var comment = function (opts) { return new comment_1.default(opts); };
+exports.comment = comment;
+var id = function (opts) { return new id_1.default(opts); };
+exports.id = id;
+var nesting = function (opts) { return new nesting_1.default(opts); };
+exports.nesting = nesting;
+var pseudo = function (opts) { return new pseudo_1.default(opts); };
+exports.pseudo = pseudo;
+var root = function (opts) { return new root_1.default(opts); };
+exports.root = root;
+var selector = function (opts) { return new selector_1.default(opts); };
+exports.selector = selector;
+var string = function (opts) { return new string_1.default(opts); };
+exports.string = string;
+var tag = function (opts) { return new tag_1.default(opts); };
+exports.tag = tag;
+var universal = function (opts) { return new universal_1.default(opts); };
+exports.universal = universal;
+//# sourceMappingURL=constructors.js.map

node_modules/postcss-selector-parser/dist/selectors/container.js

@@ -0,0 +1,433 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../util");
+var node_1 = __importDefault(require("./node"));
+var types = __importStar(require("./types"));
+var Container = /** @class */ (function (_super) {
+    __extends(Container, _super);
+    function Container(opts) {
+        var _this = _super.call(this, opts) || this;
+        if (!_this.nodes) {
+            _this.nodes = [];
+        }
+        return _this;
+    }
+    Container.prototype.append = function (selector) {
+        selector.parent = this;
+        this.nodes.push(selector);
+        return this;
+    };
+    Container.prototype.prepend = function (selector) {
+        selector.parent = this;
+        this.nodes.unshift(selector);
+        for (var id in this.indexes) {
+            this.indexes[id]++;
+        }
+        return this;
+    };
+    Container.prototype.at = function (index) {
+        return this.nodes[index];
+    };
+    Container.prototype.index = function (child) {
+        if (typeof child === "number") {
+            return child;
+        }
+        return this.nodes.indexOf(child);
+    };
+    Object.defineProperty(Container.prototype, "first", {
+        get: function () {
+            return this.at(0);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Container.prototype, "last", {
+        get: function () {
+            return this.at(this.length - 1);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Container.prototype, "length", {
+        get: function () {
+            return this.nodes.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Container.prototype.removeChild = function (child) {
+        child = this.index(child);
+        this.at(child).parent = undefined;
+        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;
+    };
+    Container.prototype.removeAll = function () {
+        var e_1, _a;
+        try {
+            for (var _b = __values(this.nodes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var node = _c.value;
+                node.parent = undefined;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        this.nodes = [];
+        return this;
+    };
+    Container.prototype.empty = function () {
+        return this.removeAll();
+    };
+    Container.prototype.insertAfter = function (oldNode, newNode) {
+        var _a;
+        newNode.parent = this;
+        var oldIndex = this.index(oldNode);
+        var resetNode = [];
+        for (var i = 2; i < arguments.length; i++) {
+            resetNode.push(arguments[i]);
+        }
+        (_a = this.nodes).splice.apply(_a, __spreadArray([oldIndex + 1, 0, newNode], __read(resetNode), false));
+        newNode.parent = this;
+        var index;
+        for (var id in this.indexes) {
+            index = this.indexes[id];
+            if (oldIndex < index) {
+                this.indexes[id] = index + arguments.length - 1;
+            }
+        }
+        return this;
+    };
+    Container.prototype.insertBefore = function (oldNode, newNode) {
+        var _a;
+        newNode.parent = this;
+        var oldIndex = this.index(oldNode);
+        var resetNode = [];
+        for (var i = 2; i < arguments.length; i++) {
+            resetNode.push(arguments[i]);
+        }
+        (_a = this.nodes).splice.apply(_a, __spreadArray([oldIndex, 0, newNode], __read(resetNode), false));
+        newNode.parent = this;
+        var index;
+        for (var id in this.indexes) {
+            index = this.indexes[id];
+            if (index >= oldIndex) {
+                this.indexes[id] = index + arguments.length - 1;
+            }
+        }
+        return this;
+    };
+    Container.prototype._findChildAtPosition = function (line, col) {
+        var found = undefined;
+        this.each(function (node) {
+            if (node.atPosition) {
+                var foundChild = node.atPosition(line, col);
+                if (foundChild) {
+                    found = foundChild;
+                    return false;
+                }
+            }
+            else if (node.isAtPosition(line, col)) {
+                found = node;
+                return false;
+            }
+        });
+        return found;
+    };
+    /**
+     * Return the most specific node at the line and column number given.
+     * The source location is based on the original parsed location, locations aren't
+     * updated as selector nodes are mutated.
+     *
+     * Note that this location is relative to the location of the first character
+     * of the selector, and not the location of the selector in the overall document
+     * when used in conjunction with postcss.
+     *
+     * If not found, returns undefined.
+     * @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)
+     */
+    Container.prototype.atPosition = function (line, col) {
+        if (this.isAtPosition(line, col)) {
+            return this._findChildAtPosition(line, col) || this;
+        }
+        else {
+            return undefined;
+        }
+    };
+    Container.prototype._inferEndPosition = function () {
+        if (this.last && this.last.source && this.last.source.end) {
+            this.source = this.source || {};
+            this.source.end = this.source.end || {};
+            Object.assign(this.source.end, this.last.source.end);
+        }
+    };
+    Container.prototype.each = function (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;
+        }
+    };
+    Container.prototype.walk = function (callback, depth) {
+        if (depth === void 0) { depth = 0; }
+        // Bound recursion so a pathologically deep node tree raises a catchable
+        // error instead of overflowing the call stack (CVE-2026-9358 / CWE-674).
+        if (depth > util_1.MAX_NESTING_DEPTH) {
+            throw new Error("Cannot walk selector: nesting depth exceeds the maximum of ".concat(util_1.MAX_NESTING_DEPTH, "."));
+        }
+        return this.each(function (node, i) {
+            var result = callback(node, i);
+            if (result !== false && node.length) {
+                result = node.walk(callback, depth + 1);
+            }
+            if (result === false) {
+                return false;
+            }
+        });
+    };
+    Container.prototype.walkAttributes = function (callback) {
+        var _this = this;
+        return this.walk(function (selector) {
+            if (selector.type === types.ATTRIBUTE) {
+                return callback.call(_this, selector);
+            }
+        });
+    };
+    Container.prototype.walkClasses = function (callback) {
+        var _this = this;
+        return this.walk(function (selector) {
+            if (selector.type === types.CLASS) {
+                return callback.call(_this, selector);
+            }
+        });
+    };
+    Container.prototype.walkCombinators = function (callback) {
+        var _this = this;
+        return this.walk(function (selector) {
+            if (selector.type === types.COMBINATOR) {
+                return callback.call(_this, selector);
+            }
+        });
+    };
+    Container.prototype.walkComments = function (callback) {
+        var _this = this;
+        return this.walk(function (selector) {
+            if (selector.type === types.COMMENT) {
+                return callback.call(_this, selector);
+            }
+        });
+    };
+    Container.prototype.walkIds = function (callback) {
+        var _this = this;
+        return this.walk(function (selector) {
+            if (selector.type === types.ID) {
+                return callback.call(_this, selector);
+            }
+        });
+    };
+    Container.prototype.walkNesting = function (callback) {
+        var _this = this;
+        return this.walk(function (selector) {
+            if (selector.type === types.NESTING) {
+                return callback.call(_this, selector);
+            }
+        });
+    };
+    Container.prototype.walkPseudos = function (callback) {
+        var _this = this;
+        return this.walk(function (selector) {
+            if (selector.type === types.PSEUDO) {
+                return callback.call(_this, selector);
+            }
+        });
+    };
+    Container.prototype.walkTags = function (callback) {
+        var _this = this;
+        return this.walk(function (selector) {
+            if (selector.type === types.TAG) {
+                return callback.call(_this, selector);
+            }
+        });
+    };
+    Container.prototype.walkUniversals = function (callback) {
+        var _this = this;
+        return this.walk(function (selector) {
+            if (selector.type === types.UNIVERSAL) {
+                return callback.call(_this, selector);
+            }
+        });
+    };
+    Container.prototype.split = function (callback) {
+        var _this = this;
+        var current = [];
+        return this.reduce(function (memo, node, index) {
+            var split = callback.call(_this, node);
+            current.push(node);
+            if (split) {
+                memo.push(current);
+                current = [];
+            }
+            else if (index === _this.length - 1) {
+                memo.push(current);
+            }
+            return memo;
+        }, []);
+    };
+    Container.prototype.map = function (callback) {
+        return this.nodes.map(callback);
+    };
+    Container.prototype.reduce = function (callback, memo) {
+        return this.nodes.reduce(callback, memo);
+    };
+    Container.prototype.every = function (callback) {
+        return this.nodes.every(callback);
+    };
+    Container.prototype.some = function (callback) {
+        return this.nodes.some(callback);
+    };
+    Container.prototype.filter = function (callback) {
+        return this.nodes.filter(callback);
+    };
+    Container.prototype.sort = function (callback) {
+        return this.nodes.sort(callback);
+    };
+    Container.prototype.toString = function (options) {
+        if (options === void 0) { options = {}; }
+        return this._stringify(options, 0, (0, util_1.resolveMaxNestingDepth)(options.maxNestingDepth));
+    };
+    Container.prototype._stringify = function (options, depth, max) {
+        var _this = this;
+        return this.map(function (child) { return _this._stringifyChild(child, options, depth, max); }).join("");
+    };
+    // Serialize a child node. Historically `toString` used `this.map(String)`,
+    // which leniently coerced anything — including raw arrays inserted via
+    // `replaceWith(array)` / `insertBefore` / `insertAfter` (e.g. Tailwind's
+    // `:merge()` expansion). Fall back to `String(child)` for values that are not
+    // parser nodes so that behaviour is preserved.
+    Container.prototype._stringifyChild = function (child, options, depth, max) {
+        return typeof child._stringify === "function"
+            ? child._stringify(options, depth, max)
+            : String(child);
+    };
+    return Container;
+}(node_1.default));
+exports.default = Container;
+//# sourceMappingURL=container.js.map

node_modules/postcss-selector-parser/dist/selectors/guards.js

@@ -0,0 +1,61 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUniversal = exports.isTag = exports.isString = exports.isSelector = exports.isRoot = exports.isPseudo = exports.isNesting = exports.isIdentifier = exports.isComment = exports.isCombinator = exports.isClassName = exports.isAttribute = void 0;
+exports.isNode = isNode;
+exports.isPseudoElement = isPseudoElement;
+exports.isPseudoClass = isPseudoClass;
+exports.isContainer = isContainer;
+exports.isNamespace = isNamespace;
+var types_1 = require("./types");
+var IS_TYPE = (_a = {},
+    _a[types_1.ATTRIBUTE] = true,
+    _a[types_1.CLASS] = true,
+    _a[types_1.COMBINATOR] = true,
+    _a[types_1.COMMENT] = true,
+    _a[types_1.ID] = true,
+    _a[types_1.NESTING] = true,
+    _a[types_1.PSEUDO] = true,
+    _a[types_1.ROOT] = true,
+    _a[types_1.SELECTOR] = true,
+    _a[types_1.STRING] = true,
+    _a[types_1.TAG] = true,
+    _a[types_1.UNIVERSAL] = true,
+    _a);
+function isNode(node) {
+    return typeof node === "object" && IS_TYPE[node.type];
+}
+function isNodeType(type, node) {
+    return isNode(node) && node.type === type;
+}
+exports.isAttribute = isNodeType.bind(null, types_1.ATTRIBUTE);
+exports.isClassName = isNodeType.bind(null, types_1.CLASS);
+exports.isCombinator = isNodeType.bind(null, types_1.COMBINATOR);
+exports.isComment = isNodeType.bind(null, types_1.COMMENT);
+exports.isIdentifier = isNodeType.bind(null, types_1.ID);
+exports.isNesting = isNodeType.bind(null, types_1.NESTING);
+exports.isPseudo = isNodeType.bind(null, types_1.PSEUDO);
+exports.isRoot = isNodeType.bind(null, types_1.ROOT);
+exports.isSelector = isNodeType.bind(null, types_1.SELECTOR);
+exports.isString = isNodeType.bind(null, types_1.STRING);
+exports.isTag = isNodeType.bind(null, types_1.TAG);
+exports.isUniversal = isNodeType.bind(null, types_1.UNIVERSAL);
+function isPseudoElement(node) {
+    return ((0, exports.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 (0, exports.isPseudo)(node) && !isPseudoElement(node);
+}
+function isContainer(node) {
+    return !!(isNode(node) && node.walk);
+}
+function isNamespace(node) {
+    return (0, exports.isAttribute)(node) || (0, exports.isTag)(node);
+}
+//# sourceMappingURL=guards.js.map

node_modules/postcss-selector-parser/dist/selectors/id.js

@@ -0,0 +1,36 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var node_1 = __importDefault(require("./node"));
+var types_1 = require("./types");
+var ID = /** @class */ (function (_super) {
+    __extends(ID, _super);
+    function ID(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.ID;
+        return _this;
+    }
+    ID.prototype.valueToString = function () {
+        return "#" + _super.prototype.valueToString.call(this);
+    };
+    return ID;
+}(node_1.default));
+exports.default = ID;
+//# sourceMappingURL=id.js.map

node_modules/postcss-selector-parser/dist/selectors/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./constructors"), exports);
+__exportStar(require("./guards"), exports);
+//# sourceMappingURL=index.js.map

node_modules/postcss-selector-parser/dist/selectors/namespace.js

@@ -0,0 +1,96 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var cssesc_1 = __importDefault(require("cssesc"));
+var util_1 = require("../util");
+var node_1 = __importDefault(require("./node"));
+var Namespace = /** @class */ (function (_super) {
+    __extends(Namespace, _super);
+    function Namespace() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(Namespace.prototype, "namespace", {
+        get: function () {
+            return this._namespace;
+        },
+        set: function (namespace) {
+            if (namespace === true || namespace === "*" || namespace === "&") {
+                this._namespace = namespace;
+                if (this.raws) {
+                    delete this.raws.namespace;
+                }
+                return;
+            }
+            var escaped = (0, cssesc_1.default)(namespace, { isIdentifier: true });
+            this._namespace = namespace;
+            if (escaped !== namespace) {
+                (0, util_1.ensureObject)(this, "raws");
+                this.raws.namespace = escaped;
+            }
+            else if (this.raws) {
+                delete this.raws.namespace;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Namespace.prototype, "ns", {
+        get: function () {
+            return this._namespace;
+        },
+        set: function (namespace) {
+            this.namespace = namespace;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Namespace.prototype, "namespaceString", {
+        get: function () {
+            if (this.namespace) {
+                var ns = this.stringifyProperty("namespace");
+                if (ns === true) {
+                    return "";
+                }
+                else {
+                    return ns;
+                }
+            }
+            else {
+                return "";
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Namespace.prototype.qualifiedName = function (value) {
+        if (this.namespace) {
+            return "".concat(this.namespaceString, "|").concat(value);
+        }
+        else {
+            return value;
+        }
+    };
+    Namespace.prototype.valueToString = function () {
+        return this.qualifiedName(_super.prototype.valueToString.call(this));
+    };
+    return Namespace;
+}(node_1.default));
+exports.default = Namespace;
+//# sourceMappingURL=namespace.js.map

node_modules/postcss-selector-parser/dist/selectors/nesting.js

@@ -0,0 +1,34 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var node_1 = __importDefault(require("./node"));
+var types_1 = require("./types");
+var Nesting = /** @class */ (function (_super) {
+    __extends(Nesting, _super);
+    function Nesting(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.NESTING;
+        _this.value = "&";
+        return _this;
+    }
+    return Nesting;
+}(node_1.default));
+exports.default = Nesting;
+//# sourceMappingURL=nesting.js.map

node_modules/postcss-selector-parser/dist/selectors/node.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../util");
+var cloneNode = function (obj, parent, depth) {
+    if (depth === void 0) { depth = 0; }
+    // Bound recursion so a pathologically deep node tree raises a catchable
+    // error instead of overflowing the call stack (CVE-2026-9358 / CWE-674).
+    if (depth > util_1.MAX_NESTING_DEPTH) {
+        throw new Error("Cannot clone selector: nesting depth exceeds the maximum of ".concat(util_1.MAX_NESTING_DEPTH, "."));
+    }
+    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) {
+                cloned[i] = parent;
+            }
+        }
+        else if (value instanceof Array) {
+            cloned[i] = value.map(function (j) { return cloneNode(j, cloned, depth + 1); });
+        }
+        else {
+            cloned[i] = cloneNode(value, cloned, depth + 1);
+        }
+    }
+    return cloned;
+};
+var Node = /** @class */ (function () {
+    function Node(opts) {
+        if (opts === void 0) { opts = {}; }
+        Object.assign(this, opts);
+        this.spaces = this.spaces || {};
+        this.spaces.before = this.spaces.before || "";
+        this.spaces.after = this.spaces.after || "";
+    }
+    Node.prototype.remove = function () {
+        if (this.parent) {
+            this.parent.removeChild(this);
+        }
+        this.parent = undefined;
+        return this;
+    };
+    Node.prototype.replaceWith = function () {
+        if (this.parent) {
+            for (var index in arguments) {
+                this.parent.insertBefore(this, arguments[index]);
+            }
+            this.remove();
+        }
+        return this;
+    };
+    Node.prototype.next = function () {
+        return this.parent.at(this.parent.index(this) + 1);
+    };
+    Node.prototype.prev = function () {
+        return this.parent.at(this.parent.index(this) - 1);
+    };
+    Node.prototype.clone = function (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.
+     * This allows non standard syntax to be appended to an existing property
+     * by specifying the escaped value. By specifying the escaped value,
+     * illegal characters are allowed to be directly inserted into css output.
+     * @param {string} name the property to set
+     * @param {any} value the unescaped value of the property
+     * @param {string} valueEscaped optional. the escaped value of the property.
+     */
+    Node.prototype.appendToPropertyAndEscape = function (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;
+        }
+        else {
+            delete this.raws[name]; // delete any escaped value that was created by the setter.
+        }
+    };
+    /**
+     * Some non-standard syntax doesn't follow normal escaping rules for css.
+     * This allows the escaped value to be specified directly, allowing illegal
+     * characters to be directly inserted into css output.
+     * @param {string} name the property to set
+     * @param {any} value the unescaped value of the property
+     * @param {string} valueEscaped the escaped value of the property.
+     */
+    Node.prototype.setPropertyAndEscape = function (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
+     * deletes the corresponding raw value causing the stringifier to fallback
+     * to the unescaped value.
+     * @param {string} name the property to set.
+     * @param {any} value The value that is both escaped and unescaped.
+     */
+    Node.prototype.setPropertyWithoutEscape = function (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)
+     */
+    Node.prototype.isAtPosition = function (line, column) {
+        if (this.source && this.source.start && this.source.end) {
+            if (this.source.start.line > line) {
+                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;
+    };
+    Node.prototype.stringifyProperty = function (name) {
+        return (this.raws && this.raws[name]) || this[name];
+    };
+    Object.defineProperty(Node.prototype, "rawSpaceBefore", {
+        get: function () {
+            var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
+            if (rawSpace === undefined) {
+                rawSpace = this.spaces && this.spaces.before;
+            }
+            return rawSpace || "";
+        },
+        set: function (raw) {
+            (0, util_1.ensureObject)(this, "raws", "spaces");
+            this.raws.spaces.before = raw;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Node.prototype, "rawSpaceAfter", {
+        get: function () {
+            var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
+            if (rawSpace === undefined) {
+                rawSpace = this.spaces.after;
+            }
+            return rawSpace || "";
+        },
+        set: function (raw) {
+            (0, util_1.ensureObject)(this, "raws", "spaces");
+            this.raws.spaces.after = raw;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Node.prototype.valueToString = function () {
+        return String(this.stringifyProperty("value"));
+    };
+    Node.prototype.toString = function () {
+        return [this.rawSpaceBefore, this.valueToString(), this.rawSpaceAfter].join("");
+    };
+    // Internal recursion entry point used by Container serialization. Leaf
+    // nodes don't recurse, so they ignore the depth/limit and stringify
+    // themselves. Containers override this to thread the nesting depth.
+    Node.prototype._stringify = function () {
+        return this.toString();
+    };
+    return Node;
+}());
+exports.default = Node;
+//# sourceMappingURL=node.js.map

node_modules/postcss-selector-parser/dist/selectors/pseudo.js

@@ -0,0 +1,45 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var container_1 = __importDefault(require("./container"));
+var types_1 = require("./types");
+var Pseudo = /** @class */ (function (_super) {
+    __extends(Pseudo, _super);
+    function Pseudo(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.PSEUDO;
+        return _this;
+    }
+    Pseudo.prototype._stringify = function (options, depth, max) {
+        var _this = this;
+        if (depth >= max) {
+            throw new Error("Cannot serialize selector: nesting depth exceeds the maximum of ".concat(max, "."));
+        }
+        var params = this.length
+            ? "(" +
+                this.map(function (child) { return _this._stringifyChild(child, options, depth + 1, max); }).join(",") +
+                ")"
+            : "";
+        return [this.rawSpaceBefore, this.stringifyProperty("value"), params, this.rawSpaceAfter].join("");
+    };
+    return Pseudo;
+}(container_1.default));
+exports.default = Pseudo;
+//# sourceMappingURL=pseudo.js.map

node_modules/postcss-selector-parser/dist/selectors/root.js

@@ -0,0 +1,56 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var container_1 = __importDefault(require("./container"));
+var types_1 = require("./types");
+var Root = /** @class */ (function (_super) {
+    __extends(Root, _super);
+    function Root(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.ROOT;
+        return _this;
+    }
+    Root.prototype._stringify = function (options, depth, max) {
+        var _this = this;
+        var str = this.reduce(function (memo, selector) {
+            memo.push(_this._stringifyChild(selector, options, depth, max));
+            return memo;
+        }, []).join(",");
+        return this.trailingComma ? str + "," : str;
+    };
+    Root.prototype.error = function (message, options) {
+        if (this._error) {
+            return this._error(message, options);
+        }
+        else {
+            return new Error(message);
+        }
+    };
+    Object.defineProperty(Root.prototype, "errorGenerator", {
+        set: function (handler) {
+            this._error = handler;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Root;
+}(container_1.default));
+exports.default = Root;
+//# sourceMappingURL=root.js.map

node_modules/postcss-selector-parser/dist/selectors/selector.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var container_1 = __importDefault(require("./container"));
+var types_1 = require("./types");
+var Selector = /** @class */ (function (_super) {
+    __extends(Selector, _super);
+    function Selector(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.SELECTOR;
+        return _this;
+    }
+    return Selector;
+}(container_1.default));
+exports.default = Selector;
+//# sourceMappingURL=selector.js.map

node_modules/postcss-selector-parser/dist/selectors/string.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var node_1 = __importDefault(require("./node"));
+var types_1 = require("./types");
+var String = /** @class */ (function (_super) {
+    __extends(String, _super);
+    function String(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.STRING;
+        return _this;
+    }
+    return String;
+}(node_1.default));
+exports.default = String;
+//# sourceMappingURL=string.js.map

node_modules/postcss-selector-parser/dist/selectors/tag.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var namespace_1 = __importDefault(require("./namespace"));
+var types_1 = require("./types");
+var Tag = /** @class */ (function (_super) {
+    __extends(Tag, _super);
+    function Tag(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.TAG;
+        return _this;
+    }
+    return Tag;
+}(namespace_1.default));
+exports.default = Tag;
+//# sourceMappingURL=tag.js.map

node_modules/postcss-selector-parser/dist/selectors/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNIVERSAL = exports.ATTRIBUTE = exports.CLASS = exports.COMBINATOR = exports.COMMENT = exports.ID = exports.NESTING = exports.PSEUDO = exports.ROOT = exports.SELECTOR = exports.STRING = exports.TAG = void 0;
+exports.TAG = "tag";
+exports.STRING = "string";
+exports.SELECTOR = "selector";
+exports.ROOT = "root";
+exports.PSEUDO = "pseudo";
+exports.NESTING = "nesting";
+exports.ID = "id";
+exports.COMMENT = "comment";
+exports.COMBINATOR = "combinator";
+exports.CLASS = "class";
+exports.ATTRIBUTE = "attribute";
+exports.UNIVERSAL = "universal";
+//# sourceMappingURL=types.js.map

node_modules/postcss-selector-parser/dist/selectors/universal.js

@@ -0,0 +1,34 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var namespace_1 = __importDefault(require("./namespace"));
+var types_1 = require("./types");
+var Universal = /** @class */ (function (_super) {
+    __extends(Universal, _super);
+    function Universal(opts) {
+        var _this = _super.call(this, opts) || this;
+        _this.type = types_1.UNIVERSAL;
+        _this.value = "*";
+        return _this;
+    }
+    return Universal;
+}(namespace_1.default));
+exports.default = Universal;
+//# sourceMappingURL=universal.js.map

node_modules/postcss-selector-parser/dist/sortAscending.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = sortAscending;
+function sortAscending(list) {
+    return list.sort(function (a, b) { return a - b; });
+}
+//# sourceMappingURL=sortAscending.js.map

node_modules/postcss-selector-parser/dist/tokenTypes.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combinator = exports.word = exports.comment = exports.str = exports.tab = exports.newline = exports.feed = exports.cr = exports.backslash = exports.bang = exports.slash = exports.doubleQuote = exports.singleQuote = exports.space = exports.greaterThan = exports.pipe = exports.equals = exports.plus = exports.caret = exports.tilde = exports.dollar = exports.closeSquare = exports.openSquare = exports.closeParenthesis = exports.openParenthesis = exports.semicolon = exports.colon = exports.comma = exports.at = exports.asterisk = exports.ampersand = void 0;
+exports.ampersand = 38; // `&`.charCodeAt(0);
+exports.asterisk = 42; // `*`.charCodeAt(0);
+exports.at = 64; // `@`.charCodeAt(0);
+exports.comma = 44; // `,`.charCodeAt(0);
+exports.colon = 58; // `:`.charCodeAt(0);
+exports.semicolon = 59; // `;`.charCodeAt(0);
+exports.openParenthesis = 40; // `(`.charCodeAt(0);
+exports.closeParenthesis = 41; // `)`.charCodeAt(0);
+exports.openSquare = 91; // `[`.charCodeAt(0);
+exports.closeSquare = 93; // `]`.charCodeAt(0);
+exports.dollar = 36; // `$`.charCodeAt(0);
+exports.tilde = 126; // `~`.charCodeAt(0);
+exports.caret = 94; // `^`.charCodeAt(0);
+exports.plus = 43; // `+`.charCodeAt(0);
+exports.equals = 61; // `=`.charCodeAt(0);
+exports.pipe = 124; // `|`.charCodeAt(0);
+exports.greaterThan = 62; // `>`.charCodeAt(0);
+exports.space = 32; // ` `.charCodeAt(0);
+exports.singleQuote = 39; // `'`.charCodeAt(0);
+exports.doubleQuote = 34; // `"`.charCodeAt(0);
+exports.slash = 47; // `/`.charCodeAt(0);
+exports.bang = 33; // `!`.charCodeAt(0);
+exports.backslash = 92; // '\\'.charCodeAt(0);
+exports.cr = 13; // '\r'.charCodeAt(0);
+exports.feed = 12; // '\f'.charCodeAt(0);
+exports.newline = 10; // '\n'.charCodeAt(0);
+exports.tab = 9; // '\t'.charCodeAt(0);
+// Expose aliases primarily for readability.
+exports.str = exports.singleQuote;
+// No good single character representation!
+exports.comment = -1;
+exports.word = -2;
+exports.combinator = -3;
+//# sourceMappingURL=tokenTypes.js.map

node_modules/postcss-selector-parser/dist/tokenize.js

@@ -0,0 +1,301 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIELDS = void 0;
+exports.default = tokenize;
+var t = __importStar(require("./tokenTypes"));
+var unescapable = (_a = {},
+    _a[t.tab] = true,
+    _a[t.newline] = true,
+    _a[t.cr] = true,
+    _a[t.feed] = true,
+    _a);
+var wordDelimiters = (_b = {},
+    _b[t.space] = true,
+    _b[t.tab] = true,
+    _b[t.newline] = true,
+    _b[t.cr] = true,
+    _b[t.feed] = true,
+    _b[t.ampersand] = true,
+    _b[t.asterisk] = true,
+    _b[t.bang] = true,
+    _b[t.comma] = true,
+    _b[t.colon] = true,
+    _b[t.semicolon] = true,
+    _b[t.openParenthesis] = true,
+    _b[t.closeParenthesis] = true,
+    _b[t.openSquare] = true,
+    _b[t.closeSquare] = true,
+    _b[t.singleQuote] = true,
+    _b[t.doubleQuote] = true,
+    _b[t.plus] = true,
+    _b[t.pipe] = true,
+    _b[t.tilde] = true,
+    _b[t.greaterThan] = true,
+    _b[t.equals] = true,
+    _b[t.dollar] = true,
+    _b[t.caret] = true,
+    _b[t.slash] = true,
+    _b);
+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 {string} css The string in which the word begins
+ * @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;
+        }
+        else if (code === t.backslash) {
+            next = consumeEscape(css, next) + 1;
+        }
+        else {
+            // All other characters are part of the word
+            next++;
+        }
+    } while (next < css.length);
+    return next - 1;
+}
+/**
+ *  Returns the last index of the escape sequence
+ * @param {string} css The string in which the sequence begins
+ * @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]) {
+        // just consume the escape char
+    }
+    else if (hex[code]) {
+        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
+        if (hexDigits < 6 && code === t.space) {
+            next++;
+        }
+    }
+    else {
+        // the next char is part of the current word
+        next++;
+    }
+    return next;
+}
+exports.FIELDS = {
+    TYPE: 0,
+    START_LINE: 1,
+    START_COL: 2,
+    END_LINE: 3,
+    END_COL: 4,
+    START_POS: 5,
+    END_POS: 6,
+};
+function tokenize(input) {
+    var tokens = [];
+    var css = input.css.valueOf();
+    var length = css.length;
+    var offset = -1;
+    var line = 1;
+    var start = 0;
+    var end = 0;
+    var code, content, endColumn, endLine, escaped, escapePos, last, lines, next, nextLine, nextOffset, quote, tokenType;
+    function unclosed(what, fix) {
+        if (input.safe) {
+            // fyi: this is never set to true.
+            css += fix;
+            next = css.length - 1;
+        }
+        else {
+            throw input.error("Unclosed " + what, line, start - offset, start);
+        }
+    }
+    while (start < length) {
+        code = css.charCodeAt(start);
+        if (code === t.newline) {
+            offset = start;
+            line += 1;
+        }
+        switch (code) {
+            case t.space:
+            case t.tab:
+            case t.newline:
+            case t.cr:
+            case t.feed:
+                next = start;
+                do {
+                    next += 1;
+                    code = css.charCodeAt(next);
+                    if (code === t.newline) {
+                        offset = next;
+                        line += 1;
+                    }
+                } while (code === t.space ||
+                    code === t.newline ||
+                    code === t.tab ||
+                    code === t.cr ||
+                    code === t.feed);
+                tokenType = t.space;
+                endLine = line;
+                endColumn = next - offset - 1;
+                end = next;
+                break;
+            case t.plus:
+            case t.greaterThan:
+            case t.tilde:
+            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;
+                endColumn = start - offset;
+                end = next;
+                break;
+            // Consume these characters as single tokens.
+            case t.asterisk:
+            case t.ampersand:
+            case t.bang:
+            case t.comma:
+            case t.equals:
+            case t.dollar:
+            case t.caret:
+            case t.openSquare:
+            case t.closeSquare:
+            case t.colon:
+            case t.semicolon:
+            case t.openParenthesis:
+            case t.closeParenthesis:
+                next = start;
+                tokenType = code;
+                endLine = line;
+                endColumn = start - offset;
+                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;
+                        escaped = !escaped;
+                    }
+                } while (escaped);
+                tokenType = t.str;
+                endLine = line;
+                endColumn = start - offset;
+                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 = next - lines[last].length;
+                    }
+                    else {
+                        nextLine = line;
+                        nextOffset = offset;
+                    }
+                    tokenType = t.comment;
+                    line = nextLine;
+                    endLine = nextLine;
+                    endColumn = next - nextOffset;
+                }
+                else if (code === t.slash) {
+                    next = start;
+                    tokenType = code;
+                    endLine = line;
+                    endColumn = start - offset;
+                    end = next + 1;
+                }
+                else {
+                    next = consumeWord(css, start);
+                    tokenType = t.word;
+                    endLine = line;
+                    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
+            end, // [6] End position
+        ]);
+        // Reset offset for the next token
+        if (nextOffset) {
+            offset = nextOffset;
+            nextOffset = null;
+        }
+        start = end;
+    }
+    return tokens;
+}
+//# sourceMappingURL=tokenize.js.map

node_modules/postcss-selector-parser/dist/util/ensureObject.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ensureObject;
+function ensureObject(obj) {
+    var props = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        props[_i - 1] = arguments[_i];
+    }
+    while (props.length > 0) {
+        var prop = props.shift();
+        if (!obj[prop]) {
+            obj[prop] = {};
+        }
+        obj = obj[prop];
+    }
+}
+//# sourceMappingURL=ensureObject.js.map

node_modules/postcss-selector-parser/dist/util/getProp.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getProp;
+function getProp(obj) {
+    var props = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        props[_i - 1] = arguments[_i];
+    }
+    while (props.length > 0) {
+        var prop = props.shift();
+        if (!obj[prop]) {
+            return undefined;
+        }
+        obj = obj[prop];
+    }
+    return obj;
+}
+//# sourceMappingURL=getProp.js.map

node_modules/postcss-selector-parser/dist/util/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_NESTING_DEPTH = exports.resolveMaxNestingDepth = exports.stripComments = exports.ensureObject = exports.getProp = exports.unesc = void 0;
+var unesc_1 = require("./unesc");
+Object.defineProperty(exports, "unesc", { enumerable: true, get: function () { return __importDefault(unesc_1).default; } });
+var getProp_1 = require("./getProp");
+Object.defineProperty(exports, "getProp", { enumerable: true, get: function () { return __importDefault(getProp_1).default; } });
+var ensureObject_1 = require("./ensureObject");
+Object.defineProperty(exports, "ensureObject", { enumerable: true, get: function () { return __importDefault(ensureObject_1).default; } });
+var stripComments_1 = require("./stripComments");
+Object.defineProperty(exports, "stripComments", { enumerable: true, get: function () { return __importDefault(stripComments_1).default; } });
+var maxNestingDepth_1 = require("./maxNestingDepth");
+Object.defineProperty(exports, "resolveMaxNestingDepth", { enumerable: true, get: function () { return __importDefault(maxNestingDepth_1).default; } });
+Object.defineProperty(exports, "MAX_NESTING_DEPTH", { enumerable: true, get: function () { return maxNestingDepth_1.MAX_NESTING_DEPTH; } });
+//# sourceMappingURL=index.js.map

node_modules/postcss-selector-parser/dist/util/maxNestingDepth.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_NESTING_DEPTH = void 0;
+exports.default = resolveMaxNestingDepth;
+/**
+ * The default maximum selector nesting depth allowed when parsing or
+ * serializing a selector. Going beyond this would otherwise recurse deeply
+ * enough to overflow the call stack (CVE-2026-9358 / CWE-674). Real-world
+ * selectors never get anywhere near this, so it acts purely as a safety net
+ * that turns an uncatchable stack overflow into a catchable error.
+ */
+exports.MAX_NESTING_DEPTH = 256;
+/**
+ * Coerce a user-supplied nesting-depth limit into a safe value. Anything that
+ * is not a non-negative safe integer (NaN, Infinity, negative numbers, or a
+ * non-number) would disable or break the guard, so it falls back to the
+ * default.
+ *
+ * @param {unknown} value the limit provided through the `maxNestingDepth` option
+ * @returns {number} a safe, non-negative integer limit
+ */
+function resolveMaxNestingDepth(value) {
+    return Number.isSafeInteger(value) && value >= 0 ? value : exports.MAX_NESTING_DEPTH;
+}
+//# sourceMappingURL=maxNestingDepth.js.map

node_modules/postcss-selector-parser/dist/util/stripComments.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: 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;
+}
+//# sourceMappingURL=stripComments.js.map

node_modules/postcss-selector-parser/dist/util/unesc.js

@@ -0,0 +1,72 @@
+"use strict";
+// Many thanks for this post which made this migration much easier.
+// https://mathiasbynens.be/notes/css-escapes
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = unesc;
+/**
+ *
+ * @param {string} str
+ * @returns {[string, number]|undefined}
+ */
+function gobbleHex(str) {
+    var lower = str.toLowerCase();
+    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
+        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
+    // "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 `\\\\`
+            // 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
+            // https://github.com/postcss/postcss-selector-parser/commit/01a6b346e3612ce1ab20219acc26abdc259ccefb
+            if (str.length === i + 1) {
+                ret += str[i];
+            }
+            continue;
+        }
+        ret += str[i];
+    }
+    return ret;
+}
+//# sourceMappingURL=unesc.js.map