@node-core/utils 7.2.0 → 7.2.2

package/node_modules/css-what/lib/commonjs/types.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AttributeAction = exports.IgnoreCaseMode = exports.SelectorType = void 0;
-var SelectorType;
-(function (SelectorType) {
-    SelectorType["Attribute"] = "attribute";
-    SelectorType["Pseudo"] = "pseudo";
-    SelectorType["PseudoElement"] = "pseudo-element";
-    SelectorType["Tag"] = "tag";
-    SelectorType["Universal"] = "universal";
-    // Traversals
-    SelectorType["Adjacent"] = "adjacent";
-    SelectorType["Child"] = "child";
-    SelectorType["Descendant"] = "descendant";
-    SelectorType["Parent"] = "parent";
-    SelectorType["Sibling"] = "sibling";
-    SelectorType["ColumnCombinator"] = "column-combinator";
-})(SelectorType = exports.SelectorType || (exports.SelectorType = {}));
-/**
- * Modes for ignore case.
- *
- * This could be updated to an enum, and the object is
- * the current stand-in that will allow code to be updated
- * without big changes.
- */
-exports.IgnoreCaseMode = {
-    Unknown: null,
-    QuirksMode: "quirks",
-    IgnoreCase: true,
-    CaseSensitive: false,
-};
-var AttributeAction;
-(function (AttributeAction) {
-    AttributeAction["Any"] = "any";
-    AttributeAction["Element"] = "element";
-    AttributeAction["End"] = "end";
-    AttributeAction["Equals"] = "equals";
-    AttributeAction["Exists"] = "exists";
-    AttributeAction["Hyphen"] = "hyphen";
-    AttributeAction["Not"] = "not";
-    AttributeAction["Start"] = "start";
-})(AttributeAction = exports.AttributeAction || (exports.AttributeAction = {}));

package/node_modules/css-what/lib/es/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./types";
-export { isTraversal, parse } from "./parse";
-export { stringify } from "./stringify";
-//# sourceMappingURL=index.d.ts.map

package/node_modules/css-what/lib/es/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/node_modules/css-what/lib/es/index.js

@@ -1,3 +0,0 @@
-export * from "./types";
-export { isTraversal, parse } from "./parse";
-export { stringify } from "./stringify";

package/node_modules/css-what/lib/es/parse.d.ts

@@ -1,20 +0,0 @@
-import { Selector, Traversal } from "./types";
-/**
- * Checks whether a specific selector is a traversal.
- * This is useful eg. in swapping the order of elements that
- * are not traversals.
- *
- * @param selector Selector to check.
- */
-export declare function isTraversal(selector: Selector): selector is Traversal;
-/**
- * Parses `selector`, optionally with the passed `options`.
- *
- * @param selector Selector to parse.
- * @param options Options for parsing.
- * @returns Returns a two-dimensional array.
- * The first dimension represents selectors separated by commas (eg. `sub1, sub2`),
- * the second contains the relevant tokens for that selector.
- */
-export declare function parse(selector: string): Selector[][];
-//# sourceMappingURL=parse.d.ts.map

package/node_modules/css-what/lib/es/parse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/parse.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,QAAQ,EAGR,SAAS,EAIZ,MAAM,SAAS,CAAC;AA6DjB;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,IAAI,SAAS,CAYrE;AAoCD;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,EAAE,EAAE,CAUpD"}

package/node_modules/css-what/lib/es/parse.js

