@wyw-in-js/transform 1.1.0 → 2.0.0-alpha.0

package/types/utils/collectOxcTemplateDependencies.js

@@ -0,0 +1,1580 @@
+/* eslint-disable no-restricted-syntax,no-continue,@typescript-eslint/no-use-before-define */
+import { ValueType } from '@wyw-in-js/shared';
+import { parseOxcProgramCached } from './parseOxc';
+const isNode = (value) => !!value &&
+    typeof value === 'object' &&
+    'type' in value &&
+    typeof value.type === 'string';
+const getChildren = (node) => {
+    const result = [];
+    const record = node;
+    Object.keys(record).forEach((key) => {
+        if (key === 'type' || key === 'start' || key === 'end' || key === 'range') {
+            return;
+        }
+        const value = record[key];
+        if (isNode(value)) {
+            result.push(value);
+            return;
+        }
+        if (Array.isArray(value)) {
+            value.forEach((item) => {
+                if (isNode(item)) {
+                    result.push(item);
+                }
+            });
+        }
+    });
+    return result;
+};
+const parseOxc = (code, filename) => {
+    return parseOxcProgramCached(filename, code, 'unambiguous');
+};
+const toSpanKey = (start, end) => `${start}:${end}`;
+const createSpanLookup = (spans) => {
+    if (!spans || spans.length === 0) {
+        return null;
+    }
+    return new Set(spans.map((span) => toSpanKey(span.start, span.end)));
+};
+const matchesSpanLookup = (node, spanLookup) => !spanLookup || spanLookup.has(toSpanKey(node.start, node.end));
+const createLocationLookup = (code) => {
+    const lineStarts = [0];
+    for (let idx = 0; idx < code.length; idx += 1) {
+        if (code[idx] === '\n') {
+            lineStarts.push(idx + 1);
+        }
+    }
+    return (offset) => {
+        let low = 0;
+        let high = lineStarts.length - 1;
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            const next = lineStarts[mid + 1] ?? Infinity;
+            if (lineStarts[mid] <= offset && offset < next) {
+                return {
+                    column: offset - lineStarts[mid],
+                    line: mid + 1,
+                };
+            }
+            if (offset < lineStarts[mid]) {
+                high = mid - 1;
+            }
+            else {
+                low = mid + 1;
+            }
+        }
+        const lastLine = lineStarts.length - 1;
+        return {
+            column: Math.max(0, offset - lineStarts[lastLine]),
+            line: lastLine + 1,
+        };
+    };
+};
+const getSourceLocation = (start, end, ctx) => ({
+    end: ctx.loc(end),
+    filename: ctx.filename,
+    identifierName: undefined,
+    start: ctx.loc(start),
+});
+const createScope = (parent, node, root = false, functionBoundary = false) => ({
+    bindings: new Map(),
+    depth: parent ? parent.depth + 1 : 0,
+    end: node.end,
+    functionBoundary,
+    params: new Set(),
+    parent,
+    root,
+    start: node.start,
+});
+const normalizeDeclarationKind = (declarationKind) => {
+    if (declarationKind === 'var') {
+        return 'var';
+    }
+    if (declarationKind === 'let') {
+        return 'let';
+    }
+    return 'const';
+};
+const moduleExportName = (node) => node.type === 'Literal' ? String(node.value) : node.name;
+const getImportSpecifierInfo = (statement, specifier) => {
+    const local = specifier.local?.name;
+    if (!local) {
+        return null;
+    }
+    if (specifier.type === 'ImportDefaultSpecifier') {
+        return {
+            imported: 'default',
+            local,
+        };
+    }
+    if (specifier.type === 'ImportNamespaceSpecifier') {
+        return {
+            imported: '*',
+            local,
+        };
+    }
+    if (statement.importKind === 'type' ||
+        specifier.importKind === 'type') {
+        return null;
+    }
+    return {
+        imported: moduleExportName(specifier.imported),
+        local,
+    };
+};
+const getDeclarationScope = (scope, declarationKind) => {
+    if (declarationKind !== 'var') {
+        return scope;
+    }
+    let current = scope;
+    while (current && !current.functionBoundary) {
+        current = current.parent;
+    }
+    return current ?? scope;
+};
+const collectBindingNames = (node) => {
+    if (node.type === 'Identifier') {
+        return [node.name];
+    }
+    if (node.type === 'RestElement') {
+        return collectBindingNames(node.argument);
+    }
+    if (node.type === 'AssignmentPattern') {
+        return collectBindingNames(node.left);
+    }
+    if (node.type === 'ObjectPattern') {
+        return node.properties.flatMap((property) => property.type === 'RestElement'
+            ? collectBindingNames(property.argument)
+            : collectBindingNames(property.value));
+    }
+    if (node.type === 'ArrayPattern') {
+        return node.elements.flatMap((element) => element ? collectBindingNames(element) : []);
+    }
+    if (node.type === 'TSParameterProperty') {
+        return collectBindingNames(node.parameter);
+    }
+    return [];
+};
+const isInTypeContext = (ancestors) => ancestors.some((ancestor) => ancestor.type.startsWith('TS') || ancestor.type.startsWith('JSDoc'));
+const isPropertyOnlyIdentifier = (node, parent) => !!parent &&
+    parent.type === 'MemberExpression' &&
+    parent.property === node &&
+    !parent.computed;
+const isObjectPropertyKey = (node, parent) => !!parent &&
+    parent.type === 'Property' &&
+    parent.key === node &&
+    !parent.computed &&
+    parent.value !== node;
+const isBindingPosition = (node, parent) => {
+    if (!parent) {
+        return false;
+    }
+    if (parent.type === 'VariableDeclarator' && parent.id === node) {
+        return true;
+    }
+    if ((parent.type === 'FunctionDeclaration' ||
+        parent.type === 'FunctionExpression' ||
+        parent.type === 'ClassDeclaration' ||
+        parent.type === 'ClassExpression') &&
+        parent.id === node) {
+        return true;
+    }
+    if ((parent.type === 'ImportSpecifier' ||
+        parent.type === 'ImportDefaultSpecifier' ||
+        parent.type === 'ImportNamespaceSpecifier') &&
+        'local' in parent &&
+        parent.local === node) {
+        return true;
+    }
+    return false;
+};
+const visit = (node, scope, enter, parent = null, ancestors = []) => {
+    const visitNode = (currentNode, currentScope, currentParent) => {
+        let nextScope;
+        if (currentNode.type === 'Program') {
+            nextScope = createScope(null, currentNode, true, true);
+        }
+        else if (currentNode.type === 'BlockStatement' ||
+            currentNode.type === 'FunctionDeclaration' ||
+            currentNode.type === 'FunctionExpression' ||
+            currentNode.type === 'ArrowFunctionExpression') {
+            nextScope = createScope(currentScope, currentNode, false, currentNode.type !== 'BlockStatement');
+        }
+        else if (currentScope) {
+            nextScope = currentScope;
+        }
+        else {
+            nextScope = createScope(null, currentNode, false, true);
+        }
+        if (currentNode.type === 'FunctionDeclaration' ||
+            currentNode.type === 'FunctionExpression' ||
+            currentNode.type === 'ArrowFunctionExpression') {
+            currentNode.params.forEach((param) => {
+                collectBindingNames(param).forEach((name) => {
+                    nextScope.params.add(name);
+                    nextScope.bindings.set(name, {
+                        declaredAt: param.start,
+                        declaration: null,
+                        declarator: null,
+                        functionNode: null,
+                        isRoot: false,
+                        kind: 'param',
+                        name,
+                        scope: nextScope,
+                    });
+                });
+            });
+        }
+        enter(currentNode, nextScope, currentParent, ancestors);
+        ancestors.push(currentNode);
+        getChildren(currentNode).forEach((child) => visitNode(child, nextScope, currentNode));
+        ancestors.pop();
+    };
+    visitNode(node, scope, parent);
+};
+const analyzeProgram = (program, { collectTargetExpressions = false, collectTemplateLiterals = false, expressionSpanLookup = null, templateSpanLookup = null, } = {}) => {
+    const bindings = new Map();
+    const usedNames = new Set();
+    const templateLiterals = [];
+    const targetExpressions = [];
+    const addBinding = (scope, binding) => {
+        scope.bindings.set(binding.name, binding);
+        const existing = bindings.get(binding.name) ?? [];
+        existing.push(binding);
+        bindings.set(binding.name, existing);
+    };
+    const collectTargets = (node, ancestors) => {
+        if (collectTemplateLiterals &&
+            node.type === 'TemplateLiteral' &&
+            node.expressions.length > 0 &&
+            !ancestors.some((ancestor) => ancestor.type === 'TemplateLiteral') &&
+            matchesSpanLookup(node, templateSpanLookup)) {
+            templateLiterals.push(node);
+        }
+        if (collectTargetExpressions &&
+            expressionSpanLookup &&
+            matchesSpanLookup(node, expressionSpanLookup)) {
+            targetExpressions.push(node);
+        }
+    };
+    visit(program, null, (node, scope, _parent, ancestors) => {
+        collectTargets(node, ancestors);
+        if (node.type === 'Identifier') {
+            usedNames.add(node.name);
+        }
+        if (node.type === 'FunctionDeclaration' ||
+            node.type === 'FunctionExpression' ||
+            node.type === 'ArrowFunctionExpression') {
+            node.params.forEach((param) => {
+                collectBindingNames(param).forEach((name) => {
+                    const binding = scope.bindings.get(name);
+                    if (binding) {
+                        addBinding(scope, binding);
+                    }
+                });
+            });
+            if (node.type !== 'FunctionDeclaration') {
+                return;
+            }
+        }
+        if (node.type === 'ImportDeclaration') {
+            const source = node.source.value;
+            node.specifiers.forEach((specifier) => {
+                const importInfo = getImportSpecifierInfo(node, specifier);
+                if (!importInfo) {
+                    return;
+                }
+                addBinding(scope, {
+                    declaredAt: specifier.start,
+                    declaration: null,
+                    declarator: null,
+                    functionNode: null,
+                    imported: importInfo.imported,
+                    importedFrom: source,
+                    isRoot: scope.root,
+                    kind: 'import',
+                    name: importInfo.local,
+                    scope,
+                });
+            });
+            return;
+        }
+        if (node.type !== 'VariableDeclaration') {
+            if (node.type === 'FunctionDeclaration' && node.id) {
+                const declarationScope = scope.parent ?? scope;
+                const binding = {
+                    declaredAt: node.start,
+                    declaration: null,
+                    declarator: null,
+                    functionNode: node,
+                    isRoot: declarationScope.root,
+                    kind: 'function',
+                    name: node.id.name,
+                    scope: declarationScope,
+                };
+                addBinding(declarationScope, binding);
+            }
+            return;
+        }
+        node.declarations.forEach((declarator) => {
+            collectBindingNames(declarator.id).forEach((name) => {
+                const declarationKind = normalizeDeclarationKind(node.kind);
+                const declarationScope = getDeclarationScope(scope, declarationKind);
+                const binding = {
+                    declarationKind,
+                    declaredAt: declarator.start,
+                    declaration: node,
+                    declarator,
+                    functionNode: null,
+                    isRoot: declarationScope.root,
+                    kind: 'variable',
+                    name,
+                    scope: declarationScope,
+                };
+                addBinding(declarationScope, binding);
+            });
+        });
+    });
+    return {
+        bindingsByName: bindings,
+        rootMutationsByBinding: collectRootMutations(program),
+        targetExpressions: targetExpressions.sort((a, b) => a.start - b.start),
+        templateLiterals,
+        usedNames,
+    };
+};
+const resolveBindingAt = (ctx, name, referenceStart) => {
+    const cachedBindings = ctx.bindingResolutionCache.get(name);
+    if (cachedBindings?.has(referenceStart)) {
+        return cachedBindings.get(referenceStart) ?? undefined;
+    }
+    const bindings = ctx.bindingsByName.get(name);
+    const bindingCache = cachedBindings ?? new Map();
+    if (!cachedBindings) {
+        ctx.bindingResolutionCache.set(name, bindingCache);
+    }
+    if (!bindings || bindings.length === 0) {
+        bindingCache.set(referenceStart, null);
+        return undefined;
+    }
+    let binding;
+    bindings.forEach((candidate) => {
+        if (candidate.scope.start > referenceStart ||
+            referenceStart >= candidate.scope.end) {
+            return;
+        }
+        if (!binding ||
+            candidate.scope.depth > binding.scope.depth ||
+            (candidate.scope.depth === binding.scope.depth &&
+                candidate.declaredAt > binding.declaredAt)) {
+            binding = candidate;
+        }
+    });
+    bindingCache.set(referenceStart, binding ?? null);
+    return binding;
+};
+const collectRootMutations = (program) => {
+    const mutations = new Map();
+    const getRootMutationTarget = (node) => {
+        if (node.type === 'Identifier') {
+            return {
+                binding: node.name,
+                path: [],
+            };
+        }
+        if (node.type !== 'MemberExpression') {
+            return null;
+        }
+        const parent = getRootMutationTarget(node.object);
+        if (!parent) {
+            return null;
+        }
+        let key = null;
+        if (node.computed &&
+            node.property.type === 'Literal' &&
+            (typeof node.property.value === 'string' ||
+                typeof node.property.value === 'number')) {
+            key = node.property.value;
+        }
+        else if (!node.computed && node.property.type === 'Identifier') {
+            key = node.property.name;
+        }
+        if (key === null) {
+            return null;
+        }
+        return {
+            binding: parent.binding,
+            path: [...parent.path, key],
+        };
+    };
+    program.body.forEach((statement) => {
+        if (statement.type !== 'ExpressionStatement') {
+            return;
+        }
+        const { expression } = statement;
+        if (expression.type === 'AssignmentExpression') {
+            const target = getRootMutationTarget(expression.left);
+            if (!target || target.path.length === 0) {
+                return;
+            }
+            const bucket = mutations.get(target.binding) ?? [];
+            bucket.push(expression);
+            mutations.set(target.binding, bucket);
+            return;
+        }
+        if (expression.type === 'UpdateExpression') {
+            const target = getRootMutationTarget(expression.argument);
+            if (!target || target.path.length === 0) {
+                return;
+            }
+            const bucket = mutations.get(target.binding) ?? [];
+            bucket.push(expression);
+            mutations.set(target.binding, bucket);
+        }
+    });
+    return mutations;
+};
+const hasLocalBinding = (scope, name) => {
+    let current = scope;
+    while (current) {
+        if (current.bindings.has(name)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+const hasLocalBindingCached = (scope, name, cache) => {
+    const scopeCache = cache.get(scope);
+    if (scopeCache?.has(name)) {
+        return scopeCache.get(name);
+    }
+    const result = hasLocalBinding(scope, name);
+    const nextScopeCache = scopeCache ?? new Map();
+    nextScopeCache.set(name, result);
+    if (!scopeCache) {
+        cache.set(scope, nextScopeCache);
+    }
+    return result;
+};
+const findReferences = (node, referenceCache) => {
+    const cachedReferences = referenceCache?.get(node);
+    if (cachedReferences) {
+        return cachedReferences;
+    }
+    const refs = new Map();
+    const localBindingCache = new WeakMap();
+    visit(node, null, (current, scope, parent, ancestors) => {
+        if (current.type !== 'Identifier' ||
+            isInTypeContext(ancestors) ||
+            isBindingPosition(current, parent) ||
+            isPropertyOnlyIdentifier(current, parent) ||
+            isObjectPropertyKey(current, parent) ||
+            hasLocalBindingCached(scope, current.name, localBindingCache)) {
+            return;
+        }
+        const key = `${current.start}:${current.end}:${current.name}`;
+        refs.set(key, {
+            end: current.end,
+            name: current.name,
+            start: current.start,
+        });
+    });
+    const resolvedReferences = [...refs.values()];
+    referenceCache?.set(node, resolvedReferences);
+    return resolvedReferences;
+};
+const isBindingDeclaredWithin = (binding, container) => container.start <= binding.declaredAt && binding.declaredAt < container.end;
+const literalCode = (value) => {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? JSON.stringify(value) : null;
+    }
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'boolean') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'object' && value !== null) {
+        return `(${JSON.stringify(value)})`;
+    }
+    return null;
+};
+const isStaticSerializableValue = (value) => literalCode(value) !== null;
+const cloneStaticValue = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((item) => cloneStaticValue(item));
+    }
+    if (typeof value === 'object' && value !== null) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, cloneStaticValue(item)]));
+    }
+    return value;
+};
+const getObjectMember = (objectValue, property) => {
+    if (objectValue === null ||
+        objectValue === undefined ||
+        (typeof objectValue !== 'object' &&
+            typeof objectValue !== 'string' &&
+            typeof objectValue !== 'number' &&
+            typeof objectValue !== 'boolean')) {
+        return undefined;
+    }
+    return objectValue[property];
+};
+const oxcStaticCallableValue = Symbol('wyw.oxc.staticCallableValue');
+const isOxcStaticCallableValue = (value) => typeof value === 'object' &&
+    value !== null &&
+    oxcStaticCallableValue in value;
+const unwrapOxcStaticCallableValue = (value) => isOxcStaticCallableValue(value) ? value[oxcStaticCallableValue] : value;
+export const createOxcStaticCallableValue = (value) => ({
+    [oxcStaticCallableValue]: value,
+});
+const assignPatternValue = (pattern, value, ctx, env, stack) => {
+    if (pattern.type === 'Identifier') {
+        env.set(pattern.name, value);
+        return true;
+    }
+    if (pattern.type === 'AssignmentPattern') {
+        return assignPatternValue(pattern.left, value === undefined
+            ? evaluateStatic(pattern.right, ctx, env, stack)
+            : value, ctx, env, stack);
+    }
+    if (pattern.type === 'ObjectPattern') {
+        if (typeof value !== 'object' || value === null) {
+            return false;
+        }
+        return pattern.properties.every((property) => {
+            if (property.type === 'RestElement') {
+                return false;
+            }
+            let key;
+            if (property.computed) {
+                key = evaluateStatic(property.key, ctx, env, stack);
+            }
+            else if (property.key.type === 'Identifier') {
+                key = property.key.name;
+            }
+            else if (property.key.type === 'Literal') {
+                key = property.key.value;
+            }
+            if (key === undefined || key === null) {
+                return false;
+            }
+            return assignPatternValue(property.value, getObjectMember(value, key), ctx, env, stack);
+        });
+    }
+    if (pattern.type === 'ArrayPattern') {
+        if (!Array.isArray(value)) {
+            return false;
+        }
+        return pattern.elements.every((element, index) => element
+            ? assignPatternValue(element, value[index], ctx, env, stack)
+            : true);
+    }
+    return false;
+};
+const applyRootMutation = (bindingName, baseValue, mutation, ctx, env, stack) => {
+    const resolvePath = (node) => {
+        if (node.type === 'Identifier') {
+            return node.name === bindingName ? { path: [] } : null;
+        }
+        if (node.type !== 'MemberExpression') {
+            return null;
+        }
+        const parent = resolvePath(node.object);
+        if (!parent) {
+            return null;
+        }
+        let key;
+        if (node.computed) {
+            key = evaluateStatic(node.property, ctx, env, stack);
+        }
+        else if (node.property.type === 'Identifier') {
+            key = node.property.name;
+        }
+        if (key === undefined ||
+            key === null ||
+            (typeof key !== 'string' && typeof key !== 'number')) {
+            return null;
+        }
+        return {
+            path: [...parent.path, key],
+        };
+    };
+    const pathInfo = resolvePath(mutation.type === 'AssignmentExpression' ? mutation.left : mutation.argument);
+    if (!pathInfo) {
+        return undefined;
+    }
+    const cloned = cloneStaticValue(baseValue);
+    if (pathInfo.path.length === 0) {
+        if (mutation.type !== 'AssignmentExpression') {
+            return undefined;
+        }
+        return evaluateStatic(mutation.right, ctx, env, stack);
+    }
+    let target = cloned;
+    for (let idx = 0; idx < pathInfo.path.length - 1; idx += 1) {
+        const key = pathInfo.path[idx];
+        const next = target?.[key];
+        if (typeof next !== 'object' || next === null) {
+            return undefined;
+        }
+        target = next;
+    }
+    const lastKey = pathInfo.path[pathInfo.path.length - 1];
+    if (mutation.type === 'AssignmentExpression') {
+        const nextValue = evaluateStatic(mutation.right, ctx, env, stack);
+        if (nextValue === undefined) {
+            return undefined;
+        }
+        target[lastKey] = nextValue;
+        return cloned;
+    }
+    const currentValue = target[lastKey];
+    if (typeof currentValue !== 'number') {
+        return undefined;
+    }
+    target[lastKey] =
+        mutation.operator === '++' ? currentValue + 1 : currentValue - 1;
+    return cloned;
+};
+const evaluateFunctionCall = (fn, args, ctx, env, stack) => {
+    if (fn.async || !fn.body) {
+        return undefined;
+    }
+    const localEnv = new Map(env);
+    for (let idx = 0; idx < fn.params.length; idx += 1) {
+        if (!assignPatternValue(fn.params[idx], args[idx], ctx, localEnv, stack)) {
+            return undefined;
+        }
+    }
+    if (fn.body.type !== 'BlockStatement') {
+        return evaluateStatic(fn.body, ctx, localEnv, stack);
+    }
+    for (const statement of fn.body.body) {
+        if (statement.type === 'VariableDeclaration') {
+            for (const declarator of statement.declarations) {
+                const value = declarator.init
+                    ? evaluateStatic(declarator.init, ctx, localEnv, stack)
+                    : undefined;
+                if (!assignPatternValue(declarator.id, value, ctx, localEnv, stack)) {
+                    return undefined;
+                }
+            }
+            continue;
+        }
+        if (statement.type === 'ReturnStatement') {
+            if (!statement.argument) {
+                return undefined;
+            }
+            return evaluateStatic(statement.argument, ctx, localEnv, stack);
+        }
+        return undefined;
+    }
+    return undefined;
+};
+const getConstantReplacement = (binding, ctx) => {
+    const init = binding?.declarator?.init;
+    if (!init) {
+        return null;
+    }
+    if (init.type === 'Literal') {
+        return literalCode(init.value);
+    }
+    if (init.type === 'ObjectExpression' &&
+        binding?.isRoot &&
+        binding.declarator?.id.type === 'Identifier') {
+        const evaluated = evaluateStatic(binding.declarator.id, ctx);
+        return literalCode(evaluated);
+    }
+    return null;
+};
+const replaceIdentifierReferences = (expression, replacements, code) => {
+    const localReplacements = [];
+    const ancestors = [];
+    const walk = (current, parent) => {
+        if (current.type === 'Identifier' &&
+            replacements.has(current.name) &&
+            !isInTypeContext(ancestors) &&
+            !isBindingPosition(current, parent) &&
+            !isPropertyOnlyIdentifier(current, parent) &&
+            !isObjectPropertyKey(current, parent)) {
+            const replacement = replacements.get(current.name);
+            // Shorthand property `{ width }` → `{ width: 500 }` when the
+            // identifier is the value side of a shorthand ObjectProperty.
+            const isShorthandValue = !!parent &&
+                parent.type === 'Property' &&
+                parent.shorthand &&
+                parent.value === current;
+            localReplacements.push({
+                start: isShorthandValue ? parent.start : current.start,
+                end: current.end,
+                value: isShorthandValue
+                    ? `${current.name}: ${replacement}`
+                    : replacement,
+            });
+        }
+        ancestors.push(current);
+        getChildren(current).forEach((child) => walk(child, current));
+        ancestors.pop();
+    };
+    walk(expression, null);
+    let result = code.slice(expression.start, expression.end);
+    localReplacements
+        .sort((a, b) => b.start - a.start)
+        .forEach((replacement) => {
+        const start = replacement.start - expression.start;
+        const end = replacement.end - expression.start;
+        result = result.slice(0, start) + replacement.value + result.slice(end);
+    });
+    return result;
+};
+const applyExpressionReplacements = (expression, replacements, code) => {
+    let result = code.slice(expression.start, expression.end);
+    replacements
+        .sort((a, b) => b.start - a.start)
+        .forEach((replacement) => {
+        const start = replacement.start - expression.start;
+        const end = replacement.end - expression.start;
+        result = result.slice(0, start) + replacement.value + result.slice(end);
+    });
+    return result;
+};
+const staticImportAliasPart = (value) => value.replace(/[^A-Za-z0-9_$]/g, '_') || 'value';
+const allocateStaticImportAlias = (binding, imported, ctx) => {
+    const key = `${binding.importedFrom ?? ''}\0${binding.name}\0${imported}`;
+    const existing = ctx.staticImportAliases.get(key);
+    if (existing) {
+        return existing;
+    }
+    const namespacePart = staticImportAliasPart(binding.name);
+    const importedPart = staticImportAliasPart(imported);
+    let alias = `_wyw_static_${namespacePart}_${importedPart}`;
+    let idx = 1;
+    while (ctx.usedNames.has(alias)) {
+        idx += 1;
+        alias = `_wyw_static_${namespacePart}_${importedPart}_${idx}`;
+    }
+    ctx.usedNames.add(alias);
+    ctx.staticImportAliases.set(key, alias);
+    return alias;
+};
+const staticMemberPropertyName = (expression) => {
+    if (!expression.computed && expression.property.type === 'Identifier') {
+        return expression.property.name;
+    }
+    if (expression.computed &&
+        expression.property.type === 'Literal' &&
+        typeof expression.property.value === 'string') {
+        return expression.property.value;
+    }
+    return null;
+};
+const collectStaticNamespaceMemberReferences = (expression, ctx) => {
+    const coveredReferenceStarts = new Set();
+    const imports = new Map();
+    const replacements = [];
+    const walk = (node) => {
+        if (node.type === 'MemberExpression' && node.object.type === 'Identifier') {
+            const binding = resolveBindingAt(ctx, node.object.name, node.object.start);
+            const imported = staticMemberPropertyName(node);
+            if (binding?.importedFrom &&
+                binding.imported === '*' &&
+                imported !== null) {
+                const alias = allocateStaticImportAlias(binding, imported, ctx);
+                imports.set(`${binding.importedFrom}\0${imported}\0${alias}`, {
+                    imported,
+                    importLocal: binding.name,
+                    local: alias,
+                    source: binding.importedFrom,
+                });
+                replacements.push({
+                    end: node.end,
+                    start: node.start,
+                    value: alias,
+                });
+                coveredReferenceStarts.add(node.object.start);
+            }
+        }
+        getChildren(node).forEach(walk);
+    };
+    walk(expression);
+    return {
+        coveredReferenceStarts,
+        imports: [...imports.values()],
+        replacements,
+    };
+};
+const isProcessEnvMember = (node) => {
+    if (node.type !== 'MemberExpression' || node.computed) {
+        return false;
+    }
+    if (node.property.type !== 'Identifier' ||
+        node.property.name !== 'env') {
+        return false;
+    }
+    return node.object.type === 'Identifier' && node.object.name === 'process';
+};
+const evaluateBinary = (expression, ctx, env = new Map(), stack = []) => {
+    if (expression.type !== 'BinaryExpression') {
+        return undefined;
+    }
+    const left = evaluateStatic(expression.left, ctx, env, stack);
+    const right = evaluateStatic(expression.right, ctx, env, stack);
+    if (left === undefined || right === undefined) {
+        return undefined;
+    }
+    if (expression.operator === '+') {
+        if (typeof left === 'number' && typeof right === 'number') {
+            return left + right;
+        }
+        if ((typeof left === 'string' || typeof left === 'number') &&
+            (typeof right === 'string' || typeof right === 'number')) {
+            return `${left}${right}`;
+        }
+    }
+    if (typeof left === 'number' && typeof right === 'number') {
+        switch (expression.operator) {
+            case '-':
+                return left - right;
+            case '*':
+                return left * right;
+            case '/':
+                return left / right;
+            case '%':
+                return left % right;
+            case '**':
+                return left ** right;
+            default:
+                break;
+        }
+    }
+    return undefined;
+};
+const evaluateStatic = (expression, ctx, env = new Map(), stack = []) => {
+    if (expression.type === 'TSAsExpression' ||
+        expression.type === 'TSSatisfiesExpression' ||
+        expression.type === 'TSNonNullExpression' ||
+        expression.type === 'TSInstantiationExpression' ||
+        expression.type === 'TSTypeAssertion' ||
+        expression.type === 'ParenthesizedExpression') {
+        return evaluateStatic(expression.expression, ctx, env, stack);
+    }
+    if (expression.type === 'Literal') {
+        return expression.value;
+    }
+    if (expression.type === 'UnaryExpression') {
+        if (expression.operator === 'typeof') {
+            const argIsProcessEnvAccess = expression.argument.type === 'MemberExpression' &&
+                isProcessEnvMember(expression.argument.object);
+            const arg = evaluateStatic(expression.argument, ctx, env, stack);
+            if (arg === undefined) {
+                return argIsProcessEnvAccess ? 'undefined' : undefined;
+            }
+            return typeof arg;
+        }
+        const arg = evaluateStatic(expression.argument, ctx, env, stack);
+        if (arg === undefined) {
+            return undefined;
+        }
+        switch (expression.operator) {
+            case '-':
+                return typeof arg === 'number' ? -arg : undefined;
+            case '+':
+                return typeof arg === 'number' ? +arg : undefined;
+            case '!':
+                return !arg;
+            case '~':
+                return typeof arg === 'number' ? ~arg : undefined;
+            case 'void':
+                return undefined;
+            default:
+                return undefined;
+        }
+    }
+    if (expression.type === 'LogicalExpression') {
+        const left = evaluateStatic(expression.left, ctx, env, stack);
+        // process.env.X access is the only source we trust as "deterministically
+        // undefined" — it's a build-time lookup we control. For everything else,
+        // undefined means "couldn't evaluate" and we must bail to avoid inlining
+        // a wrong fallback when the runtime value isn't actually nullish.
+        const leftIsProcessEnvAccess = expression.left.type === 'MemberExpression' &&
+            isProcessEnvMember(expression.left.object);
+        if (left === undefined && !leftIsProcessEnvAccess) {
+            return undefined;
+        }
+        if (expression.operator === '||') {
+            return left || evaluateStatic(expression.right, ctx, env, stack);
+        }
+        if (expression.operator === '??') {
+            return left ?? evaluateStatic(expression.right, ctx, env, stack);
+        }
+        if (expression.operator === '&&') {
+            return left && evaluateStatic(expression.right, ctx, env, stack);
+        }
+        return undefined;
+    }
+    if (expression.type === 'ConditionalExpression') {
+        const test = evaluateStatic(expression.test, ctx, env, stack);
+        if (test === undefined) {
+            return undefined;
+        }
+        return evaluateStatic(test ? expression.consequent : expression.alternate, ctx, env, stack);
+    }
+    if (expression.type === 'TemplateLiteral') {
+        let result = '';
+        for (let idx = 0; idx < expression.quasis.length; idx += 1) {
+            result += expression.quasis[idx]?.value.cooked ?? '';
+            const nextExpression = expression.expressions[idx];
+            if (!nextExpression) {
+                continue;
+            }
+            const value = evaluateStatic(nextExpression, ctx, env, stack);
+            if (value === undefined ||
+                (typeof value !== 'string' && typeof value !== 'number')) {
+                return undefined;
+            }
+            result += String(value);
+        }
+        return result;
+    }
+    if (expression.type === 'Identifier') {
+        if (env.has(expression.name)) {
+            return unwrapOxcStaticCallableValue(env.get(expression.name));
+        }
+        const binding = resolveBindingAt(ctx, expression.name, expression.start);
+        if (!binding || binding.importedFrom) {
+            return undefined;
+        }
+        if (binding.kind === 'param') {
+            return undefined;
+        }
+        if (stack.includes(binding.name)) {
+            return undefined;
+        }
+        let value;
+        const { declarator } = binding;
+        const init = declarator?.init;
+        if (init) {
+            if (declarator.id.type !== 'Identifier') {
+                return undefined;
+            }
+            value = evaluateStatic(init, ctx, env, [...stack, binding.name]);
+        }
+        else if (binding.functionNode) {
+            value = binding.functionNode;
+        }
+        if (value !== undefined &&
+            binding.isRoot &&
+            typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value)) {
+            const mutations = ctx.rootMutationsByBinding.get(binding.name) ?? [];
+            let nextValue = cloneStaticValue(value);
+            for (const mutation of mutations) {
+                if (mutation.start >= ctx.currentExpressionStart) {
+                    break;
+                }
+                const applied = applyRootMutation(binding.name, nextValue, mutation, ctx, env, [...stack, binding.name]);
+                if (applied === undefined) {
+                    return undefined;
+                }
+                nextValue = applied;
+            }
+            return nextValue;
+        }
+        return value;
+    }
+    if (expression.type === 'ObjectExpression') {
+        const result = {};
+        for (const property of expression.properties) {
+            if (property.type === 'SpreadElement') {
+                const spreadValue = evaluateStatic(property.argument, ctx, env, stack);
+                if (typeof spreadValue !== 'object' || spreadValue === null) {
+                    return undefined;
+                }
+                Object.assign(result, spreadValue);
+                continue;
+            }
+            let key;
+            if (property.computed) {
+                key = evaluateStatic(property.key, ctx, env, stack);
+            }
+            else if (property.key.type === 'Identifier') {
+                key = property.key.name;
+            }
+            else if (property.key.type === 'Literal') {
+                key = property.key.value;
+            }
+            if (key === undefined ||
+                key === null ||
+                (typeof key !== 'string' && typeof key !== 'number')) {
+                return undefined;
+            }
+            const value = evaluateStatic(property.value, ctx, env, stack);
+            if (value === undefined) {
+                return undefined;
+            }
+            result[key] = value;
+        }
+        return result;
+    }
+    if (expression.type === 'ArrayExpression') {
+        const result = [];
+        for (const element of expression.elements) {
+            if (!element) {
+                return undefined;
+            }
+            if (element.type === 'SpreadElement') {
+                const spreadValue = evaluateStatic(element.argument, ctx, env, stack);
+                if (!Array.isArray(spreadValue)) {
+                    return undefined;
+                }
+                result.push(...spreadValue);
+                continue;
+            }
+            const value = evaluateStatic(element, ctx, env, stack);
+            if (value === undefined) {
+                return undefined;
+            }
+            result.push(value);
+        }
+        return result;
+    }
+    if (expression.type === 'MemberExpression') {
+        let key;
+        if (expression.computed) {
+            key = evaluateStatic(expression.property, ctx, env, stack);
+        }
+        else if (expression.property.type === 'Identifier') {
+            key = expression.property.name;
+        }
+        if (key === undefined ||
+            key === null ||
+            (typeof key !== 'string' && typeof key !== 'number')) {
+            return undefined;
+        }
+        if (isProcessEnvMember(expression.object) &&
+            typeof key === 'string' &&
+            !env.has('process')) {
+            // Treat process.env.X as deterministically undefined at build time.
+            // Reading from real process.env would couple the bundle to whatever
+            // happens to be set on the build machine; falling back to the
+            // ?? / || branch (or a runtime read) is more predictable.
+            return undefined;
+        }
+        const objectValue = evaluateStatic(expression.object, ctx, env, stack);
+        if (objectValue === undefined) {
+            return undefined;
+        }
+        return getObjectMember(objectValue, key);
+    }
+    if (expression.type === 'NewExpression') {
+        if (expression.callee.type !== 'Identifier' ||
+            expression.arguments.length !== 1) {
+            return undefined;
+        }
+        const [argument] = expression.arguments;
+        if (!argument || argument.type === 'SpreadElement') {
+            return undefined;
+        }
+        const value = evaluateStatic(argument, ctx, env, stack);
+        if (value === undefined) {
+            return undefined;
+        }
+        if (expression.callee.name === 'String') {
+            return String(value);
+        }
+        if (expression.callee.name === 'Number') {
+            return Number(value);
+        }
+        if (expression.callee.name === 'Boolean') {
+            return Boolean(value);
+        }
+        return undefined;
+    }
+    if (expression.type === 'CallExpression') {
+        if (expression.callee.type === 'Identifier') {
+            const args = expression.arguments.map((arg) => arg.type === 'SpreadElement'
+                ? undefined
+                : evaluateStatic(arg, ctx, env, stack));
+            if (args.some((value) => value === undefined)) {
+                return undefined;
+            }
+            const staticCallable = env.get(expression.callee.name);
+            if (isOxcStaticCallableValue(staticCallable) &&
+                expression.arguments.length === 0) {
+                return unwrapOxcStaticCallableValue(staticCallable);
+            }
+            if (expression.callee.name === 'String' && args.length === 1) {
+                return String(args[0]);
+            }
+            if (expression.callee.name === 'Number' && args.length === 1) {
+                return Number(args[0]);
+            }
+            if (expression.callee.name === 'Boolean' && args.length === 1) {
+                return Boolean(args[0]);
+            }
+            const binding = resolveBindingAt(ctx, expression.callee.name, expression.callee.start);
+            const fn = binding?.functionNode ?? binding?.declarator?.init;
+            if (fn &&
+                (fn.type === 'ArrowFunctionExpression' ||
+                    fn.type === 'FunctionDeclaration' ||
+                    fn.type === 'FunctionExpression')) {
+                return evaluateFunctionCall(fn, args, ctx, env, [
+                    ...stack,
+                    expression.callee.name,
+                ]);
+            }
+        }
+        if (expression.callee.type === 'MemberExpression') {
+            const objectValue = evaluateStatic(expression.callee.object, ctx, env, stack);
+            let key;
+            if (expression.callee.computed) {
+                key = evaluateStatic(expression.callee.property, ctx, env, stack);
+            }
+            else if (expression.callee.property.type === 'Identifier') {
+                key = expression.callee.property.name;
+            }
+            if (typeof objectValue === 'string') {
+                if (key === 'toLowerCase' && expression.arguments.length === 0) {
+                    return objectValue.toLowerCase();
+                }
+                if (key === 'toUpperCase' && expression.arguments.length === 0) {
+                    return objectValue.toUpperCase();
+                }
+            }
+        }
+    }
+    return evaluateBinary(expression, ctx, env, stack);
+};
+const allocateExpressionName = (ctx) => {
+    let base = '_exp';
+    let idx = 1;
+    while (ctx.usedNames.has(base)) {
+        idx += 1;
+        base = `_exp${idx}`;
+    }
+    ctx.usedNames.add(base);
+    return base;
+};
+const hoistedBindingKey = (binding) => `${binding.scope.start}:${binding.scope.end}:${binding.declaredAt}:${binding.name}`;
+const allocateHoistedBindingName = (originalName, ctx) => {
+    const sanitized = originalName.replace(/[^A-Za-z0-9_$]/g, '_') || 'hoisted';
+    const base = /^[A-Za-z_$]/.test(sanitized) ? `_${sanitized}` : '_hoisted';
+    let candidate = base;
+    let idx = 2;
+    while (ctx.usedNames.has(candidate)) {
+        candidate = `${base}${idx}`;
+        idx += 1;
+    }
+    ctx.usedNames.add(candidate);
+    return candidate;
+};
+const getHoistedBindingName = (binding, ctx) => {
+    const key = hoistedBindingKey(binding);
+    const existing = ctx.hoistedBindingNames.get(key);
+    if (existing) {
+        return existing;
+    }
+    const next = allocateHoistedBindingName(binding.name, ctx);
+    ctx.hoistedBindingNames.set(key, next);
+    return next;
+};
+const declarationInitCode = (init, ctx) => {
+    const renamedDependencies = new Map();
+    findReferences(init, ctx.referencesByNode).forEach(({ name, start }) => {
+        const dependency = resolveBindingAt(ctx, name, start);
+        if (!dependency ||
+            dependency.importedFrom ||
+            dependency.isRoot ||
+            dependency.declarator?.id.type !== 'Identifier') {
+            return;
+        }
+        renamedDependencies.set(name, getHoistedBindingName(dependency, ctx));
+    });
+    return renamedDependencies.size > 0
+        ? replaceIdentifierReferences(init, renamedDependencies, ctx.code)
+        : ctx.code.slice(init.start, init.end);
+};
+const addHoistedCode = (key, code, ctx) => {
+    if (ctx.hoistedDeclarations.has(key)) {
+        return;
+    }
+    ctx.hoistedDeclarations.set(key, code);
+    const declarations = ctx.hoistedDeclarationsByInsertionPoint.get(ctx.currentInsertionPoint) ??
+        [];
+    declarations.push(code);
+    ctx.hoistedDeclarationsByInsertionPoint.set(ctx.currentInsertionPoint, declarations);
+};
+const declarationCode = (binding, ctx) => {
+    const { declarator } = binding;
+    if (!declarator) {
+        return '';
+    }
+    const { id } = declarator;
+    if (id.type !== 'Identifier') {
+        const idCode = ctx.code.slice(id.start, id.end);
+        if (!declarator.init) {
+            return `let ${idCode};`;
+        }
+        return `let ${idCode} = ${declarationInitCode(declarator.init, ctx)};`;
+    }
+    const hoistedName = getHoistedBindingName(binding, ctx);
+    if (!declarator.init) {
+        return `let ${hoistedName};`;
+    }
+    return `let ${hoistedName} = ${declarationInitCode(declarator.init, ctx)};`;
+};
+const assertHoistable = (binding, ctx, stack = []) => {
+    if (!binding.declarator?.init || binding.importedFrom || binding.isRoot) {
+        return;
+    }
+    if (stack.includes(binding.name)) {
+        return;
+    }
+    const refs = findReferences(binding.declarator.init, ctx.referencesByNode);
+    refs.forEach(({ name, start }) => {
+        const nextBinding = resolveBindingAt(ctx, name, start);
+        if (!nextBinding) {
+            return;
+        }
+        if (nextBinding.kind === 'param') {
+            throw new Error(`This identifier cannot be used in the template, because it is a function parameter.`);
+        }
+        assertHoistable(nextBinding, ctx, [...stack, binding.name]);
+    });
+};
+const addHoistedDeclaration = (binding, ctx, stack = []) => {
+    if (!binding.declaration ||
+        !binding.declarator ||
+        binding.importedFrom ||
+        binding.isRoot ||
+        stack.includes(binding.name)) {
+        return;
+    }
+    const hoistSource = binding.declarator.init ?? binding.declarator;
+    findReferences(hoistSource, ctx.referencesByNode).forEach(({ name, start }) => {
+        const dependency = resolveBindingAt(ctx, name, start);
+        if (dependency) {
+            addHoistedDeclaration(dependency, ctx, [...stack, binding.name]);
+        }
+    });
+    if (!ctx.hoistedDeclarations.has(binding.name)) {
+        addHoistedCode(binding.name, declarationCode(binding, ctx), ctx);
+    }
+};
+const literalExpressionValue = (expression, ctx) => {
+    if (expression.type !== 'Literal') {
+        return null;
+    }
+    if (expression.value !== null &&
+        typeof expression.value !== 'string' &&
+        typeof expression.value !== 'number' &&
+        typeof expression.value !== 'boolean') {
+        return null;
+    }
+    let type;
+    if (expression.value === null) {
+        type = 'NullLiteral';
+    }
+    else if (typeof expression.value === 'string') {
+        type = 'StringLiteral';
+    }
+    else if (typeof expression.value === 'number') {
+        type = 'NumericLiteral';
+    }
+    else {
+        type = 'BooleanLiteral';
+    }
+    const loc = getSourceLocation(expression.start, expression.end, ctx);
+    const ex = expression.value === null
+        ? { loc, type }
+        : {
+            loc,
+            type,
+            value: expression.value,
+        };
+    return {
+        ex,
+        kind: ValueType.CONST,
+        source: ctx.code.slice(expression.start, expression.end),
+        value: expression.value,
+    };
+};
+const extractExpression = (expression, ctx, evaluate) => {
+    const source = ctx.code.slice(expression.start, expression.end);
+    const isFunction = expression.type === 'FunctionExpression' ||
+        expression.type === 'ArrowFunctionExpression';
+    if (evaluate) {
+        const evaluated = evaluateStatic(expression, ctx);
+        const literal = literalCode(evaluated);
+        if (literal) {
+            findReferences(expression, ctx.referencesByNode).forEach(({ name }) => ctx.dependencyNames.add(name));
+            return {
+                expressionCode: literal,
+                importedFrom: [],
+                kind: isFunction ? ValueType.FUNCTION : ValueType.LAZY,
+                staticImports: [],
+                staticValue: isStaticSerializableValue(evaluated)
+                    ? cloneStaticValue(evaluated)
+                    : undefined,
+            };
+        }
+    }
+    const identifierReplacements = new Map();
+    const importedFrom = [];
+    const namespaceStatic = collectStaticNamespaceMemberReferences(expression, ctx);
+    const staticImports = [
+        ...namespaceStatic.imports,
+    ];
+    let hasNonStaticLocalReference = false;
+    findReferences(expression, ctx.referencesByNode).forEach(({ name, start }) => {
+        const binding = resolveBindingAt(ctx, name, start);
+        if (!binding) {
+            return;
+        }
+        if (isFunction && isBindingDeclaredWithin(binding, expression)) {
+            return;
+        }
+        ctx.dependencyNames.add(name);
+        if (binding.importedFrom) {
+            importedFrom.push(binding.importedFrom);
+            if (binding.imported && binding.imported !== '*') {
+                staticImports.push({
+                    imported: binding.imported,
+                    local: binding.name,
+                    source: binding.importedFrom,
+                });
+            }
+            else if (binding.imported === '*' &&
+                namespaceStatic.coveredReferenceStarts.has(start)) {
+                // The static candidate source gets a synthetic named import alias,
+                // while the eval fallback keeps the original namespace expression.
+            }
+            else {
+                hasNonStaticLocalReference = true;
+            }
+            return;
+        }
+        const replacement = getConstantReplacement(binding, ctx);
+        if (evaluate && replacement) {
+            identifierReplacements.set(name, replacement);
+            return;
+        }
+        hasNonStaticLocalReference = true;
+        assertHoistable(binding, ctx);
+        addHoistedDeclaration(binding, ctx);
+        if (!binding.isRoot && binding.declarator?.id.type === 'Identifier') {
+            identifierReplacements.set(name, getHoistedBindingName(binding, ctx));
+        }
+    });
+    return {
+        expressionCode: identifierReplacements.size > 0
+            ? replaceIdentifierReferences(expression, identifierReplacements, ctx.code)
+            : source,
+        importedFrom,
+        kind: isFunction ? ValueType.FUNCTION : ValueType.LAZY,
+        staticExpressionCode: namespaceStatic.replacements.length > 0
+            ? applyExpressionReplacements(expression, namespaceStatic.replacements, ctx.code)
+            : undefined,
+        staticImports: hasNonStaticLocalReference ? [] : staticImports,
+    };
+};
+const getInsertionPoints = (program, expressions) => {
+    if (expressions.length === 0) {
+        return [];
+    }
+    if (program.body.length === 0) {
+        return expressions.map(() => 0);
+    }
+    const insertionPoints = [];
+    let ownerIndex = 0;
+    expressions.forEach((expression) => {
+        while (ownerIndex < program.body.length - 1 &&
+            program.body[ownerIndex].end < expression.start) {
+            ownerIndex += 1;
+        }
+        let owner = program.body[ownerIndex];
+        if (!owner ||
+            owner.start > expression.start ||
+            owner.end < expression.end) {
+            owner = program.body.find((statement) => statement.start <= expression.start && statement.end >= expression.end);
+        }
+        insertionPoints.push(owner?.start ?? 0);
+    });
+    return insertionPoints;
+};
+const applyReplacements = (code, replacements) => {
+    let result = code;
+    replacements
+        .sort((a, b) => b.start - a.start)
+        .forEach((replacement) => {
+        result =
+            result.slice(0, replacement.start) +
+                replacement.value +
+                result.slice(replacement.end);
+    });
+    return result;
+};
+const extractExpressions = (code, filename, evaluate, program, analysis, expressions) => {
+    if (expressions.length === 0) {
+        return {
+            code,
+            dependencyNames: [],
+            expressionValues: [],
+            staticValueCandidates: [],
+            staticValues: [],
+        };
+    }
+    const insertionPoints = getInsertionPoints(program, expressions);
+    const ctx = {
+        bindingResolutionCache: new Map(),
+        bindingsByName: analysis.bindingsByName,
+        code,
+        currentInsertionPoint: insertionPoints[0] ?? 0,
+        currentExpressionStart: expressions[0].start,
+        dependencyNames: new Set(),
+        expressionValues: [],
+        filename,
+        hoistedBindingNames: new Map(),
+        hoistedDeclarations: new Map(),
+        hoistedDeclarationsByInsertionPoint: new Map(),
+        loc: createLocationLookup(code),
+        referencesByNode: new WeakMap(),
+        replacements: [],
+        rootMutationsByBinding: analysis.rootMutationsByBinding,
+        staticImportAliases: new Map(),
+        staticValueCandidates: [],
+        staticValues: [],
+        usedNames: new Set(analysis.usedNames),
+    };
+    expressions.forEach((expression, index) => {
+        ctx.currentInsertionPoint = insertionPoints[index] ?? 0;
+        ctx.currentExpressionStart = expression.start;
+        const literal = literalExpressionValue(expression, ctx);
+        if (literal) {
+            ctx.expressionValues.push(literal);
+            return;
+        }
+        const { expressionCode, importedFrom, kind, staticExpressionCode, staticImports, staticValue, } = extractExpression(expression, ctx, evaluate);
+        const expName = allocateExpressionName(ctx);
+        addHoistedCode(expName, `const ${expName} = () => (${expressionCode});`, ctx);
+        if (staticValue !== undefined && kind !== ValueType.FUNCTION) {
+            ctx.staticValues.push({
+                name: expName,
+                value: staticValue,
+            });
+        }
+        else if (staticImports.length > 0 && kind !== ValueType.FUNCTION) {
+            const uniqueImports = new Map();
+            staticImports.forEach((item) => {
+                uniqueImports.set(`${item.local}\0${item.importLocal ?? ''}\0${item.source}\0${item.imported}`, item);
+            });
+            ctx.staticValueCandidates.push({
+                imports: [...uniqueImports.values()],
+                name: expName,
+                source: staticExpressionCode ?? expressionCode,
+            });
+        }
+        ctx.replacements.push({
+            start: expression.start,
+            end: expression.end,
+            value: `${expName}()`,
+        });
+        ctx.expressionValues.push({
+            ex: {
+                loc: getSourceLocation(expression.start, expression.end, ctx),
+                name: expName,
+                type: 'Identifier',
+            },
+            importedFrom,
+            kind,
+            source: ctx.code.slice(expression.start, expression.end),
+        });
+    });
+    ctx.hoistedDeclarationsByInsertionPoint.forEach((declarations, point) => {
+        ctx.replacements.push({
+            start: point,
+            end: point,
+            value: `${declarations.join('\n')}\n`,
+        });
+    });
+    return {
+        code: applyReplacements(code, ctx.replacements),
+        dependencyNames: [...ctx.dependencyNames],
+        expressionValues: ctx.expressionValues,
+        staticValueCandidates: ctx.staticValueCandidates,
+        staticValues: ctx.staticValues,
+    };
+};
+export const isOxcStaticSerializableValue = (value) => isStaticSerializableValue(value);
+export const evaluateOxcStaticExpressionAt = (code, filename, expressionSpan, staticBindings = new Map()) => {
+    const program = parseOxc(code, filename);
+    const analysis = analyzeProgram(program, {
+        collectTargetExpressions: true,
+        expressionSpanLookup: createSpanLookup([expressionSpan]),
+    });
+    const [expression] = analysis.targetExpressions;
+    if (!expression) {
+        return undefined;
+    }
+    const ctx = {
+        bindingResolutionCache: new Map(),
+        bindingsByName: analysis.bindingsByName,
+        code,
+        currentInsertionPoint: 0,
+        currentExpressionStart: expression.start,
+        dependencyNames: new Set(),
+        expressionValues: [],
+        filename,
+        hoistedBindingNames: new Map(),
+        hoistedDeclarations: new Map(),
+        hoistedDeclarationsByInsertionPoint: new Map(),
+        loc: createLocationLookup(code),
+        referencesByNode: new WeakMap(),
+        replacements: [],
+        rootMutationsByBinding: analysis.rootMutationsByBinding,
+        staticImportAliases: new Map(),
+        staticValueCandidates: [],
+        staticValues: [],
+        usedNames: new Set(analysis.usedNames),
+    };
+    return evaluateStatic(expression, ctx, new Map(staticBindings));
+};
+export const evaluateOxcStaticExpression = (source, filename, staticBindings = new Map()) => {
+    const code = `const __wyw_static_value = ${source};`;
+    const program = parseOxc(code, filename);
+    const declaration = program.body[0];
+    if (declaration?.type !== 'VariableDeclaration') {
+        return undefined;
+    }
+    const [declarator] = declaration.declarations;
+    if (!declarator?.init) {
+        return undefined;
+    }
+    return evaluateOxcStaticExpressionAt(code, filename, {
+        end: declarator.init.end,
+        start: declarator.init.start,
+    }, staticBindings);
+};
+export const collectOxcExpressionDependencies = (code, filename, evaluate = false, targetExpressionSpans) => {
+    const program = parseOxc(code, filename);
+    const analysis = analyzeProgram(program, {
+        collectTargetExpressions: true,
+        expressionSpanLookup: createSpanLookup(targetExpressionSpans),
+    });
+    return extractExpressions(code, filename, evaluate, program, analysis, analysis.targetExpressions);
+};
+export const collectOxcTemplateDependencies = (code, filename, evaluate = false, targetTemplateSpans) => {
+    const program = parseOxc(code, filename);
+    const analysis = analyzeProgram(program, {
+        collectTemplateLiterals: true,
+        templateSpanLookup: createSpanLookup(targetTemplateSpans),
+    });
+    const expressions = analysis.templateLiterals.flatMap((template) => template.expressions);
+    return extractExpressions(code, filename, evaluate, program, analysis, expressions);
+};