xmlui 0.11.3 → 0.11.6

package/dist/scripts/src/components-core/script-runner/visitors.js

@@ -1,369 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectVariableDependencies = collectVariableDependencies;
-const lodash_es_1 = require("lodash-es");
-const eval_tree_common_1 = require("./eval-tree-common");
-const ScriptingSourceTree_1 = require("./ScriptingSourceTree");
-const process_statement_common_1 = require("./process-statement-common");
-/**
- * Collects the name of local context variables the specified program depends on
- * @param program Program to visit
- * @param referenceTrackedApis
- */
-function collectVariableDependencies(program, referenceTrackedApis = {}) {
-    // --- We use these variables to keep track of local variable scopes
-    const evalContext = {};
-    const thread = (0, process_statement_common_1.ensureMainThread)(evalContext);
-    const deps = collectDependencies(program);
-    // --- Filter out duplicates
-    return deps.filter((item, index) => deps.indexOf(item) === index);
-    // --- This is the function we call recursively to collect dependencies
-    function collectDependencies(program, parent, tag) {
-        var _a;
-        if (Array.isArray(program)) {
-            // --- Visit statements
-            let deps = [];
-            program.forEach((stmt) => {
-                let stmtDeps = [];
-                switch (stmt.type) {
-                    case ScriptingSourceTree_1.T_BLOCK_STATEMENT:
-                        thread.blocks.push({ vars: {} });
-                        stmtDeps = collectDependencies(stmt.stmts, stmt, "block");
-                        thread.blocks.pop();
-                        break;
-                    case ScriptingSourceTree_1.T_EXPRESSION_STATEMENT:
-                        stmtDeps = collectDependencies(stmt.expr, stmt, "expression");
-                        break;
-                    case ScriptingSourceTree_1.T_ARROW_EXPRESSION_STATEMENT:
-                        thread.blocks.push({ vars: {} });
-                        stmtDeps = collectDependencies(stmt.expr, stmt, "arrow");
-                        thread.blocks.pop();
-                        break;
-                    case ScriptingSourceTree_1.T_LET_STATEMENT:
-                    case ScriptingSourceTree_1.T_CONST_STATEMENT:
-                        processDeclarations((0, process_statement_common_1.innermostBlockScope)(thread), stmt.decls);
-                        stmt.decls.forEach((decl) => {
-                            if (decl.expr) {
-                                stmtDeps = stmtDeps.concat(collectDependencies(decl.expr, stmt, "letOrConst"));
-                            }
-                        });
-                        break;
-                    case ScriptingSourceTree_1.T_IF_STATEMENT:
-                        stmtDeps = collectDependencies(stmt.cond, stmt, "if");
-                        stmtDeps = stmtDeps.concat(collectDependencies([stmt.thenB], stmt, "if"));
-                        if (stmt.elseB) {
-                            stmtDeps = stmtDeps.concat(collectDependencies([stmt.elseB], stmt, "if"));
-                        }
-                        break;
-                    case ScriptingSourceTree_1.T_RETURN_STATEMENT:
-                        if (stmt.expr) {
-                            stmtDeps = collectDependencies(stmt.expr, stmt, "return");
-                        }
-                        break;
-                    case ScriptingSourceTree_1.T_WHILE_STATEMENT:
-                        stmtDeps = collectDependencies(stmt.cond, stmt, "while");
-                        stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "while"));
-                        break;
-                    case ScriptingSourceTree_1.T_DO_WHILE_STATEMENT:
-                        stmtDeps = collectDependencies(stmt.cond, stmt, "doWhile");
-                        stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "doWhile"));
-                        break;
-                    case ScriptingSourceTree_1.T_FOR_STATEMENT:
-                        thread.blocks.push({ vars: {} });
-                        if (stmt.init) {
-                            stmtDeps.concat(collectDependencies([stmt.init], stmt, "for"));
-                        }
-                        if (stmt.cond) {
-                            stmtDeps = stmtDeps.concat(collectDependencies(stmt.cond, stmt, "for"));
-                        }
-                        if (stmt.upd) {
-                            stmtDeps = stmtDeps.concat(collectDependencies(stmt.upd, stmt, "for"));
-                        }
-                        stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "for"));
-                        thread.blocks.pop();
-                        break;
-                    case ScriptingSourceTree_1.T_FOR_IN_STATEMENT:
-                        thread.blocks.push({ vars: {} });
-                        if (stmt.varB !== "none") {
-                            const block = (0, process_statement_common_1.innermostBlockScope)(thread);
-                            block.vars[stmt.id.name] = true;
-                        }
-                        stmtDeps = stmtDeps.concat(collectDependencies(stmt.expr, stmt, "forIn"));
-                        stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "forIn"));
-                        thread.blocks.pop();
-                        break;
-                    case ScriptingSourceTree_1.T_FOR_OF_STATEMENT:
-                        thread.blocks.push({ vars: {} });
-                        if (stmt.varB !== "none") {
-                            const block = (0, process_statement_common_1.innermostBlockScope)(thread);
-                            block.vars[stmt.id.name] = true;
-                        }
-                        stmtDeps = stmtDeps.concat(collectDependencies(stmt.expr, stmt, "forOf"));
-                        stmtDeps = stmtDeps.concat(collectDependencies([stmt.body], stmt, "forOf"));
-                        thread.blocks.pop();
-                        break;
-                    case ScriptingSourceTree_1.T_THROW_STATEMENT:
-                        stmtDeps = collectDependencies(stmt.expr, stmt, "throw");
-                        break;
-                    case ScriptingSourceTree_1.T_TRY_STATEMENT:
-                        stmtDeps = collectDependencies([stmt.tryB], stmt, "try");
-                        if (stmt.catchB) {
-                            thread.blocks.push({ vars: {} });
-                            if (stmt.catchV) {
-                                const block = (0, process_statement_common_1.innermostBlockScope)(thread);
-                                block.vars[stmt.catchV.name] = true;
-                            }
-                            stmtDeps = stmtDeps.concat(collectDependencies([stmt.catchB], stmt, "catchBlock"));
-                            thread.blocks.pop();
-                        }
-                        if (stmt.finallyB) {
-                            stmtDeps = stmtDeps.concat(collectDependencies([stmt.finallyB], stmt, "finallyBlock"));
-                        }
-                        break;
-                    case ScriptingSourceTree_1.T_SWITCH_STATEMENT:
-                        stmtDeps = collectDependencies(stmt.expr, stmt, "switch");
-                        stmt.cases.forEach((c) => {
-                            if (c.caseE) {
-                                stmtDeps = stmtDeps.concat(collectDependencies(c.caseE, stmt, "switch"));
-                            }
-                            if (c.stmts) {
-                                stmtDeps = stmtDeps.concat(collectDependencies(c.stmts, stmt, "switch"));
-                            }
-                        });
-                        break;
-                }
-                deps = deps.concat(stmtDeps);
-            });
-            return deps;
-        }
-        else {
-            // --- Visit expression
-            switch (program.type) {
-                case ScriptingSourceTree_1.T_IDENTIFIER:
-                    // --- Any non-block-scoped variable is a dependency to return
-                    const scope = (0, eval_tree_common_1.getIdentifierScope)(program, evalContext, thread);
-                    return scope.type !== "block" ? [program.name] : [];
-                case ScriptingSourceTree_1.T_MEMBER_ACCESS_EXPRESSION:
-                    // --- Check for a simple member-access chain. If it exist, add the member to the chain with the "." syntax
-                    const memberChain = traverseMemberAccessChain(program);
-                    return memberChain
-                        ? [memberChain]
-                        : collectDependencies(program.obj, program, "memberAccess");
-                case ScriptingSourceTree_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION:
-                    // --- Check for a simple member-access chain. If it exist, add the member to the chain with the "[]" syntax
-                    const calcMemberChain = traverseMemberAccessChain(program);
-                    if (calcMemberChain) {
-                        return [calcMemberChain];
-                    }
-                    let calcDeps = collectDependencies(program.obj, program, "calculatedMember");
-                    return calcDeps.concat(collectDependencies(program.member, program, "calculatedMember"));
-                case ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION:
-                    let sequenceDeps = [];
-                    program.exprs.forEach((expr) => {
-                        sequenceDeps = sequenceDeps.concat(collectDependencies(expr, program, "sequence"));
-                    });
-                    return sequenceDeps;
-                case ScriptingSourceTree_1.T_FUNCTION_INVOCATION_EXPRESSION:
-                    let uncDeps = [];
-                    (_a = program.arguments) === null || _a === void 0 ? void 0 : _a.forEach((arg) => {
-                        uncDeps = uncDeps.concat(collectDependencies(arg, program, "functionInvocation"));
-                    });
-                    if (program.obj.type === ScriptingSourceTree_1.T_MEMBER_ACCESS_EXPRESSION) {
-                        const caller = program.obj;
-                        if (caller.obj.type === ScriptingSourceTree_1.T_IDENTIFIER) {
-                            if (typeof (0, lodash_es_1.get)(referenceTrackedApis, `${caller.obj.name}.${caller.member}`) ===
-                                "function") {
-                                uncDeps.push(`${caller.obj.name}.${caller.member}`);
-                            }
-                            else {
-                                uncDeps.push(`${caller.obj.name}`);
-                            }
-                        }
-                        else if (caller.obj.type === ScriptingSourceTree_1.T_MEMBER_ACCESS_EXPRESSION ||
-                            caller.obj.type === ScriptingSourceTree_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION) {
-                            uncDeps = uncDeps.concat(collectDependencies(caller.obj, caller, "functionInvocation"));
-                        }
-                        else {
-                            uncDeps = uncDeps.concat(collectDependencies(caller, program, "functionInvocation"));
-                        }
-                    }
-                    else {
-                        uncDeps = uncDeps.concat(collectDependencies(program.obj, program, "functionInvocation"));
-                    }
-                    return uncDeps;
-                case ScriptingSourceTree_1.T_ARROW_EXPRESSION:
-                    // --- Process the current arguments
-                    thread.blocks.push({ vars: {} });
-                    const block = (0, process_statement_common_1.innermostBlockScope)(thread);
-                    const argSpecs = program.args;
-                    let restFound = false;
-                    for (let i = 0; i < argSpecs.length; i++) {
-                        // --- Turn argument specification into processable variable declarations
-                        const argSpec = argSpecs[i];
-                        let decl;
-                        switch (argSpec.type) {
-                            case ScriptingSourceTree_1.T_IDENTIFIER: {
-                                decl = {
-                                    type: ScriptingSourceTree_1.T_VAR_DECLARATION,
-                                    nodeId: argSpec.nodeId,
-                                    id: argSpec.name,
-                                };
-                                break;
-                            }
-                            case ScriptingSourceTree_1.T_DESTRUCTURE: {
-                                decl = {
-                                    type: ScriptingSourceTree_1.T_VAR_DECLARATION,
-                                    nodeId: argSpec.nodeId,
-                                    id: argSpec.id,
-                                    aDestr: argSpec.aDestr,
-                                    oDestr: argSpec.oDestr,
-                                };
-                                break;
-                            }
-                            case ScriptingSourceTree_1.T_SPREAD_EXPRESSION: {
-                                restFound = true;
-                                decl = {
-                                    type: ScriptingSourceTree_1.T_VAR_DECLARATION,
-                                    nodeId: argSpec.nodeId,
-                                    id: argSpec.expr.name,
-                                };
-                                break;
-                            }
-                            default:
-                                throw new Error("Unexpected arrow argument specification");
-                        }
-                        // --- Process declarations
-                        processDeclarations(block, [decl]);
-                    }
-                    // --- Process the arrow expression's body
-                    const arrowDeps = collectDependencies([program.statement], program, "arrow");
-                    // --- Remove the block scope
-                    thread.blocks.pop();
-                    // --- Done
-                    return arrowDeps;
-                case ScriptingSourceTree_1.T_OBJECT_LITERAL:
-                    let objectDeps = [];
-                    program.props.forEach((prop) => {
-                        if (Array.isArray(prop)) {
-                            objectDeps = objectDeps.concat(collectDependencies(prop[1], program, "objectLiteral"));
-                        }
-                        else {
-                            objectDeps = objectDeps.concat(collectDependencies(prop, program, "objectLiteral"));
-                        }
-                    });
-                    return objectDeps;
-                case ScriptingSourceTree_1.T_ARRAY_LITERAL:
-                    let arrayDeps = [];
-                    program.items.forEach((expr) => {
-                        if (expr) {
-                            arrayDeps = arrayDeps.concat(collectDependencies(expr, program, "array"));
-                        }
-                    });
-                    return arrayDeps;
-                case ScriptingSourceTree_1.T_UNARY_EXPRESSION:
-                    return collectDependencies(program.expr, program, "unary");
-                case ScriptingSourceTree_1.T_PREFIX_OP_EXPRESSION:
-                    return collectDependencies(program.expr, program, "prefix");
-                case ScriptingSourceTree_1.T_POSTFIX_OP_EXPRESSION:
-                    return collectDependencies(program.expr, program, "postfix");
-                case ScriptingSourceTree_1.T_BINARY_EXPRESSION:
-                    return collectDependencies(program.left, program, "left").concat(collectDependencies(program.right, program, "right"));
-                case ScriptingSourceTree_1.T_ASSIGNMENT_EXPRESSION:
-                    return collectDependencies(program.expr, program, "right");
-                case ScriptingSourceTree_1.T_CONDITIONAL_EXPRESSION:
-                    return collectDependencies(program.cond, program, "condition").concat(collectDependencies(program.thenE, program, "trueExpr"), collectDependencies(program.elseE, program, "falseExpr"));
-                case ScriptingSourceTree_1.T_VAR_DECLARATION:
-                    return collectDependencies(program.expr, program, "varDeclaration");
-                case ScriptingSourceTree_1.T_SPREAD_EXPRESSION:
-                    return collectDependencies(program.expr, program, "spread");
-            }
-        }
-        return [];
-    }
-    // --- Traverses a member access chain. Returns the chain as a string or null
-    // --- if the chain is not simple
-    function traverseMemberAccessChain(expr) {
-        var _a, _b;
-        switch (expr.type) {
-            case ScriptingSourceTree_1.T_MEMBER_ACCESS_EXPRESSION:
-                const memberChain = traverseMemberAccessChain(expr.obj);
-                return memberChain ? `${memberChain}.${expr.member}` : null;
-            case ScriptingSourceTree_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION:
-                let value = null;
-                if (expr.member.type === ScriptingSourceTree_1.T_LITERAL) {
-                    value = `'${(_b = (_a = expr.member.value) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : null}'`;
-                }
-                else if (expr.member.type === ScriptingSourceTree_1.T_IDENTIFIER) {
-                    value = expr.member.name;
-                }
-                if (!value)
-                    break;
-                const calcMemberChain = traverseMemberAccessChain(expr.obj);
-                return calcMemberChain ? `${calcMemberChain}[${value}]` : null;
-            case ScriptingSourceTree_1.T_IDENTIFIER:
-                const scope = (0, eval_tree_common_1.getIdentifierScope)(expr, evalContext, thread);
-                return scope.type !== "block" ? expr.name : null;
-        }
-        return null;
-    }
-}
-// --- Process a variable declaration
-function processDeclarations(block, declarations) {
-    for (let i = 0; i < declarations.length; i++) {
-        visitDeclaration(block, declarations[i]);
-    }
-    // --- Visit a variable
-    function visitDeclaration(block, decl) {
-        // --- Process each declaration
-        if (decl.id) {
-            visitIdDeclaration(block, decl.id);
-        }
-        else if (decl.aDestr) {
-            visitArrayDestruct(block, decl.aDestr);
-        }
-        else if (decl.oDestr) {
-            visitObjectDestruct(block, decl.oDestr);
-        }
-        else {
-            throw new Error("Unknown declaration specifier");
-        }
-    }
-    // --- Visits a single ID declaration
-    function visitIdDeclaration(block, id) {
-        if (block.vars[id]) {
-            throw new Error(`Variable ${id} is already declared in the current scope.`);
-        }
-        block.vars[id] = true;
-    }
-    // --- Visits an array destructure declaration
-    function visitArrayDestruct(block, arrayD) {
-        for (let i = 0; i < arrayD.length; i++) {
-            const arrDecl = arrayD[i];
-            if (arrDecl.id) {
-                visitIdDeclaration(block, arrDecl.id);
-            }
-            else if (arrDecl.aDestr) {
-                visitArrayDestruct(block, arrDecl.aDestr);
-            }
-            else if (arrDecl.oDestr) {
-                visitObjectDestruct(block, arrDecl.oDestr);
-            }
-        }
-    }
-    // --- Visits an object destructure declaration
-    function visitObjectDestruct(block, objectD) {
-        var _a;
-        for (let i = 0; i < objectD.length; i++) {
-            const objDecl = objectD[i];
-            if (objDecl.aDestr) {
-                visitArrayDestruct(block, objDecl.aDestr);
-            }
-            else if (objDecl.oDestr) {
-                visitObjectDestruct(block, objDecl.oDestr);
-            }
-            else {
-                visitIdDeclaration(block, (_a = objDecl.alias) !== null && _a !== void 0 ? _a : objDecl.id);
-            }
-        }
-    }
-}

