@zenithbuild/cli 0.6.13 → 0.7.0

package/dist/build/server-script.js

@@ -0,0 +1,210 @@
+import { readFileSync } from 'node:fs';
+import { findNextKnownComponentTag } from '../component-tag-parser.js';
+/**
+ * @param {string} source
+ * @param {string} sourceFile
+ * @param {object} [compilerOpts]
+ * @returns {{ source: string, serverScript: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, source_path: string } | null }}
+ */
+export function extractServerScript(source, sourceFile, compilerOpts = {}) {
+    const scriptRe = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+    const serverMatches = [];
+    const reservedServerExportRe = /\bexport\s+const\s+(?:data|prerender|guard|load|ssr_data|props|ssr)\b|\bexport\s+(?:async\s+)?function\s+(?:load|guard)\s*\(|\bexport\s+const\s+(?:load|guard)\s*=/;
+    for (const match of source.matchAll(scriptRe)) {
+        const attrs = String(match[1] || '');
+        const body = String(match[2] || '');
+        const isServer = /\bserver\b/i.test(attrs);
+        if (!isServer && reservedServerExportRe.test(body)) {
+            throw new Error(`Zenith server script contract violation:\n` +
+                `  File: ${sourceFile}\n` +
+                `  Reason: guard/load/data exports are only allowed in <script server lang="ts"> or adjacent .guard.ts / .load.ts files\n` +
+                `  Example: move the export into <script server lang="ts">`);
+        }
+        if (isServer) {
+            serverMatches.push(match);
+        }
+    }
+    if (serverMatches.length === 0) {
+        return { source, serverScript: null };
+    }
+    if (serverMatches.length > 1) {
+        throw new Error(`Zenith server script contract violation:\n` +
+            `  File: ${sourceFile}\n` +
+            `  Reason: multiple <script server> blocks are not supported\n` +
+            `  Example: keep exactly one <script server>...</script> block`);
+    }
+    const match = serverMatches[0];
+    const full = match[0] || '';
+    const attrs = String(match[1] || '');
+    const hasLangTs = /\blang\s*=\s*["']ts["']/i.test(attrs);
+    const hasLangJs = /\blang\s*=\s*["'](?:js|javascript)["']/i.test(attrs);
+    const hasAnyLang = /\blang\s*=/i.test(attrs);
+    const isTypescriptDefault = compilerOpts && compilerOpts.typescriptDefault === true;
+    if (!hasLangTs) {
+        if (!isTypescriptDefault || hasLangJs || hasAnyLang) {
+            throw new Error(`Zenith server script contract violation:\n` +
+                `  File: ${sourceFile}\n` +
+                `  Reason: Zenith requires TypeScript server scripts. Add lang="ts" (or enable typescriptDefault).\n` +
+                `  Example: <script server lang="ts">`);
+        }
+    }
+    const serverSource = String(match[2] || '').trim();
+    if (!serverSource) {
+        throw new Error(`Zenith server script contract violation:\n` +
+            `  File: ${sourceFile}\n` +
+            `  Reason: <script server> block is empty\n` +
+            `  Example: export const data = { ... }`);
+    }
+    const loadFnMatch = serverSource.match(/\bexport\s+(?:async\s+)?function\s+load\s*\(([^)]*)\)/);
+    const loadConstParenMatch = serverSource.match(/\bexport\s+const\s+load\s*=\s*(?:async\s*)?\(([^)]*)\)\s*=>/);
+    const loadConstSingleArgMatch = serverSource.match(/\bexport\s+const\s+load\s*=\s*(?:async\s*)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>/);
+    const hasLoad = Boolean(loadFnMatch || loadConstParenMatch || loadConstSingleArgMatch);
+    const loadMatchCount = Number(Boolean(loadFnMatch)) +
+        Number(Boolean(loadConstParenMatch)) +
+        Number(Boolean(loadConstSingleArgMatch));
+    if (loadMatchCount > 1) {
+        throw new Error(`Zenith server script contract violation:\n` +
+            `  File: ${sourceFile}\n` +
+            `  Reason: multiple load exports detected\n` +
+            `  Example: keep exactly one export const load = async (ctx) => ({ ... })`);
+    }
+    const guardFnMatch = serverSource.match(/\bexport\s+(?:async\s+)?function\s+guard\s*\(([^)]*)\)/);
+    const guardConstParenMatch = serverSource.match(/\bexport\s+const\s+guard\s*=\s*(?:async\s*)?\(([^)]*)\)\s*=>/);
+    const guardConstSingleArgMatch = serverSource.match(/\bexport\s+const\s+guard\s*=\s*(?:async\s*)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>/);
+    const hasGuard = Boolean(guardFnMatch || guardConstParenMatch || guardConstSingleArgMatch);
+    const guardMatchCount = Number(Boolean(guardFnMatch)) +
+        Number(Boolean(guardConstParenMatch)) +
+        Number(Boolean(guardConstSingleArgMatch));
+    if (guardMatchCount > 1) {
+        throw new Error(`Zenith server script contract violation:\n` +
+            `  File: ${sourceFile}\n` +
+            `  Reason: multiple guard exports detected\n` +
+            `  Example: keep exactly one export const guard = async (ctx) => ({ ... })`);
+    }
+    const hasData = /\bexport\s+const\s+data\b/.test(serverSource);
+    const hasSsrData = /\bexport\s+const\s+ssr_data\b/.test(serverSource);
+    const hasSsr = /\bexport\s+const\s+ssr\b/.test(serverSource);
+    const hasProps = /\bexport\s+const\s+props\b/.test(serverSource);
+    if (hasData && hasLoad) {
+        throw new Error(`Zenith server script contract violation:\n` +
+            `  File: ${sourceFile}\n` +
+            `  Reason: export either data or load(ctx), not both\n` +
+            `  Example: remove data and return payload from load(ctx)`);
+    }
+    if ((hasData || hasLoad) && (hasSsrData || hasSsr || hasProps)) {
+        throw new Error(`Zenith server script contract violation:\n` +
+            `  File: ${sourceFile}\n` +
+            `  Reason: data/load cannot be combined with legacy ssr_data/ssr/props exports\n` +
+            `  Example: use only export const data or export const load`);
+    }
+    if (hasLoad) {
+        const singleArg = String(loadConstSingleArgMatch?.[1] || '').trim();
+        const paramsText = String((loadFnMatch || loadConstParenMatch)?.[1] || '').trim();
+        const arity = singleArg ? 1 : paramsText.length === 0 ? 0 : paramsText.split(',').length;
+        if (arity !== 1) {
+            throw new Error(`Zenith server script contract violation:\n` +
+                `  File: ${sourceFile}\n` +
+                `  Reason: load(ctx) must accept exactly one argument\n` +
+                `  Example: export const load = async (ctx) => ({ ... })`);
+        }
+    }
+    if (hasGuard) {
+        const singleArg = String(guardConstSingleArgMatch?.[1] || '').trim();
+        const paramsText = String((guardFnMatch || guardConstParenMatch)?.[1] || '').trim();
+        const arity = singleArg ? 1 : paramsText.length === 0 ? 0 : paramsText.split(',').length;
+        if (arity !== 1) {
+            throw new Error(`Zenith server script contract violation:\n` +
+                `  File: ${sourceFile}\n` +
+                `  Reason: guard(ctx) must accept exactly one argument\n` +
+                `  Example: export const guard = async (ctx) => ({ ... })`);
+        }
+    }
+    const prerenderMatch = serverSource.match(/\bexport\s+const\s+prerender\s*=\s*([^\n;]+)/);
+    let prerender = false;
+    if (prerenderMatch) {
+        const rawValue = String(prerenderMatch[1] || '').trim();
+        if (!/^(true|false)\b/.test(rawValue)) {
+            throw new Error(`Zenith server script contract violation:\n` +
+                `  File: ${sourceFile}\n` +
+                `  Reason: prerender must be a boolean literal\n` +
+                `  Example: export const prerender = true`);
+        }
+        prerender = rawValue.startsWith('true');
+    }
+    const start = match.index ?? -1;
+    if (start < 0) {
+        return {
+            source,
+            serverScript: {
+                source: serverSource,
+                prerender,
+                has_guard: hasGuard,
+                has_load: hasLoad,
+                source_path: sourceFile
+            }
+        };
+    }
+    const end = start + full.length;
+    const stripped = `${source.slice(0, start)}${source.slice(end)}`;
+    return {
+        source: stripped,
+        serverScript: {
+            source: serverSource,
+            prerender,
+            has_guard: hasGuard,
+            has_load: hasLoad,
+            source_path: sourceFile
+        }
+    };
+}
+/**
+ * @param {string} source
+ * @param {Map<string, string>} registry
+ * @param {string | null} [ownerPath]
+ * @returns {Map<string, Array<{ attrs: string, ownerPath: string | null }>>}
+ */
+export function collectComponentUsageAttrs(source, registry, ownerPath = null) {
+    const out = new Map();
+    let cursor = 0;
+    while (cursor < source.length) {
+        const tag = findNextKnownComponentTag(source, registry, cursor);
+        if (!tag) {
+            break;
+        }
+        const name = tag.name;
+        const attrs = String(tag.attrs || '').trim();
+        if (!out.has(name)) {
+            out.set(name, []);
+        }
+        out.get(name).push({ attrs, ownerPath });
+        cursor = tag.end;
+    }
+    return out;
+}
+/**
+ * @param {string} source
+ * @param {Map<string, string>} registry
+ * @param {string | null} [ownerPath]
+ * @param {Set<string>} [visitedFiles]
+ * @param {Map<string, Array<{ attrs: string, ownerPath: string | null }>>} [out]
+ * @returns {Map<string, Array<{ attrs: string, ownerPath: string | null }>>}
+ */
+export function collectRecursiveComponentUsageAttrs(source, registry, ownerPath = null, visitedFiles = new Set(), out = new Map()) {
+    const local = collectComponentUsageAttrs(source, registry, ownerPath);
+    for (const [name, attrsList] of local.entries()) {
+        if (!out.has(name)) {
+            out.set(name, []);
+        }
+        out.get(name).push(...attrsList);
+    }
+    for (const name of local.keys()) {
+        const compPath = registry.get(name);
+        if (!compPath || visitedFiles.has(compPath)) {
+            continue;
+        }
+        visitedFiles.add(compPath);
+        const componentSource = readFileSync(compPath, 'utf8');
+        collectRecursiveComponentUsageAttrs(componentSource, registry, compPath, visitedFiles, out);
+    }
+    return out;
+}

