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

package/types/utils/oxcEmit.js

@@ -0,0 +1,506 @@
+/* eslint-disable no-restricted-syntax */
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { parseSync } from 'oxc-parser';
+let oxcTransform = null;
+const getCommonJsFilename = () => typeof __filename === 'string' ? __filename : null;
+const getCurrentFilenameFromStack = () => {
+    const { stack } = new Error();
+    const match = stack?.match(/(?:\(|\s)(file:\/\/[^)\s]+\/oxcEmit\.(?:js|ts)|\/[^)\s]+\/oxcEmit\.(?:js|ts)):\d+:\d+/);
+    const filename = match?.[1];
+    if (!filename) {
+        return null;
+    }
+    return filename.startsWith('file://') ? fileURLToPath(filename) : filename;
+};
+const getNativeBindingCandidates = () => {
+    const { arch, platform } = process;
+    if (platform === 'darwin') {
+        return arch === 'arm64'
+            ? [
+                './transform.darwin-universal.node',
+                '@oxc-transform/binding-darwin-universal',
+                './transform.darwin-arm64.node',
+                '@oxc-transform/binding-darwin-arm64',
+            ]
+            : [
+                './transform.darwin-universal.node',
+                '@oxc-transform/binding-darwin-universal',
+                './transform.darwin-x64.node',
+                '@oxc-transform/binding-darwin-x64',
+            ];
+    }
+    if (platform === 'win32') {
+        if (arch === 'arm64') {
+            return [
+                './transform.win32-arm64-msvc.node',
+                '@oxc-transform/binding-win32-arm64-msvc',
+            ];
+        }
+        return [
+            './transform.win32-x64-msvc.node',
+            '@oxc-transform/binding-win32-x64-msvc',
+        ];
+    }
+    if (platform === 'linux') {
+        if (arch === 'arm64') {
+            return [
+                './transform.linux-arm64-gnu.node',
+                '@oxc-transform/binding-linux-arm64-gnu',
+                './transform.linux-arm64-musl.node',
+                '@oxc-transform/binding-linux-arm64-musl',
+            ];
+        }
+        if (arch === 'arm') {
+            return [
+                './transform.linux-arm-gnueabihf.node',
+                '@oxc-transform/binding-linux-arm-gnueabihf',
+                './transform.linux-arm-musleabihf.node',
+                '@oxc-transform/binding-linux-arm-musleabihf',
+            ];
+        }
+        if (arch === 's390x') {
+            return [
+                './transform.linux-s390x-gnu.node',
+                '@oxc-transform/binding-linux-s390x-gnu',
+            ];
+        }
+        if (arch === 'riscv64') {
+            return [
+                './transform.linux-riscv64-gnu.node',
+                '@oxc-transform/binding-linux-riscv64-gnu',
+                './transform.linux-riscv64-musl.node',
+                '@oxc-transform/binding-linux-riscv64-musl',
+            ];
+        }
+        return [
+            './transform.linux-x64-gnu.node',
+            '@oxc-transform/binding-linux-x64-gnu',
+            './transform.linux-x64-musl.node',
+            '@oxc-transform/binding-linux-x64-musl',
+        ];
+    }
+    if (platform === 'freebsd') {
+        return [
+            './transform.freebsd-x64.node',
+            '@oxc-transform/binding-freebsd-x64',
+        ];
+    }
+    if (platform === 'android') {
+        return [
+            './transform.android-arm64.node',
+            '@oxc-transform/binding-android-arm64',
+        ];
+    }
+    return [];
+};
+const loadNativeOxcTransform = (requireFromHere) => {
+    const requireFromOxc = createRequire(requireFromHere.resolve('oxc-transform'));
+    const errors = [];
+    for (const candidate of [
+        ...getNativeBindingCandidates(),
+        './transform.wasi.cjs',
+        '@oxc-transform/binding-wasm32-wasi',
+    ]) {
+        try {
+            return requireFromOxc(candidate);
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    throw new Error('[wyw-in-js] Cannot load oxc-transform native binding.', {
+        cause: errors,
+    });
+};
+const loadOxcTransform = () => {
+    if (!oxcTransform) {
+        const filename = getCommonJsFilename() ??
+            getCurrentFilenameFromStack() ??
+            `${process.cwd()}/package.json`;
+        const requireFromHere = createRequire(filename);
+        let oxcTransformModule;
+        try {
+            oxcTransformModule = requireFromHere('oxc-transform');
+        }
+        catch {
+            oxcTransformModule = loadNativeOxcTransform(requireFromHere);
+        }
+        const syncTransform = oxcTransformModule.transformSync ?? oxcTransformModule.transform;
+        if (!syncTransform) {
+            throw new Error('[wyw-in-js] Loaded oxc-transform module does not expose a sync transform API.');
+        }
+        oxcTransform = syncTransform;
+    }
+    return oxcTransform;
+};
+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 parseJsModule = (code, filename) => {
+    const parsed = parseSync(filename, code, {
+        astType: 'js',
+        range: true,
+        sourceType: 'module',
+    });
+    const fatalError = parsed.errors.find((error) => error.severity === 'Error');
+    if (fatalError) {
+        throw new Error(fatalError.message);
+    }
+    return parsed.program;
+};
+const tryParseJsModule = (code, filename) => {
+    try {
+        return parseJsModule(code, filename);
+    }
+    catch {
+        return null;
+    }
+};
+const getLang = (filename) => {
+    if (filename.endsWith('.tsx'))
+        return 'tsx';
+    if (filename.endsWith('.ts') || filename.endsWith('.mts'))
+        return 'ts';
+    if (filename.endsWith('.jsx'))
+        return 'jsx';
+    return 'js';
+};
+const getCurrentNodeTarget = () => {
+    const [major] = process.versions.node.split('.');
+    return `node${major}`;
+};
+const assertOxcSuccess = (errors) => {
+    const fatalErrors = errors.filter((error) => error.severity === 'Error');
+    if (fatalErrors.length > 0) {
+        throw new Error(fatalErrors.map((error) => error.message).join('\n'));
+    }
+};
+export const stripTypesAndJsxWithOxc = (code, filename, options = {}) => {
+    const result = loadOxcTransform()(filename, code, {
+        jsx: {
+            runtime: 'automatic',
+        },
+        lang: getLang(filename),
+        sourceType: 'module',
+        sourcemap: options.sourcemap ?? false,
+        target: getCurrentNodeTarget(),
+        typescript: {
+            allowNamespaces: true,
+            onlyRemoveTypeImports: false,
+            removeClassFieldsWithoutInitializer: true,
+        },
+    });
+    assertOxcSuccess(result.errors);
+    return {
+        code: result.code,
+        map: result.map,
+    };
+};
+const nameFromModuleExport = (node) => node.type === 'Literal' ? String(node.value) : node.name;
+const propertyAccess = (name) => /^[$A-Z_a-z][$\w]*$/.test(name) ? `.${name}` : `[${JSON.stringify(name)}]`;
+const exportAssignment = (exported, local) => `exports${propertyAccess(exported)} = ${local};`;
+const exportGetter = (exported, value) => [
+    `Object.defineProperty(exports, ${JSON.stringify(exported)}, {`,
+    '  enumerable: true,',
+    '  get: function () {',
+    `    return ${value};`,
+    '  }',
+    '});',
+].join('\n');
+const defaultInteropExpression = (value) => `${value} && ${value}.__esModule ? ${value}.default : ("default" in Object(${value}) ? ${value}.default : ${value})`;
+const collectBindingNames = (pattern) => {
+    if (!pattern) {
+        return [];
+    }
+    if (pattern.type === 'Identifier') {
+        return [pattern.name];
+    }
+    if (pattern.type === 'RestElement') {
+        return collectBindingNames(pattern.argument);
+    }
+    if (pattern.type === 'AssignmentPattern') {
+        return collectBindingNames(pattern.left);
+    }
+    if (pattern.type === 'ObjectPattern') {
+        return pattern.properties.flatMap((property) => property.type === 'RestElement'
+            ? collectBindingNames(property.argument)
+            : collectBindingNames(property.value));
+    }
+    if (pattern.type === 'ArrayPattern') {
+        return pattern.elements.flatMap((element) => collectBindingNames(element));
+    }
+    return [];
+};
+const declarationBindings = (node) => {
+    if (!node) {
+        return [];
+    }
+    if (node.type === 'VariableDeclaration') {
+        return node.declarations.flatMap((declarator) => collectBindingNames(declarator.id));
+    }
+    if ((node.type === 'FunctionDeclaration' || node.type === 'ClassDeclaration') &&
+        node.id) {
+        return [node.id.name];
+    }
+    return [];
+};
+const emitImportDeclaration = (node, index) => {
+    const source = JSON.stringify(node.source.value);
+    if (node.specifiers.length === 0) {
+        return `require(${source});`;
+    }
+    const temp = `__wyw_import_${index}`;
+    const lines = [`const ${temp} = require(${source});`];
+    node.specifiers.forEach((specifier) => {
+        if (specifier.type === 'ImportNamespaceSpecifier') {
+            lines.push(`const ${specifier.local.name} = ${temp};`);
+            return;
+        }
+        if (specifier.type === 'ImportDefaultSpecifier') {
+            lines.push(`const ${specifier.local.name} = ${defaultInteropExpression(temp)};`);
+            return;
+        }
+        const imported = nameFromModuleExport(specifier.imported);
+        const value = imported === 'default'
+            ? defaultInteropExpression(temp)
+            : `${temp}${propertyAccess(imported)}`;
+        lines.push(`const ${specifier.local.name} = ${value};`);
+    });
+    return lines.join('\n');
+};
+const variableDeclaratorCode = (code, declarator, exportedNames) => {
+    if (declarator.id.type !== 'Identifier') {
+        return code.slice(declarator.start, declarator.end);
+    }
+    const binding = declarator.id.name;
+    const init = declarator.init
+        ? code.slice(declarator.init.start, declarator.init.end)
+        : 'undefined';
+    const exported = exportedNames.includes(binding);
+    const value = exported ? `exports${propertyAccess(binding)} = ${init}` : init;
+    return `${binding} = ${value}`;
+};
+const emitVariableExport = (code, node) => {
+    const bindings = node.declarations.flatMap((declarator) => collectBindingNames(declarator.id));
+    const allSimple = node.declarations.every((declarator) => declarator.id.type === 'Identifier');
+    if (allSimple) {
+        return node.declarations
+            .map((declarator) => `${node.kind} ${variableDeclaratorCode(code, declarator, bindings)};`)
+            .join('\n');
+    }
+    const declaration = code.slice(node.start, node.end);
+    const assignments = bindings.map((binding) => exportAssignment(binding, binding));
+    return [declaration, ...assignments].join('\n');
+};
+const emitVariableDeclaration = (code, node) => {
+    if (node.declarations.length <= 1) {
+        return code.slice(node.start, node.end);
+    }
+    return node.declarations
+        .map((declarator) => `${node.kind} ${code.slice(declarator.start, declarator.end)};`)
+        .join('\n');
+};
+const containsSyntaxThatRequiresOxcStrip = (node) => {
+    if (!node || typeof node !== 'object') {
+        return false;
+    }
+    const record = node;
+    if (typeof record.type === 'string') {
+        if (record.type.startsWith('TS') || record.type.startsWith('JSX')) {
+            return true;
+        }
+    }
+    return Object.values(record).some((value) => {
+        if (!value || typeof value !== 'object') {
+            return false;
+        }
+        if (Array.isArray(value)) {
+            return value.some(containsSyntaxThatRequiresOxcStrip);
+        }
+        return containsSyntaxThatRequiresOxcStrip(value);
+    });
+};
+const collectPredeclaredExports = (statement) => {
+    if (statement.type === 'ExportNamedDeclaration') {
+        if (statement.declaration) {
+            return declarationBindings(statement.declaration);
+        }
+        return statement.specifiers.map((specifier) => nameFromModuleExport(specifier.exported));
+    }
+    if (statement.type === 'ExportDefaultDeclaration') {
+        return ['default'];
+    }
+    return [];
+};
+const stripLegacyCodegenTrailingCommas = (code) => code.replace(/,\n(\s*})/g, '\n$1');
+const stripLeadingBlankLines = (code) => code.replace(/^(?:[ \t]*\n)+/, '');
+const stripExportPrefix = (code, node) => node.declaration
+    ? code.slice(node.declaration.start, node.declaration.end)
+    : '';
+const emitNamedExportDeclaration = (code, node, importIndex) => {
+    if (node.source) {
+        const source = JSON.stringify(node.source.value);
+        const temp = `__wyw_reexport_${importIndex}`;
+        const lines = [`const ${temp} = require(${source});`];
+        node.specifiers.forEach((specifier) => {
+            const local = nameFromModuleExport(specifier.local);
+            const exported = nameFromModuleExport(specifier.exported);
+            const value = local === 'default'
+                ? defaultInteropExpression(temp)
+                : `${temp}${propertyAccess(local)}`;
+            lines.push([
+                `Object.defineProperty(exports, ${JSON.stringify(exported)}, {`,
+                `  enumerable: true,`,
+                `  get: function () {`,
+                `    return ${value};`,
+                `  }`,
+                `});`,
+            ].join('\n'));
+        });
+        return lines.join('\n');
+    }
+    if (node.declaration) {
+        if (node.declaration.type === 'VariableDeclaration') {
+            return emitVariableExport(code, node.declaration);
+        }
+        const declaration = stripExportPrefix(code, node);
+        const assignments = declarationBindings(node.declaration).map((binding) => exportAssignment(binding, binding));
+        return [declaration, ...assignments].join('\n');
+    }
+    return node.specifiers
+        .map((specifier) => {
+        const local = nameFromModuleExport(specifier.local);
+        const exported = nameFromModuleExport(specifier.exported);
+        return exportGetter(exported, local);
+    })
+        .join('\n');
+};
+const defaultDeclarationName = (node) => {
+    if ((node.type === 'FunctionDeclaration' || node.type === 'ClassDeclaration') &&
+        node.id) {
+        return node.id.name;
+    }
+    return null;
+};
+const emitDefaultExportDeclaration = (code, node) => {
+    const declaration = node.declaration;
+    const declarationCode = code.slice(declaration.start, declaration.end);
+    const declarationName = defaultDeclarationName(declaration);
+    if (declarationName) {
+        return `${declarationCode}\nexports.default = ${declarationName};`;
+    }
+    if (declaration.type === 'FunctionDeclaration' ||
+        declaration.type === 'ClassDeclaration') {
+        return `const _default = ${declarationCode};\nexports.default = _default;`;
+    }
+    return `exports.default = ${declarationCode};`;
+};
+const emitExportAllDeclaration = (node, index) => {
+    const record = node;
+    const source = JSON.stringify(record.source.value);
+    const temp = `__wyw_reexport_all_${index}`;
+    if ('exported' in record && record.exported) {
+        const exported = nameFromModuleExport(record.exported);
+        return `exports${propertyAccess(exported)} = require(${source});`;
+    }
+    return [
+        `const ${temp} = require(${source});`,
+        `Object.keys(${temp}).forEach((key) => {`,
+        `  if (key !== "default" && key !== "__esModule") exports[key] = ${temp}[key];`,
+        `});`,
+    ].join('\n');
+};
+export const emitOxcCommonJS = (code, filename) => {
+    const parsedOriginal = tryParseJsModule(code, filename);
+    const canUseOriginal = parsedOriginal && !containsSyntaxThatRequiresOxcStrip(parsedOriginal);
+    const source = canUseOriginal
+        ? { code, program: parsedOriginal }
+        : (() => {
+            const stripped = stripTypesAndJsxWithOxc(code, filename);
+            return {
+                code: stripped.code,
+                program: parseJsModule(stripped.code, filename),
+            };
+        })();
+    const replacements = [];
+    let needsEsModuleMarker = false;
+    const predeclaredExports = new Set();
+    source.program.body.forEach((statement, index) => {
+        const node = statement;
+        if (node.type === 'ImportDeclaration') {
+            replacements.push({
+                end: node.end,
+                start: node.start,
+                value: emitImportDeclaration(node, index),
+            });
+            return;
+        }
+        if (node.type === 'ExportNamedDeclaration') {
+            needsEsModuleMarker = true;
+            collectPredeclaredExports(node).forEach((name) => predeclaredExports.add(name));
+            replacements.push({
+                end: node.end,
+                start: node.start,
+                value: emitNamedExportDeclaration(source.code, node, index),
+            });
+            return;
+        }
+        if (node.type === 'ExportDefaultDeclaration') {
+            needsEsModuleMarker = true;
+            collectPredeclaredExports(node).forEach((name) => predeclaredExports.add(name));
+            replacements.push({
+                end: node.end,
+                start: node.start,
+                value: emitDefaultExportDeclaration(source.code, node),
+            });
+            return;
+        }
+        if (node.type === 'ExportAllDeclaration') {
+            needsEsModuleMarker = true;
+            replacements.push({
+                end: node.end,
+                start: node.start,
+                value: emitExportAllDeclaration(node, index),
+            });
+            return;
+        }
+        if (node.type === 'VariableDeclaration' && node.declarations.length > 1) {
+            replacements.push({
+                end: node.end,
+                start: node.start,
+                value: emitVariableDeclaration(source.code, node),
+            });
+        }
+    });
+    const commonjs = stripLegacyCodegenTrailingCommas(applyReplacements(source.code, replacements));
+    const normalizedCommonjs = stripLeadingBlankLines(commonjs);
+    const predeclared = [...predeclaredExports]
+        .map((name) => `exports${propertyAccess(name)} = void 0;`)
+        .join('\n');
+    const preamble = needsEsModuleMarker
+        ? [
+            '"use strict";',
+            '',
+            'Object.defineProperty(exports, "__esModule", {',
+            '  value: true',
+            '});',
+            predeclared,
+            '',
+        ]
+            .filter((line, index) => predeclared || index !== 5)
+            .join('\n')
+        : '"use strict";\n';
+    return {
+        code: `${preamble}${normalizedCommonjs}`,
+    };
+};

package/types/utils/oxcPreevalStage.d.ts

@@ -0,0 +1,20 @@
+import type { IFileContext } from '@wyw-in-js/processor-utils';
+import type { StrictOptions } from '@wyw-in-js/shared';
+import { EventEmitter } from './EventEmitter';
+import type { WYWTransformMetadata } from './TransformMetadata';
+import type { OxcStaticValueCandidate } from './collectOxcTemplateDependencies';
+type OxcPreevalOptions = Pick<StrictOptions, 'classNameSlug' | 'codeRemover' | 'displayName' | 'evaluate' | 'extensions' | 'features' | 'tagResolver'> & {
+    eventEmitter?: EventEmitter;
+};
+type OxcPreevalResult = {
+    baseCode: string;
+    code: string;
+    dependencyNames: string[];
+    metadata: WYWTransformMetadata | null;
+    staticDependencies: string[];
+    staticValueCache: Map<string, unknown>;
+    staticValueCandidates: OxcStaticValueCandidate[];
+};
+export declare const appendOxcWywPreval: (code: string, filename: string, dependencyNames: string[]) => string;
+export declare const runOxcPreevalStage: (code: string, fileContext: IFileContext, options: OxcPreevalOptions) => OxcPreevalResult;
+export {};

package/types/utils/oxcPreevalStage.js

@@ -0,0 +1,102 @@
+import { parseSync } from 'oxc-parser';
+import { isFeatureEnabled } from '@wyw-in-js/shared';
+import { EventEmitter } from './EventEmitter';
+import { applyOxcProcessors } from './applyOxcProcessors';
+import { removeDangerousCodeWithOxc, replaceImportMetaEnvWithOxc, rewriteDynamicImportsAndAddRequireFallbackWithOxc, } from './oxcPreevalTransforms';
+const DYNAMIC_IMPORT_RE = /\bimport(?:\s|\/\*[\s\S]*?\*\/)*\(/;
+const REQUIRE_CALL_RE = /\brequire(?:\s|\/\*[\s\S]*?\*\/)*\(/;
+const isEnvDisabled = (value) => value === '0' || value === 'false' || value === 'no' || value === 'off';
+const isStaticImportValuesEnabled = (features, filename) => {
+    const envValue = process.env.WYW_STATIC_IMPORT_VALUES?.trim().toLowerCase();
+    if (envValue) {
+        return !isEnvDisabled(envValue);
+    }
+    return isFeatureEnabled(features, 'staticImportValues', filename);
+};
+const parseSourceType = (code, filename) => {
+    const parsed = parseSync(filename, code, {
+        astType: filename.endsWith('.ts') || filename.endsWith('.tsx') ? 'ts' : 'js',
+        range: true,
+        sourceType: 'unambiguous',
+    });
+    const fatalError = parsed.errors.find((error) => error.severity === 'Error');
+    if (fatalError) {
+        throw new Error(fatalError.message);
+    }
+    return parsed.program.sourceType === 'script' ? 'script' : 'module';
+};
+export const appendOxcWywPreval = (code, filename, dependencyNames) => {
+    const uniqueNames = [...new Set(dependencyNames)];
+    const properties = uniqueNames.map((name) => `${name}: ${name}`).join(', ');
+    const object = uniqueNames.length > 0 ? `{ ${properties} }` : '{}';
+    if (parseSourceType(code, filename) === 'script') {
+        return `${code}\nexports.__wywPreval = ${object};`;
+    }
+    return `${code}\nexport const __wywPreval = ${object};`;
+};
+export const runOxcPreevalStage = (code, fileContext, options) => {
+    const filename = fileContext.filename ?? 'unknown.js';
+    const dependencyNames = [];
+    const eventEmitter = options.eventEmitter ?? EventEmitter.dummy;
+    const processed = eventEmitter.perf('transform:preeval:processTemplate', () => applyOxcProcessors(code, fileContext, options, (processor) => {
+        processor.dependencies.forEach((dependency) => {
+            if (dependency.ex.type === 'Identifier') {
+                dependencyNames.push(dependency.ex.name);
+            }
+        });
+        processor.doEvaltimeReplacement();
+    }));
+    const staticValuesEnabled = isStaticImportValuesEnabled(options.features, filename);
+    const staticValueNames = staticValuesEnabled
+        ? new Set(processed.staticValues.map((item) => item.name))
+        : null;
+    const evalDependencyNames = staticValuesEnabled
+        ? dependencyNames.filter((name) => !staticValueNames.has(name))
+        : dependencyNames;
+    let nextCode = eventEmitter.perf('transform:preeval:importMetaEnv', () => replaceImportMetaEnvWithOxc(processed.code, filename));
+    if (isFeatureEnabled(options.features, 'dangerousCodeRemover', filename)) {
+        nextCode = eventEmitter.perf('transform:preeval:removeDangerousCode', () => removeDangerousCodeWithOxc(nextCode, filename, options.codeRemover));
+    }
+    const shouldRewriteDynamicImports = DYNAMIC_IMPORT_RE.test(nextCode);
+    const shouldAddRequireFallback = REQUIRE_CALL_RE.test(nextCode);
+    if (shouldRewriteDynamicImports || shouldAddRequireFallback) {
+        nextCode = rewriteDynamicImportsAndAddRequireFallbackWithOxc(nextCode, filename, {
+            addRequireFallback: shouldAddRequireFallback,
+            eventEmitter,
+            rewriteDynamicImports: shouldRewriteDynamicImports,
+        });
+    }
+    if (processed.processors.length === 0) {
+        return {
+            baseCode: nextCode,
+            code: nextCode,
+            dependencyNames: [],
+            metadata: null,
+            staticDependencies: [],
+            staticValueCandidates: [],
+            staticValueCache: new Map(),
+        };
+    }
+    const staticValueCache = new Map();
+    if (staticValuesEnabled) {
+        processed.staticValues.forEach(({ name, value }) => {
+            staticValueCache.set(name, value);
+        });
+    }
+    return {
+        baseCode: nextCode,
+        code: appendOxcWywPreval(nextCode, filename, evalDependencyNames),
+        dependencyNames: evalDependencyNames,
+        metadata: {
+            dependencies: [],
+            processors: processed.processors,
+            replacements: [],
+            rules: {},
+        },
+        staticDependencies: [],
+        staticValueCandidates: staticValuesEnabled
+            ? processed.staticValueCandidates
+            : [],
+        staticValueCache,
+    };
+};

package/types/utils/oxcPreevalTransforms.d.ts

@@ -0,0 +1,13 @@
+import type { CodeRemoverOptions } from '@wyw-in-js/shared';
+import { EventEmitter } from './EventEmitter';
+export declare const replaceImportMetaEnvWithOxc: (code: string, filename: string) => string;
+type CombinedSyntaxRewriteOptions = {
+    addRequireFallback: boolean;
+    eventEmitter?: EventEmitter;
+    rewriteDynamicImports: boolean;
+};
+export declare const rewriteDynamicImportsWithOxc: (code: string, filename: string) => string;
+export declare const addRequireFallbackWithOxc: (code: string, filename: string) => string;
+export declare const rewriteDynamicImportsAndAddRequireFallbackWithOxc: (code: string, filename: string, options: CombinedSyntaxRewriteOptions) => string;
+export declare const removeDangerousCodeWithOxc: (code: string, filename: string, options?: CodeRemoverOptions) => string;
+export {};