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

package/types/utils/applyOxcProcessors.js

@@ -0,0 +1,1391 @@
+/* eslint-disable no-restricted-syntax */
+import { basename, dirname } from 'path';
+import { BaseProcessor, expressionToCode } from '@wyw-in-js/processor-utils';
+import { ValueType } from '@wyw-in-js/shared';
+import { collectOxcProcessorImportsFromProgram } from './collectOxcExportsAndImports';
+import { EventEmitter } from './EventEmitter';
+import { collectOxcExpressionDependencies, } from './collectOxcTemplateDependencies';
+import { isNotNull } from './isNotNull';
+import { createOxcAstService, printOxcAstServiceImport, } from './oxcAstService';
+import { parseOxcProgramCached } from './parseOxc';
+import { getProcessorForImport } from './processorLookup';
+let didWarnSkipSymbolMismatch = false;
+const GENERATED_HELPER_NAME_RE = /^_exp\d*$/;
+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, 'module');
+};
+const visit = (node, enter, parent = null) => {
+    enter(node, parent);
+    getChildren(node).forEach((child) => visit(child, enter, node));
+};
+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 insertAddedImports = (code, program, addedImports) => {
+    if (addedImports.length === 0) {
+        return code;
+    }
+    const uniqueImports = [
+        ...new Map(addedImports.map((item) => [
+            `${item.source}\0${item.imported}\0${item.local}`,
+            item,
+        ])).values(),
+    ];
+    const importBlock = uniqueImports.map(printOxcAstServiceImport).join('\n');
+    const lastImport = [...program.body]
+        .reverse()
+        .find((statement) => statement.type === 'ImportDeclaration');
+    const hashbangEnd = code.startsWith('#!')
+        ? (() => {
+            const newline = code.indexOf('\n');
+            return newline === -1 ? code.length : newline + 1;
+        })()
+        : 0;
+    const insertionPoint = lastImport?.end ?? hashbangEnd;
+    const prefix = code.slice(0, insertionPoint);
+    const suffix = code.slice(insertionPoint);
+    const leadingBreak = prefix.length > 0 && !prefix.endsWith('\n') ? '\n' : '';
+    const trailingBreak = suffix.length > 0 && !suffix.startsWith('\n') ? '\n' : '';
+    return `${prefix}${leadingBreak}${importBlock}${trailingBreak}${suffix}`;
+};
+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, loc, filename) => ({
+    end: loc(end),
+    filename: filename ?? undefined,
+    start: loc(start),
+});
+const buildCodeFrameError = (code, location, message) => {
+    const lines = code.split('\n');
+    const startLine = location.start.line;
+    const endLine = location.end.line;
+    const frameStart = Math.max(1, startLine - 2);
+    const frameEnd = Math.min(lines.length, endLine + 2);
+    const lineNoWidth = String(frameEnd).length;
+    const frame = [];
+    for (let lineNo = frameStart; lineNo <= frameEnd; lineNo += 1) {
+        const marker = lineNo === startLine ? '>' : ' ';
+        const line = lines[lineNo - 1] ?? '';
+        frame.push(line.length > 0
+            ? `${marker} ${String(lineNo).padStart(lineNoWidth)} | ${line}`
+            : `${marker} ${String(lineNo).padStart(lineNoWidth)} |`);
+        if (lineNo === startLine) {
+            const pointerLength = startLine === endLine
+                ? Math.max(1, location.end.column - location.start.column)
+                : 1;
+            frame.push(`  ${' '.repeat(lineNoWidth)} | ${' '.repeat(location.start.column)}${'^'.repeat(pointerLength)}`);
+        }
+    }
+    const prefix = location.filename ? `${location.filename}: ` : '';
+    return new Error(`${prefix}${message}\n${frame.join('\n')}`);
+};
+const collectUsedNames = (program) => {
+    const names = new Set();
+    visit(program, (node) => {
+        if (node.type === 'Identifier') {
+            names.add(node.name);
+        }
+    });
+    return names;
+};
+const isNodeReference = (node, parent) => {
+    if (node.type === 'Identifier') {
+        const parentRecord = parent;
+        if (!parentRecord) {
+            return true;
+        }
+        if (parent?.type === 'ImportDeclaration' ||
+            parent?.type === 'ImportSpecifier' ||
+            parent?.type === 'ImportDefaultSpecifier' ||
+            parent?.type === 'ImportNamespaceSpecifier') {
+            return false;
+        }
+        if (parent?.type === 'MemberExpression' &&
+            parentRecord.property === node &&
+            !parentRecord.computed) {
+            return false;
+        }
+        if ((parent?.type === 'VariableDeclarator' ||
+            parent?.type === 'FunctionDeclaration' ||
+            parent?.type === 'ClassDeclaration' ||
+            parent?.type === 'ClassExpression') &&
+            parentRecord.id === node) {
+            return false;
+        }
+        if ((parent?.type === 'PropertyDefinition' ||
+            parent?.type === 'MethodDefinition') &&
+            parentRecord.key === node &&
+            !parentRecord.computed) {
+            return false;
+        }
+        if (parent?.type === 'Property' &&
+            parentRecord.key === node &&
+            parentRecord.value !== node &&
+            !parentRecord.computed) {
+            return false;
+        }
+        return true;
+    }
+    if (node.type === 'JSXIdentifier') {
+        const parentRecord = parent;
+        if (parent?.type === 'JSXAttribute' && parentRecord?.name === node) {
+            return false;
+        }
+        return true;
+    }
+    return false;
+};
+const collectReferencedNames = (root) => {
+    const names = new Set();
+    const walk = (node, parent = null) => {
+        if (node.type === 'ImportDeclaration') {
+            return;
+        }
+        if (isNodeReference(node, parent) &&
+            'name' in node &&
+            typeof node.name === 'string') {
+            names.add(node.name);
+        }
+        getChildren(node).forEach((child) => walk(child, node));
+    };
+    walk(root);
+    return names;
+};
+const collectImportLocalNames = (node) => {
+    if (node.type !== 'ImportDeclaration') {
+        return [];
+    }
+    const { specifiers } = node;
+    if (!Array.isArray(specifiers)) {
+        return [];
+    }
+    return specifiers
+        .map((specifier) => {
+        const { local } = specifier;
+        return isNode(local) && 'name' in local && typeof local.name === 'string'
+            ? local.name
+            : null;
+    })
+        .filter(isNotNull);
+};
+const getImportSpecifierLocalName = (node) => {
+    const { local } = node;
+    return isNode(local) && 'name' in local && typeof local.name === 'string'
+        ? local.name
+        : null;
+};
+const collectDeclaredNames = (node) => {
+    if (node.type === 'Identifier') {
+        return [node.name];
+    }
+    if (node.type === 'RestElement') {
+        return collectDeclaredNames(node.argument);
+    }
+    if (node.type === 'AssignmentPattern') {
+        return collectDeclaredNames(node.left);
+    }
+    if (node.type === 'ObjectPattern') {
+        return node.properties.flatMap((property) => property.type === 'RestElement'
+            ? collectDeclaredNames(property.argument)
+            : collectDeclaredNames(property.value));
+    }
+    if (node.type === 'ArrayPattern') {
+        return node.elements.flatMap((element) => element ? collectDeclaredNames(element) : []);
+    }
+    if (node.type === 'TSParameterProperty') {
+        return collectDeclaredNames(node.parameter);
+    }
+    return [];
+};
+const collectTopLevelBindings = (statement) => {
+    const bindings = new Set();
+    if (statement.type === 'ImportDeclaration') {
+        collectImportLocalNames(statement).forEach((name) => bindings.add(name));
+        return bindings;
+    }
+    if (statement.type === 'VariableDeclaration') {
+        const { declarations } = statement;
+        if (!Array.isArray(declarations)) {
+            return bindings;
+        }
+        declarations.forEach((declarator) => {
+            const { id } = declarator;
+            if (isNode(id)) {
+                collectDeclaredNames(id).forEach((name) => bindings.add(name));
+            }
+        });
+        return bindings;
+    }
+    if ((statement.type === 'FunctionDeclaration' ||
+        statement.type === 'ClassDeclaration' ||
+        statement.type === 'TSEnumDeclaration') &&
+        'id' in statement) {
+        const { id } = statement;
+        if (isNode(id) && id.type === 'Identifier') {
+            bindings.add(id.name);
+        }
+        return bindings;
+    }
+    if (statement.type === 'ExportNamedDeclaration') {
+        const { declaration } = statement;
+        return isNode(declaration)
+            ? collectTopLevelBindings(declaration)
+            : bindings;
+    }
+    return bindings;
+};
+const collectTopLevelStatementInfos = (program) => program.body.map((statement) => ({
+    bindings: collectTopLevelBindings(statement),
+    node: statement,
+    references: collectReferencedNames(statement),
+}));
+const collectTopLevelBindingsFromStatements = (statements) => new Set(statements.flatMap((statement) => [...statement.bindings]));
+const collectRemovableNamesFromStatements = (statements, initialNames) => {
+    const removable = new Set(initialNames);
+    const bindingToStatement = new Map();
+    statements.forEach((statement) => {
+        statement.bindings.forEach((name) => {
+            bindingToStatement.set(name, statement);
+        });
+    });
+    const queue = [...removable];
+    while (queue.length > 0) {
+        const name = queue.shift();
+        const statement = bindingToStatement.get(name);
+        if (statement) {
+            statement.references.forEach((reference) => {
+                if (bindingToStatement.has(reference) && !removable.has(reference)) {
+                    removable.add(reference);
+                    queue.push(reference);
+                }
+            });
+        }
+    }
+    return removable;
+};
+const createScopedCleanupScope = (parent) => ({
+    bindings: new Map(),
+    parent,
+});
+const resolveScopedBinding = (scope, name) => {
+    let current = scope;
+    while (current) {
+        const bindingId = current.bindings.get(name);
+        if (bindingId) {
+            return bindingId;
+        }
+        current = current.parent;
+    }
+    return null;
+};
+const collectScopedBindingInfos = (program) => {
+    const bindings = new Map();
+    let sequence = 0;
+    const addBinding = (scope, name, kind, declaration) => {
+        const id = `${kind}:${name}:${declaration.start}:${sequence}`;
+        sequence += 1;
+        bindings.set(id, {
+            declaration,
+            dependencies: new Set(),
+            externalReferences: 0,
+            id,
+            incomingFromBindings: new Set(),
+            kind,
+            name,
+        });
+        scope.bindings.set(name, id);
+        return id;
+    };
+    const addPatternBindings = (scope, pattern, kind, declaration) => {
+        collectDeclaredNames(pattern).forEach((name) => {
+            addBinding(scope, name, kind, declaration);
+        });
+    };
+    const recordReference = (scope, name, ownerBindingId) => {
+        const targetId = resolveScopedBinding(scope, name);
+        if (!targetId) {
+            return;
+        }
+        const target = bindings.get(targetId);
+        if (!target) {
+            return;
+        }
+        if (ownerBindingId && ownerBindingId !== targetId) {
+            target.incomingFromBindings.add(ownerBindingId);
+            bindings.get(ownerBindingId)?.dependencies.add(targetId);
+            return;
+        }
+        target.externalReferences += 1;
+    };
+    let walk;
+    function walkPatternReferenceSubexpressions(node, scope, ownerBindingId) {
+        if (node.type === 'Identifier') {
+            return;
+        }
+        if (node.type === 'TSParameterProperty') {
+            walkPatternReferenceSubexpressions(node.parameter, scope, ownerBindingId);
+            return;
+        }
+        if (node.type === 'RestElement') {
+            walkPatternReferenceSubexpressions(node.argument, scope, ownerBindingId);
+            return;
+        }
+        if (node.type === 'AssignmentPattern') {
+            walkPatternReferenceSubexpressions(node.left, scope, ownerBindingId);
+            walk(node.right, scope, node, ownerBindingId);
+            return;
+        }
+        if (node.type === 'ObjectPattern') {
+            node.properties.forEach((property) => {
+                if (property.type === 'RestElement') {
+                    walkPatternReferenceSubexpressions(property.argument, scope, ownerBindingId);
+                    return;
+                }
+                if (property.computed && isNode(property.key)) {
+                    walk(property.key, scope, property, ownerBindingId);
+                }
+                walkPatternReferenceSubexpressions(property.value, scope, ownerBindingId);
+            });
+            return;
+        }
+        if (node.type === 'ArrayPattern') {
+            node.elements.forEach((element) => {
+                if (element && isNode(element)) {
+                    walkPatternReferenceSubexpressions(element, scope, ownerBindingId);
+                }
+            });
+        }
+    }
+    walk = (node, scope, parent = null, ownerBindingId = null) => {
+        if (node.type === 'ImportDeclaration') {
+            const { specifiers } = node;
+            if (Array.isArray(specifiers)) {
+                specifiers.forEach((specifier) => {
+                    const { local } = specifier;
+                    if (isNode(local) &&
+                        local.type === 'Identifier' &&
+                        typeof local.name === 'string') {
+                        addBinding(scope, local.name, 'import', node);
+                    }
+                });
+            }
+            return;
+        }
+        if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+            walk(node.declaration, scope, node, ownerBindingId);
+            collectTopLevelBindings(node).forEach((name) => {
+                recordReference(scope, name, ownerBindingId);
+            });
+            return;
+        }
+        if (node.type === 'ExportDefaultDeclaration') {
+            const { declaration } = node;
+            if (isNode(declaration)) {
+                walk(declaration, scope, node, ownerBindingId);
+                if ((declaration.type === 'FunctionDeclaration' ||
+                    declaration.type === 'ClassDeclaration') &&
+                    declaration.id) {
+                    recordReference(scope, declaration.id.name, ownerBindingId);
+                }
+            }
+            return;
+        }
+        if (node.type === 'VariableDeclaration') {
+            const { declarations } = node;
+            if (!Array.isArray(declarations)) {
+                return;
+            }
+            declarations.forEach((declarator) => {
+                const { id } = declarator;
+                if (isNode(id)) {
+                    addPatternBindings(scope, id, 'variable', node);
+                }
+            });
+            declarations.forEach((declarator) => {
+                const { id } = declarator;
+                const { init } = declarator;
+                if (!isNode(id) || !isNode(init)) {
+                    return;
+                }
+                const ownerName = collectDeclaredNames(id)[0] ?? null;
+                const nextOwner = ownerName !== null ? resolveScopedBinding(scope, ownerName) : null;
+                walk(init, scope, declarator, nextOwner);
+            });
+            return;
+        }
+        if (node.type === 'FunctionDeclaration' && node.id) {
+            const functionBindingId = addBinding(scope, node.id.name, 'function', node);
+            const fnScope = createScopedCleanupScope(scope);
+            node.params.forEach((param) => {
+                addPatternBindings(fnScope, param, 'param', param);
+                walkPatternReferenceSubexpressions(param, fnScope, functionBindingId);
+            });
+            if (node.body) {
+                walk(node.body, fnScope, node, functionBindingId);
+            }
+            return;
+        }
+        if (node.type === 'FunctionExpression' ||
+            node.type === 'ArrowFunctionExpression') {
+            const fnScope = createScopedCleanupScope(scope);
+            if (node.type === 'FunctionExpression' && node.id) {
+                addBinding(fnScope, node.id.name, 'function', node);
+            }
+            node.params.forEach((param) => {
+                addPatternBindings(fnScope, param, 'param', param);
+                walkPatternReferenceSubexpressions(param, fnScope, ownerBindingId);
+            });
+            if (node.body) {
+                walk(node.body, fnScope, node, ownerBindingId);
+            }
+            return;
+        }
+        if (node.type === 'BlockStatement') {
+            const blockScope = createScopedCleanupScope(scope);
+            getChildren(node).forEach((child) => walk(child, blockScope, node, ownerBindingId));
+            return;
+        }
+        if (isNodeReference(node, parent) &&
+            'name' in node &&
+            typeof node.name === 'string') {
+            recordReference(scope, node.name, ownerBindingId);
+        }
+        getChildren(node).forEach((child) => walk(child, scope, node, ownerBindingId));
+    };
+    walk(program, createScopedCleanupScope(null));
+    return bindings;
+};
+const collectScopedRemovableBindingIds = (bindings, initialNames) => {
+    const removable = new Set();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const binding of bindings.values()) {
+            if (!removable.has(binding.id) &&
+                binding.kind !== 'import' &&
+                binding.kind !== 'param' &&
+                binding.externalReferences === 0) {
+                const seededByName = initialNames.has(binding.name) ||
+                    (GENERATED_HELPER_NAME_RE.test(binding.name) &&
+                        binding.incomingFromBindings.size === 0);
+                const allIncomingRemovable = binding.incomingFromBindings.size > 0 &&
+                    [...binding.incomingFromBindings].every((sourceId) => removable.has(sourceId));
+                if ((seededByName && binding.incomingFromBindings.size === 0) ||
+                    allIncomingRemovable) {
+                    removable.add(binding.id);
+                    changed = true;
+                }
+            }
+        }
+    }
+    return removable;
+};
+function expandImportRemovalRange(code, start, end) {
+    let removalStart = start;
+    while (removalStart > 0 &&
+        (code[removalStart - 1] === ' ' || code[removalStart - 1] === '\t')) {
+        removalStart -= 1;
+    }
+    let removalEnd = end;
+    if (code[removalEnd] === ';') {
+        removalEnd += 1;
+    }
+    while (removalEnd < code.length &&
+        (code[removalEnd] === ' ' || code[removalEnd] === '\t')) {
+        removalEnd += 1;
+    }
+    if (code[removalEnd] === '\r' && code[removalEnd + 1] === '\n') {
+        removalEnd += 2;
+    }
+    else if (code[removalEnd] === '\n') {
+        removalEnd += 1;
+    }
+    return {
+        end: removalEnd,
+        start: removalStart,
+        value: '',
+    };
+}
+const collectUnusedScopedDeclarationRemovals = (code, bindings, initialRemovableNames) => {
+    const removableBindingIds = collectScopedRemovableBindingIds(bindings, initialRemovableNames);
+    const removals = new Map();
+    bindings.forEach((binding) => {
+        if (!removableBindingIds.has(binding.id) ||
+            binding.kind === 'import' ||
+            binding.kind === 'param' ||
+            binding.externalReferences > 0 ||
+            [...binding.incomingFromBindings].some((sourceId) => !removableBindingIds.has(sourceId))) {
+            return;
+        }
+        if (binding.kind === 'function' &&
+            binding.declaration.type === 'FunctionDeclaration') {
+            const range = expandImportRemovalRange(code, binding.declaration.start, binding.declaration.end);
+            removals.set(`${range.start}:${range.end}`, range);
+            return;
+        }
+        if (binding.declaration.type !== 'VariableDeclaration') {
+            return;
+        }
+        const { declarations } = binding.declaration;
+        if (!Array.isArray(declarations) || declarations.length !== 1) {
+            return;
+        }
+        const range = expandImportRemovalRange(code, binding.declaration.start, binding.declaration.end);
+        removals.set(`${range.start}:${range.end}`, range);
+    });
+    return [...removals.values()];
+};
+const expandImportSpecifierRemovalRange = (code, start, end) => {
+    let removalStart = start;
+    let removalEnd = end;
+    let whitespaceStart = removalStart;
+    while (whitespaceStart > 0 &&
+        (code[whitespaceStart - 1] === ' ' || code[whitespaceStart - 1] === '\t')) {
+        whitespaceStart -= 1;
+    }
+    if (code[whitespaceStart - 1] !== '{') {
+        removalStart = whitespaceStart;
+    }
+    while (removalEnd < code.length &&
+        (code[removalEnd] === ' ' || code[removalEnd] === '\t')) {
+        removalEnd += 1;
+    }
+    if (code[removalEnd] === ',') {
+        removalEnd += 1;
+        while (removalEnd < code.length &&
+            (code[removalEnd] === ' ' || code[removalEnd] === '\t')) {
+            removalEnd += 1;
+        }
+    }
+    else {
+        while (removalStart > 0 &&
+            (code[removalStart - 1] === ' ' || code[removalStart - 1] === '\t')) {
+            removalStart -= 1;
+        }
+        if (code[removalStart - 1] === ',') {
+            removalStart -= 1;
+            while (removalStart > 0 &&
+                (code[removalStart - 1] === ' ' || code[removalStart - 1] === '\t')) {
+                removalStart -= 1;
+            }
+        }
+    }
+    return {
+        end: removalEnd,
+        start: removalStart,
+        value: '',
+    };
+};
+const mergeEmptyRemovalRanges = (removals) => {
+    if (removals.length <= 1) {
+        return removals;
+    }
+    const sorted = [...removals].sort((a, b) => a.start - b.start);
+    const merged = [];
+    sorted.forEach((removal) => {
+        const previous = merged[merged.length - 1];
+        if (previous &&
+            previous.value === '' &&
+            removal.value === '' &&
+            removal.start <= previous.end) {
+            previous.end = Math.max(previous.end, removal.end);
+            return;
+        }
+        merged.push({ ...removal });
+    });
+    return merged;
+};
+const collectUnusedImportRemovals = (code, program, referencedNames, removableNames, preserveSideEffectImportLocals) => {
+    const removals = [];
+    program.body.forEach((statement) => {
+        if (statement.type !== 'ImportDeclaration') {
+            return;
+        }
+        const localNames = collectImportLocalNames(statement);
+        const removableLocalNames = localNames.filter((localName) => removableNames.has(localName));
+        if (removableLocalNames.length > 0 &&
+            removableLocalNames.length === localNames.length &&
+            removableLocalNames.every((localName) => !referencedNames.has(localName))) {
+            if (removableLocalNames.some((localName) => preserveSideEffectImportLocals.has(localName))) {
+                removals.push({
+                    end: statement.end,
+                    start: statement.start,
+                    value: `import ${code.slice(statement.source.start, statement.source.end)};`,
+                });
+                return;
+            }
+            removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+            return;
+        }
+        const { specifiers } = statement;
+        if (!Array.isArray(specifiers) || specifiers.length <= 1) {
+            return;
+        }
+        specifiers.forEach((specifier) => {
+            if (!isNode(specifier)) {
+                return;
+            }
+            const localName = getImportSpecifierLocalName(specifier);
+            if (localName &&
+                removableNames.has(localName) &&
+                !referencedNames.has(localName)) {
+                removals.push(expandImportSpecifierRemovalRange(code, specifier.start, specifier.end));
+            }
+        });
+    });
+    return removals;
+};
+const collectUnusedTopLevelDeclarationRemovals = (code, program, referencedNames, removableNames) => {
+    const removals = [];
+    program.body.forEach((statement) => {
+        if (statement.type !== 'VariableDeclaration') {
+            return;
+        }
+        const localNames = [...collectTopLevelBindings(statement)];
+        if (localNames.length > 0 &&
+            localNames.every((localName) => removableNames.has(localName)) &&
+            localNames.every((localName) => !referencedNames.has(localName))) {
+            removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+        }
+    });
+    return removals;
+};
+const collectUnusedGeneratedHelperDeclarationRemovals = (code, program, referencedNames) => {
+    const removals = [];
+    program.body.forEach((statement) => {
+        if (statement.type !== 'VariableDeclaration') {
+            return;
+        }
+        const localNames = [...collectTopLevelBindings(statement)];
+        if (localNames.length > 0 &&
+            localNames.every((localName) => GENERATED_HELPER_NAME_RE.test(localName)) &&
+            localNames.every((localName) => !referencedNames.has(localName))) {
+            removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+        }
+    });
+    return removals;
+};
+const collectTopLevelExpressionStatementRemovals = (code, statements, topLevelBindings, removableExpressionRefs) => {
+    const removals = [];
+    statements.forEach((statement) => {
+        if (statement.node.type !== 'ExpressionStatement') {
+            return;
+        }
+        const { expression } = statement.node;
+        const isPureExpression = expression.type === 'Identifier' ||
+            expression.type === 'Literal' ||
+            expression.type === 'ObjectExpression' ||
+            expression.type === 'ArrayExpression' ||
+            expression.type === 'ArrowFunctionExpression' ||
+            expression.type === 'FunctionExpression' ||
+            (expression.type === 'TemplateLiteral' &&
+                expression.expressions.length === 0);
+        if (!isPureExpression) {
+            return;
+        }
+        const localReferences = [...statement.references].filter((name) => topLevelBindings.has(name));
+        if (localReferences.length > 0 &&
+            localReferences.every((name) => removableExpressionRefs.has(name))) {
+            removals.push(expandImportRemovalRange(code, statement.node.start, statement.node.end));
+        }
+    });
+    return removals;
+};
+const collectEmptyTopLevelBlockRemovals = (code, program) => {
+    const removals = [];
+    program.body.forEach((statement) => {
+        if (statement.type !== 'BlockStatement' || statement.body.length > 0) {
+            return;
+        }
+        removals.push(expandImportRemovalRange(code, statement.start, statement.end));
+    });
+    return removals;
+};
+const removeUnusedAfterReplacement = (code, filename, initialRemovableNames, removableExpressionRefs, preserveSideEffectImportLocals) => {
+    let current = code;
+    const cumulativeRemovableNames = new Set(initialRemovableNames);
+    const applyIfParsable = (next) => {
+        try {
+            parseOxc(next, filename);
+            return next;
+        }
+        catch {
+            return current;
+        }
+    };
+    for (let idx = 0; idx < 5; idx += 1) {
+        const previous = current;
+        const program = parseOxc(current, filename);
+        const statements = collectTopLevelStatementInfos(program);
+        const removableNames = collectRemovableNamesFromStatements(statements, cumulativeRemovableNames);
+        removableNames.forEach((name) => cumulativeRemovableNames.add(name));
+        const referencedNames = collectReferencedNames(program);
+        const topLevelBindings = collectTopLevelBindingsFromStatements(statements);
+        const scopedBindings = collectScopedBindingInfos(program);
+        const removals = mergeEmptyRemovalRanges([
+            ...collectUnusedScopedDeclarationRemovals(current, scopedBindings, cumulativeRemovableNames),
+            ...collectUnusedTopLevelDeclarationRemovals(current, program, referencedNames, cumulativeRemovableNames),
+            ...collectUnusedGeneratedHelperDeclarationRemovals(current, program, referencedNames),
+            ...collectUnusedImportRemovals(current, program, referencedNames, cumulativeRemovableNames, preserveSideEffectImportLocals),
+            ...collectTopLevelExpressionStatementRemovals(current, statements, topLevelBindings, removableExpressionRefs),
+            ...collectEmptyTopLevelBlockRemovals(current, program),
+        ]);
+        current =
+            removals.length > 0
+                ? applyIfParsable(applyReplacements(current, removals))
+                : current;
+        if (current === previous) {
+            return current;
+        }
+    }
+    return current;
+};
+const getMemberName = (node) => {
+    if (node.computed) {
+        return node.property.type === 'Literal' &&
+            typeof node.property.value === 'string'
+            ? node.property.value
+            : null;
+    }
+    return node.property.type === 'Identifier' ? node.property.name : null;
+};
+const unwrapQualifiedExpression = (node) => {
+    if (node.type === 'TSAsExpression' ||
+        node.type === 'TSSatisfiesExpression' ||
+        node.type === 'TSNonNullExpression' ||
+        node.type === 'TSTypeAssertion' ||
+        node.type === 'ParenthesizedExpression') {
+        return unwrapQualifiedExpression(node.expression);
+    }
+    if (node.type === 'SequenceExpression') {
+        const sequence = node;
+        return unwrapQualifiedExpression(sequence.expressions[sequence.expressions.length - 1] ?? node);
+    }
+    return node;
+};
+const getRootIdentifier = (node) => {
+    const expression = unwrapQualifiedExpression(node);
+    if (expression.type === 'Identifier') {
+        return expression;
+    }
+    if (expression.type === 'MemberExpression') {
+        return getRootIdentifier(expression.object);
+    }
+    if (expression.type === 'CallExpression') {
+        return getRootIdentifier(expression.callee);
+    }
+    return null;
+};
+const getQualifiedName = (node) => {
+    const expression = unwrapQualifiedExpression(node);
+    if (expression.type === 'Identifier') {
+        return expression.name;
+    }
+    if (expression.type === 'MemberExpression') {
+        const object = getQualifiedName(expression.object);
+        const member = getMemberName(expression);
+        return object && member ? `${object}.${member}` : null;
+    }
+    if (expression.type === 'CallExpression') {
+        return getQualifiedName(expression.callee);
+    }
+    return null;
+};
+const resolveDefinedProcessor = (callee, definedProcessors) => {
+    const qualified = getQualifiedName(callee);
+    if (qualified) {
+        const definedProcessor = definedProcessors.get(qualified);
+        if (definedProcessor) {
+            return {
+                collapseQualifiedCallee: qualified.includes('.'),
+                definedProcessor,
+            };
+        }
+    }
+    const root = getRootIdentifier(callee);
+    if (!root) {
+        return null;
+    }
+    const definedProcessor = definedProcessors.get(root.name);
+    return definedProcessor
+        ? {
+            collapseQualifiedCallee: false,
+            definedProcessor,
+        }
+        : null;
+};
+const isCallTagOfTaggedTemplate = (node, parent) => parent?.type === 'TaggedTemplateExpression' && parent.tag === node;
+const expandReplacementTarget = (target, ancestors) => {
+    let current = target;
+    for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+        const ancestor = ancestors[idx];
+        if (ancestor.type === 'SequenceExpression' &&
+            ancestor.expressions[ancestor.expressions.length - 1] === current) {
+            current = ancestor;
+        }
+        else if (ancestor.type === 'ParenthesizedExpression' &&
+            ancestor.expression === current) {
+            current = ancestor;
+        }
+        else {
+            break;
+        }
+    }
+    return current;
+};
+const collectProcessorUsages = (program, definedProcessors) => {
+    const usages = [];
+    const walk = (node, ancestors, parent = null) => {
+        if (node.type === 'TaggedTemplateExpression') {
+            const callee = node.tag;
+            const resolvedProcessor = resolveDefinedProcessor(callee, definedProcessors);
+            if (resolvedProcessor) {
+                usages.push({
+                    ancestors,
+                    callee,
+                    collapseQualifiedCallee: resolvedProcessor.collapseQualifiedCallee,
+                    definedProcessor: resolvedProcessor.definedProcessor,
+                    kind: 'template',
+                    replacementTarget: expandReplacementTarget(node, ancestors),
+                    target: node,
+                });
+            }
+        }
+        else if (node.type === 'CallExpression' &&
+            !isCallTagOfTaggedTemplate(node, parent)) {
+            const { callee } = node;
+            const resolvedProcessor = resolveDefinedProcessor(callee, definedProcessors);
+            if (resolvedProcessor) {
+                usages.push({
+                    ancestors,
+                    callee,
+                    collapseQualifiedCallee: resolvedProcessor.collapseQualifiedCallee,
+                    definedProcessor: resolvedProcessor.definedProcessor,
+                    kind: 'call',
+                    replacementTarget: expandReplacementTarget(node, ancestors),
+                    target: node,
+                });
+            }
+        }
+        getChildren(node).forEach((child) => walk(child, [...ancestors, node], node));
+    };
+    walk(program, []);
+    return usages.sort((a, b) => a.target.start - b.target.start);
+};
+const expressionSpan = (expression) => ({
+    end: expression.end,
+    start: expression.start,
+});
+const collectCallArgumentSpans = (node) => {
+    const expression = unwrapQualifiedExpression(node);
+    if (expression.type === 'CallExpression') {
+        const call = expression;
+        const calleeSpans = collectCallArgumentSpans(call.callee);
+        const argumentSpans = call.arguments.flatMap((arg) => arg.type === 'SpreadElement' ? [] : [expressionSpan(arg)]);
+        return [...calleeSpans, ...argumentSpans];
+    }
+    if (expression.type === 'MemberExpression') {
+        return collectCallArgumentSpans(expression.object);
+    }
+    return [];
+};
+const collectUsageExpressionSpans = (usage) => {
+    const calleeSpans = collectCallArgumentSpans(usage.callee);
+    if (usage.kind === 'template') {
+        return [
+            ...calleeSpans,
+            ...usage.target.quasi.expressions.map((expression) => expressionSpan(expression)),
+        ];
+    }
+    return [
+        ...calleeSpans,
+        ...usage.target.arguments.flatMap((arg) => arg.type === 'SpreadElement' ? [] : [expressionSpan(arg)]),
+    ];
+};
+const literalExpressionValue = (expression, code, source, location) => {
+    if (expression.type !== 'Literal') {
+        return null;
+    }
+    if (expression.value === null ||
+        typeof expression.value === 'string' ||
+        typeof expression.value === 'number' ||
+        typeof expression.value === 'boolean') {
+        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 ex = expression.value === null
+            ? { loc: location, type }
+            : {
+                loc: location,
+                type,
+                value: expression.value,
+            };
+        return {
+            buildCodeFrameError: (message) => buildCodeFrameError(code, location, message),
+            ex,
+            kind: ValueType.CONST,
+            source,
+            value: expression.value,
+        };
+    }
+    return null;
+};
+const expressionValue = (expression, code, loc, filename) => {
+    const source = code.slice(expression.start, expression.end);
+    const location = getSourceLocation(expression.start, expression.end, loc, filename);
+    const literal = literalExpressionValue(expression, code, source, location);
+    if (literal) {
+        return literal;
+    }
+    const helperCallName = expression.type === 'CallExpression' &&
+        expression.arguments.length === 0 &&
+        expression.callee.type === 'Identifier' &&
+        GENERATED_HELPER_NAME_RE.test(expression.callee.name)
+        ? expression.callee.name
+        : null;
+    let ex;
+    if (expression.type === 'Identifier') {
+        ex = { loc: location, name: expression.name, type: 'Identifier' };
+    }
+    else if (helperCallName) {
+        ex = { loc: location, name: helperCallName, type: 'Identifier' };
+    }
+    else {
+        ex = {
+            loc: location,
+            name: code.slice(expression.start, expression.end),
+            type: 'Identifier',
+        };
+    }
+    return {
+        buildCodeFrameError: (message) => buildCodeFrameError(code, location, message),
+        ex,
+        kind: expression.type === 'ArrowFunctionExpression' ||
+            expression.type === 'FunctionExpression'
+            ? ValueType.FUNCTION
+            : ValueType.LAZY,
+        source,
+    };
+};
+const withCurrentExpressionLocation = (value, expression, loc, filename) => {
+    const location = getSourceLocation(expression.start, expression.end, loc, filename);
+    if (value.kind === ValueType.CONST) {
+        return {
+            ...value,
+            ex: {
+                ...value.ex,
+                loc: location,
+            },
+        };
+    }
+    if (value.kind === ValueType.FUNCTION) {
+        return {
+            ...value,
+            ex: {
+                ...value.ex,
+                loc: location,
+            },
+        };
+    }
+    return {
+        ...value,
+        ex: {
+            ...value.ex,
+            loc: location,
+        },
+    };
+};
+const shiftExpressionValue = (expressionValues, expression, code, loc, filename) => expressionValues.length > 0
+    ? withCurrentExpressionLocation(expressionValues.shift(), expression, loc, filename)
+    : expressionValue(expression, code, loc, filename);
+const zipTemplate = (template, code, loc, filename, expressionValues) => {
+    const parts = template.quasi.quasis.flatMap((quasi, idx) => {
+        const expression = template.quasi.expressions[idx];
+        const templateElement = {
+            ...quasi,
+            loc: getSourceLocation(quasi.start, quasi.end, loc, filename),
+        };
+        return [
+            templateElement,
+            expression
+                ? shiftExpressionValue(expressionValues, expression, code, loc, filename)
+                : null,
+        ].filter(isNotNull);
+    });
+    return ['template', parts];
+};
+const buildCalleeParams = (node, code, loc, filename, expressionValues, collapseQualifiedCallee = false) => {
+    const expression = unwrapQualifiedExpression(node);
+    if (collapseQualifiedCallee &&
+        (expression.type === 'Identifier' || expression.type === 'MemberExpression')) {
+        return [['callee', expression]];
+    }
+    if (expression.type === 'Identifier') {
+        return [['callee', { name: expression.name, type: 'Identifier' }]];
+    }
+    if (expression.type === 'MemberExpression') {
+        const params = buildCalleeParams(expression.object, code, loc, filename, expressionValues, collapseQualifiedCallee);
+        const member = getMemberName(expression);
+        return params && member ? [...params, ['member', member]] : null;
+    }
+    if (expression.type === 'CallExpression') {
+        const call = expression;
+        const params = buildCalleeParams(call.callee, code, loc, filename, expressionValues, collapseQualifiedCallee);
+        if (!params) {
+            return null;
+        }
+        const callValues = call.arguments
+            .filter((arg) => arg.type !== 'SpreadElement')
+            .map((arg) => shiftExpressionValue(expressionValues, arg, code, loc, filename));
+        return [...params, ['call', ...callValues]];
+    }
+    return null;
+};
+const buildParams = (usage, code, loc, filename, expressionValues, collapseQualifiedCallee) => {
+    const params = buildCalleeParams(usage.callee, code, loc, filename, expressionValues, collapseQualifiedCallee);
+    if (!params) {
+        return null;
+    }
+    if (usage.kind === 'template') {
+        return [
+            ...params,
+            zipTemplate(usage.target, code, loc, filename, expressionValues),
+        ];
+    }
+    const callValues = usage.target.arguments
+        .filter((arg) => arg.type !== 'SpreadElement')
+        .map((arg) => shiftExpressionValue(expressionValues, arg, code, loc, filename));
+    return [...params, ['call', ...callValues]];
+};
+const getPropertyKeyName = (property, code) => {
+    const { key } = property;
+    if (!isNode(key)) {
+        return null;
+    }
+    if (key.type === 'Identifier') {
+        return key.name;
+    }
+    if (key.type === 'Literal') {
+        return String(key.value);
+    }
+    return typeof key.start === 'number' && typeof key.end === 'number'
+        ? code.slice(key.start, key.end)
+        : null;
+};
+const getDisplayName = (ancestors, idx, code, filename) => {
+    const owner = [...ancestors].reverse().find((node) => {
+        return (node.type === 'Property' ||
+            node.type === 'JSXOpeningElement' ||
+            node.type === 'VariableDeclarator');
+    });
+    if (owner?.type === 'Property') {
+        const keyName = getPropertyKeyName(owner, code);
+        if (keyName) {
+            return keyName;
+        }
+    }
+    else if (owner?.type === 'JSXOpeningElement') {
+        const { name } = owner;
+        if (isNode(name) && name.type === 'JSXIdentifier') {
+            return name.name;
+        }
+    }
+    else if (owner?.type === 'VariableDeclarator') {
+        const { id } = owner;
+        if (isNode(id) && id.type === 'Identifier') {
+            return id.name;
+        }
+    }
+    let displayName = basename(filename ?? 'unknown').replace(/\.[a-z\d]+$/, '');
+    if (filename && /^index\.[a-z\d]+$/.test(basename(filename))) {
+        displayName = basename(dirname(filename));
+    }
+    if (!displayName) {
+        throw new Error("Couldn't determine a name for the component. Ensure that it's either:\n" +
+            '- Assigned to a variable\n' +
+            '- Is an object property\n' +
+            '- Is a prop in a JSX element\n');
+    }
+    return `${displayName}${idx}`;
+};
+const getTagOwner = (ancestors) => {
+    const owner = [...ancestors]
+        .reverse()
+        .find((node) => node.type === 'Property' ||
+        node.type === 'JSXOpeningElement' ||
+        node.type === 'VariableDeclarator');
+    return owner ?? null;
+};
+const isTagReferenced = (program, ancestors) => {
+    const owner = getTagOwner(ancestors);
+    if (owner?.type !== 'VariableDeclarator') {
+        return true;
+    }
+    const { id } = owner;
+    if (!isNode(id) || id.type !== 'Identifier') {
+        return true;
+    }
+    if (ancestors.some((node) => node.type === 'ExportNamedDeclaration')) {
+        return true;
+    }
+    let referenced = false;
+    visit(program, (node, parent) => {
+        const referenceName = node.type === 'Identifier' || node.type === 'JSXIdentifier'
+            ? node.name
+            : null;
+        if (referenced ||
+            referenceName !== id.name ||
+            (node.type === 'Identifier' &&
+                node.start === id.start &&
+                node.end === id.end)) {
+            return;
+        }
+        referenced = isNodeReference(node, parent);
+    });
+    return referenced;
+};
+const isReplacementPure = (replacement) => replacement.type === 'CallExpression';
+const createProcessor = (definedProcessor, params, target, replacementTarget, ancestors, fileContext, options, code, loc, idx, isReferenced, usedNames, replacements) => {
+    const [Processor, tagSource] = definedProcessor;
+    const astService = createOxcAstService(usedNames);
+    const replacer = (replacement, isPure) => {
+        const next = typeof replacement === 'function' ? replacement(target) : replacement;
+        const replacementCode = expressionToCode(next);
+        replacements.push({
+            start: replacementTarget.start,
+            end: replacementTarget.end,
+            value: isPure && isReplacementPure(next)
+                ? `/*#__PURE__*/${replacementCode}`
+                : replacementCode,
+        });
+    };
+    try {
+        let displayName;
+        try {
+            displayName = getDisplayName(ancestors, idx, code, fileContext.filename);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.startsWith("Couldn't determine a name for the component")) {
+                let displayNameNode = target;
+                if (target.type === 'TaggedTemplateExpression') {
+                    displayNameNode = target.tag;
+                }
+                else if (target.type === 'CallExpression') {
+                    displayNameNode = target.callee;
+                }
+                const pointerNode = displayNameNode.type === 'MemberExpression'
+                    ? getRootIdentifier(displayNameNode) ?? displayNameNode
+                    : displayNameNode;
+                throw buildCodeFrameError(code, getSourceLocation(pointerNode.start, pointerNode.end, loc, fileContext.filename), error.message);
+            }
+            throw error;
+        }
+        return {
+            astService,
+            processor: new Processor(params, tagSource, astService, getSourceLocation(target.start, target.end, loc, fileContext.filename), replacer, displayName, isReferenced, idx, options, fileContext),
+        };
+    }
+    catch (e) {
+        if (e === BaseProcessor.SKIP) {
+            return null;
+        }
+        if (typeof e === 'symbol' &&
+            e.description === BaseProcessor.SKIP.description) {
+            if (!didWarnSkipSymbolMismatch) {
+                didWarnSkipSymbolMismatch = true;
+                // eslint-disable-next-line no-console
+                console.warn([
+                    "[wyw-in-js] Processor threw Symbol('skip') that does not match BaseProcessor.SKIP identity.",
+                    'This usually means duplicate copies of @wyw-in-js/processor-utils (or the processor) are bundled/installed.',
+                    'Consider deduping dependencies to avoid subtle issues (instanceof checks, sentinels, etc).',
+                ].join('\n'));
+            }
+            return null;
+        }
+        throw e;
+    }
+};
+export const applyOxcProcessors = (code, fileContext, options, callback, cleanupUnused = false) => {
+    const filename = fileContext.filename ?? 'unknown.js';
+    const eventEmitter = options.eventEmitter ?? EventEmitter.dummy;
+    let workingCode = code;
+    let program = parseOxc(workingCode, filename);
+    const definedProcessors = new Map();
+    const removableImportLocals = new Set();
+    const removableExpressionRefs = new Set();
+    eventEmitter.perf('transform:preeval:processTemplate:imports', () => {
+        const imports = eventEmitter.perf('transform:preeval:processTemplate:imports:analysis', () => collectOxcProcessorImportsFromProgram(program, workingCode));
+        eventEmitter.perf('transform:preeval:processTemplate:imports:lookup', () => {
+            imports.forEach((item) => {
+                const localName = item.local.name ?? item.local.code;
+                if (item.imported === 'side-effect' || !localName) {
+                    return;
+                }
+                const [processor, tagSource] = getProcessorForImport({
+                    imported: item.imported,
+                    source: item.source,
+                }, filename, options);
+                if (processor) {
+                    definedProcessors.set(localName, [processor, tagSource]);
+                    removableImportLocals.add(localName);
+                    const rootLocalName = localName.split('.')[0];
+                    if (rootLocalName) {
+                        removableImportLocals.add(rootLocalName);
+                    }
+                }
+            });
+        });
+    });
+    if (definedProcessors.size === 0) {
+        return {
+            code: workingCode,
+            processors: [],
+            staticValueCandidates: [],
+            staticValues: [],
+        };
+    }
+    let processorUsages = eventEmitter.perf('transform:preeval:processTemplate:usages', () => collectProcessorUsages(program, definedProcessors));
+    if (processorUsages.length === 0) {
+        return {
+            code: workingCode,
+            processors: [],
+            staticValueCandidates: [],
+            staticValues: [],
+        };
+    }
+    const targetExpressionSpans = processorUsages.flatMap(collectUsageExpressionSpans);
+    const extracted = targetExpressionSpans.length > 0
+        ? eventEmitter.perf('transform:preeval:processTemplate:deps', () => collectOxcExpressionDependencies(workingCode, filename, options.evaluate, targetExpressionSpans))
+        : {
+            code: workingCode,
+            dependencyNames: [],
+            expressionValues: [],
+            staticValueCandidates: [],
+            staticValues: [],
+        };
+    if (extracted.code !== workingCode) {
+        workingCode = extracted.code;
+        program = eventEmitter.perf('transform:preeval:processTemplate:reparse', () => parseOxc(workingCode, filename));
+        processorUsages = eventEmitter.perf('transform:preeval:processTemplate:usages', () => collectProcessorUsages(program, definedProcessors));
+    }
+    const templateExpressionValues = extracted.expressionValues.map((value) => ({
+        ...value,
+        buildCodeFrameError: (message) => buildCodeFrameError(code, value.ex.loc, message),
+    }));
+    const loc = createLocationLookup(workingCode);
+    const usedNames = eventEmitter.perf('transform:preeval:processTemplate:usedNames', () => collectUsedNames(program));
+    const addedImports = [];
+    const replacements = [];
+    const processors = [];
+    extracted.dependencyNames.forEach((name) => removableImportLocals.add(name));
+    eventEmitter.perf('transform:preeval:processTemplate:processors', () => {
+        processorUsages.forEach((usage, idx) => {
+            const params = buildParams(usage, workingCode, loc, filename, templateExpressionValues, usage.collapseQualifiedCallee);
+            if (!params) {
+                return;
+            }
+            const created = createProcessor(usage.definedProcessor, params, usage.target, usage.replacementTarget, usage.ancestors, fileContext, options, workingCode, loc, idx, isTagReferenced(program, usage.ancestors), usedNames, replacements);
+            if (!created) {
+                return;
+            }
+            const { astService, processor } = created;
+            const owner = getTagOwner(usage.ancestors);
+            if (owner?.type === 'VariableDeclarator') {
+                const { id } = owner;
+                if (isNode(id) && id.type === 'Identifier') {
+                    removableExpressionRefs.add(id.name);
+                }
+            }
+            processors.push(processor);
+            callback(processor);
+            addedImports.push(...astService.getAddedImports());
+        });
+    });
+    const replacedCode = applyReplacements(workingCode, replacements);
+    const codeWithAddedImports = insertAddedImports(replacedCode, program, addedImports);
+    return {
+        code: cleanupUnused
+            ? eventEmitter.perf('transform:preeval:processTemplate:cleanup', () => removeUnusedAfterReplacement(codeWithAddedImports, filename, removableImportLocals, new Set([...removableExpressionRefs, ...extracted.dependencyNames]), options.preserveSideEffectImportLocals ?? new Set()))
+            : codeWithAddedImports,
+        processors,
+        staticValueCandidates: extracted.staticValueCandidates,
+        staticValues: extracted.staticValues,
+    };
+};