iobroker.mywebui 1.37.21 → 1.37.22

package/www/node_modules/@node-projects/css-parser/dist/stringify/index.d.ts

@@ -0,0 +1,5 @@
+import type { CssStylesheetAST } from '../type.js';
+import { type CompilerOptions } from './compiler.js';
+export type { CompilerOptions };
+declare const _default: (node: CssStylesheetAST, options?: CompilerOptions) => string;
+export default _default;

package/www/node_modules/@node-projects/css-parser/dist/stringify/index.js

@@ -0,0 +1,5 @@
+import Compiler from './compiler.js';
+export default (node, options) => {
+    const compiler = new Compiler(options || {});
+    return compiler.compile(node);
+};

package/www/node_modules/@node-projects/css-parser/dist/type.d.ts

@@ -0,0 +1,205 @@
+import type CssParseError from './CssParseError.js';
+import type Position from './CssPosition.js';
+export declare enum CssTypes {
+    stylesheet = "stylesheet",
+    rule = "rule",
+    declaration = "declaration",
+    comment = "comment",
+    whitespace = "whitespace",
+    atRule = "at-rule",
+    container = "container",
+    charset = "charset",
+    counterStyle = "counter-style",
+    document = "document",
+    customMedia = "custom-media",
+    fontFace = "font-face",
+    fontFeatureValues = "font-feature-values",
+    host = "host",
+    import = "import",
+    keyframes = "keyframes",
+    keyframe = "keyframe",
+    layer = "layer",
+    media = "media",
+    namespace = "namespace",
+    page = "page",
+    pageMarginBox = "page-margin-box",
+    positionTry = "position-try",
+    property = "property",
+    scope = "scope",
+    startingStyle = "starting-style",
+    supports = "supports",
+    viewTransition = "view-transition"
+}
+export type CssCommonAST = {
+    type: CssTypes;
+};
+export type CssCommonPositionAST = CssCommonAST & {
+    position?: Position;
+    parent?: unknown;
+};
+export type CssWhitespaceAST = CssCommonPositionAST & {
+    type: CssTypes.whitespace;
+    value: string;
+};
+export type CssStylesheetAST = CssCommonAST & {
+    type: CssTypes.stylesheet;
+    stylesheet: {
+        source?: string;
+        rules: Array<CssAtRuleAST | CssWhitespaceAST>;
+        parsingErrors?: Array<CssParseError>;
+    };
+};
+export type CssRuleAST = CssCommonPositionAST & {
+    type: CssTypes.rule;
+    selectors: Array<string>;
+    declarations: Array<CssDeclarationAST | CssCommentAST | CssAtRuleAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssDeclarationAST = CssCommonPositionAST & {
+    type: CssTypes.declaration;
+    property: string;
+    value: string;
+    rawBetween?: string;
+    rawValue?: string;
+};
+export type CssCommentAST = CssCommonPositionAST & {
+    type: CssTypes.comment;
+    comment: string;
+};
+export type CssContainerAST = CssCommonPositionAST & {
+    type: CssTypes.container;
+    container: string;
+    rules: Array<CssAtRuleAST | CssDeclarationAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssCharsetAST = CssCommonPositionAST & {
+    type: CssTypes.charset;
+    charset: string;
+    rawSource?: string;
+};
+export type CssCustomMediaAST = CssCommonPositionAST & {
+    type: CssTypes.customMedia;
+    name: string;
+    media: string;
+    rawSource?: string;
+};
+export type CssDocumentAST = CssCommonPositionAST & {
+    type: CssTypes.document;
+    document: string;
+    vendor?: string;
+    rules: Array<CssAtRuleAST | CssDeclarationAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssFontFaceAST = CssCommonPositionAST & {
+    type: CssTypes.fontFace;
+    declarations: Array<CssDeclarationAST | CssCommentAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssHostAST = CssCommonPositionAST & {
+    type: CssTypes.host;
+    rules: Array<CssAtRuleAST | CssDeclarationAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssImportAST = CssCommonPositionAST & {
+    type: CssTypes.import;
+    import: string;
+    rawSource?: string;
+};
+export type CssKeyframesAST = CssCommonPositionAST & {
+    type: CssTypes.keyframes;
+    name: string;
+    vendor?: string;
+    keyframes: Array<CssKeyframeAST | CssCommentAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssKeyframeAST = CssCommonPositionAST & {
+    type: CssTypes.keyframe;
+    values: Array<string>;
+    declarations: Array<CssDeclarationAST | CssCommentAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssLayerAST = CssCommonPositionAST & {
+    type: CssTypes.layer;
+    layer: string;
+    rules?: Array<CssAtRuleAST | CssDeclarationAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+    rawSource?: string;
+};
+export type CssMediaAST = CssCommonPositionAST & {
+    type: CssTypes.media;
+    media: string;
+    rules: Array<CssAtRuleAST | CssDeclarationAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssNamespaceAST = CssCommonPositionAST & {
+    type: CssTypes.namespace;
+    namespace: string;
+    rawSource?: string;
+};
+export type CssPageAST = CssCommonPositionAST & {
+    type: CssTypes.page;
+    selectors: Array<string>;
+    declarations: Array<CssDeclarationAST | CssCommentAST | CssAtRuleAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssSupportsAST = CssCommonPositionAST & {
+    type: CssTypes.supports;
+    supports: string;
+    rules: Array<CssAtRuleAST | CssDeclarationAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssStartingStyleAST = CssCommonPositionAST & {
+    type: CssTypes.startingStyle;
+    rules: Array<CssAtRuleAST | CssDeclarationAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssCounterStyleAST = CssCommonPositionAST & {
+    type: CssTypes.counterStyle;
+    name: string;
+    declarations: Array<CssDeclarationAST | CssCommentAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssFontFeatureValuesAST = CssCommonPositionAST & {
+    type: CssTypes.fontFeatureValues;
+    fontFamily: string;
+    rules: Array<CssAtRuleAST | CssDeclarationAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssPositionTryAST = CssCommonPositionAST & {
+    type: CssTypes.positionTry;
+    name: string;
+    declarations: Array<CssDeclarationAST | CssCommentAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssPropertyAST = CssCommonPositionAST & {
+    type: CssTypes.property;
+    name: string;
+    declarations: Array<CssDeclarationAST | CssCommentAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssScopeAST = CssCommonPositionAST & {
+    type: CssTypes.scope;
+    scope: string;
+    rules: Array<CssAtRuleAST | CssDeclarationAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssViewTransitionAST = CssCommonPositionAST & {
+    type: CssTypes.viewTransition;
+    declarations: Array<CssDeclarationAST | CssCommentAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssPageMarginBoxAST = CssCommonPositionAST & {
+    type: CssTypes.pageMarginBox;
+    name: string;
+    declarations: Array<CssDeclarationAST | CssCommentAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssGenericAtRuleAST = CssCommonPositionAST & {
+    type: CssTypes.atRule;
+    name: string;
+    prelude: string;
+    rules?: Array<CssAtRuleAST | CssDeclarationAST | CssWhitespaceAST>;
+    rawPrelude?: string;
+};
+export type CssAtRuleAST = CssRuleAST | CssCommentAST | CssContainerAST | CssCharsetAST | CssCounterStyleAST | CssCustomMediaAST | CssDocumentAST | CssFontFaceAST | CssFontFeatureValuesAST | CssHostAST | CssImportAST | CssKeyframesAST | CssLayerAST | CssMediaAST | CssNamespaceAST | CssPageAST | CssPageMarginBoxAST | CssPositionTryAST | CssPropertyAST | CssScopeAST | CssSupportsAST | CssStartingStyleAST | CssViewTransitionAST | CssGenericAtRuleAST;
+export type CssAllNodesAST = CssAtRuleAST | CssStylesheetAST | CssDeclarationAST | CssKeyframeAST | CssWhitespaceAST;

package/www/node_modules/@node-projects/css-parser/dist/type.js

@@ -0,0 +1,31 @@
+export var CssTypes;
+(function (CssTypes) {
+    CssTypes["stylesheet"] = "stylesheet";
+    CssTypes["rule"] = "rule";
+    CssTypes["declaration"] = "declaration";
+    CssTypes["comment"] = "comment";
+    CssTypes["whitespace"] = "whitespace";
+    CssTypes["atRule"] = "at-rule";
+    CssTypes["container"] = "container";
+    CssTypes["charset"] = "charset";
+    CssTypes["counterStyle"] = "counter-style";
+    CssTypes["document"] = "document";
+    CssTypes["customMedia"] = "custom-media";
+    CssTypes["fontFace"] = "font-face";
+    CssTypes["fontFeatureValues"] = "font-feature-values";
+    CssTypes["host"] = "host";
+    CssTypes["import"] = "import";
+    CssTypes["keyframes"] = "keyframes";
+    CssTypes["keyframe"] = "keyframe";
+    CssTypes["layer"] = "layer";
+    CssTypes["media"] = "media";
+    CssTypes["namespace"] = "namespace";
+    CssTypes["page"] = "page";
+    CssTypes["pageMarginBox"] = "page-margin-box";
+    CssTypes["positionTry"] = "position-try";
+    CssTypes["property"] = "property";
+    CssTypes["scope"] = "scope";
+    CssTypes["startingStyle"] = "starting-style";
+    CssTypes["supports"] = "supports";
+    CssTypes["viewTransition"] = "view-transition";
+})(CssTypes || (CssTypes = {}));

package/www/node_modules/@node-projects/css-parser/dist/utils/stringSearch.d.ts

@@ -0,0 +1,53 @@
+export declare const MAX_LOOP = 10000;
+/**
+ * Find the first occurrence of any search string in the input string, ignoring escaped characters
+ * @param string - The input string to search in
+ * @param search - Array of strings to search for
+ * @param position - Optional starting position for the search
+ * @returns The index of the first match, or -1 if not found
+ * @throws {Error} If too many escape sequences are encountered (> MAX_LOOP)
+ * @example
+ * ```ts
+ * // Basic search
+ * indexOfArrayNonEscaped('a,b,c', [',']) // 1
+ *
+ * // Handles escaped characters
+ * indexOfArrayNonEscaped('a\\,b,c', [',']) // 4, the first comma is escaped
+ * ```
+ */
+export declare const indexOfArrayNonEscaped: (string: string, search: Array<string>, position?: number) => number;
+/**
+ * Find the first occurrence of any search string in the input string, respecting brackets and quotes
+ * @param string - The input string to search in
+ * @param search - Array of strings to search for
+ * @param position - Optional starting position for the search
+ * @returns The index of the first match, or -1 if not found
+ * @throws {Error} If too many escape sequences are encountered (> MAX_LOOP)
+ * @example
+ * ```ts
+ * // Basic search
+ * indexOfArrayWithBracketAndQuoteSupport('a,b,c', [',']) // 1
+ *
+ * // Respects brackets - won't match inside ()
+ * indexOfArrayWithBracketAndQuoteSupport('(a,b),c', [',']) // 4, ignores the comma inside ()
+ *
+ * // Respects quotes - won't match inside quotes
+ * indexOfArrayWithBracketAndQuoteSupport('"a,b",c', [',']) // 4, ignores the comma inside quotes
+ * indexOfArrayWithBracketAndQuoteSupport("'a,b',c", [',']) // 4, ignores the comma inside quotes
+ *
+ * // Handles escaped characters
+ * indexOfArrayWithBracketAndQuoteSupport('a\\,b,c', [',']) // 4, the first comma is escaped
+ * ```
+ */
+export declare const indexOfArrayWithBracketAndQuoteSupport: (string: string, search: Array<string>, position?: number) => number;
+/**
+ * Split a string by search tokens, respecting brackets and quotes
+ * @example
+ * ```ts
+ * splitWithBracketAndQuoteSupport('a,b', [',']) // ['a', 'b']
+ * splitWithBracketAndQuoteSupport('a,(b,c)', [',']) // ['a', '(b,c)']
+ * splitWithBracketAndQuoteSupport('a,"b,c"', [',']) // ['a', '"b,c"']
+ * splitWithBracketAndQuoteSupport("a,'b,c'", [',']) // ['a', "'b,c'"]
+ * ```
+ */
+export declare const splitWithBracketAndQuoteSupport: (string: string, search: Array<string>) => Array<string>;

package/www/node_modules/@node-projects/css-parser/dist/utils/stringSearch.js

@@ -0,0 +1,166 @@
+export const MAX_LOOP = 10000;
+// ─── Character-code constants for fast comparisons ───────────────────────────
+const Ch_BACKSLASH = 92; //  \
+const Ch_OPEN_PAREN = 40; //  (
+const Ch_DOUBLE_QUOTE = 34; //  "
+const Ch_SINGLE_QUOTE = 39; //  '
+/**
+ * Find the first occurrence of any search string in the input string, ignoring escaped characters
+ * @param string - The input string to search in
+ * @param search - Array of strings to search for
+ * @param position - Optional starting position for the search
+ * @returns The index of the first match, or -1 if not found
+ * @throws {Error} If too many escape sequences are encountered (> MAX_LOOP)
+ * @example
+ * ```ts
+ * // Basic search
+ * indexOfArrayNonEscaped('a,b,c', [',']) // 1
+ *
+ * // Handles escaped characters
+ * indexOfArrayNonEscaped('a\\,b,c', [',']) // 4, the first comma is escaped
+ * ```
+ */
+export const indexOfArrayNonEscaped = (string, search, position) => {
+    let currentPosition = position ?? 0;
+    let maxLoop = MAX_LOOP;
+    do {
+        // Find the minimum index across all search terms and backslash
+        // without allocating temporary arrays.
+        let found = string.indexOf('\\', currentPosition);
+        for (let i = 0; i < search.length; i++) {
+            const idx = string.indexOf(search[i], currentPosition);
+            if (idx !== -1 && (found === -1 || idx < found)) {
+                found = idx;
+            }
+        }
+        if (found === -1) {
+            return -1;
+        }
+        if (string.charCodeAt(found) === Ch_BACKSLASH) {
+            currentPosition = found + 2;
+            maxLoop--;
+        }
+        else {
+            return found;
+        }
+    } while (maxLoop > 0);
+    throw new Error('Too many escaping');
+};
+/**
+ * Find the first occurrence of any search string in the input string, respecting brackets and quotes
+ * @param string - The input string to search in
+ * @param search - Array of strings to search for
+ * @param position - Optional starting position for the search
+ * @returns The index of the first match, or -1 if not found
+ * @throws {Error} If too many escape sequences are encountered (> MAX_LOOP)
+ * @example
+ * ```ts
+ * // Basic search
+ * indexOfArrayWithBracketAndQuoteSupport('a,b,c', [',']) // 1
+ *
+ * // Respects brackets - won't match inside ()
+ * indexOfArrayWithBracketAndQuoteSupport('(a,b),c', [',']) // 4, ignores the comma inside ()
+ *
+ * // Respects quotes - won't match inside quotes
+ * indexOfArrayWithBracketAndQuoteSupport('"a,b",c', [',']) // 4, ignores the comma inside quotes
+ * indexOfArrayWithBracketAndQuoteSupport("'a,b',c", [',']) // 4, ignores the comma inside quotes
+ *
+ * // Handles escaped characters
+ * indexOfArrayWithBracketAndQuoteSupport('a\\,b,c', [',']) // 4, the first comma is escaped
+ * ```
+ */
+export const indexOfArrayWithBracketAndQuoteSupport = (string, search, position) => {
+    let currentSearchPosition = position ?? 0;
+    let maxLoop = MAX_LOOP;
+    do {
+        // Find the minimum index across all search terms plus special characters,
+        // without allocating temporary arrays on each iteration.
+        let firstMatchPos = -1;
+        for (let i = 0; i < search.length; i++) {
+            const idx = string.indexOf(search[i], currentSearchPosition);
+            if (idx !== -1 && (firstMatchPos === -1 || idx < firstMatchPos)) {
+                firstMatchPos = idx;
+            }
+        }
+        const parenIdx = string.indexOf('(', currentSearchPosition);
+        if (parenIdx !== -1 && (firstMatchPos === -1 || parenIdx < firstMatchPos)) {
+            firstMatchPos = parenIdx;
+        }
+        const dqIdx = string.indexOf('"', currentSearchPosition);
+        if (dqIdx !== -1 && (firstMatchPos === -1 || dqIdx < firstMatchPos)) {
+            firstMatchPos = dqIdx;
+        }
+        const sqIdx = string.indexOf("'", currentSearchPosition);
+        if (sqIdx !== -1 && (firstMatchPos === -1 || sqIdx < firstMatchPos)) {
+            firstMatchPos = sqIdx;
+        }
+        const bsIdx = string.indexOf('\\', currentSearchPosition);
+        if (bsIdx !== -1 && (firstMatchPos === -1 || bsIdx < firstMatchPos)) {
+            firstMatchPos = bsIdx;
+        }
+        if (firstMatchPos === -1) {
+            return -1;
+        }
+        const charCode = string.charCodeAt(firstMatchPos);
+        switch (charCode) {
+            case Ch_BACKSLASH:
+                currentSearchPosition = firstMatchPos + 2;
+                break;
+            case Ch_OPEN_PAREN:
+                {
+                    const endPosition = indexOfArrayWithBracketAndQuoteSupport(string, [')'], firstMatchPos + 1);
+                    if (endPosition === -1) {
+                        return -1;
+                    }
+                    currentSearchPosition = endPosition + 1;
+                }
+                break;
+            case Ch_DOUBLE_QUOTE:
+                {
+                    const endQuotePosition = indexOfArrayNonEscaped(string, ['"'], firstMatchPos + 1);
+                    if (endQuotePosition === -1) {
+                        return -1;
+                    }
+                    currentSearchPosition = endQuotePosition + 1;
+                }
+                break;
+            case Ch_SINGLE_QUOTE:
+                {
+                    const endQuotePosition = indexOfArrayNonEscaped(string, ["'"], firstMatchPos + 1);
+                    if (endQuotePosition === -1) {
+                        return -1;
+                    }
+                    currentSearchPosition = endQuotePosition + 1;
+                }
+                break;
+            default:
+                return firstMatchPos;
+        }
+        maxLoop--;
+    } while (maxLoop > 0);
+    throw new Error('Too many escaping');
+};
+/**
+ * Split a string by search tokens, respecting brackets and quotes
+ * @example
+ * ```ts
+ * splitWithBracketAndQuoteSupport('a,b', [',']) // ['a', 'b']
+ * splitWithBracketAndQuoteSupport('a,(b,c)', [',']) // ['a', '(b,c)']
+ * splitWithBracketAndQuoteSupport('a,"b,c"', [',']) // ['a', '"b,c"']
+ * splitWithBracketAndQuoteSupport("a,'b,c'", [',']) // ['a', "'b,c'"]
+ * ```
+ */
+export const splitWithBracketAndQuoteSupport = (string, search) => {
+    const result = [];
+    let currentPosition = 0;
+    while (currentPosition < string.length) {
+        const index = indexOfArrayWithBracketAndQuoteSupport(string, search, currentPosition);
+        if (index === -1) {
+            result.push(string.substring(currentPosition));
+            return result;
+        }
+        result.push(string.substring(currentPosition, index));
+        currentPosition = index + 1;
+    }
+    return result;
+};