zibri 2.1.7 → 2.2.1

package/dist/esm/preact/preact.utilities.js

@@ -0,0 +1,978 @@
+import renderToString from 'preact-render-to-string';
+import { PreactCollector } from './collector';
+import { pkgToFilename } from './generate-client-scripts.function';
+import { preactHooks } from './hooks/hooks';
+import { findStringEnd, stringAwareReplace } from './string-aware-replace.function';
+import { HtmlResponse } from '../parsing/html/html-response.model';
+import { FsUtilities } from '../utilities/fs.utilities';
+import { ObjectUtilities } from '../utilities/object.utilities';
+/**
+ * Utilities for handling preact templates.
+ */
+export class PreactUtilities {
+    static clientManifest;
+    /**
+     * 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.
+     * @example
+     * ```ts
+     * PreactUtilities.render(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 render(...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 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 = renderToString(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 = 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.render(component, props);
+        return HtmlResponse.fromString(htmlString);
+    }
+    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 = FsUtilities.getPath(process.cwd(), 'assets', 'public', 'vendor', 'manifest.json');
+            // eslint-disable-next-line typescript/no-unsafe-assignment
+            this.clientManifest = JSON.parse(await 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 = stringAwareReplace(result, new RegExp(`(?<![\\w$])${moduleVar}\\.([\\w$]+)(?![\\w$])`, 'g'), (_match, name) => name);
+            }
+        }
+        return result;
+    }
+    static getClientScriptUrl(pkg) {
+        return `/assets/vendor/${pkgToFilename(pkg)}`;
+    }
+    static rewriteFrameworkHooks(body) {
+        let result = body;
+        for (const hook of preactHooks) {
+            result = 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 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 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 = 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 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 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 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 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 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 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 = stringAwareReplace(result, new RegExp(`(?<=[{,]\\s*)${from}(?=\\s*[,}])`, 'g'), () => `${from}: ${to}`);
+            // rename remaining references (variable uses, not property keys)
+            result = stringAwareReplace(result, new RegExp(`(?<![\\w$.])${from}(?![\\w$:])`, 'g'), to);
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=preact.utilities.js.map