package/dist/build/type-declarations.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @param {string} pagesDir
+ * @returns {string}
+ */
+export function deriveProjectRootFromPagesDir(pagesDir: string): string;
+/**
+ * @param {{ manifest: Array<{ path: string, file: string }>, pagesDir: string }} input
+ * @returns {Promise<void>}
+ */
+export function ensureZenithTypeDeclarations(input: {
+    manifest: Array<{
+        path: string;
+        file: string;
+    }>;
+    pagesDir: string;
+}): Promise<void>;

package/dist/build/type-declarations.js

@@ -0,0 +1,158 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { basename, dirname, join, resolve } from 'node:path';
+/**
+ * @param {string} targetPath
+ * @param {string} next
+ */
+function writeIfChanged(targetPath, next) {
+    const previous = existsSync(targetPath) ? readFileSync(targetPath, 'utf8') : null;
+    if (previous === next) {
+        return;
+    }
+    writeFileSync(targetPath, next, 'utf8');
+}
+/**
+ * @param {string} routePath
+ * @returns {string}
+ */
+function routeParamsType(routePath) {
+    const segments = String(routePath || '').split('/').filter(Boolean);
+    const fields = [];
+    for (const segment of segments) {
+        if (segment.startsWith(':')) {
+            fields.push(`${segment.slice(1)}: string`);
+            continue;
+        }
+        if (segment.startsWith('*')) {
+            const raw = segment.slice(1);
+            const name = raw.endsWith('?') ? raw.slice(0, -1) : raw;
+            fields.push(`${name}: string`);
+        }
+    }
+    if (fields.length === 0) {
+        return '{}';
+    }
+    return `{ ${fields.join(', ')} }`;
+}
+/**
+ * @param {Array<{ path: string, file: string }>} manifest
+ * @returns {string}
+ */
+function renderZenithRouteDts(manifest) {
+    const lines = [
+        '// Auto-generated by Zenith CLI. Do not edit manually.',
+        'export {};',
+        '',
+        'declare global {',
+        '  namespace Zenith {',
+        '    interface RouteParamsMap {'
+    ];
+    const sortedManifest = [...manifest].sort((a, b) => a.path.localeCompare(b.path));
+    for (const entry of sortedManifest) {
+        lines.push(`      ${JSON.stringify(entry.path)}: ${routeParamsType(entry.path)};`);
+    }
+    lines.push('    }');
+    lines.push('');
+    lines.push('    type ParamsFor<P extends keyof RouteParamsMap> = RouteParamsMap[P];');
+    lines.push('  }');
+    lines.push('}');
+    lines.push('');
+    return `${lines.join('\n')}\n`;
+}
+/**
+ * @returns {string}
+ */
+function renderZenithEnvDts() {
+    return [
+        '// Auto-generated by Zenith CLI. Do not edit manually.',
+        'export {};',
+        '',
+        'declare global {',
+        '  namespace Zenith {',
+        '    type Params = Record<string, string>;',
+        '',
+        '    interface ErrorState {',
+        '      status?: number;',
+        '      code?: string;',
+        '      message: string;',
+        '    }',
+        '',
+        '    type PageData = Record<string, unknown> & { __zenith_error?: ErrorState };',
+        '',
+        '    interface RouteMeta {',
+        '      id: string;',
+        '      file: string;',
+        '      pattern: string;',
+        '    }',
+        '',
+        '    interface LoadContext {',
+        '      params: Params;',
+        '      url: URL;',
+        '      request: Request;',
+        '      route: RouteMeta;',
+        '    }',
+        '',
+        '    type Load<T extends PageData = PageData> = (ctx: LoadContext) => Promise<T> | T;',
+        '',
+        '    interface Fragment {',
+        '      __zenith_fragment: true;',
+        '      mount: (anchor: Node | null) => void;',
+        '      unmount: () => void;',
+        '    }',
+        '',
+        '    type Renderable =',
+        '      | string',
+        '      | number',
+        '      | boolean',
+        '      | null',
+        '      | undefined',
+        '      | Renderable[]',
+        '      | Fragment;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+}
+/**
+ * @param {string} pagesDir
+ * @returns {string}
+ */
+export function deriveProjectRootFromPagesDir(pagesDir) {
+    const normalized = resolve(pagesDir);
+    const parent = dirname(normalized);
+    if (basename(parent) === 'src') {
+        return dirname(parent);
+    }
+    return parent;
+}
+/**
+ * @param {{ manifest: Array<{ path: string, file: string }>, pagesDir: string }} input
+ * @returns {Promise<void>}
+ */
+export async function ensureZenithTypeDeclarations(input) {
+    const projectRoot = deriveProjectRootFromPagesDir(input.pagesDir);
+    const zenithDir = resolve(projectRoot, '.zenith');
+    await mkdir(zenithDir, { recursive: true });
+    const envPath = join(zenithDir, 'zenith-env.d.ts');
+    const routesPath = join(zenithDir, 'zenith-routes.d.ts');
+    writeIfChanged(envPath, renderZenithEnvDts());
+    writeIfChanged(routesPath, renderZenithRouteDts(input.manifest));
+    const tsconfigPath = resolve(projectRoot, 'tsconfig.json');
+    if (!existsSync(tsconfigPath)) {
+        return;
+    }
+    try {
+        const raw = readFileSync(tsconfigPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        const include = Array.isArray(parsed.include) ? [...parsed.include] : [];
+        if (!include.includes('.zenith/**/*.d.ts')) {
+            include.push('.zenith/**/*.d.ts');
+            parsed.include = include;
+            writeIfChanged(tsconfigPath, `${JSON.stringify(parsed, null, 2)}\n`);
+        }
+    }
+    catch {
+        // Non-JSON tsconfig variants are left untouched.
+    }
+}

package/dist/build/typescript-expression-utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @param {string} key
+ * @returns {string}
+ */
+export function renderObjectKey(key: string): string;
+/**
+ * @param {string} source
+ * @returns {string[]}
+ */
+export function extractDeclaredIdentifiers(source: string): string[];
+/**
+ * @param {string} expr
+ * @returns {string}
+ */
+export function normalizeTypeScriptExpression(expr: string): string;
+export function expandScopedShorthandPropertiesInSource(source: any): string;
+/**
+ * @param {string} expr
+ * @param {Map<string, string>} scopeMap
+ * @param {Set<string> | null | undefined} scopeAmbiguous
+ * @returns {string}
+ */
+export function rewriteIdentifiersWithinExpression(expr: string, scopeMap: Map<string, string>, scopeAmbiguous: Set<string> | null | undefined): string;

package/dist/build/typescript-expression-utils.js

@@ -0,0 +1,272 @@
+import { loadTypeScriptApi } from './compiler-runtime.js';
+/**
+ * @param {string} key
+ * @returns {string}
+ */
+export function renderObjectKey(key) {
+    if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) {
+        return key;
+    }
+    return JSON.stringify(key);
+}
+function deriveScopedIdentifierAlias(value) {
+    const ident = String(value || '').trim();
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(ident)) {
+        return null;
+    }
+    const parts = ident.split('_').filter(Boolean);
+    const candidate = parts.length > 1 ? parts[parts.length - 1] : ident;
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(candidate) ? candidate : ident;
+}
+/**
+ * @param {string} source
+ * @returns {string[]}
+ */
+export function extractDeclaredIdentifiers(source) {
+    const text = String(source || '').trim();
+    if (!text) {
+        return [];
+    }
+    const ts = loadTypeScriptApi();
+    if (ts) {
+        const sourceFile = ts.createSourceFile('zenith-hoisted-declaration.ts', text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+        const identifiers = [];
+        const collectBindingNames = (name) => {
+            if (ts.isIdentifier(name)) {
+                identifiers.push(name.text);
+                return;
+            }
+            if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
+                for (const element of name.elements) {
+                    if (ts.isBindingElement(element)) {
+                        collectBindingNames(element.name);
+                    }
+                }
+            }
+        };
+        for (const statement of sourceFile.statements) {
+            if (!ts.isVariableStatement(statement)) {
+                continue;
+            }
+            for (const declaration of statement.declarationList.declarations) {
+                collectBindingNames(declaration.name);
+            }
+        }
+        if (identifiers.length > 0) {
+            return identifiers;
+        }
+    }
+    const fallback = [];
+    const match = text.match(/^\s*(?:const|let|var)\s+([\s\S]+?);?\s*$/);
+    if (!match) {
+        return fallback;
+    }
+    const declarationList = match[1];
+    const identifierRe = /(?:^|,)\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*(?::[^=,]+)?=/g;
+    let found;
+    while ((found = identifierRe.exec(declarationList)) !== null) {
+        fallback.push(found[1]);
+    }
+    return fallback;
+}
+/**
+ * @param {string} expr
+ * @returns {string}
+ */
+export function normalizeTypeScriptExpression(expr) {
+    const source = String(expr || '').trim();
+    if (!source) {
+        return source;
+    }
+    const ts = loadTypeScriptApi();
+    if (!ts) {
+        return source;
+    }
+    const wrapped = `const __zenith_expr__ = (${source});`;
+    let transpiled;
+    try {
+        transpiled = ts.transpileModule(wrapped, {
+            fileName: 'zenith-expression.ts',
+            compilerOptions: {
+                module: ts.ModuleKind.ESNext,
+                target: ts.ScriptTarget.ESNext,
+                newLine: ts.NewLineKind.LineFeed,
+            },
+            reportDiagnostics: false,
+        }).outputText;
+    }
+    catch {
+        return source;
+    }
+    let sourceFile;
+    try {
+        sourceFile = ts.createSourceFile('zenith-expression.js', transpiled, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+    }
+    catch {
+        return source;
+    }
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement)) {
+            continue;
+        }
+        const declaration = statement.declarationList.declarations.find((entry) => ts.isIdentifier(entry.name) && entry.name.text === '__zenith_expr__');
+        const initializer = declaration?.initializer;
+        if (!initializer) {
+            continue;
+        }
+        const root = ts.isParenthesizedExpression(initializer) ? initializer.expression : initializer;
+        return ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })
+            .printNode(ts.EmitHint.Unspecified, root, sourceFile)
+            .trim();
+    }
+    return source;
+}
+export function expandScopedShorthandPropertiesInSource(source) {
+    const text = String(source || '');
+    if (!text.trim()) {
+        return text;
+    }
+    const ts = loadTypeScriptApi();
+    if (!ts) {
+        return text;
+    }
+    let sourceFile;
+    try {
+        sourceFile = ts.createSourceFile('zenith-shorthand-fix.ts', text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    }
+    catch {
+        return text;
+    }
+    const transformer = (context) => {
+        const visit = (node) => {
+            if (ts.isShorthandPropertyAssignment(node)) {
+                const alias = deriveScopedIdentifierAlias(node.name.text);
+                if (typeof alias === 'string' && alias.length > 0 && alias !== node.name.text) {
+                    return ts.factory.createPropertyAssignment(ts.factory.createIdentifier(alias), ts.factory.createIdentifier(node.name.text));
+                }
+            }
+            return ts.visitEachChild(node, visit, context);
+        };
+        return (node) => ts.visitNode(node, visit);
+    };
+    const result = ts.transform(sourceFile, [transformer]);
+    try {
+        return ts.createPrinter({ newLine: ts.NewLineKind.LineFeed })
+            .printFile(result.transformed[0])
+            .trimEnd();
+    }
+    catch {
+        return text;
+    }
+    finally {
+        result.dispose();
+    }
+}
+/**
+ * @param {string} expr
+ * @param {Map<string, string>} scopeMap
+ * @param {Set<string> | null | undefined} scopeAmbiguous
+ * @returns {string}
+ */
+export function rewriteIdentifiersWithinExpression(expr, scopeMap, scopeAmbiguous) {
+    const ts = loadTypeScriptApi();
+    if (!(scopeMap instanceof Map) || !ts) {
+        return normalizeTypeScriptExpression(expr);
+    }
+    const wrapped = `const __zenith_expr__ = (${expr});`;
+    let sourceFile;
+    try {
+        sourceFile = ts.createSourceFile('zenith-expression.ts', wrapped, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    }
+    catch {
+        return expr;
+    }
+    const statement = sourceFile.statements[0];
+    if (!statement || !ts.isVariableStatement(statement)) {
+        return expr;
+    }
+    const initializer = statement.declarationList.declarations[0]?.initializer;
+    const root = initializer && ts.isParenthesizedExpression(initializer) ? initializer.expression : initializer;
+    if (!root) {
+        return expr;
+    }
+    const replacements = [];
+    const collectBoundNames = (name, target) => {
+        if (ts.isIdentifier(name)) {
+            target.add(name.text);
+            return;
+        }
+        if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
+            for (const element of name.elements) {
+                if (ts.isBindingElement(element)) {
+                    collectBoundNames(element.name, target);
+                }
+            }
+        }
+    };
+    const shouldSkipIdentifier = (node, localBindings) => {
+        if (localBindings.has(node.text)) {
+            return true;
+        }
+        const parent = node.parent;
+        if (!parent) {
+            return false;
+        }
+        if (ts.isPropertyAccessExpression(parent) && parent.name === node) {
+            return true;
+        }
+        if (ts.isPropertyAssignment(parent) && parent.name === node) {
+            return true;
+        }
+        if (ts.isShorthandPropertyAssignment(parent)) {
+            return true;
+        }
+        if (ts.isBindingElement(parent) && parent.name === node) {
+            return true;
+        }
+        if (ts.isParameter(parent) && parent.name === node) {
+            return true;
+        }
+        return false;
+    };
+    const visit = (node, localBindings) => {
+        let nextBindings = localBindings;
+        if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+            nextBindings = new Set(localBindings);
+            if (node.name && ts.isIdentifier(node.name)) {
+                nextBindings.add(node.name.text);
+            }
+            for (const param of node.parameters) {
+                collectBoundNames(param.name, nextBindings);
+            }
+        }
+        if (ts.isIdentifier(node) && !shouldSkipIdentifier(node, nextBindings)) {
+            const rewritten = scopeMap.get(node.text);
+            if (typeof rewritten === 'string' &&
+                rewritten.length > 0 &&
+                rewritten !== node.text &&
+                !(scopeAmbiguous instanceof Set && scopeAmbiguous.has(node.text))) {
+                replacements.push({
+                    start: node.getStart(sourceFile),
+                    end: node.getEnd(),
+                    text: rewritten
+                });
+            }
+        }
+        ts.forEachChild(node, (child) => visit(child, nextBindings));
+    };
+    visit(root, new Set());
+    if (replacements.length === 0) {
+        return normalizeTypeScriptExpression(expr);
+    }
+    let rewritten = wrapped;
+    for (const replacement of replacements.sort((a, b) => b.start - a.start)) {
+        rewritten = `${rewritten.slice(0, replacement.start)}${replacement.text}${rewritten.slice(replacement.end)}`;
+    }
+    const prefix = 'const __zenith_expr__ = (';
+    const suffix = ');';
+    if (!rewritten.startsWith(prefix) || !rewritten.endsWith(suffix)) {
+        return normalizeTypeScriptExpression(expr);
+    }
+    return normalizeTypeScriptExpression(rewritten.slice(prefix.length, rewritten.length - suffix.length));
+}