iobroker.mywebui 1.37.21 → 1.37.22

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

@@ -0,0 +1,118 @@
+/**
+ * A fast lexer (scanner) for CSS input.
+ *
+ * Inspired by the approach used in es-module-shims / es-module-lexer,
+ * this lexer uses numeric character-code comparisons (`charCodeAt`)
+ * instead of single-character string comparisons, and employs sticky
+ * (`y`-flag) regular expressions matched directly against the full
+ * input to avoid creating temporary substring slices.
+ *
+ * The Lexer keeps an index (`pos`) into the original input.  Simple
+ * token types (whitespace, braces, colons, semicolons, commas) are
+ * scanned character-by-character via `charCodeAt`, avoiding regular
+ * expressions for those cases.  For complex patterns `matchRegex` uses
+ * a sticky regex positioned at `pos` so no string copy is needed.
+ */
+declare const Ch_SLASH = 47;
+declare const Ch_AT = 64;
+declare const Ch_CLOSE = 125;
+declare const Ch_STAR = 42;
+export declare class Lexer {
+    /** The complete CSS source string. */
+    readonly input: string;
+    /** Current read position (index into `input`). */
+    pos: number;
+    /** Current source line (1-based). */
+    lineno: number;
+    /** Current source column (1-based). */
+    column: number;
+    constructor(input: string);
+    /** Returns `true` when there is still input to consume. */
+    get hasMore(): boolean;
+    /**
+     * Returns the character code at `pos + offset` without advancing,
+     * or `NaN` when past the end of input.
+     *
+     * Comparing numeric codes (`charCodeAt`) is faster than creating
+     * single-character strings with bracket indexing.
+     */
+    charCodeAt(offset?: number): number;
+    /**
+     * Returns the character at `pos + offset` without advancing, or an
+     * empty string when past the end of input.
+     */
+    charAt(offset?: number): string;
+    /**
+     * Returns the remaining input from the current position.
+     *
+     * This creates a new string (same cost as the old `css.slice(…)` approach)
+     * and is provided for compatibility with the bracket/quote-aware search
+     * utilities that accept a plain string.
+     */
+    get remaining(): string;
+    /**
+     * Advance `pos` by `n` characters, updating line/column tracking.
+     * Returns the consumed slice.
+     */
+    consume(n: number): string;
+    /**
+     * Advance `pos` up to (but not including) `absolutePos`, updating
+     * line/column tracking.  Returns the consumed slice.
+     */
+    consumeTo(absolutePos: number): string;
+    /**
+     * Apply a sticky (`y`-flag) regex directly against the full input
+     * at the current position.  If the regex matches, the matched text
+     * is consumed and the `RegExpExecArray` is returned; otherwise
+     * `null` is returned and `pos` is not changed.
+     *
+     * Using the `y` flag with `lastIndex` avoids creating a temporary
+     * substring slice (which the old `^`-anchor + `this.remaining`
+     * approach required).
+     */
+    matchRegex(re: RegExp): RegExpExecArray | null;
+    /**
+     * Consume zero or more whitespace characters (space, tab, CR, LF,
+     * form-feed) using `charCodeAt` instead of string comparisons.
+     */
+    skipWhitespace(): void;
+    /**
+     * If the current character is `{`, consume it and any following
+     * whitespace, then return `true`.  Otherwise return `false`.
+     */
+    tryOpenBrace(): boolean;
+    /**
+     * If the current character is `}`, consume it and return `true`.
+     * Otherwise return `false`.
+     */
+    tryCloseBrace(): boolean;
+    /**
+     * If the current character is `:`, consume it and any following
+     * whitespace, then return `true`.  Otherwise return `false`.
+     */
+    tryColon(): boolean;
+    /**
+     * Consume any leading semicolons and whitespace characters using
+     * `charCodeAt` instead of string comparisons.
+     */
+    skipSemicolonAndWhitespace(): void;
+    /**
+     * If the current character is `,`, consume it and any following
+     * whitespace, then return `true`.  Otherwise return `false`.
+     */
+    tryCommaAndWhitespace(): boolean;
+    /**
+     * Returns a snapshot of the current source position as an object
+     * suitable for use in `Position` nodes.
+     */
+    getPosition(): {
+        line: number;
+        column: number;
+    };
+    /**
+     * Update `lineno`, `column`, and `pos` for a range of characters in
+     * the original input.  Uses `charCodeAt` for the newline check.
+     */
+    private _advanceRange;
+}
+export { Ch_AT, Ch_CLOSE, Ch_SLASH, Ch_STAR };

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

