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

package/types/utils/oxcPreevalTransforms.js

@@ -0,0 +1,1179 @@
+/* eslint-disable no-restricted-syntax,no-continue */
+import { collectOxcExportsAndImports } from './collectOxcExportsAndImports';
+import { EventEmitter } from './EventEmitter';
+import { parseOxcProgramCached } from './parseOxc';
+const ssrCheckFields = new Set([
+    'document',
+    'location',
+    'navigator',
+    'sessionStorage',
+    'localStorage',
+    'window',
+]);
+const forbiddenGlobals = new Set([
+    ...ssrCheckFields,
+    '$RefreshReg$',
+    '$RefreshSig$',
+    'XMLHttpRequest',
+    'clearImmediate',
+    'clearInterval',
+    'clearTimeout',
+    'fetch',
+    'navigator',
+    'setImmediate',
+    'setInterval',
+    'setTimeout',
+]);
+const alwaysForbiddenIdentifiers = new Set(['$RefreshReg$', '$RefreshSig$']);
+const promiseCallbackMethods = new Set(['then', 'catch', 'finally']);
+const jsxRuntimeSources = new Set([
+    'react/jsx-runtime',
+    'react/jsx-dev-runtime',
+]);
+const defaultPlaceholder = '...';
+const defaultReactComponentTypes = [
+    'ExoticComponent',
+    'FC',
+    'ForwardRefExoticComponent',
+    'FunctionComponent',
+    'LazyExoticComponent',
+    'MemoExoticComponent',
+    'NamedExoticComponent',
+];
+const generatedProcessorHelperNameRe = /^_exp\d*$/;
+const requireCallRe = /\brequire\s*\(/;
+const windowTokenRe = /\bwindow\b/;
+const removableOwnerTypes = new Set([
+    'DoWhileStatement',
+    'ExpressionStatement',
+    'ForInStatement',
+    'ForOfStatement',
+    'ForStatement',
+    'FunctionDeclaration',
+    'IfStatement',
+    'PropertyDefinition',
+    'ReturnStatement',
+    'VariableDeclaration',
+    'WhileStatement',
+]);
+const importMetaEnvRe = /\bimport\s*\.\s*meta\s*\.\s*env\b/;
+const createScope = (parent, key) => ({
+    bindings: new Map(),
+    key,
+    names: new Set(),
+    parent,
+});
+const createsScope = (node) => node.type === 'Program' ||
+    node.type === 'BlockStatement' ||
+    node.type === 'FunctionDeclaration' ||
+    node.type === 'FunctionExpression' ||
+    node.type === 'ArrowFunctionExpression';
+const hasBinding = (scope, name) => {
+    let current = scope;
+    while (current) {
+        if (current.names.has(name)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+const getBindingKey = (scope, name) => {
+    let current = scope;
+    while (current) {
+        if (current.names.has(name)) {
+            return `${current.key}\0${name}`;
+        }
+        current = current.parent;
+    }
+    return null;
+};
+const getStaticBinding = (scope, name) => {
+    let current = scope;
+    while (current) {
+        if (current.bindings.has(name)) {
+            return current.bindings.get(name);
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+const isFileLikeRequireSpecifier = (value) => value.startsWith('.') || value.startsWith('/') || value.startsWith('file:');
+const isNode = (value) => !!value &&
+    typeof value === 'object' &&
+    'type' in value &&
+    typeof value.type === 'string';
+const getChildren = (node) => {
+    const result = [];
+    const record = node;
+    Object.keys(record).forEach((key) => {
+        if (key === 'type' || key === 'start' || key === 'end' || key === 'range') {
+            return;
+        }
+        const value = record[key];
+        if (isNode(value)) {
+            result.push(value);
+            return;
+        }
+        if (Array.isArray(value)) {
+            value.forEach((item) => {
+                if (isNode(item)) {
+                    result.push(item);
+                }
+            });
+        }
+    });
+    return result;
+};
+const parseOxc = (code, filename) => {
+    return parseOxcProgramCached(filename, code, 'unambiguous');
+};
+const unwrapExpression = (node) => {
+    if (node.type === 'TSAsExpression' ||
+        node.type === 'TSSatisfiesExpression' ||
+        node.type === 'TSNonNullExpression' ||
+        node.type === 'TSTypeAssertion' ||
+        node.type === 'ParenthesizedExpression') {
+        return unwrapExpression(node.expression);
+    }
+    return node;
+};
+const getMemberPropertyName = (node) => {
+    if (node.type !== 'MemberExpression') {
+        return null;
+    }
+    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 isStringLikeExpression = (node) => {
+    const expression = unwrapExpression(node);
+    if (expression.type === 'Literal' && typeof expression.value === 'string') {
+        return true;
+    }
+    if (expression.type === 'TemplateLiteral') {
+        return true;
+    }
+    if (expression.type === 'BinaryExpression' && expression.operator === '+') {
+        return (isStringLikeExpression(expression.left) ||
+            isStringLikeExpression(expression.right));
+    }
+    if (expression.type === 'CallExpression' &&
+        expression.callee.type === 'MemberExpression' &&
+        getMemberPropertyName(expression.callee) === 'concat') {
+        return isStringLikeExpression(expression.callee.object);
+    }
+    return false;
+};
+const templateLiteralToConcat = (code, node) => {
+    if (node.type !== 'TemplateLiteral' || node.expressions.length === 0) {
+        return code.slice(node.start, node.end);
+    }
+    const parts = [];
+    node.quasis.forEach((quasi, index) => {
+        const cooked = quasi.value.cooked ?? quasi.value.raw;
+        if (cooked !== '') {
+            parts.push(JSON.stringify(cooked));
+        }
+        const expression = node.expressions[index];
+        if (expression) {
+            parts.push(code.slice(expression.start, expression.end));
+        }
+    });
+    return parts.length > 0 ? parts.join(' + ') : '""';
+};
+const dynamicImportArgumentCode = (code, node) => {
+    if (node.type === 'TemplateLiteral') {
+        return templateLiteralToConcat(code, node);
+    }
+    return code.slice(node.start, node.end);
+};
+const evaluateStaticValue = (node, scope, seen = new Set()) => {
+    const expression = unwrapExpression(node);
+    if (expression.type === 'Literal') {
+        return expression.value;
+    }
+    if (expression.type === 'TemplateLiteral') {
+        let result = '';
+        for (let idx = 0; idx < expression.quasis.length; idx += 1) {
+            result += expression.quasis[idx]?.value.cooked ?? '';
+            const nextExpression = expression.expressions[idx];
+            if (!nextExpression) {
+                continue;
+            }
+            const value = evaluateStaticValue(nextExpression, scope, seen);
+            if (value === undefined ||
+                (typeof value !== 'string' && typeof value !== 'number')) {
+                return undefined;
+            }
+            result += String(value);
+        }
+        return result;
+    }
+    if (expression.type === 'Identifier') {
+        if (seen.has(expression.name)) {
+            return undefined;
+        }
+        const binding = getStaticBinding(scope, expression.name);
+        if (!binding) {
+            return undefined;
+        }
+        return evaluateStaticValue(binding, scope, new Set([...seen, expression.name]));
+    }
+    if (expression.type === 'BinaryExpression' && expression.operator === '+') {
+        const left = evaluateStaticValue(expression.left, scope, seen);
+        const right = evaluateStaticValue(expression.right, scope, seen);
+        if (left === undefined || right === undefined) {
+            return undefined;
+        }
+        if (typeof left === 'number' && typeof right === 'number') {
+            return left + right;
+        }
+        if ((typeof left === 'string' || typeof left === 'number') &&
+            (typeof right === 'string' || typeof right === 'number')) {
+            return `${left}${right}`;
+        }
+    }
+    if (expression.type === 'CallExpression' &&
+        expression.callee.type === 'MemberExpression') {
+        const objectValue = evaluateStaticValue(expression.callee.object, scope, seen);
+        const propertyName = getMemberPropertyName(expression.callee);
+        if (!propertyName) {
+            return undefined;
+        }
+        if (typeof objectValue === 'string') {
+            if (propertyName === 'toLowerCase' && expression.arguments.length === 0) {
+                return objectValue.toLowerCase();
+            }
+            if (propertyName === 'toUpperCase' && expression.arguments.length === 0) {
+                return objectValue.toUpperCase();
+            }
+            if (propertyName === 'trim' && expression.arguments.length === 0) {
+                return objectValue.trim();
+            }
+            if (propertyName === 'concat') {
+                const args = expression.arguments.map((argument) => argument.type === 'SpreadElement'
+                    ? undefined
+                    : evaluateStaticValue(argument, scope, seen));
+                if (args.some((value) => value === undefined) ||
+                    args.some((value) => typeof value !== 'string' && typeof value !== 'number')) {
+                    return undefined;
+                }
+                return objectValue.concat(...args.map((value) => String(value)));
+            }
+        }
+    }
+    return undefined;
+};
+const isLiteralRequireArg = (node) => {
+    const expression = unwrapExpression(node);
+    if (expression.type === 'Literal' && typeof expression.value === 'string') {
+        return true;
+    }
+    if (expression.type === 'TemplateLiteral' &&
+        expression.expressions.length === 0) {
+        return true;
+    }
+    return false;
+};
+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 isIdentifierNamed = (value, name) => isNode(value) && value.type === 'Identifier' && value.name === name;
+const isImportMeta = (node) => {
+    if (!isNode(node) || node.type !== 'MetaProperty') {
+        return false;
+    }
+    const metaProperty = node;
+    return (isIdentifierNamed(metaProperty.meta, 'import') &&
+        isIdentifierNamed(metaProperty.property, 'meta'));
+};
+const isImportMetaEnv = (node) => {
+    if (node.type !== 'MemberExpression') {
+        return false;
+    }
+    if (node.computed || !isIdentifierNamed(node.property, 'env')) {
+        return false;
+    }
+    return isImportMeta(node.object);
+};
+const collectBindingNames = (node) => {
+    if (node.type === 'Identifier') {
+        return [node.name];
+    }
+    if (node.type === 'RestElement') {
+        return collectBindingNames(node.argument);
+    }
+    if (node.type === 'AssignmentPattern') {
+        return collectBindingNames(node.left);
+    }
+    if (node.type === 'ObjectPattern') {
+        return node.properties.flatMap((property) => property.type === 'RestElement'
+            ? collectBindingNames(property.argument)
+            : collectBindingNames(property.value));
+    }
+    if (node.type === 'ArrayPattern') {
+        return node.elements.flatMap((element) => element ? collectBindingNames(element) : []);
+    }
+    if (node.type === 'TSParameterProperty') {
+        return collectBindingNames(node.parameter);
+    }
+    return [];
+};
+const predeclareScopeNames = (node, scope) => {
+    if (node.type === 'FunctionDeclaration' ||
+        node.type === 'FunctionExpression' ||
+        node.type === 'ArrowFunctionExpression') {
+        if (node.type !== 'ArrowFunctionExpression' && node.id) {
+            scope.names.add(node.id.name);
+        }
+        node.params.forEach((param) => {
+            collectBindingNames(param).forEach((name) => {
+                scope.names.add(name);
+            });
+        });
+    }
+    const visitScopeDescendants = (child) => {
+        if (child.type === 'VariableDeclarator') {
+            collectBindingNames(child.id).forEach((name) => {
+                scope.names.add(name);
+            });
+        }
+        else if (child.type === 'FunctionDeclaration' && child.id) {
+            scope.names.add(child.id.name);
+        }
+        else if (child.type === 'ClassDeclaration' && child.id) {
+            scope.names.add(child.id.name);
+        }
+        else if (child.type === 'ImportDefaultSpecifier' ||
+            child.type === 'ImportNamespaceSpecifier' ||
+            child.type === 'ImportSpecifier') {
+            scope.names.add(child.local.name);
+        }
+        if (createsScope(child)) {
+            return;
+        }
+        getChildren(child).forEach(visitScopeDescendants);
+    };
+    getChildren(node).forEach(visitScopeDescendants);
+};
+const declareBindings = (node, scope) => {
+    if (node.type === 'VariableDeclarator') {
+        const names = collectBindingNames(node.id);
+        names.forEach((name) => {
+            scope.names.add(name);
+            scope.bindings.set(name, null);
+        });
+        if (node.id.type === 'Identifier' && node.init) {
+            scope.bindings.set(node.id.name, node.init);
+        }
+        return;
+    }
+    if (node.type === 'FunctionDeclaration' && node.id) {
+        scope.names.add(node.id.name);
+        scope.bindings.set(node.id.name, null);
+    }
+    if (node.type === 'ClassDeclaration' && node.id) {
+        scope.names.add(node.id.name);
+        scope.bindings.set(node.id.name, null);
+        return;
+    }
+    if (node.type === 'ImportDefaultSpecifier' ||
+        node.type === 'ImportNamespaceSpecifier' ||
+        node.type === 'ImportSpecifier') {
+        scope.names.add(node.local.name);
+        scope.bindings.set(node.local.name, null);
+        return;
+    }
+    if (node.type === 'FunctionDeclaration' ||
+        node.type === 'FunctionExpression' ||
+        node.type === 'ArrowFunctionExpression') {
+        node.params.forEach((param) => {
+            collectBindingNames(param).forEach((name) => {
+                scope.names.add(name);
+                scope.bindings.set(name, null);
+            });
+        });
+    }
+};
+const visit = (node, scope, enter, parent = null, ancestors = []) => {
+    let currentScope = scope;
+    if (createsScope(node)) {
+        currentScope = createScope(scope, `${node.type}:${node.start}:${node.end}`);
+        predeclareScopeNames(node, currentScope);
+    }
+    declareBindings(node, currentScope);
+    enter(node, currentScope, parent, ancestors);
+    getChildren(node).forEach((child) => visit(child, currentScope, enter, node, [...ancestors, node]));
+};
+export const replaceImportMetaEnvWithOxc = (code, filename) => {
+    if (!importMetaEnvRe.test(code)) {
+        return code;
+    }
+    const replacements = [];
+    visit(parseOxc(code, filename), createScope(null, 'root'), (node) => {
+        if (!isImportMetaEnv(node)) {
+            return;
+        }
+        replacements.push({
+            end: node.end,
+            start: node.start,
+            value: '__wyw_import_meta_env',
+        });
+    });
+    return applyReplacements(code, replacements);
+};
+function collectDynamicImportAndRequireFallbackReplacements(code, filename, options) {
+    const eventEmitter = options.eventEmitter ?? EventEmitter.dummy;
+    const dynamicImportCandidates = [];
+    const requireFallbackCandidates = [];
+    eventEmitter.perf('transform:preeval:dynamicImportRequireFallback:scan', () => {
+        visit(parseOxc(code, filename), createScope(null, 'root'), (node, scope) => {
+            if (options.rewriteDynamicImports &&
+                node.type === 'ImportExpression') {
+                dynamicImportCandidates.push(node);
+            }
+            if (!options.addRequireFallback || node.type !== 'CallExpression') {
+                return;
+            }
+            const call = node;
+            if (call.callee.type !== 'Identifier' ||
+                call.callee.name !== 'require' ||
+                hasBinding(scope, 'require') ||
+                call.arguments.length !== 1) {
+                return;
+            }
+            const [firstArg] = call.arguments;
+            if (!firstArg ||
+                firstArg.type === 'SpreadElement' ||
+                isLiteralRequireArg(firstArg)) {
+                return;
+            }
+            requireFallbackCandidates.push({
+                call,
+                scope,
+            });
+        });
+    });
+    const replacements = [];
+    eventEmitter.perf('transform:preeval:dynamicImport', () => {
+        dynamicImportCandidates.forEach((importExpression) => {
+            const argument = importExpression.source;
+            const nextArgument = isStringLikeExpression(argument)
+                ? unwrapExpression(argument)
+                : argument;
+            replacements.push({
+                end: importExpression.end,
+                start: importExpression.start,
+                value: `__wyw_dynamic_import(${dynamicImportArgumentCode(code, nextArgument)})`,
+            });
+        });
+    });
+    eventEmitter.perf('transform:preeval:requireFallback', () => {
+        requireFallbackCandidates.forEach(({ call, scope }) => {
+            const [firstArg] = call.arguments;
+            if (!firstArg || firstArg.type === 'SpreadElement') {
+                return;
+            }
+            const staticValue = evaluateStaticValue(firstArg, scope);
+            if (typeof staticValue === 'string' &&
+                isFileLikeRequireSpecifier(staticValue)) {
+                replacements.push({
+                    end: firstArg.end,
+                    start: firstArg.start,
+                    value: JSON.stringify(staticValue),
+                });
+                return;
+            }
+            replacements.push({
+                end: firstArg.end,
+                start: firstArg.end,
+                value: ', true',
+            });
+        });
+    });
+    return replacements;
+}
+export const rewriteDynamicImportsWithOxc = (code, filename) => {
+    const replacements = collectDynamicImportAndRequireFallbackReplacements(code, filename, {
+        addRequireFallback: false,
+        rewriteDynamicImports: true,
+    });
+    return applyReplacements(code, replacements);
+};
+export const addRequireFallbackWithOxc = (code, filename) => {
+    const replacements = collectDynamicImportAndRequireFallbackReplacements(code, filename, {
+        addRequireFallback: true,
+        rewriteDynamicImports: false,
+    });
+    return applyReplacements(code, replacements);
+};
+export const rewriteDynamicImportsAndAddRequireFallbackWithOxc = (code, filename, options) => {
+    const replacements = collectDynamicImportAndRequireFallbackReplacements(code, filename, options);
+    return applyReplacements(code, replacements);
+};
+const isBindingPosition = (node, parent) => {
+    if (!parent) {
+        return false;
+    }
+    if (parent.type === 'VariableDeclarator' && parent.id === node) {
+        return true;
+    }
+    if ((parent.type === 'FunctionDeclaration' ||
+        parent.type === 'FunctionExpression' ||
+        parent.type === 'ClassDeclaration' ||
+        parent.type === 'ClassExpression') &&
+        parent.id === node) {
+        return true;
+    }
+    if (parent.type === 'ImportSpecifier' &&
+        (parent.local === node || parent.imported === node)) {
+        return true;
+    }
+    if ((parent.type === 'ImportDefaultSpecifier' ||
+        parent.type === 'ImportNamespaceSpecifier') &&
+        parent.local === node) {
+        return true;
+    }
+    if (parent.type === 'ExportSpecifier' &&
+        (parent.local === node || parent.exported === node)) {
+        return true;
+    }
+    return false;
+};
+const isPropertyOnlyIdentifier = (node, parent) => {
+    if (!parent) {
+        return false;
+    }
+    if (parent.type === 'MemberExpression' &&
+        !parent.computed &&
+        parent.property === node) {
+        return true;
+    }
+    if ((parent.type === 'Property' ||
+        parent.type === 'MethodDefinition' ||
+        parent.type === 'PropertyDefinition') &&
+        !parent.computed &&
+        parent.key === node) {
+        return true;
+    }
+    return false;
+};
+const isTypeContext = (ancestors) => ancestors.some((ancestor) => ancestor.type.startsWith('TS') || ancestor.type.startsWith('JSDoc'));
+const isInsideTypeof = (ancestors) => ancestors.some((ancestor) => ancestor.type === 'UnaryExpression' && ancestor.operator === 'typeof');
+const isInsideImportDeclaration = (ancestors) => ancestors.some((ancestor) => ancestor.type === 'ImportDeclaration');
+function findLastAncestor(ancestors, predicate) {
+    for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+        const ancestor = ancestors[idx];
+        if (predicate(ancestor)) {
+            return ancestor;
+        }
+    }
+    return null;
+}
+const findRemovableOwner = (node, ancestors) => {
+    let owner = node;
+    let ownerAncestorIndex = -1;
+    if (!removableOwnerTypes.has(node.type)) {
+        for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+            const ancestor = ancestors[idx];
+            if (removableOwnerTypes.has(ancestor.type)) {
+                owner = ancestor;
+                ownerAncestorIndex = idx;
+                break;
+            }
+        }
+    }
+    const parent = ownerAncestorIndex > 0 ? ancestors[ownerAncestorIndex - 1] : null;
+    if (parent?.type === 'ExportNamedDeclaration' &&
+        'declaration' in parent &&
+        parent.declaration === owner) {
+        return parent;
+    }
+    return owner;
+};
+const collectReExportedLocalNames = (program) => {
+    const names = new Set();
+    for (const stmt of program.body) {
+        if (stmt.type !== 'ExportNamedDeclaration' ||
+            stmt.declaration ||
+            stmt.source) {
+            continue;
+        }
+        for (const spec of stmt.specifiers) {
+            if (spec.type === 'ExportSpecifier' && spec.local.type === 'Identifier') {
+                names.add(spec.local.name);
+            }
+        }
+    }
+    return names;
+};
+// When an offending identifier sits inside the value of a top-level export,
+// removing the surrounding declaration would strip the export binding too.
+// ESM linker then fails on consumers' `import { name } from '...'` because the
+// named export no longer exists. To keep the binding alive, replace just the
+// value (declarator init or default-export expression) with `undefined`.
+const findExportedBindingProtection = (node, ancestors, reExportedLocalNames) => {
+    for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+        const ancestor = ancestors[idx];
+        if (ancestor.type === 'ExportDefaultDeclaration') {
+            const decl = ancestor.declaration;
+            if (decl && decl !== node && 'start' in decl && 'end' in decl) {
+                return { start: decl.start, end: decl.end, value: 'undefined' };
+            }
+            return null;
+        }
+        if (ancestor.type !== 'VariableDeclarator') {
+            continue;
+        }
+        if (ancestor.id.type !== 'Identifier' ||
+            !ancestor.init ||
+            ancestor.init === node) {
+            return null;
+        }
+        const varDecl = ancestors[idx - 1];
+        const wrapper = ancestors[idx - 2] ?? null;
+        if (varDecl?.type !== 'VariableDeclaration') {
+            return null;
+        }
+        const isDirectExport = wrapper?.type === 'ExportNamedDeclaration' &&
+            wrapper.declaration === varDecl;
+        const isTopLevelDeclaration = wrapper === null || wrapper?.type === 'Program';
+        const isReExported = isTopLevelDeclaration && reExportedLocalNames.has(ancestor.id.name);
+        if (!isDirectExport && !isReExported) {
+            return null;
+        }
+        return {
+            start: ancestor.init.start,
+            end: ancestor.init.end,
+            value: 'undefined',
+        };
+    }
+    return null;
+};
+const findPromiseCallbackOwner = (ancestors) => {
+    for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+        const ancestor = ancestors[idx];
+        if (ancestor.type === 'NewExpression' &&
+            ancestor.callee.type === 'Identifier' &&
+            ancestor.callee.name === 'Promise') {
+            return ancestor;
+        }
+        if (ancestor.type === 'CallExpression' &&
+            ancestor.callee.type === 'MemberExpression' &&
+            promiseCallbackMethods.has(getMemberPropertyName(ancestor.callee) ?? '')) {
+            return ancestor;
+        }
+    }
+    return null;
+};
+const containsForbiddenIdentifier = (node) => {
+    if (node.type === 'Identifier' && alwaysForbiddenIdentifiers.has(node.name)) {
+        return true;
+    }
+    return getChildren(node).some(containsForbiddenIdentifier);
+};
+const collectWindowScopedNames = (program) => {
+    const windowScopedNames = new Set();
+    visit(program, createScope(null, 'root'), (node, scope) => {
+        if (node.type !== 'MemberExpression' ||
+            node.object.type !== 'Identifier' ||
+            node.object.name !== 'window' ||
+            hasBinding(scope, 'window')) {
+            return;
+        }
+        const propertyName = getMemberPropertyName(node);
+        if (propertyName) {
+            windowScopedNames.add(propertyName);
+        }
+    });
+    return windowScopedNames;
+};
+const containsForbiddenReference = (node, scope, windowScopedNames, derivedForbiddenBindings = new Set()) => {
+    let found = false;
+    visit(node, scope, (child, childScope, parent, ancestors) => {
+        if (found ||
+            child.type !== 'Identifier' ||
+            isTypeContext(ancestors) ||
+            isInsideTypeof(ancestors) ||
+            isPropertyOnlyIdentifier(child, parent) ||
+            isBindingPosition(child, parent)) {
+            return;
+        }
+        const bindingKey = getBindingKey(childScope, child.name);
+        if (alwaysForbiddenIdentifiers.has(child.name) ||
+            (forbiddenGlobals.has(child.name) &&
+                !hasBinding(childScope, child.name)) ||
+            (windowScopedNames.has(child.name) &&
+                !hasBinding(childScope, child.name)) ||
+            (bindingKey !== null && derivedForbiddenBindings.has(bindingKey))) {
+            found = true;
+        }
+    });
+    return found;
+};
+const nameFromModuleExport = (node) => {
+    if (node.type === 'Identifier') {
+        return node.name;
+    }
+    if (node.type === 'Literal' && typeof node.value === 'string') {
+        return node.value;
+    }
+    return null;
+};
+const collectImportBindings = (code, filename, program) => {
+    const bindings = new Map();
+    const addBinding = (binding) => {
+        bindings.set(`${binding.local}\0${binding.source}\0${binding.imported}`, binding);
+    };
+    program.body.forEach((statement) => {
+        if (statement.type !== 'ImportDeclaration') {
+            return;
+        }
+        const source = statement.source.value;
+        statement.specifiers.forEach((specifier) => {
+            if (specifier.type === 'ImportDefaultSpecifier') {
+                addBinding({
+                    imported: 'default',
+                    local: specifier.local.name,
+                    source,
+                });
+                return;
+            }
+            if (specifier.type === 'ImportNamespaceSpecifier') {
+                addBinding({
+                    imported: '*',
+                    local: specifier.local.name,
+                    source,
+                });
+                return;
+            }
+            const imported = nameFromModuleExport(specifier.imported);
+            if (!imported) {
+                return;
+            }
+            addBinding({
+                imported,
+                local: specifier.local.name,
+                source,
+            });
+        });
+    });
+    if (!requireCallRe.test(code)) {
+        return [...bindings.values()];
+    }
+    collectOxcExportsAndImports(code, filename).imports.forEach((item) => {
+        if (item.imported === 'side-effect') {
+            return;
+        }
+        addBinding({
+            imported: item.imported,
+            local: item.local.code,
+            source: item.source,
+        });
+        if (item.local.name && item.local.name !== item.local.code) {
+            addBinding({
+                imported: item.imported,
+                local: item.local.name,
+                source: item.source,
+            });
+        }
+    });
+    return [...bindings.values()];
+};
+const getImportBinding = (imports, local) => imports.find((item) => item.local === local);
+function unwrapSequenceCallee(node) {
+    if (node.type === 'SequenceExpression' &&
+        node.expressions.length === 2 &&
+        node.expressions[0]?.type === 'Literal' &&
+        node.expressions[0].value === 0) {
+        return node.expressions[1];
+    }
+    return node;
+}
+const getExpressionImportKey = (node) => {
+    const expression = unwrapSequenceCallee(node);
+    if (expression.type === 'Identifier') {
+        return expression.name;
+    }
+    if (expression.type !== 'MemberExpression') {
+        return null;
+    }
+    if (expression.object.type !== 'Identifier') {
+        return null;
+    }
+    const propertyName = getMemberPropertyName(expression);
+    return propertyName ? `${expression.object.name}.${propertyName}` : null;
+};
+const isHookOrCreateElement = (name) => name === 'createElement' || /use[A-Z]/.test(name);
+const getInnermostCallee = (call) => {
+    let callee = unwrapSequenceCallee(call.callee);
+    while (callee.type === 'CallExpression') {
+        callee = unwrapSequenceCallee(callee.callee);
+    }
+    return callee;
+};
+const getImportForExpression = (node, imports) => {
+    const expression = unwrapSequenceCallee(node);
+    const directMatchKey = getExpressionImportKey(expression);
+    if (directMatchKey) {
+        const directMatch = getImportBinding(imports, directMatchKey);
+        if (directMatch) {
+            return [directMatch.source, directMatch.imported];
+        }
+    }
+    if (expression.type === 'Identifier') {
+        const matched = getImportBinding(imports, expression.name);
+        return matched ? [matched.source, matched.imported] : undefined;
+    }
+    if (expression.type !== 'MemberExpression') {
+        return undefined;
+    }
+    if (expression.object.type !== 'Identifier') {
+        return undefined;
+    }
+    const propertyName = getMemberPropertyName(expression);
+    if (!propertyName) {
+        return undefined;
+    }
+    const objectImport = getImportBinding(imports, expression.object.name);
+    if (!objectImport) {
+        return undefined;
+    }
+    if (objectImport.imported === 'default' ||
+        objectImport.imported === '*' ||
+        objectImport.source === 'react') {
+        return [objectImport.source, propertyName];
+    }
+    return undefined;
+};
+const isReactRuntimeCall = (call, imports) => {
+    const callee = unwrapSequenceCallee(call.callee);
+    const matched = getImportForExpression(callee, imports);
+    if (!matched) {
+        return false;
+    }
+    const [source, imported] = matched;
+    if (jsxRuntimeSources.has(source)) {
+        return true;
+    }
+    return source === 'react' && isHookOrCreateElement(imported);
+};
+const isHocCall = (call, hocs, imports) => {
+    const matched = getImportForExpression(getInnermostCallee(call), imports);
+    return !!matched && hocs[matched[0]]?.includes(matched[1]);
+};
+const getComponentTypes = (options) => {
+    const componentTypes = {
+        ...(options?.componentTypes ?? { react: [defaultPlaceholder] }),
+    };
+    const reactTypes = componentTypes.react;
+    if (Array.isArray(reactTypes) && reactTypes.includes(defaultPlaceholder)) {
+        const idx = reactTypes.indexOf(defaultPlaceholder);
+        componentTypes.react = [...reactTypes];
+        componentTypes.react.splice(idx, 1, ...defaultReactComponentTypes);
+    }
+    return componentTypes;
+};
+const getTypeImport = (node, imports) => {
+    if (node.type === 'Identifier') {
+        const matched = getImportBinding(imports, node.name);
+        return matched ? [matched.source, matched.imported] : undefined;
+    }
+    if (node.type !== 'TSQualifiedName') {
+        return undefined;
+    }
+    if (node.left.type !== 'Identifier') {
+        return undefined;
+    }
+    const matched = getImportBinding(imports, node.left.name);
+    return matched ? [matched.source, node.right.name] : undefined;
+};
+const isComponentTypeMatch = (id, componentTypes, imports) => {
+    if (id.type !== 'Identifier') {
+        return false;
+    }
+    const annotation = id.typeAnnotation;
+    if (!annotation ||
+        annotation.type !== 'TSTypeAnnotation' ||
+        annotation.typeAnnotation.type !== 'TSTypeReference') {
+        return false;
+    }
+    const matched = getTypeImport(annotation.typeAnnotation.typeName, imports);
+    return !!matched && componentTypes[matched[0]]?.includes(matched[1]);
+};
+const getClassName = (node) => node.type === 'ClassDeclaration' && node.id ? node.id.name : null;
+const isFunctionLikeNode = (node) => node.type === 'FunctionDeclaration' ||
+    node.type === 'FunctionExpression' ||
+    node.type === 'ArrowFunctionExpression';
+const isImmediatelyInvokedFunction = (fnNode, ancestors, fnIndex) => {
+    // Walk past any ParenthesizedExpression / SequenceExpression wrappers that
+    // sit between the function and its enclosing CallExpression. oxc-parser
+    // preserves ParenthesizedExpression nodes, so `(() => {...})()` shows up
+    // as CallExpression -> ParenthesizedExpression -> ArrowFunctionExpression.
+    let child = fnNode;
+    for (let idx = fnIndex - 1; idx >= 0; idx -= 1) {
+        const ancestor = ancestors[idx];
+        if (ancestor.type === 'ParenthesizedExpression' &&
+            'expression' in ancestor &&
+            ancestor.expression === child) {
+            child = ancestor;
+            continue;
+        }
+        if (ancestor.type === 'SequenceExpression' &&
+            Array.isArray(ancestor.expressions) &&
+            ancestor.expressions[ancestor.expressions.length - 1] === child) {
+            child = ancestor;
+            continue;
+        }
+        return ancestor.type === 'CallExpression' && ancestor.callee === child;
+    }
+    return false;
+};
+// A reference is "deferred" when it lives inside a function body that is
+// not immediately invoked. Module preeval reads exports without calling
+// them, so deferred references never run and must not be sanitized — that
+// would silently drop the binding (or remove the entire export) and break
+// importers that expect the function to be callable.
+const isInDeferredFunctionScope = (ancestors) => {
+    for (let idx = ancestors.length - 1; idx >= 0; idx -= 1) {
+        const ancestor = ancestors[idx];
+        if (!isFunctionLikeNode(ancestor)) {
+            continue;
+        }
+        if (!isImmediatelyInvokedFunction(ancestor, ancestors, idx)) {
+            return true;
+        }
+    }
+    return false;
+};
+const findFunctionReplacement = (ancestors) => {
+    const renderMethod = findLastAncestor(ancestors, (ancestor) => ancestor.type === 'MethodDefinition' &&
+        ancestor.key.type === 'Identifier' &&
+        ancestor.key.name === 'render');
+    if (renderMethod) {
+        const classDecl = findLastAncestor(ancestors, (ancestor) => ancestor.type === 'ClassDeclaration');
+        const className = classDecl ? getClassName(classDecl) : null;
+        if (classDecl && className) {
+            return {
+                start: classDecl.start,
+                end: classDecl.end,
+                value: `function ${className}() { return null; }`,
+            };
+        }
+    }
+    const functionNode = findLastAncestor(ancestors, isFunctionLikeNode);
+    if (!functionNode) {
+        return null;
+    }
+    if (functionNode.type === 'ArrowFunctionExpression') {
+        return {
+            start: functionNode.start,
+            end: functionNode.end,
+            value: `${functionNode.async ? 'async ' : ''}() => { return null; }`,
+        };
+    }
+    if (functionNode.type === 'FunctionDeclaration') {
+        return {
+            start: functionNode.start,
+            end: functionNode.end,
+            value: `${functionNode.async ? 'async ' : ''}function ${functionNode.id?.name ?? ''}() { return null; }`,
+        };
+    }
+    return {
+        start: functionNode.body.start,
+        end: functionNode.body.end,
+        value: '{ return null; }',
+    };
+};
+const normalizeReplacements = (replacements) => {
+    const sorted = [...replacements].sort((a, b) => a.start === b.start ? b.end - a.end : a.start - b.start);
+    const result = [];
+    sorted.forEach((replacement) => {
+        const last = result[result.length - 1];
+        if (last &&
+            replacement.start >= last.start &&
+            replacement.end <= last.end) {
+            return;
+        }
+        result.push(replacement);
+    });
+    return result;
+};
+export const removeDangerousCodeWithOxc = (code, filename, options) => {
+    const replacements = [];
+    const derivedForbiddenBindings = new Set();
+    const program = parseOxc(code, filename);
+    const imports = collectImportBindings(code, filename, program);
+    const componentTypes = getComponentTypes(options);
+    const hocs = options?.hocs ?? {};
+    const hasHocs = Object.keys(hocs).length > 0;
+    const windowScopedNames = windowTokenRe.test(code)
+        ? collectWindowScopedNames(program)
+        : new Set();
+    const reExportedLocalNames = collectReExportedLocalNames(program);
+    const derivedBindingDiscovery = { found: true };
+    while (derivedBindingDiscovery.found) {
+        derivedBindingDiscovery.found = false;
+        visit(program, createScope(null, 'root'), (node, scope) => {
+            if (node.type !== 'VariableDeclarator' ||
+                node.id.type !== 'Identifier' ||
+                !node.init) {
+                return;
+            }
+            const bindingKey = getBindingKey(scope, node.id.name);
+            if (!bindingKey || derivedForbiddenBindings.has(bindingKey)) {
+                return;
+            }
+            if (containsForbiddenIdentifier(node.init) ||
+                containsForbiddenReference(node.init, scope, windowScopedNames, derivedForbiddenBindings)) {
+                derivedForbiddenBindings.add(bindingKey);
+                derivedBindingDiscovery.found = true;
+            }
+        });
+    }
+    visit(program, createScope(null, 'root'), (node, scope, parent, ancestors) => {
+        if (node.type === 'JSXElement' || node.type === 'JSXFragment') {
+            replacements.push(findFunctionReplacement(ancestors) ?? {
+                start: node.start,
+                end: node.end,
+                value: 'null',
+            });
+            return;
+        }
+        if (node.type === 'CallExpression') {
+            if (isReactRuntimeCall(node, imports)) {
+                const replacement = findFunctionReplacement(ancestors);
+                if (replacement) {
+                    replacements.push(replacement);
+                }
+                return;
+            }
+            if (hasHocs && isHocCall(node, hocs, imports)) {
+                replacements.push({
+                    start: node.start,
+                    end: node.end,
+                    value: '() => null',
+                });
+                return;
+            }
+        }
+        if (node.type === 'VariableDeclarator' &&
+            node.id.type === 'Identifier' &&
+            node.init &&
+            isComponentTypeMatch(node.id, componentTypes, imports)) {
+            replacements.push({
+                start: node.init.start,
+                end: node.init.end,
+                value: '() => null',
+            });
+            return;
+        }
+        if (node.type === 'UnaryExpression' &&
+            node.operator === 'typeof' &&
+            node.argument.type === 'Identifier' &&
+            ssrCheckFields.has(node.argument.name) &&
+            !hasBinding(scope, node.argument.name)) {
+            replacements.push({
+                start: node.start,
+                end: node.end,
+                value: '"undefined"',
+            });
+            return;
+        }
+        if (node.type === 'MetaProperty') {
+            const owner = findRemovableOwner(node, ancestors);
+            replacements.push({ start: owner.start, end: owner.end, value: '' });
+            return;
+        }
+        if (node.type !== 'Identifier' ||
+            isTypeContext(ancestors) ||
+            isInsideTypeof(ancestors) ||
+            isInsideImportDeclaration(ancestors)) {
+            return;
+        }
+        if (isPropertyOnlyIdentifier(node, parent)) {
+            return;
+        }
+        const isAlwaysForbidden = alwaysForbiddenIdentifiers.has(node.name);
+        const bindingKey = getBindingKey(scope, node.name);
+        const isDerivedForbidden = bindingKey !== null && derivedForbiddenBindings.has(bindingKey);
+        const isWindowScoped = windowScopedNames.has(node.name) && !hasBinding(scope, node.name);
+        const isForbiddenGlobal = forbiddenGlobals.has(node.name) && !hasBinding(scope, node.name);
+        if (!isAlwaysForbidden &&
+            !isDerivedForbidden &&
+            !isWindowScoped &&
+            !isForbiddenGlobal) {
+            return;
+        }
+        if (!isAlwaysForbidden && isInDeferredFunctionScope(ancestors)) {
+            return;
+        }
+        if (isBindingPosition(node, parent) && !isAlwaysForbidden) {
+            return;
+        }
+        if (parent?.type === 'ExportDefaultDeclaration' &&
+            parent.declaration === node) {
+            return;
+        }
+        if (generatedProcessorHelperNameRe.test(node.name) &&
+            hasBinding(scope, node.name)) {
+            return;
+        }
+        const generatedHelperDeclarator = findLastAncestor(ancestors, (ancestor) => ancestor.type === 'VariableDeclarator' &&
+            ancestor.id.type === 'Identifier' &&
+            generatedProcessorHelperNameRe.test(ancestor.id.name));
+        if (generatedHelperDeclarator) {
+            return;
+        }
+        if (parent?.type === 'Property' &&
+            parent.value === node &&
+            hasBinding(scope, node.name)) {
+            return;
+        }
+        if (parent?.type === 'Property' && parent.value === node) {
+            replacements.push({
+                start: node.start,
+                end: node.end,
+                value: parent.shorthand ? `${node.name}: undefined` : 'undefined',
+            });
+            return;
+        }
+        const grandparent = ancestors[ancestors.length - 2] ?? null;
+        if (parent?.type === 'MemberExpression' &&
+            parent.object === node &&
+            grandparent?.type === 'SpreadElement' &&
+            grandparent.argument === parent) {
+            replacements.push({
+                start: grandparent.start,
+                end: grandparent.end,
+                value: '...{}',
+            });
+            return;
+        }
+        const exportProtection = findExportedBindingProtection(node, ancestors, reExportedLocalNames);
+        if (exportProtection) {
+            replacements.push(exportProtection);
+            return;
+        }
+        const promiseOwner = findPromiseCallbackOwner(ancestors);
+        const owner = promiseOwner
+            ? findRemovableOwner(promiseOwner, ancestors)
+            : findRemovableOwner(node, ancestors);
+        replacements.push({ start: owner.start, end: owner.end, value: '' });
+    });
+    return applyReplacements(code, normalizeReplacements(replacements));
+};