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

package/types/utils/applyOxcProcessors/cleanupBindings.js

@@ -0,0 +1,189 @@
+/* eslint-disable no-restricted-syntax */
+import { isNotNull } from '../isNotNull';
+import { getOxcNodeChildren, isOxcNode, walkOxc } from '../oxc/ast';
+export const collectUsedNames = (program) => {
+    const names = new Set();
+    walkOxc(program, (node) => {
+        if (node.type === 'Identifier') {
+            names.add(node.name);
+        }
+    });
+    return names;
+};
+export 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;
+};
+export 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);
+        }
+        getOxcNodeChildren(node).forEach((child) => walk(child, node));
+    };
+    walk(root);
+    return names;
+};
+export const collectImportLocalNames = (node) => {
+    if (node.type !== 'ImportDeclaration') {
+        return [];
+    }
+    const { specifiers } = node;
+    if (!Array.isArray(specifiers)) {
+        return [];
+    }
+    return specifiers
+        .map((specifier) => {
+        const { local } = specifier;
+        return isOxcNode(local) &&
+            'name' in local &&
+            typeof local.name === 'string'
+            ? local.name
+            : null;
+    })
+        .filter(isNotNull);
+};
+export const getImportSpecifierLocalName = (node) => {
+    const { local } = node;
+    return isOxcNode(local) && 'name' in local && typeof local.name === 'string'
+        ? local.name
+        : null;
+};
+export 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 [];
+};
+export 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 (isOxcNode(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 (isOxcNode(id) && id.type === 'Identifier') {
+            bindings.add(id.name);
+        }
+        return bindings;
+    }
+    if (statement.type === 'ExportNamedDeclaration') {
+        const { declaration } = statement;
+        return isOxcNode(declaration)
+            ? collectTopLevelBindings(declaration)
+            : bindings;
+    }
+    return bindings;
+};
+export const collectTopLevelStatementInfos = (program) => program.body.map((statement) => ({
+    bindings: collectTopLevelBindings(statement),
+    node: statement,
+    references: collectReferencedNames(statement),
+}));
+export const collectTopLevelBindingsFromStatements = (statements) => new Set(statements.flatMap((statement) => [...statement.bindings]));
+export 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;
+};

package/types/utils/applyOxcProcessors/cleanupRemovals.d.ts

@@ -0,0 +1,16 @@
+import type { Program } from 'oxc-parser';
+import type { Replacement, ScopedBindingInfo, ScopedCleanupScope, TopLevelStatementInfo } from './types';
+export declare const createScopedCleanupScope: (parent: ScopedCleanupScope | null) => ScopedCleanupScope;
+export declare const resolveScopedBinding: (scope: ScopedCleanupScope, name: string) => string | null;
+export declare const collectScopedBindingInfos: (program: Program) => Map<string, ScopedBindingInfo>;
+export declare const collectScopedRemovableBindingIds: (bindings: Map<string, ScopedBindingInfo>, initialNames: Set<string>) => Set<string>;
+export declare function expandImportRemovalRange(code: string, start: number, end: number): Replacement;
+export declare const collectUnusedScopedDeclarationRemovals: (code: string, bindings: Map<string, ScopedBindingInfo>, initialRemovableNames: Set<string>) => Replacement[];
+export declare const expandImportSpecifierRemovalRange: (code: string, start: number, end: number) => Replacement;
+export declare const mergeEmptyRemovalRanges: (removals: Replacement[]) => Replacement[];
+export declare const collectUnusedImportRemovals: (code: string, program: Program, referencedNames: Set<string>, removableNames: Set<string>, preserveSideEffectImportLocals: Set<string>) => Replacement[];
+export declare const collectUnusedTopLevelDeclarationRemovals: (code: string, program: Program, referencedNames: Set<string>, removableNames: Set<string>) => Replacement[];
+export declare const collectUnusedGeneratedHelperDeclarationRemovals: (code: string, program: Program, referencedNames: Set<string>) => Replacement[];
+export declare const collectTopLevelExpressionStatementRemovals: (code: string, statements: TopLevelStatementInfo[], topLevelBindings: Set<string>, removableExpressionRefs: Set<string>) => Replacement[];
+export declare const collectEmptyTopLevelBlockRemovals: (code: string, program: Program) => Replacement[];
+export declare const removeUnusedAfterReplacement: (code: string, filename: string, initialRemovableNames: Set<string>, removableExpressionRefs: Set<string>, preserveSideEffectImportLocals: Set<string>) => string;

package/types/utils/applyOxcProcessors/cleanupRemovals.js

@@ -0,0 +1,482 @@
+/* eslint-disable no-restricted-syntax,no-continue */
+import { getOxcNodeChildren, isOxcNode } from '../oxc/ast';
+import { applyOxcReplacements } from '../oxc/replacements';
+import { collectDeclaredNames, collectImportLocalNames, collectReferencedNames, collectRemovableNamesFromStatements, collectTopLevelBindings, collectTopLevelBindingsFromStatements, collectTopLevelStatementInfos, getImportSpecifierLocalName, isNodeReference, } from './cleanupBindings';
+import { GENERATED_HELPER_NAME_RE, parseOxc } from './shared';
+export const createScopedCleanupScope = (parent) => ({
+    bindings: new Map(),
+    parent,
+});
+export const resolveScopedBinding = (scope, name) => {
+    let current = scope;
+    while (current) {
+        const bindingId = current.bindings.get(name);
+        if (bindingId) {
+            return bindingId;
+        }
+        current = current.parent;
+    }
+    return null;
+};
+export 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 && isOxcNode(property.key)) {
+                    walk(property.key, scope, property, ownerBindingId);
+                }
+                walkPatternReferenceSubexpressions(property.value, scope, ownerBindingId);
+            });
+            return;
+        }
+        if (node.type === 'ArrayPattern') {
+            node.elements.forEach((element) => {
+                if (element && isOxcNode(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 (isOxcNode(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 (isOxcNode(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 (isOxcNode(id)) {
+                    addPatternBindings(scope, id, 'variable', node);
+                }
+            });
+            declarations.forEach((declarator) => {
+                const { id } = declarator;
+                const { init } = declarator;
+                if (!isOxcNode(id) || !isOxcNode(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);
+            getOxcNodeChildren(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);
+        }
+        getOxcNodeChildren(node).forEach((child) => walk(child, scope, node, ownerBindingId));
+    };
+    walk(program, createScopedCleanupScope(null));
+    return bindings;
+};
+export 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;
+};
+export 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: '',
+    };
+}
+export 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()];
+};
+export 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: '',
+    };
+};
+export 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;
+};
+export 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 (!isOxcNode(specifier)) {
+                return;
+            }
+            const localName = getImportSpecifierLocalName(specifier);
+            if (localName &&
+                removableNames.has(localName) &&
+                !referencedNames.has(localName)) {
+                removals.push(expandImportSpecifierRemovalRange(code, specifier.start, specifier.end));
+            }
+        });
+    });
+    return removals;
+};
+export 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;
+};
+export 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;
+};
+export 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;
+};
+export 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;
+};
+export 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(applyOxcReplacements(current, removals))
+                : current;
+        if (current === previous) {
+            return current;
+        }
+    }
+    return current;
+};