package/dist/scripts/src/components-core/theming/StyleContext.js

@@ -1,133 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StyleInjectionTargetContext = void 0;
-exports.StyleProvider = StyleProvider;
-exports.useStyleRegistry = useStyleRegistry;
-exports.useComponentStyle = useComponentStyle;
-exports.useDomRoot = useDomRoot;
-exports.useStyles = useStyles;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const react_1 = require("react");
-const StyleRegistry_1 = require("./StyleRegistry");
-const constants_1 = require("../constants");
-const IndexerContext_1 = require("../../components/App/IndexerContext");
-// The context is typed to hold either a StyleRegistry instance or null.
-const StyleContext = (0, react_1.createContext)(null);
-/**
- * A "smart" provider that creates a StyleRegistry only if one doesn't
- * already exist in the context.
- */
-function StyleProvider({ children, styleRegistry = new StyleRegistry_1.StyleRegistry(), forceNew = false, // Optional prop to force a new registry
- }) {
-    // Check if a provider already exists above this one in the tree.
-    const parentRegistry = (0, react_1.useContext)(StyleContext);
-    // If we are the top-most provider, create a new registry for this tree.
-    // On the client, this runs once. On the server, it runs once per request
-    // IF this provider is at the root of the tree being rendered.
-    // Use useState to create the registry instance.
-    const [registry] = (0, react_1.useState)(() => {
-        const newRegistry = styleRegistry;
-        // This logic only runs on the CLIENT, once, when the registry is created.
-        if (typeof window !== "undefined") {
-            // 1. Find the style tag injected by the server.
-            const ssrTag = document.querySelector('style[data-style-registry="true"]');
-            // 2. Read the hashes from our custom data attribute.
-            const ssrHashes = ssrTag === null || ssrTag === void 0 ? void 0 : ssrTag.getAttribute("data-ssr-hashes");
-            if (ssrHashes) {
-                // 3. Pre-populate the 'injected' set with all the server-rendered hashes.
-                let hashes = ssrHashes.split(",");
-                newRegistry.ssrHashes = new Set(hashes);
-                newRegistry.injected = new Set(hashes);
-            }
-        }
-        return newRegistry;
-    });
-    // If we're already inside a provider, don't do anything. Just render the children.
-    // This makes nesting StyleProviders safe and harmless.
-    if (parentRegistry && !forceNew) {
-        return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: children });
-    }
-    return (0, jsx_runtime_1.jsx)(StyleContext.Provider, { value: registry, children: children });
-}
-function useStyleRegistry() {
-    const registry = (0, react_1.useContext)(StyleContext);
-    if (registry === null) {
-        throw new Error("Component must be used within a StyleProvider");
-    }
-    return registry;
-}
-function useComponentStyle(styles) {
-    const rootStyle = (0, react_1.useMemo)(() => {
-        return (!styles || Object.keys(styles).length === 0)
-            ? constants_1.EMPTY_OBJECT
-            : {
-                "&": styles,
-                // "@container style(--screenSize: 1) or @container style(--screenSize: 2) ... etc": responsiveSizes,
-            };
-    }, [styles]);
-    return useStyles(rootStyle);
-}
-exports.StyleInjectionTargetContext = (0, react_1.createContext)(null);
-function useDomRoot() {
-    const domRoot = (0, react_1.useContext)(exports.StyleInjectionTargetContext);
-    return domRoot;
-}
-function useStyles(styles, { prepend } = constants_1.EMPTY_OBJECT) {
-    // we skip this whole thing if we're indexing
-    const { indexing } = (0, IndexerContext_1.useIndexerContext)();
-    const domRoot = useDomRoot();
-    const injectionTarget = typeof document === "undefined" ? null : domRoot instanceof ShadowRoot ? domRoot : document.head;
-    const registry = useStyleRegistry();
-    const { className, styleHash } = (0, react_1.useMemo)(() => {
-        if (indexing || !styles || styles === constants_1.EMPTY_OBJECT || Object.keys(styles).length === 0) {
-            return { className: undefined, styleHash: undefined };
-        }
-        return registry.register(styles);
-    }, [indexing, registry, styles]);
-    (0, react_1.useInsertionEffect)(() => {
-        if (!styleHash || registry.injected.has(styleHash)) {
-            return;
-        }
-        const { css } = registry.cache.get(styleHash) || {};
-        if (css) {
-            const styleElement = document.createElement("style");
-            styleElement.setAttribute("data-style-hash", styleHash);
-            styleElement.innerHTML = `@layer dynamic {\n${css}\n}`;
-            if (prepend) {
-                injectionTarget.insertBefore(styleElement, injectionTarget.firstChild.nextSibling);
-            }
-            else {
-                injectionTarget.appendChild(styleElement);
-            }
-            registry.injected.add(styleHash);
-        }
-    }, [registry, styleHash, injectionTarget]);
-    // HOOK 2: For lifecycle management (reference counting and CLEANUP).
-    (0, react_1.useEffect)(() => {
-        if (!styleHash) {
-            return;
-        }
-        // On MOUNT, tell the registry that this component is using this style.
-        registry.incrementRef(styleHash);
-        // Return a cleanup function to run on UNMOUNT.
-        return () => {
-            registry.decrementRef(styleHash);
-            // Schedule the cleanup check to run asynchronously.
-            // This allows React's Strict Mode double-render to complete before
-            // we check if the style tag should be removed.
-            setTimeout(() => {
-                var _a;
-                // Only proceed with cleanup if...
-                // 1. No other component is using this style (ref count is 0).
-                // 2. This style was NOT part of the initial server render.
-                if (registry.getRefCount(styleHash) === 0 && !registry.ssrHashes.has(styleHash)) {
-                    // If it's still zero, it means no component re-mounted to claim this style.
-                    // Now it's safe to perform the cleanup.
-                    registry.injected.delete(styleHash);
-                    (_a = injectionTarget.querySelector(`style[data-style-hash="${styleHash}"]`)) === null || _a === void 0 ? void 0 : _a.remove();
-                }
-            }, 0); // A timeout of 0ms is sufficient to push this to the end of the event loop.
-        };
-    }, [injectionTarget, registry, styleHash]); // Dependency array ensures this runs once per style change.
-    return className;
-}

