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

package/types/utils/applyOxcProcessors.js

@@ -1,1391 +1 @@
-/* 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,
-    };
-};
+export { applyOxcProcessors } from './applyOxcProcessors/applyOxcProcessors';