@@ -1,420 +0,0 @@
-import { SelectorType, AttributeAction, } from "./types";
-const reName = /^[^\\#]?(?:\\(?:[\da-f]{1,6}\s?|.)|[\w\-\u00b0-\uFFFF])+/;
-const reEscape = /\\([\da-f]{1,6}\s?|(\s)|.)/gi;
-const actionTypes = new Map([
-    [126 /* Tilde */, AttributeAction.Element],
-    [94 /* Circumflex */, AttributeAction.Start],
-    [36 /* Dollar */, AttributeAction.End],
-    [42 /* Asterisk */, AttributeAction.Any],
-    [33 /* ExclamationMark */, AttributeAction.Not],
-    [124 /* Pipe */, AttributeAction.Hyphen],
-]);
-// Pseudos, whose data property is parsed as well.
-const unpackPseudos = new Set([
-    "has",
-    "not",
-    "matches",
-    "is",
-    "where",
-    "host",
-    "host-context",
-]);
-/**
- * Checks whether a specific selector is a traversal.
- * This is useful eg. in swapping the order of elements that
- * are not traversals.
- *
- * @param selector Selector to check.
- */
-export function isTraversal(selector) {
-    switch (selector.type) {
-        case SelectorType.Adjacent:
-        case SelectorType.Child:
-        case SelectorType.Descendant:
-        case SelectorType.Parent:
-        case SelectorType.Sibling:
-        case SelectorType.ColumnCombinator:
-            return true;
-        default:
-            return false;
-    }
-}
-const stripQuotesFromPseudos = new Set(["contains", "icontains"]);
-// Unescape function taken from https://github.com/jquery/sizzle/blob/master/src/sizzle.js#L152
-function funescape(_, escaped, escapedWhitespace) {
-    const high = parseInt(escaped, 16) - 0x10000;
-    // NaN means non-codepoint
-    return high !== high || escapedWhitespace
-        ? escaped
-        : high < 0
-            ? // BMP codepoint
-                String.fromCharCode(high + 0x10000)
-            : // Supplemental Plane codepoint (surrogate pair)
-                String.fromCharCode((high >> 10) | 0xd800, (high & 0x3ff) | 0xdc00);
-}
-function unescapeCSS(str) {
-    return str.replace(reEscape, funescape);
-}
-function isQuote(c) {
-    return c === 39 /* SingleQuote */ || c === 34 /* DoubleQuote */;
-}
-function isWhitespace(c) {
-    return (c === 32 /* Space */ ||
-        c === 9 /* Tab */ ||
-        c === 10 /* NewLine */ ||
-        c === 12 /* FormFeed */ ||
-        c === 13 /* CarriageReturn */);
-}
-/**
- * Parses `selector`, optionally with the passed `options`.
- *
- * @param selector Selector to parse.
- * @param options Options for parsing.
- * @returns Returns a two-dimensional array.
- * The first dimension represents selectors separated by commas (eg. `sub1, sub2`),
- * the second contains the relevant tokens for that selector.
- */
-export function parse(selector) {
-    const subselects = [];
-    const endIndex = parseSelector(subselects, `${selector}`, 0);
-    if (endIndex < selector.length) {
-        throw new Error(`Unmatched selector: ${selector.slice(endIndex)}`);
-    }
-    return subselects;
-}
-function parseSelector(subselects, selector, selectorIndex) {
-    let tokens = [];
-    function getName(offset) {
-        const match = selector.slice(selectorIndex + offset).match(reName);
-        if (!match) {
-            throw new Error(`Expected name, found ${selector.slice(selectorIndex)}`);
-        }
-        const [name] = match;
-        selectorIndex += offset + name.length;
-        return unescapeCSS(name);
-    }
-    function stripWhitespace(offset) {
-        selectorIndex += offset;
-        while (selectorIndex < selector.length &&
-            isWhitespace(selector.charCodeAt(selectorIndex))) {
-            selectorIndex++;
-        }
-    }
-    function readValueWithParenthesis() {
-        selectorIndex += 1;
-        const start = selectorIndex;
-        let counter = 1;
-        for (; counter > 0 && selectorIndex < selector.length; selectorIndex++) {
-            if (selector.charCodeAt(selectorIndex) ===
-                40 /* LeftParenthesis */ &&
-                !isEscaped(selectorIndex)) {
-                counter++;
-            }
-            else if (selector.charCodeAt(selectorIndex) ===
-                41 /* RightParenthesis */ &&
-                !isEscaped(selectorIndex)) {
-                counter--;
-            }
-        }
-        if (counter) {
-            throw new Error("Parenthesis not matched");
-        }
-        return unescapeCSS(selector.slice(start, selectorIndex - 1));
-    }
-    function isEscaped(pos) {
-        let slashCount = 0;
-        while (selector.charCodeAt(--pos) === 92 /* BackSlash */)
-            slashCount++;
-        return (slashCount & 1) === 1;
-    }
-    function ensureNotTraversal() {
-        if (tokens.length > 0 && isTraversal(tokens[tokens.length - 1])) {
-            throw new Error("Did not expect successive traversals.");
-        }
-    }
-    function addTraversal(type) {
-        if (tokens.length > 0 &&
-            tokens[tokens.length - 1].type === SelectorType.Descendant) {
-            tokens[tokens.length - 1].type = type;
-            return;
-        }
-        ensureNotTraversal();
-        tokens.push({ type });
-    }
-    function addSpecialAttribute(name, action) {
-        tokens.push({
-            type: SelectorType.Attribute,
-            name,
-            action,
-            value: getName(1),
-            namespace: null,
-            ignoreCase: "quirks",
-        });
-    }
-    /**
-     * We have finished parsing the current part of the selector.
-     *
-     * Remove descendant tokens at the end if they exist,
-     * and return the last index, so that parsing can be
-     * picked up from here.
-     */
-    function finalizeSubselector() {
-        if (tokens.length &&
-            tokens[tokens.length - 1].type === SelectorType.Descendant) {
-            tokens.pop();
-        }
-        if (tokens.length === 0) {
-            throw new Error("Empty sub-selector");
-        }
-        subselects.push(tokens);
-    }
-    stripWhitespace(0);
-    if (selector.length === selectorIndex) {
-        return selectorIndex;
-    }
-    loop: while (selectorIndex < selector.length) {
-        const firstChar = selector.charCodeAt(selectorIndex);
-        switch (firstChar) {
-            // Whitespace
-            case 32 /* Space */:
-            case 9 /* Tab */:
-            case 10 /* NewLine */:
-            case 12 /* FormFeed */:
-            case 13 /* CarriageReturn */: {
-                if (tokens.length === 0 ||
-                    tokens[0].type !== SelectorType.Descendant) {
-                    ensureNotTraversal();
-                    tokens.push({ type: SelectorType.Descendant });
-                }
-                stripWhitespace(1);
-                break;
-            }
-            // Traversals
-            case 62 /* GreaterThan */: {
-                addTraversal(SelectorType.Child);
-                stripWhitespace(1);
-                break;
-            }
-            case 60 /* LessThan */: {
-                addTraversal(SelectorType.Parent);
-                stripWhitespace(1);
-                break;
-            }
-            case 126 /* Tilde */: {
-                addTraversal(SelectorType.Sibling);
-                stripWhitespace(1);
-                break;
-            }
-            case 43 /* Plus */: {
-                addTraversal(SelectorType.Adjacent);
-                stripWhitespace(1);
-                break;
-            }
-            // Special attribute selectors: .class, #id
-            case 46 /* Period */: {
-                addSpecialAttribute("class", AttributeAction.Element);
-                break;
-            }
-            case 35 /* Hash */: {
-                addSpecialAttribute("id", AttributeAction.Equals);
-                break;
-            }
-            case 91 /* LeftSquareBracket */: {
-                stripWhitespace(1);
-                // Determine attribute name and namespace
-                let name;
-                let namespace = null;
-                if (selector.charCodeAt(selectorIndex) === 124 /* Pipe */) {
-                    // Equivalent to no namespace
-                    name = getName(1);
-                }
-                else if (selector.startsWith("*|", selectorIndex)) {
-                    namespace = "*";
-                    name = getName(2);
-                }
-                else {
-                    name = getName(0);
-                    if (selector.charCodeAt(selectorIndex) === 124 /* Pipe */ &&
-                        selector.charCodeAt(selectorIndex + 1) !==
-                            61 /* Equal */) {
-                        namespace = name;
-                        name = getName(1);
-                    }
-                }
-                stripWhitespace(0);
-                // Determine comparison operation
-                let action = AttributeAction.Exists;
-                const possibleAction = actionTypes.get(selector.charCodeAt(selectorIndex));
-                if (possibleAction) {
-                    action = possibleAction;
-                    if (selector.charCodeAt(selectorIndex + 1) !==
-                        61 /* Equal */) {
-                        throw new Error("Expected `=`");
-                    }
-                    stripWhitespace(2);
-                }
-                else if (selector.charCodeAt(selectorIndex) === 61 /* Equal */) {
-                    action = AttributeAction.Equals;
-                    stripWhitespace(1);
-                }
-                // Determine value
-                let value = "";
-                let ignoreCase = null;
-                if (action !== "exists") {
-                    if (isQuote(selector.charCodeAt(selectorIndex))) {
-                        const quote = selector.charCodeAt(selectorIndex);
-                        let sectionEnd = selectorIndex + 1;
-                        while (sectionEnd < selector.length &&
-                            (selector.charCodeAt(sectionEnd) !== quote ||
-                                isEscaped(sectionEnd))) {
-                            sectionEnd += 1;
-                        }
-                        if (selector.charCodeAt(sectionEnd) !== quote) {
-                            throw new Error("Attribute value didn't end");
-                        }
-                        value = unescapeCSS(selector.slice(selectorIndex + 1, sectionEnd));
-                        selectorIndex = sectionEnd + 1;
-                    }
-                    else {
-                        const valueStart = selectorIndex;
-                        while (selectorIndex < selector.length &&
-                            ((!isWhitespace(selector.charCodeAt(selectorIndex)) &&
-                                selector.charCodeAt(selectorIndex) !==
-                                    93 /* RightSquareBracket */) ||
-                                isEscaped(selectorIndex))) {
-                            selectorIndex += 1;
-                        }
-                        value = unescapeCSS(selector.slice(valueStart, selectorIndex));
-                    }
-                    stripWhitespace(0);
-                    // See if we have a force ignore flag
-                    const forceIgnore = selector.charCodeAt(selectorIndex) | 0x20;
-                    // If the forceIgnore flag is set (either `i` or `s`), use that value
-                    if (forceIgnore === 115 /* LowerS */) {
-                        ignoreCase = false;
-                        stripWhitespace(1);
-                    }
-                    else if (forceIgnore === 105 /* LowerI */) {
-                        ignoreCase = true;
-                        stripWhitespace(1);
-                    }
-                }
-                if (selector.charCodeAt(selectorIndex) !==
-                    93 /* RightSquareBracket */) {
-                    throw new Error("Attribute selector didn't terminate");
-                }
-                selectorIndex += 1;
-                const attributeSelector = {
-                    type: SelectorType.Attribute,
-                    name,
-                    action,
-                    value,
-                    namespace,
-                    ignoreCase,
-                };
-                tokens.push(attributeSelector);
-                break;
-            }
-            case 58 /* Colon */: {
-                if (selector.charCodeAt(selectorIndex + 1) === 58 /* Colon */) {
-                    tokens.push({
-                        type: SelectorType.PseudoElement,
-                        name: getName(2).toLowerCase(),
-                        data: selector.charCodeAt(selectorIndex) ===
-                            40 /* LeftParenthesis */
-                            ? readValueWithParenthesis()
-                            : null,
-                    });
-                    continue;
-                }
-                const name = getName(1).toLowerCase();
-                let data = null;
-                if (selector.charCodeAt(selectorIndex) ===
-                    40 /* LeftParenthesis */) {
-                    if (unpackPseudos.has(name)) {
-                        if (isQuote(selector.charCodeAt(selectorIndex + 1))) {
-                            throw new Error(`Pseudo-selector ${name} cannot be quoted`);
-                        }
-                        data = [];
-                        selectorIndex = parseSelector(data, selector, selectorIndex + 1);
-                        if (selector.charCodeAt(selectorIndex) !==
-                            41 /* RightParenthesis */) {
-                            throw new Error(`Missing closing parenthesis in :${name} (${selector})`);
-                        }
-                        selectorIndex += 1;
-                    }
-                    else {
-                        data = readValueWithParenthesis();
-                        if (stripQuotesFromPseudos.has(name)) {
-                            const quot = data.charCodeAt(0);
-                            if (quot === data.charCodeAt(data.length - 1) &&
-                                isQuote(quot)) {
-                                data = data.slice(1, -1);
-                            }
-                        }
-                        data = unescapeCSS(data);
-                    }
-                }
-                tokens.push({ type: SelectorType.Pseudo, name, data });
-                break;
-            }
-            case 44 /* Comma */: {
-                finalizeSubselector();
-                tokens = [];
-                stripWhitespace(1);
-                break;
-            }
-            default: {
-                if (selector.startsWith("/*", selectorIndex)) {
-                    const endIndex = selector.indexOf("*/", selectorIndex + 2);
-                    if (endIndex < 0) {
-                        throw new Error("Comment was not terminated");
-                    }
-                    selectorIndex = endIndex + 2;
-                    // Remove leading whitespace
-                    if (tokens.length === 0) {
-                        stripWhitespace(0);
-                    }
-                    break;
-                }
-                let namespace = null;
-                let name;
-                if (firstChar === 42 /* Asterisk */) {
-                    selectorIndex += 1;
-                    name = "*";
-                }
-                else if (firstChar === 124 /* Pipe */) {
-                    name = "";
-                    if (selector.charCodeAt(selectorIndex + 1) === 124 /* Pipe */) {
-                        addTraversal(SelectorType.ColumnCombinator);
-                        stripWhitespace(2);
-                        break;
-                    }
-                }
-                else if (reName.test(selector.slice(selectorIndex))) {
-                    name = getName(0);
-                }
-                else {
-                    break loop;
-                }
-                if (selector.charCodeAt(selectorIndex) === 124 /* Pipe */ &&
-                    selector.charCodeAt(selectorIndex + 1) !== 124 /* Pipe */) {
-                    namespace = name;
-                    if (selector.charCodeAt(selectorIndex + 1) ===
-                        42 /* Asterisk */) {
-                        name = "*";
-                        selectorIndex += 2;
-                    }
-                    else {
-                        name = getName(1);
-                    }
-                }
-                tokens.push(name === "*"
-                    ? { type: SelectorType.Universal, namespace }
-                    : { type: SelectorType.Tag, name, namespace });
-            }
-        }
-    }
-    finalizeSubselector();
-    return selectorIndex;
-}

package/node_modules/css-what/lib/es/stringify.d.ts

@@ -1,8 +0,0 @@
-import { Selector } from "./types";
-/**
- * Turns `selector` back into a string.
- *
- * @param selector Selector to stringify.
- */
-export declare function stringify(selector: Selector[][]): string;
-//# sourceMappingURL=stringify.d.ts.map

package/node_modules/css-what/lib/es/stringify.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stringify.d.ts","sourceRoot":"","sources":["../../src/stringify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAiC,MAAM,SAAS,CAAC;AA6BlE;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,GAAG,MAAM,CAIxD"}

package/node_modules/css-what/lib/es/stringify.js

@@ -1,126 +0,0 @@
-import { SelectorType, AttributeAction } from "./types";
-const attribValChars = ["\\", '"'];
-const pseudoValChars = [...attribValChars, "(", ")"];
-const charsToEscapeInAttributeValue = new Set(attribValChars.map((c) => c.charCodeAt(0)));
-const charsToEscapeInPseudoValue = new Set(pseudoValChars.map((c) => c.charCodeAt(0)));
-const charsToEscapeInName = new Set([
-    ...pseudoValChars,
-    "~",
-    "^",
-    "$",
-    "*",
-    "+",
-    "!",
-    "|",
-    ":",
-    "[",
-    "]",
-    " ",
-    ".",
-].map((c) => c.charCodeAt(0)));
-/**
- * Turns `selector` back into a string.
- *
- * @param selector Selector to stringify.
- */
-export function stringify(selector) {
-    return selector
-        .map((token) => token.map(stringifyToken).join(""))
-        .join(", ");
-}
-function stringifyToken(token, index, arr) {
-    switch (token.type) {
-        // Simple types
-        case SelectorType.Child:
-            return index === 0 ? "> " : " > ";
-        case SelectorType.Parent:
-            return index === 0 ? "< " : " < ";
-        case SelectorType.Sibling:
-            return index === 0 ? "~ " : " ~ ";
-        case SelectorType.Adjacent:
-            return index === 0 ? "+ " : " + ";
-        case SelectorType.Descendant:
-            return " ";
-        case SelectorType.ColumnCombinator:
-            return index === 0 ? "|| " : " || ";
-        case SelectorType.Universal:
-            // Return an empty string if the selector isn't needed.
-            return token.namespace === "*" &&
-                index + 1 < arr.length &&
-                "name" in arr[index + 1]
-                ? ""
-                : `${getNamespace(token.namespace)}*`;
-        case SelectorType.Tag:
-            return getNamespacedName(token);
-        case SelectorType.PseudoElement:
-            return `::${escapeName(token.name, charsToEscapeInName)}${token.data === null
-                ? ""
-                : `(${escapeName(token.data, charsToEscapeInPseudoValue)})`}`;
-        case SelectorType.Pseudo:
-            return `:${escapeName(token.name, charsToEscapeInName)}${token.data === null
-                ? ""
-                : `(${typeof token.data === "string"
-                    ? escapeName(token.data, charsToEscapeInPseudoValue)
-                    : stringify(token.data)})`}`;
-        case SelectorType.Attribute: {
-            if (token.name === "id" &&
-                token.action === AttributeAction.Equals &&
-                token.ignoreCase === "quirks" &&
-                !token.namespace) {
-                return `#${escapeName(token.value, charsToEscapeInName)}`;
-            }
-            if (token.name === "class" &&
-                token.action === AttributeAction.Element &&
-                token.ignoreCase === "quirks" &&
-                !token.namespace) {
-                return `.${escapeName(token.value, charsToEscapeInName)}`;
-            }
-            const name = getNamespacedName(token);
-            if (token.action === AttributeAction.Exists) {
-                return `[${name}]`;
-            }
-            return `[${name}${getActionValue(token.action)}="${escapeName(token.value, charsToEscapeInAttributeValue)}"${token.ignoreCase === null ? "" : token.ignoreCase ? " i" : " s"}]`;
-        }
-    }
-}
-function getActionValue(action) {
-    switch (action) {
-        case AttributeAction.Equals:
-            return "";
-        case AttributeAction.Element:
-            return "~";
-        case AttributeAction.Start:
-            return "^";
-        case AttributeAction.End:
-            return "$";
-        case AttributeAction.Any:
-            return "*";
-        case AttributeAction.Not:
-            return "!";
-        case AttributeAction.Hyphen:
-            return "|";
-        case AttributeAction.Exists:
-            throw new Error("Shouldn't be here");
-    }
-}
-function getNamespacedName(token) {
-    return `${getNamespace(token.namespace)}${escapeName(token.name, charsToEscapeInName)}`;
-}
-function getNamespace(namespace) {
-    return namespace !== null
-        ? `${namespace === "*"
-            ? "*"
-            : escapeName(namespace, charsToEscapeInName)}|`
-        : "";
-}
-function escapeName(str, charsToEscape) {
-    let lastIdx = 0;
-    let ret = "";
-    for (let i = 0; i < str.length; i++) {
-        if (charsToEscape.has(str.charCodeAt(i))) {
-            ret += `${str.slice(lastIdx, i)}\\${str.charAt(i)}`;
-            lastIdx = i + 1;
-        }
-    }
-    return ret.length > 0 ? ret + str.slice(lastIdx) : str;
-}