package/dist/scripts/src/components-core/theming/StyleRegistry.js

@@ -1,171 +0,0 @@
-"use strict";
-// app/utils/styleUtils.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StyleRegistry = void 0;
-// --- Helper Functions ---
-function hashString(str) {
-    let hash = 5381;
-    let i = str.length;
-    while (i) {
-        hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    let s = (hash >>> 0).toString(36);
-    // console.log("hashString", str, "->", s);
-    return s;
-}
-/**
- * Converts a camelCase string to kebab-case, but ignores CSS Custom Properties.
- * @param {string} str The string to convert.
- * @returns {string} The formatted string.
- */
-function toKebabCase(str) {
-    // NEW: If the string is a CSS Custom Property (starts with '--'),
-    // return it as-is without any changes.
-    if (str.startsWith('--')) {
-        return str;
-    }
-    // Otherwise, convert from camelCase to kebab-case as before.
-    return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
-}
-/**
- * Creates a stable, canonical JSON string from an object by sorting keys recursively.
- * This ensures that objects with the same content produce the same string regardless of key order.
- * @param obj The object to stringify.
- * @returns A stable string representation.
- */
-function stableJSONStringify(obj) {
-    return JSON.stringify(obj);
-    // if (obj === null || typeof obj !== 'object') {
-    //   return JSON.stringify(obj);
-    // }
-    //
-    // if (Array.isArray(obj)) {
-    //   const arrayStr = obj.map(item => stableJSONStringify(item)).join(',');
-    //   return `[${arrayStr}]`;
-    // }
-    //
-    // const keys = Object.keys(obj).sort();
-    // const props = keys.map(key => {
-    //   const value = stableJSONStringify(obj[key]);
-    //   return `"${key}":${value}`;
-    // });
-    //
-    // return `{${props.join(',')}}`;
-}
-// --- The StyleRegistry Class (with updated logic) ---
-class StyleRegistry {
-    constructor() {
-        this.cache = new Map();
-        this.rootClasses = new Set();
-        this.injected = new Set();
-        // NEW: A map to track how many components are using a style.
-        this.refCounts = new Map();
-        // NEW: A set to specifically track hashes injected by SSR.
-        this.ssrHashes = new Set();
-    }
-    register(styles) {
-        const key = stableJSONStringify(styles);
-        const styleHash = hashString(key);
-        const cachedEntry = this.cache.get(styleHash);
-        if (cachedEntry) {
-            return cachedEntry;
-        }
-        // The entry point for our new recursive generator.
-        const className = `css-${styleHash}`;
-        const css = this._generateCss(`.${className}`, styles);
-        const entry = { className, styleHash, css };
-        this.cache.set(styleHash, entry);
-        return entry;
-    }
-    /**
-     * [PRIVATE] Recursively generates CSS rules from a style object.
-     * This is the new, more powerful engine.
-     * @param selector - The CSS selector for the current context (e.g., '.css-123' or '&:hover').
-     * @param styles - The style object to process.
-     * @returns A string of CSS rules.
-     */
-    _generateCss(selector, styles) {
-        const directProps = [];
-        const nestedRules = [];
-        // 1. Separate direct CSS properties from nested rules.
-        for (const key in styles) {
-            const value = styles[key];
-            if (typeof value === 'object' && value !== null) {
-                // It's a nested rule (e.g., '&:hover', '@media').
-                nestedRules.push(this._processNestedRule(selector, key, value));
-            }
-            else {
-                // It's a direct CSS property (e.g., 'backgroundColor').
-                directProps.push(`${toKebabCase(key)}:${value};`);
-            }
-        }
-        let finalCss = '';
-        // 2. Generate the CSS for the direct properties at the current selector level.
-        if (directProps.length > 0) {
-            finalCss += `${selector} {${directProps.join('')}}`;
-        }
-        // 3. Append the CSS from all the processed nested rules.
-        finalCss += nestedRules.join('');
-        return finalCss;
-    }
-    _processNestedRule(parentSelector, nestedKey, nestedStyles) {
-        // If the key is an at-rule (@media, @container, @keyframes), wrap the recursive call.
-        if (nestedKey.startsWith('@')) {
-            // The inner content is generated relative to the original parent selector.
-            return `${nestedKey}{${this._generateCss(parentSelector, nestedStyles)}}`;
-        }
-        // If the key is a nested selector, resolve the '&' placeholder.
-        // e.g., parent='.css-123', nestedKey='&:hover' -> '.css-123:hover'
-        const newSelector = nestedKey.replace(/&/g, parentSelector);
-        return this._generateCss(newSelector, nestedStyles);
-    }
-    getSsrStyles() {
-        const allCss = Array.from(this.cache.values()).map(entry => entry.css).join('');
-        // Wrap the entire output in our top-most layer.
-        return `@layer dynamic {${allCss}}`;
-    }
-    /**
-     * Adds a class name to be applied to the <html> tag.
-     */
-    addRootClasses(classNames) {
-        classNames.forEach((className) => {
-            this.rootClasses.add(className);
-        });
-    }
-    /**
-     * Returns a space-separated string of all collected html classes.
-     */
-    getRootClasses() {
-        return Array.from(this.rootClasses).join(' ');
-    }
-    // NEW: A helper to safely get the current reference count.
-    getRefCount(styleHash) {
-        return this.refCounts.get(styleHash) || 0;
-    }
-    /**
-     * Increments the reference count for a given style hash.
-     */
-    incrementRef(styleHash) {
-        const newCount = (this.refCounts.get(styleHash) || 0) + 1;
-        this.refCounts.set(styleHash, newCount);
-        // console.log("incrementing ref count for styleHash:", styleHash, "to", newCount);
-    }
-    /**
-     * Decrements the reference count for a given style hash.
-     * @returns {number} The new reference count.
-     */
-    decrementRef(styleHash) {
-        const currentCount = this.refCounts.get(styleHash) || 0;
-        const newCount = Math.max(0, currentCount - 1);
-        // console.log("decrementing ref count for styleHash:", styleHash, "from", currentCount, "to", newCount);
-        if (newCount > 0) {
-            this.refCounts.set(styleHash, newCount);
-        }
-        else {
-            // If the count is zero, remove it from the map.
-            this.refCounts.delete(styleHash);
-        }
-        return newCount;
-    }
-}
-exports.StyleRegistry = StyleRegistry;