@@ -0,0 +1,248 @@
+/**
+ * A fast lexer (scanner) for CSS input.
+ *
+ * Inspired by the approach used in es-module-shims / es-module-lexer,
+ * this lexer uses numeric character-code comparisons (`charCodeAt`)
+ * instead of single-character string comparisons, and employs sticky
+ * (`y`-flag) regular expressions matched directly against the full
+ * input to avoid creating temporary substring slices.
+ *
+ * The Lexer keeps an index (`pos`) into the original input.  Simple
+ * token types (whitespace, braces, colons, semicolons, commas) are
+ * scanned character-by-character via `charCodeAt`, avoiding regular
+ * expressions for those cases.  For complex patterns `matchRegex` uses
+ * a sticky regex positioned at `pos` so no string copy is needed.
+ */
+// ─── Character-code constants ────────────────────────────────────────────────
+// Using charCodeAt comparisons is measurably faster than creating
+// single-character strings and comparing with `===`.
+const Ch_TAB = 9; //  \t
+const Ch_LF = 10; //  \n
+const Ch_FF = 12; //  \f
+const Ch_CR = 13; //  \r
+const Ch_SPACE = 32; //  ' '
+const Ch_COMMA = 44; //  ,
+const Ch_SLASH = 47; //  /
+const Ch_COLON = 58; //  :
+const Ch_SEMI = 59; //  ;
+const Ch_AT = 64; //  @
+const Ch_OPEN = 123; //  {
+const Ch_CLOSE = 125; //  }
+const Ch_STAR = 42; //  *
+export class Lexer {
+    /** The complete CSS source string. */
+    input;
+    /** Current read position (index into `input`). */
+    pos;
+    /** Current source line (1-based). */
+    lineno;
+    /** Current source column (1-based). */
+    column;
+    constructor(input) {
+        this.input = input;
+        this.pos = 0;
+        this.lineno = 1;
+        this.column = 1;
+    }
+    // ─── Lookahead helpers ────────────────────────────────────────────────────
+    /** Returns `true` when there is still input to consume. */
+    get hasMore() {
+        return this.pos < this.input.length;
+    }
+    /**
+     * Returns the character code at `pos + offset` without advancing,
+     * or `NaN` when past the end of input.
+     *
+     * Comparing numeric codes (`charCodeAt`) is faster than creating
+     * single-character strings with bracket indexing.
+     */
+    charCodeAt(offset = 0) {
+        return this.input.charCodeAt(this.pos + offset);
+    }
+    /**
+     * Returns the character at `pos + offset` without advancing, or an
+     * empty string when past the end of input.
+     */
+    charAt(offset = 0) {
+        return this.input[this.pos + offset] ?? '';
+    }
+    /**
+     * Returns the remaining input from the current position.
+     *
+     * This creates a new string (same cost as the old `css.slice(…)` approach)
+     * and is provided for compatibility with the bracket/quote-aware search
+     * utilities that accept a plain string.
+     */
+    get remaining() {
+        return this.input.slice(this.pos);
+    }
+    // ─── Consumption helpers ──────────────────────────────────────────────────
+    /**
+     * Advance `pos` by `n` characters, updating line/column tracking.
+     * Returns the consumed slice.
+     */
+    consume(n) {
+        const start = this.pos;
+        const end = start + n;
+        this._advanceRange(start, end);
+        return this.input.slice(start, end);
+    }
+    /**
+     * Advance `pos` up to (but not including) `absolutePos`, updating
+     * line/column tracking.  Returns the consumed slice.
+     */
+    consumeTo(absolutePos) {
+        return this.consume(absolutePos - this.pos);
+    }
+    /**
+     * Apply a sticky (`y`-flag) regex directly against the full input
+     * at the current position.  If the regex matches, the matched text
+     * is consumed and the `RegExpExecArray` is returned; otherwise
+     * `null` is returned and `pos` is not changed.
+     *
+     * Using the `y` flag with `lastIndex` avoids creating a temporary
+     * substring slice (which the old `^`-anchor + `this.remaining`
+     * approach required).
+     */
+    matchRegex(re) {
+        re.lastIndex = this.pos;
+        const m = re.exec(this.input);
+        if (m) {
+            this._advanceRange(this.pos, this.pos + m[0].length);
+        }
+        return m;
+    }
+    // ─── Character-based token scanners ──────────────────────────────────────
+    /**
+     * Consume zero or more whitespace characters (space, tab, CR, LF,
+     * form-feed) using `charCodeAt` instead of string comparisons.
+     */
+    skipWhitespace() {
+        const src = this.input;
+        const len = src.length;
+        while (this.pos < len) {
+            const ch = src.charCodeAt(this.pos);
+            if (ch === Ch_LF) {
+                this.lineno++;
+                this.column = 1;
+                this.pos++;
+            }
+            else if (ch === Ch_SPACE ||
+                ch === Ch_TAB ||
+                ch === Ch_CR ||
+                ch === Ch_FF) {
+                this.column++;
+                this.pos++;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    /**
+     * If the current character is `{`, consume it and any following
+     * whitespace, then return `true`.  Otherwise return `false`.
+     */
+    tryOpenBrace() {
+        if (this.input.charCodeAt(this.pos) !== Ch_OPEN) {
+            return false;
+        }
+        this.pos++;
+        this.column++;
+        this.skipWhitespace();
+        return true;
+    }
+    /**
+     * If the current character is `}`, consume it and return `true`.
+     * Otherwise return `false`.
+     */
+    tryCloseBrace() {
+        if (this.input.charCodeAt(this.pos) !== Ch_CLOSE) {
+            return false;
+        }
+        this.pos++;
+        this.column++;
+        return true;
+    }
+    /**
+     * If the current character is `:`, consume it and any following
+     * whitespace, then return `true`.  Otherwise return `false`.
+     */
+    tryColon() {
+        if (this.input.charCodeAt(this.pos) !== Ch_COLON) {
+            return false;
+        }
+        this.pos++;
+        this.column++;
+        this.skipWhitespace();
+        return true;
+    }
+    /**
+     * Consume any leading semicolons and whitespace characters using
+     * `charCodeAt` instead of string comparisons.
+     */
+    skipSemicolonAndWhitespace() {
+        const src = this.input;
+        const len = src.length;
+        while (this.pos < len) {
+            const ch = src.charCodeAt(this.pos);
+            if (ch === Ch_LF) {
+                this.lineno++;
+                this.column = 1;
+                this.pos++;
+            }
+            else if (ch === Ch_SEMI ||
+                ch === Ch_SPACE ||
+                ch === Ch_TAB ||
+                ch === Ch_CR ||
+                ch === Ch_FF) {
+                this.column++;
+                this.pos++;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    /**
+     * If the current character is `,`, consume it and any following
+     * whitespace, then return `true`.  Otherwise return `false`.
+     */
+    tryCommaAndWhitespace() {
+        if (this.input.charCodeAt(this.pos) !== Ch_COMMA) {
+            return false;
+        }
+        this.pos++;
+        this.column++;
+        this.skipWhitespace();
+        return true;
+    }
+    // ─── Position snapshot ────────────────────────────────────────────────────
+    /**
+     * Returns a snapshot of the current source position as an object
+     * suitable for use in `Position` nodes.
+     */
+    getPosition() {
+        return { line: this.lineno, column: this.column };
+    }
+    // ─── Internal helpers ─────────────────────────────────────────────────────
+    /**
+     * Update `lineno`, `column`, and `pos` for a range of characters in
+     * the original input.  Uses `charCodeAt` for the newline check.
+     */
+    _advanceRange(from, to) {
+        const src = this.input;
+        for (let i = from; i < to; i++) {
+            if (src.charCodeAt(i) === Ch_LF) {
+                this.lineno++;
+                this.column = 1;
+            }
+            else {
+                this.column++;
+            }
+        }
+        this.pos = to;
+    }
+}
+// Re-export character codes so the parser can use them for fast checks
+export { Ch_AT, Ch_CLOSE, Ch_SLASH, Ch_STAR };

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

@@ -0,0 +1,172 @@
+import { type CssAllNodesAST, type CssCharsetAST, type CssCommentAST, type CssCommonPositionAST, type CssContainerAST, type CssCounterStyleAST, type CssCustomMediaAST, type CssDeclarationAST, type CssDocumentAST, type CssFontFaceAST, type CssFontFeatureValuesAST, type CssGenericAtRuleAST, type CssHostAST, type CssImportAST, type CssKeyframeAST, type CssKeyframesAST, type CssLayerAST, type CssMediaAST, type CssNamespaceAST, type CssPageAST, type CssPageMarginBoxAST, type CssPositionTryAST, type CssPropertyAST, type CssRuleAST, type CssScopeAST, type CssStartingStyleAST, type CssStylesheetAST, type CssSupportsAST, type CssViewTransitionAST, type CssWhitespaceAST } from '../type.js';
+export type CompilerOptions = {
+    indent?: string;
+    compress?: boolean;
+    identity?: boolean;
+    removeEmptyRules?: boolean;
+};
+declare class Compiler {
+    level: number;
+    indentation: string;
+    compress: boolean;
+    identity: boolean;
+    removeEmptyRules: boolean;
+    constructor(options?: CompilerOptions);
+    emit(str: string, _position?: CssCommonPositionAST['position']): string;
+    /**
+     * Increase, decrease or return current indentation.
+     */
+    indent(level?: number): string;
+    visit(node: CssAllNodesAST): string;
+    mapVisit(nodes: Array<CssAllNodesAST>, delim?: string): string;
+    /**
+     * Emit a block at-rule that contains nested rules (e.g. @media, @supports, @container).
+     */
+    private rulesBlock;
+    /**
+     * Emit a block at-rule that contains declarations (e.g. @font-face, @property).
+     */
+    private declsBlock;
+    compile(node: CssStylesheetAST): string;
+    /**
+     * Identity mode: walk the AST including whitespace nodes.
+     * Falls back to beautified output when whitespace nodes are not available.
+     */
+    private identityCompile;
+    /**
+     * Visit stylesheet node.
+     */
+    stylesheet(node: CssStylesheetAST): string;
+    /**
+     * Strip whitespace nodes from an array (used in beautified/compressed modes).
+     */
+    private stripWhitespace;
+    /**
+     * Filter out empty rules when removeEmptyRules is enabled.
+     */
+    private filterEmptyRules;
+    /**
+     * Check whether a node was newly created (not parsed from source).
+     * New nodes lack the raw formatting properties set by the parser.
+     */
+    private isNewNode;
+    /**
+     * Visit block children in identity mode, formatting newly added nodes
+     * with beautified output while preserving original formatting for
+     * existing nodes.
+     *
+     * @param nodes    - The child nodes to visit
+     * @param context  - 'decls' for declaration blocks, 'rules' for nested
+     *                   rule blocks (e.g. @media), 'stylesheet' for top-level
+     */
+    private identityVisitBlock;
+    /**
+     * Visit whitespace node.
+     */
+    whitespace(node: CssWhitespaceAST): string;
+    /**
+     * Visit comment node.
+     */
+    comment(node: CssCommentAST): string;
+    /**
+     * Visit container node.
+     */
+    container(node: CssContainerAST): string;
+    /**
+     * Visit container node.
+     */
+    layer(node: CssLayerAST): string;
+    /**
+     * Visit import node.
+     */
+    import(node: CssImportAST): string;
+    /**
+     * Visit media node.
+     */
+    media(node: CssMediaAST): string;
+    /**
+     * Visit document node.
+     */
+    document(node: CssDocumentAST): string;
+    /**
+     * Visit charset node.
+     */
+    charset(node: CssCharsetAST): string;
+    /**
+     * Visit namespace node.
+     */
+    namespace(node: CssNamespaceAST): string;
+    /**
+     * Visit starting-style node.
+     */
+    startingStyle(node: CssStartingStyleAST): string;
+    /**
+     * Visit supports node.
+     */
+    supports(node: CssSupportsAST): string;
+    /**
+     * Visit keyframes node.
+     */
+    keyframes(node: CssKeyframesAST): string;
+    /**
+     * Visit keyframe node.
+     */
+    keyframe(node: CssKeyframeAST): string;
+    /**
+     * Visit page node.
+     */
+    page(node: CssPageAST): string;
+    /**
+     * Visit @page margin box node (@top-left, @bottom-right, etc.).
+     */
+    pageMarginBox(node: CssPageMarginBoxAST): string;
+    /**
+     * Visit font-face node.
+     */
+    fontFace(node: CssFontFaceAST): string;
+    /**
+     * Visit host node.
+     */
+    host(node: CssHostAST): string;
+    /**
+     * Visit custom-media node.
+     */
+    customMedia(node: CssCustomMediaAST): string;
+    /**
+     * Visit @property node.
+     */
+    property(node: CssPropertyAST): string;
+    /**
+     * Visit @counter-style node.
+     */
+    counterStyle(node: CssCounterStyleAST): string;
+    /**
+     * Visit @font-feature-values node.
+     */
+    fontFeatureValues(node: CssFontFeatureValuesAST): string;
+    /**
+     * Visit @scope node.
+     */
+    scope(node: CssScopeAST): string;
+    /**
+     * Visit @view-transition node.
+     */
+    viewTransition(node: CssViewTransitionAST): string;
+    /**
+     * Visit @position-try node.
+     */
+    positionTry(node: CssPositionTryAST): string;
+    /**
+     * Visit generic at-rule node (fallback for any unrecognized at-rule).
+     */
+    genericAtRule(node: CssGenericAtRuleAST): string;
+    /**
+     * Visit rule node.
+     */
+    rule(node: CssRuleAST): string;
+    /**
+     * Visit declaration node.
+     */
+    declaration(node: CssDeclarationAST): string;
+}
+export default Compiler;