npm - zibri - Versions diffs - 2.2.0 → 2.3.0 - Mend

zibri 2.2.0 → 2.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2438) hide show

package/dist/cjs/preact/preact.utilities.js ADDED Viewed

@@ -0,0 +1,1021 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreactUtilities = void 0;
+const preact_render_to_string_1 = __importDefault(require("preact-render-to-string"));
+const collector_1 = require("./collector");
+const generate_client_scripts_function_1 = require("./generate-client-scripts.function");
+const hooks_1 = require("./hooks/hooks");
+const string_aware_replace_function_1 = require("./string-aware-replace.function");
+const html_response_model_1 = require("../parsing/html/html-response.model");
+const fs_utilities_1 = require("../utilities/fs.utilities");
+const object_utilities_1 = require("../utilities/object.utilities");
+/**
+ * Utilities for handling preact templates.
+ */
+class PreactUtilities {
+    static clientManifest;
+    /**
+     * Renders the given component as an email, so no script injection is happening.
+     * @example
+     * ```ts
+     * PreactUtilities.renderEmail(TestEmail, { recipient: 'James Smith' });
+     * ```
+     * @param args - Component and props.
+     * @param args.component - The function component to render.
+     * @param args.props - The properties to pass into the component.
+     * @returns The fully rendered html.
+     */
+    static renderEmail(...args) {
+        const [component, props] = args;
+        const node = component(props ?? {});
+        return [
+            '<!DOCTYPE html>',
+            this.unescapeConditionalComments((0, preact_render_to_string_1.default)(node))
+        ].join('\n');
+    }
+    /**
+     * Renders the given component as a page with the component "body" (everything before the top-level return)
+     * inlined into the same <script> tag that also contains the handler bootstrap.
+     * @example
+     * ```ts
+     * PreactUtilities.renderPage(TestPage, { initialCount: 1 });
+     * ```
+     * @param args - Component and props.
+     * @param args.component - The function component to render.
+     * @param args.props - The properties to pass into the component.
+     * @returns The fully rendered html string, with the body and any handlers attached in a script tag.
+     */
+    static async renderPage(...args) {
+        const [component, props] = args;
+        // ---------- extract component source and prepare inlined script ----------
+        const componentSrc = component.toString();
+        const paramsText = this.extractParamsText(componentSrc);
+        const bodyText = this.extractBodyText(componentSrc);
+        const rootPackages = await this.getPackagesForComponent(component.name);
+        const rawBeforeReturn = this.rewriteClientImportRefs(this.rewriteFrameworkHooks(this.getBodyTextBeforeReturn(bodyText, 'root_')), rootPackages);
+        const propsSection = this.getInlinedPropsSection(paramsText, props ?? {});
+        const collector = new collector_1.PreactCollector();
+        const rootVNode = component(props ?? {});
+        if (rootVNode instanceof Promise) {
+            throw new Error(`[ssr] The root component '${component.name}' is async. `
+                + 'Async components are not supported — remove the async keyword and any top-level await. '
+                + 'If you need async data, fetch it before calling render() and pass the result as props.');
+        }
+        collector.walk(rootVNode, undefined);
+        let html = (0, preact_render_to_string_1.default)(rootVNode);
+        const allPackages = new Set();
+        for (const pkg of await this.getPackagesForComponent(component.name)) {
+            allPackages.add(pkg);
+        }
+        // Also collect from nested components
+        for (const entry of collector.getNestedComponentEntries()) {
+            for (const pkg of await this.getPackagesForComponent(entry.fn.name)) {
+                allPackages.add(pkg);
+            }
+        }
+        for (const pkg of allPackages) {
+            const tag = `<script src="${this.getClientScriptUrl(pkg)}"></script>`;
+            html = html.includes('</head>')
+                ? html.replace('</head>', `${tag}\n</head>`)
+                : tag + '\n' + html;
+        }
+        // ---------- build nested component script sections ----------
+        // Build ancestor map upfront so applyRenames can scope renames to the correct subtree.
+        const ancestorMap = new Map(collector.getNestedComponentEntries().map(e => [e.prefix, e.parentPrefix]));
+        const prefixToRenameMap = new Map();
+        const sectionPartsByPrefix = new Map();
+        for (const entry of collector.getNestedComponentEntries()) {
+            const { fn, prefix, parentPrefix, propBindings, propValues, destructureRenameMap, propsParamName, inlineBindings } = entry;
+            const fnSrc = fn.toString();
+            const fnPackages = await this.getPackagesForComponent(fn.name);
+            const body = this.rewriteClientImportRefs(this.getBodyTextBeforeReturn(this.extractBodyText(fnSrc), prefix), fnPackages);
+            // Build rename map: declared names + all prop local names -> prefixed versions.
+            const renameMap = this.buildRenameMap(body, prefix, propBindings, propsParamName, fn, inlineBindings);
+            prefixToRenameMap.set(prefix, renameMap);
+            // Apply this component's rename map only to handlers within its own subtree.
+            collector.applyRenames(renameMap, prefix, ancestorMap);
+            // Emit prop binding + default value declarations for this instance.
+            const bindingLines = this.buildPropBindingLines(prefix, propBindings, propValues, destructureRenameMap, propsParamName, (v) => this.resolveInAncestors(v, prefixToRenameMap, ancestorMap, parentPrefix), fn, inlineBindings, renameMap);
+            // Apply this component's rename map to its own body text.
+            const renamedBody = this.applyRenameMap(body, renameMap);
+            const cleanBody = this.rewriteFrameworkHooks(this.removeJsxReturnStatements(renamedBody, prefix));
+            sectionPartsByPrefix.set(prefix, { bindingLines, cleanBody });
+        }
+        // Nest everything — root body, nested sections, reattachment — inside root_: { }
+        // so nested component bindings can close over root-declared variables.
+        const rootLevelEntries = collector.getNestedComponentEntries()
+            .filter(e => e.parentPrefix === undefined);
+        const rootInner = [
+            rawBeforeReturn,
+            ...rootLevelEntries.map(e => this.buildSectionTree(e.prefix, sectionPartsByPrefix, collector.getNestedComponentEntries(), prefix => collector.getHandlerReattachmentSectionForPrefix(prefix))),
+            collector.getHandlerReattachmentSectionForPrefix(undefined)
+        ].filter(s => s.trim()).join('\n');
+        const rootBlock = this.wrapInLabeledBlock(rootInner, 'root_');
+        if (rootBlock.trim() || propsSection.trim()) {
+            const hooksSection = hooks_1.preactHooks
+                .map(fn => fn.toString())
+                .filter(s => s.trim())
+                .join('\n')
+                .split('\n')
+                .map(e => `    ${e}`)
+                .join('\n');
+            const scriptContent = [
+                `${hooksSection}\n`,
+                propsSection,
+                rootBlock
+            ]
+                .filter(Boolean)
+                .join('\n')
+                .replaceAll('</script>', '\\u003c/script>');
+            if (html.includes('</body>')) {
+                html = html.replace('</body>', `<script>\n${scriptContent}\n</script>\n</body>`);
+            }
+            else {
+                html += `\n<script>\n${scriptContent}\n</script>`;
+            }
+        }
+        return '<!DOCTYPE html>\n' + html;
+    }
+    /**
+     * Render a component and inline the component "body" (everything before the top-level return)
+     * into the same <script> tag that also contains the handler bootstrap. Then wrap it into a html response..
+     * @example
+     * ```ts
+     * PreactUtilities.renderResponse(TestPage, { initialCount: 1 });
+     * ```
+     * @param args - Component and props.
+     * @param args.component - The function component to render.
+     * @param args.props - The properties to pass into the component.
+     * @returns The fully rendered html as a ready to return html response.
+     */
+    static async renderResponse(...args) {
+        const [component, props] = args;
+        // eslint-disable-next-line typescript/no-explicit-any
+        const htmlString = await this.renderPage(component, props);
+        return html_response_model_1.HtmlResponse.fromString(htmlString);
+    }
+    static unescapeConditionalComments(html) {
+        let result = html;
+        // Standard MSO blocks — both opening and closing are escaped
+        // &lt;!--[if ...]>...&lt;![endif]-->
+        result = result.replaceAll(/&lt;!--\[if ([^\]]*)]>([\S\s]*?)&lt;!\[endif]-->/g, (_match, condition, inner) => {
+            const unescaped = inner
+                .replaceAll('&lt;', '<')
+                .replaceAll('&gt;', '>')
+                .replaceAll('&quot;', '"')
+                .replaceAll('&amp;', '&');
+            return `<!--[if ${condition}]>${unescaped}<![endif]-->`;
+        });
+        // "Show in non-MSO" open: &lt;!--[if !mso]>&lt;!-->
+        result = result.replaceAll(/&lt;!--\[if ([^\]]*)]>&lt;!-->/g, '<!--[if $1]><!-->');
+        // "Show in non-MSO" close: <!--<![endif]--> (already unescaped by preact, no change needed)
+        return result;
+    }
+    static resolveInAncestors(value, prefixToRenameMap, ancestorMap, startPrefix) {
+        let result = value;
+        let current = startPrefix;
+        while (current !== undefined) {
+            const map = prefixToRenameMap.get(current);
+            if (map) {
+                result = this.applyRenameMap(result, map);
+            }
+            current = ancestorMap.get(current);
+        }
+        return result;
+    }
+    static buildSectionTree(prefix, parts, allEntries, getReattachment) {
+        const { bindingLines, cleanBody } = parts.get(prefix) ?? { bindingLines: '', cleanBody: '' };
+        const children = allEntries.filter(e => e.parentPrefix === prefix);
+        const childSections = children
+            .map(c => this.buildSectionTree(c.prefix, parts, allEntries, getReattachment))
+            .join('\n');
+        const reattachment = getReattachment(prefix);
+        const blockContents = [cleanBody, childSections, reattachment]
+            .filter(s => s.trim()).join('\n');
+        const wrappedBody = this.wrapInLabeledBlock(blockContents, prefix);
+        return [bindingLines, wrappedBody].filter(s => s.trim()).join('\n');
+    }
+    static async getClientManifest() {
+        if (this.clientManifest) {
+            return this.clientManifest;
+        }
+        try {
+            const manifestPath = fs_utilities_1.FsUtilities.getPath(process.cwd(), 'assets', 'public', 'vendor', 'manifest.json');
+            // eslint-disable-next-line typescript/no-unsafe-assignment
+            this.clientManifest = JSON.parse(await fs_utilities_1.FsUtilities.readFile(manifestPath));
+        }
+        catch {
+            this.clientManifest = {};
+        }
+        return this.clientManifest ?? {};
+    }
+    static async getPackagesForComponent(componentName) {
+        return (await this.getClientManifest())[componentName] ?? [];
+    }
+    static rewriteClientImportRefs(body, packages) {
+        let result = body;
+        for (const pkg of packages) {
+            const baseVar = pkg.replaceAll(/[^\da-z]/gi, '_') + '_client_';
+            // Find all variables tsc generated for this package: chart_js_client_1, chart_js_client_2, etc.
+            const varPattern = new RegExp(`(?<![\\w$])${baseVar}(\\d+)(?=[.\\s,;)\\]])`, 'g');
+            const moduleVars = new Set();
+            let varMatch;
+            while ((varMatch = varPattern.exec(result)) !== null) {
+                moduleVars.add(`${baseVar}${varMatch[1]}`);
+            }
+            for (const moduleVar of moduleVars) {
+                result = (0, string_aware_replace_function_1.stringAwareReplace)(result, new RegExp(`(?<![\\w$])${moduleVar}\\.([\\w$]+)(?![\\w$])`, 'g'), (_match, name) => name);
+            }
+        }
+        return result;
+    }
+    static getClientScriptUrl(pkg) {
+        return `/assets/vendor/${(0, generate_client_scripts_function_1.pkgToFilename)(pkg)}`;
+    }
+    static rewriteFrameworkHooks(body) {
+        let result = body;
+        for (const hook of hooks_1.preactHooks) {
+            result = (0, string_aware_replace_function_1.stringAwareReplace)(result, new RegExp(`(?:\\(0,\\s*)?\\w*zibri\\w*_\\d+\\.${hook.name}\\)?(?=\\()`, 'g'), hook.name);
+        }
+        return result;
+    }
+    static getBodyTextBeforeReturn(bodyText, label) {
+        if (!bodyText.length) {
+            return '';
+        }
+        const candidate = this.findBeforeTopLevelReturn(bodyText);
+        return this.removeJsxReturnStatements(candidate, label);
+    }
+    // eslint-disable-next-line sonar/cognitive-complexity
+    static removeJsxReturnStatements(body, label) {
+        let result = '';
+        let i = 0;
+        let inSingle = false, inDouble = false, inTemplate = false;
+        let inLine = false, inBlock = false;
+        while (i < body.length) {
+            const ch = body[i];
+            const prev = body[i - 1];
+            if (inLine) {
+                if (ch === '\n') {
+                    inLine = false;
+                }
+                result += ch;
+                i++;
+                continue;
+            }
+            if (inBlock) {
+                if (prev === '*' && ch === '/') {
+                    inBlock = false;
+                }
+                result += ch;
+                i++;
+                continue;
+            }
+            if (!inSingle && !inDouble && !inTemplate) {
+                if (ch === '/' && body[i + 1] === '/') {
+                    inLine = true;
+                    result += ch;
+                    i++;
+                    continue;
+                }
+                if (ch === '/' && body[i + 1] === '*') {
+                    inBlock = true;
+                    result += ch;
+                    i++;
+                    continue;
+                }
+            }
+            if (!inLine && !inBlock) {
+                if (!inDouble && !inTemplate && ch === '\'' && prev !== '\\') {
+                    inSingle = !inSingle;
+                    result += ch;
+                    i++;
+                    continue;
+                }
+                if (!inSingle && !inTemplate && ch === '"' && prev !== '\\') {
+                    inDouble = !inDouble;
+                    result += ch;
+                    i++;
+                    continue;
+                }
+                if (!inSingle && !inDouble && ch === '`' && prev !== '\\') {
+                    inTemplate = !inTemplate;
+                    result += ch;
+                    i++;
+                    continue;
+                }
+            }
+            if (inSingle || inDouble || inTemplate) {
+                result += ch;
+                i++;
+                continue;
+            }
+            // At a return keyword — check if it returns JSX
+            if (/^return\b/.test(body.slice(i))) {
+                const stmtEnd = this.findReturnStatementEnd(body, i);
+                const stmt = body.slice(i, stmtEnd);
+                if (this.isJsxReturn(stmt)) {
+                    result += `break ${label};`;
+                    i = stmtEnd;
+                    continue;
+                }
+            }
+            result += ch;
+            i++;
+        }
+        return result;
+    }
+    // eslint-disable-next-line sonar/cognitive-complexity
+    static findReturnStatementEnd(body, start) {
+        let i = start + 'return'.length;
+        let depth = 0;
+        let inSingle = false, inDouble = false, inTemplate = false;
+        while (i < body.length) {
+            const ch = body[i];
+            const prev = body[i - 1];
+            if (!inDouble && !inTemplate && ch === '\'' && prev !== '\\') {
+                inSingle = !inSingle;
+                i++;
+                continue;
+            }
+            if (!inSingle && !inTemplate && ch === '"' && prev !== '\\') {
+                inDouble = !inDouble;
+                i++;
+                continue;
+            }
+            if (!inSingle && !inDouble && ch === '`' && prev !== '\\') {
+                inTemplate = !inTemplate;
+                i++;
+                continue;
+            }
+            if (inSingle || inDouble || inTemplate) {
+                i++;
+                continue;
+            }
+            if (ch === '(' || ch === '{' || ch === '[') {
+                depth++;
+            }
+            else if (ch === ')' || ch === '}' || ch === ']') {
+                if (depth === 0) {
+                    return i;
+                } // hit enclosing block's closing brace
+                depth--;
+            }
+            else if (ch === ';' && depth === 0) {
+                return i + 1;
+            }
+            i++;
+        }
+        return i;
+    }
+    static isJsxReturn(stmt) {
+        // Matches compiled TSX output from tsc + preact/jsx-runtime
+        return stmt.includes('jsx_runtime')
+            || stmt.includes('_jsx(')
+            // eslint-disable-next-line cspell/spellchecker
+            || stmt.includes('_jsxs(')
+            || stmt.includes('jsxDEV(');
+    }
+    // eslint-disable-next-line sonar/cognitive-complexity
+    static findBeforeTopLevelReturn(bodyText) {
+        // extract up to top-level return
+        let i = 0;
+        let depth = 0;
+        let inSingle = false;
+        let inDouble = false;
+        let inTemplate = false;
+        let inLine = false;
+        let inBlock = false;
+        while (i < bodyText.length) {
+            const ch = bodyText[i];
+            const prev = bodyText[i - 1];
+            if (inLine) {
+                if (ch === '\n') {
+                    inLine = false;
+                }
+                i++;
+                continue;
+            }
+            if (inBlock) {
+                if (prev === '*' && ch === '/') {
+                    inBlock = false;
+                }
+                i++;
+                continue;
+            }
+            if (!inSingle && !inDouble && !inTemplate) {
+                if (ch === '/' && bodyText[i + 1] === '/') {
+                    inLine = true;
+                    i++;
+                    continue;
+                }
+                if (ch === '/' && bodyText[i + 1] === '*') {
+                    inBlock = true;
+                    i++;
+                    continue;
+                }
+            }
+            if (!inLine && !inBlock) {
+                if (!inDouble && !inTemplate && ch === '\'' && prev !== '\\') {
+                    inSingle = !inSingle;
+                    i++;
+                    continue;
+                }
+                if (!inSingle && !inTemplate && ch === '"' && prev !== '\\') {
+                    inDouble = !inDouble;
+                    i++;
+                    continue;
+                }
+                if (!inSingle && !inDouble && ch === '`' && prev !== '\\') {
+                    inTemplate = !inTemplate;
+                    i++;
+                    continue;
+                }
+            }
+            if (inSingle || inDouble || inTemplate || inLine || inBlock) {
+                i++;
+                continue;
+            }
+            if (ch === '{') {
+                depth++;
+            }
+            else if (ch === '}') {
+                depth = Math.max(0, depth - 1);
+            }
+            else if (depth === 0 && /^return\b/.test(bodyText.slice(i))) {
+                return bodyText.slice(0, i);
+            }
+            i++;
+        }
+        return bodyText;
+    }
+    static extractParamsText(src) {
+        const firstParen = src.indexOf('(');
+        if (firstParen === -1) {
+            return '';
+        }
+        // find matching ) for params (simple paren matcher)
+        let depth = 0;
+        let paramsEnd = -1;
+        for (let i = firstParen; i < src.length; i++) {
+            const ch = src[i];
+            if (ch === '(') {
+                depth++;
+                continue;
+            }
+            if (ch === ')') {
+                depth--;
+                if (depth === 0) {
+                    paramsEnd = i;
+                    break;
+                }
+            }
+        }
+        if (paramsEnd === -1) {
+            return '';
+        }
+        return src.slice(firstParen + 1, paramsEnd).trim();
+    }
+    // eslint-disable-next-line sonar/cognitive-complexity
+    static extractBodyText(src) {
+        const firstParen = src.indexOf('(');
+        if (firstParen === -1) {
+            return '';
+        }
+        // find matching ) for params (simple paren matcher)
+        let depth = 0;
+        let paramsEnd = -1;
+        for (let i = firstParen; i < src.length; i++) {
+            const ch = src[i];
+            if (ch === '(') {
+                depth++;
+                continue;
+            }
+            if (ch === ')') {
+                depth--;
+                if (depth === 0) {
+                    paramsEnd = i;
+                    break;
+                }
+            }
+        }
+        if (paramsEnd === -1) {
+            return '';
+        }
+        // find body braces
+        const braceStart = src.indexOf('{', paramsEnd);
+        if (braceStart === -1) {
+            return '';
+        }
+        // match closing brace (handle simple string/comment cases enough for typical components)
+        depth = 0;
+        let inSingle = false;
+        let inDouble = false;
+        let inTemplate = false;
+        let inLine = false;
+        let inBlock = false;
+        for (let pos = braceStart; pos < src.length; pos++) {
+            const ch = src[pos];
+            const prev = src[pos - 1];
+            if (inLine) {
+                if (ch === '\n') {
+                    inLine = false;
+                }
+                continue;
+            }
+            if (inBlock) {
+                if (prev === '*' && ch === '/') {
+                    inBlock = false;
+                }
+                continue;
+            }
+            if (!inSingle && !inDouble && !inTemplate) {
+                if (ch === '/' && src[pos + 1] === '/') {
+                    inLine = true;
+                    pos++;
+                    continue;
+                }
+                if (ch === '/' && src[pos + 1] === '*') {
+                    inBlock = true;
+                    pos++;
+                    continue;
+                }
+            }
+            if (!inLine && !inBlock) {
+                if (!inDouble && !inTemplate && ch === '\'' && prev !== '\\') {
+                    inSingle = !inSingle;
+                }
+                else if (!inSingle && !inTemplate && ch === '"' && prev !== '\\') {
+                    inDouble = !inDouble;
+                }
+                else if (!inSingle && !inDouble && ch === '`' && prev !== '\\') {
+                    inTemplate = !inTemplate;
+                }
+            }
+            if (inSingle || inDouble || inTemplate || inLine || inBlock) {
+                continue;
+            }
+            if (ch === '{') {
+                depth++;
+            }
+            else if (ch === '}') {
+                depth--;
+                if (depth === 0) {
+                    return src.slice(braceStart + 1, pos);
+                }
+            }
+        }
+        return '';
+    }
+    static getInlinedPropsSection(paramsText, propsObj) {
+        // Separate functions from serializable values
+        const fnProps = {};
+        const serializableProps = {};
+        for (const [key, val] of Object.entries(propsObj)) {
+            if (typeof val === 'function') {
+                fnProps[key] = val.toString();
+            }
+            else {
+                serializableProps[key] = val;
+            }
+        }
+        const safe = JSON.stringify(serializableProps, undefined, 4)
+            .split('\n')
+            .map((l, i) => i === 0 ? l : '    ' + l)
+            .join('\n')
+            .replaceAll('<', '\\u003c');
+        const lines = [`    const __PROPS = ${safe};`];
+        // Emit function props as standalone consts — they can't be JSON-serialized
+        for (const [key, src] of Object.entries(fnProps)) {
+            lines.push(`    const ${key} = ${src};`);
+        }
+        const trimmed = paramsText.trim();
+        if (!paramsText.length) {
+            return lines.join('\n');
+        }
+        if (trimmed.startsWith('{')) {
+            const inside = trimmed.replaceAll(/^{\s*|\s*}$/g, '');
+            const keys = this.splitTopLevelTokens(inside)
+                .map(s => {
+                const parts = s.trim().split(':');
+                const propName = parts[0].trim();
+                const maybeLocal = (parts[1] ?? '').trim();
+                if (maybeLocal && /^[$_a-z]\w*$/i.test(maybeLocal)) {
+                    return `${propName}: ${maybeLocal}`;
+                }
+                return propName;
+            })
+                .filter(Boolean)
+                // Only destructure from __PROPS — function props are already declared as consts
+                .filter(k => {
+                const propName = k.split(':')[0].trim();
+                return !(propName in fnProps);
+            })
+                .filter(k => /^[$_a-z]\w*(?:\s*:\s*[$_a-z]\w*)?$/i.test(k.trim()));
+            if (keys.length) {
+                lines.push(`    const { ${keys.join(', ')} } = __PROPS;`);
+            }
+            return lines.join('\n');
+        }
+        const firstName = trimmed.split(',')[0].split('=')[0].trim();
+        if (firstName.length && /^[$_a-z]\w*$/i.test(firstName)) {
+            lines.push(`    const ${firstName} = __PROPS.${firstName} !== undefined ? __PROPS.${firstName} : __PROPS;`);
+        }
+        return lines.join('\n');
+    }
+    // eslint-disable-next-line sonar/cognitive-complexity
+    static buildRenameMap(strippedBody, prefix, propBindings, propsParamName, componentFn, inlineBindings) {
+        const renameMap = new Map();
+        // Declared names in the body
+        const declPatterns = [
+            /\b(?:let|const|var)\s+([$A-Z_a-z]\w*)/g,
+            /\bfunction\s*\*?\s*([$A-Z_a-z]\w*)\s*\(/g,
+            /\bclass\s+([$A-Z_a-z]\w*)/g
+        ];
+        const blankedBody = this.blankStringsAndComments(strippedBody);
+        for (const pattern of declPatterns) {
+            let match;
+            while ((match = pattern.exec(blankedBody)) !== null) {
+                renameMap.set(match[1], `${prefix}${match[1]}`);
+            }
+        }
+        for (const { inner } of this.findDestructurePatterns(blankedBody)) {
+            for (const name of this.extractDestructuredNames(inner)) {
+                renameMap.set(name, `${prefix}${name}`);
+            }
+        }
+        // Handler prop local names (from propBindings)
+        for (const key of object_utilities_1.ObjectUtilities.keys(propBindings)) {
+            if (key.startsWith('__propsObj_')) {
+                const paramName = key.replace('__propsObj_', '');
+                renameMap.set(paramName, `${prefix}${paramName}`);
+            }
+            else {
+                renameMap.set(key, `${prefix}${key}`);
+            }
+        }
+        for (const localName of object_utilities_1.ObjectUtilities.keys(inlineBindings)) {
+            renameMap.set(localName, `${prefix}${localName}`);
+        }
+        if (propsParamName) {
+            renameMap.set(propsParamName, `${prefix}${propsParamName}`);
+        }
+        else {
+            // ALL destructured param names — including those using defaults not passed by parent
+            const allParams = this.extractAllParamEntries(componentFn.toString());
+            for (const { localName } of allParams) {
+                if (localName && localName !== 'children') {
+                    renameMap.set(localName, `${prefix}${localName}`);
+                }
+            }
+        }
+        return renameMap;
+    }
+    static blankStringsAndComments(text) {
+        let result = '';
+        let i = 0;
+        while (i < text.length) {
+            if (text[i] === '"' || text[i] === '\'' || text[i] === '`') {
+                const end = (0, string_aware_replace_function_1.findStringEnd)(text, i, text[i]);
+                result += ' '.repeat(end - i);
+                i = end;
+            }
+            else if (text[i] === '/' && text[i + 1] === '/') {
+                const end = text.indexOf('\n', i);
+                const commentEnd = end === -1 ? text.length : end;
+                result += ' '.repeat(commentEnd - i);
+                i = commentEnd;
+            }
+            else if (text[i] === '/' && text[i + 1] === '*') {
+                const end = text.indexOf('*/', i + 2);
+                const commentEnd = end === -1 ? text.length : end + 2;
+                result += ' '.repeat(commentEnd - i);
+                i = commentEnd;
+            }
+            else {
+                result += text[i];
+                i++;
+            }
+        }
+        return result;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    static findDestructurePatterns(body) {
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        const results = [];
+        const pattern = /\b(?:let|const|var)\s*([[{])/g;
+        let match;
+        while ((match = pattern.exec(body)) !== null) {
+            const isArray = match[1] === '[';
+            const open = match[1];
+            const close = isArray ? ']' : '}';
+            let depth = 1;
+            let i = match.index + match[0].length;
+            while (i < body.length && depth > 0) {
+                if (body[i] === open) {
+                    depth++;
+                }
+                else if (body[i] === close) {
+                    depth--;
+                }
+                i++;
+            }
+            const inner = body.slice(match.index + match[0].length, i - 1);
+            results.push({ inner, isArray });
+        }
+        return results;
+    }
+    // eslint-disable-next-line sonar/cognitive-complexity
+    static extractDestructuredNames(destructureText) {
+        const names = [];
+        const tokens = this.splitTopLevelTokens(destructureText);
+        for (const token of tokens) {
+            if (!token) {
+                continue;
+            }
+            // Strip default value at depth 0
+            let eqIdx = -1;
+            let ed = 0;
+            let inS = false;
+            let sChar = '';
+            for (let i = 0; i < token.length; i++) {
+                const ch = token[i];
+                const prev = token[i - 1];
+                if (inS) {
+                    if (ch === sChar && prev !== '\\') {
+                        inS = false;
+                    }
+                    continue;
+                }
+                if (ch === '"' || ch === '\'' || ch === '`') {
+                    inS = true;
+                    sChar = ch;
+                    continue;
+                }
+                if (ch === '(' || ch === '{' || ch === '[') {
+                    ed++;
+                }
+                else if (ch === ')' || ch === '}' || ch === ']') {
+                    ed--;
+                }
+                else if (ch === '=' && ed === 0 && token[i + 1] !== '>') {
+                    eqIdx = i;
+                    break;
+                }
+            }
+            const withoutDefault = (eqIdx !== -1 ? token.slice(0, eqIdx) : token).trim();
+            // Nested object destructure: { a, b: localB }
+            if (withoutDefault.startsWith('{')) {
+                const inner = withoutDefault.slice(1, withoutDefault.lastIndexOf('}')).trim();
+                names.push(...this.extractDestructuredNames(inner));
+                continue;
+            }
+            // Nested array destructure: [a, b]
+            if (withoutDefault.startsWith('[')) {
+                const inner = withoutDefault.slice(1, withoutDefault.lastIndexOf(']')).trim();
+                names.push(...this.extractDestructuredNames(inner));
+                continue;
+            }
+            // Rename: propName: localName — take the local name (right side)
+            const colonIdx = withoutDefault.indexOf(':');
+            if (colonIdx !== -1) {
+                const afterColon = withoutDefault.slice(colonIdx + 1).trim();
+                // Only treat as rename if right side is a plain identifier, not a type
+                if (/^[$_a-z]\w*$/i.test(afterColon)) {
+                    names.push(afterColon);
+                }
+                // Otherwise it's a TypeScript type annotation — left side is the local name
+                else {
+                    const beforeColon = withoutDefault.slice(0, colonIdx).trim();
+                    if (/^[$_a-z]\w*$/i.test(beforeColon)) {
+                        names.push(beforeColon);
+                    }
+                }
+                continue;
+            }
+            // Plain identifier: possibly with rest spread ...name
+            const plain = withoutDefault.replace(/^\.{3}/, '').trim();
+            if (/^[$_a-z]\w*$/i.test(plain)) {
+                names.push(plain);
+            }
+        }
+        return names;
+    }
+    static wrapInLabeledBlock(body, prefix) {
+        const indented = body
+            .split('\n')
+            .filter(s => s.trim())
+            .map(l => `    ${l}`)
+            .join('\n');
+        return indented.trim()
+            ? `    ${prefix}: {\n${indented}\n    }\n`
+            : '';
+    }
+    // eslint-disable-next-line sonar/cognitive-complexity
+    static buildPropBindingLines(prefix, propBindings, propValues, destructureRenameMap, propsParamName, resolveValue, componentFn, inlineBindings, ownRenameMap) {
+        const lines = [];
+        if (propsParamName) {
+            // Non-destructured param: reconstruct the full props object
+            const entries = [];
+            for (const [key, value] of object_utilities_1.ObjectUtilities.entries(propBindings)) {
+                if (key.startsWith('__propsObj_')) {
+                    // eslint-disable-next-line typescript/no-unsafe-assignment
+                    const parsed = JSON.parse(value);
+                    for (const [propName, resolvedName] of object_utilities_1.ObjectUtilities.entries(parsed)) {
+                        entries.push(`${propName}: ${resolveValue(resolvedName)}`);
+                    }
+                }
+                else {
+                    entries.push(`${key}: ${resolveValue(value)}`);
+                }
+            }
+            // Inline bindings go into the props object too
+            for (const [localName, src] of object_utilities_1.ObjectUtilities.entries(inlineBindings)) {
+                const resolvedSrc = resolveValue(src);
+                // Reverse-lookup to get the prop name for this local name
+                const propName = destructureRenameMap.get(localName) ?? localName;
+                entries.push(`${propName}: ${resolvedSrc}`);
+            }
+            for (const [propName, val] of object_utilities_1.ObjectUtilities.entries(propValues)) {
+                entries.push(`${propName}: ${JSON.stringify(val)}`);
+            }
+            if (entries.length) {
+                lines.push(`    const ${prefix}${propsParamName} = { ${entries.join(', ')} };`);
+            }
+        }
+        else {
+            // Destructured param: emit one const per prop local name
+            // Handler bindings — simple delegations resolved to a name
+            for (const [key, value] of object_utilities_1.ObjectUtilities.entries(propBindings)) {
+                if (key.startsWith('__propsObj_')) {
+                    continue;
+                }
+                lines.push(`    const ${prefix}${key} = ${resolveValue(value)};`);
+            }
+            // Inline bindings — complex expressions emitted as named consts with
+            // parentRenameMap applied so references to parent-scope names are resolved
+            for (const [localName, src] of object_utilities_1.ObjectUtilities.entries(inlineBindings)) {
+                const resolvedSrc = resolveValue(src);
+                lines.push(`    const ${prefix}${localName} = ${resolvedSrc};`);
+            }
+            // All declared params — emit passed value, or default, or skip
+            const allParams = this.extractAllParamEntries(componentFn.toString());
+            for (const { localName, defaultSrc } of allParams) {
+                if (!localName || localName === 'children') {
+                    continue;
+                }
+                // Skip if already emitted as a handler or inline binding
+                if (localName in propBindings || localName in inlineBindings) {
+                    continue;
+                }
+                const propName = destructureRenameMap.get(localName) ?? localName;
+                if (propName in propValues) {
+                    lines.push(`    const ${prefix}${localName} = ${JSON.stringify(propValues[propName])};`);
+                    continue;
+                }
+                if (defaultSrc !== undefined) {
+                    // Apply own rename map so `id = label` becomes `checkbox0_id = checkbox0_label`
+                    const renamedDefault = this.applyRenameMap(defaultSrc, ownRenameMap);
+                    lines.push(`    const ${prefix}${localName} = ${renamedDefault};`);
+                    continue;
+                }
+                lines.push(`    const ${prefix}${localName} = undefined;`);
+            }
+        }
+        return lines.join('\n');
+    }
+    // eslint-disable-next-line sonar/cognitive-complexity
+    static extractAllParamEntries(fnSrc) {
+        const results = [];
+        const firstParen = fnSrc.indexOf('(');
+        if (firstParen === -1) {
+            return results;
+        }
+        let depth = 0, paramsEnd = -1;
+        for (let i = firstParen; i < fnSrc.length; i++) {
+            if (fnSrc[i] === '(') {
+                depth++;
+            }
+            else if (fnSrc[i] === ')') {
+                depth--;
+                if (depth === 0) {
+                    paramsEnd = i;
+                    break;
+                }
+            }
+        }
+        if (paramsEnd === -1) {
+            return results;
+        }
+        const paramsText = fnSrc.slice(firstParen + 1, paramsEnd).trim();
+        if (!paramsText.startsWith('{')) {
+            return results;
+        }
+        const braceOpen = paramsText.indexOf('{');
+        const braceClose = paramsText.lastIndexOf('}');
+        if (braceOpen === -1 || braceClose === -1) {
+            return results;
+        }
+        const destructureText = paramsText.slice(braceOpen + 1, braceClose);
+        // Use the same top-level comma splitter from extractDestructuredNames
+        const tokens = this.splitTopLevelTokens(destructureText);
+        for (const token of tokens) {
+            if (!token) {
+                continue;
+            }
+            // Extract default value at depth 0 — same logic as before
+            let eqIdx = -1;
+            let ed = 0;
+            let inS = false;
+            let sChar = '';
+            for (let i = 0; i < token.length; i++) {
+                const ch = token[i];
+                const prev = token[i - 1];
+                if (inS) {
+                    if (ch === sChar && prev !== '\\') {
+                        inS = false;
+                    }
+                    continue;
+                }
+                if (ch === '"' || ch === '\'' || ch === '`') {
+                    inS = true;
+                    sChar = ch;
+                    continue;
+                }
+                if (ch === '(' || ch === '{' || ch === '[') {
+                    ed++;
+                }
+                else if (ch === ')' || ch === '}' || ch === ']') {
+                    ed--;
+                }
+                else if (ch === '=' && ed === 0 && token[i + 1] !== '>') {
+                    eqIdx = i;
+                    break;
+                }
+            }
+            const withoutDefault = (eqIdx !== -1 ? token.slice(0, eqIdx) : token).trim();
+            const defaultSrc = eqIdx !== -1
+                ? token.slice(eqIdx + 1).trim()
+                : undefined;
+            // Delegate name extraction to extractDestructuredNames
+            const names = this.extractDestructuredNames(withoutDefault);
+            // For top-level params we only want the single local name
+            const localName = names[0] ?? '';
+            if (localName) {
+                results.push({ localName, defaultSrc });
+            }
+        }
+        return results;
+    }
+    static splitTopLevelTokens(text) {
+        const tokens = [];
+        let tokenStart = 0;
+        let depth = 0;
+        let inStr = false;
+        let strChar = '';
+        for (let i = 0; i < text.length; i++) {
+            const ch = text[i];
+            const prev = text[i - 1];
+            if (inStr) {
+                if (ch === strChar && prev !== '\\') {
+                    inStr = false;
+                }
+                continue;
+            }
+            if (ch === '"' || ch === '\'' || ch === '`') {
+                inStr = true;
+                strChar = ch;
+                continue;
+            }
+            if (ch === '(' || ch === '{' || ch === '[') {
+                depth++;
+            }
+            else if (ch === ')' || ch === '}' || ch === ']') {
+                depth--;
+            }
+            else if (ch === ',' && depth === 0) {
+                tokens.push(text.slice(tokenStart, i).trim());
+                tokenStart = i + 1;
+            }
+        }
+        tokens.push(text.slice(tokenStart).trim());
+        return tokens;
+    }
+    static applyRenameMap(text, renameMap) {
+        const sorted = [...renameMap.entries()]
+            .sort((a, b) => b[0].length - a[0].length);
+        let result = text;
+        for (const [from, to] of sorted) {
+            // Expand to explicit form { from: to } so the key is preserved.
+            result = (0, string_aware_replace_function_1.stringAwareReplace)(result, new RegExp(`(?<=[{,]\\s*)${from}(?=\\s*[,}])`, 'g'), () => `${from}: ${to}`);
+            // rename remaining references (variable uses, not property keys)
+            result = (0, string_aware_replace_function_1.stringAwareReplace)(result, new RegExp(`(?<![\\w$.])${from}(?![\\w$:])`, 'g'), to);
+        }
+        return result;
+    }
+}
+exports.PreactUtilities = PreactUtilities;
+//# sourceMappingURL=preact.utilities.js.map