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

package/types/utils/oxcAstService.js

@@ -0,0 +1,79 @@
+const createIdentifier = (name) => ({
+    name,
+    type: 'Identifier',
+});
+const createNameAllocator = (usedNames) => {
+    const used = new Set(usedNames);
+    return (hint) => {
+        let candidate = hint.replace(/[^A-Za-z0-9_$]/g, '_') || '_import';
+        if (!/^[A-Za-z_$]/.test(candidate)) {
+            candidate = `_${candidate}`;
+        }
+        let next = candidate;
+        let idx = 2;
+        while (used.has(next)) {
+            next = `${candidate}${idx}`;
+            idx += 1;
+        }
+        used.add(next);
+        return next;
+    };
+};
+export const createOxcAstService = (usedNames = []) => {
+    const addedImports = [];
+    const allocateName = createNameAllocator(usedNames);
+    return {
+        addDefaultImport(source, nameHint = 'defaultImport') {
+            const local = allocateName(nameHint);
+            addedImports.push({ imported: 'default', local, source });
+            return createIdentifier(local);
+        },
+        addNamedImport(name, source, nameHint = name) {
+            const local = allocateName(nameHint);
+            addedImports.push({ imported: name, local, source });
+            return createIdentifier(local);
+        },
+        arrayExpression(elements) {
+            return { elements, type: 'ArrayExpression' };
+        },
+        arrowFunctionExpression(params, body) {
+            return { body, params, type: 'ArrowFunctionExpression' };
+        },
+        blockStatement(body) {
+            return { body, type: 'BlockStatement' };
+        },
+        booleanLiteral(value) {
+            return { type: 'BooleanLiteral', value };
+        },
+        callExpression(callee, args) {
+            return { arguments: args, callee, type: 'CallExpression' };
+        },
+        getAddedImports() {
+            return [...addedImports];
+        },
+        identifier(name) {
+            return createIdentifier(name);
+        },
+        memberExpression(object, property, computed = false) {
+            return { computed, object, property, type: 'MemberExpression' };
+        },
+        nullLiteral() {
+            return { type: 'NullLiteral' };
+        },
+        numericLiteral(value) {
+            return { type: 'NumericLiteral', value };
+        },
+        objectExpression(properties) {
+            return { properties, type: 'ObjectExpression' };
+        },
+        objectProperty(key, value) {
+            return { key, type: 'ObjectProperty', value };
+        },
+        stringLiteral(value) {
+            return { type: 'StringLiteral', value };
+        },
+    };
+};
+export const printOxcAstServiceImport = ({ imported, local, source, }) => imported === 'default'
+    ? `import ${local} from ${JSON.stringify(source)};`
+    : `import { ${imported}${imported === local ? '' : ` as ${local}`} } from ${JSON.stringify(source)};`;

package/types/utils/oxcEmit.d.ts

@@ -0,0 +1,19 @@
+type SourceMap = {
+    file?: string;
+    mappings: string;
+    names: string[];
+    sourceRoot?: string;
+    sources: string[];
+    sourcesContent?: string[];
+    version: number;
+    x_google_ignoreList?: number[];
+};
+export type OxcEmitResult = {
+    code: string;
+    map?: SourceMap;
+};
+export declare const stripTypesAndJsxWithOxc: (code: string, filename: string, options?: {
+    sourcemap?: boolean;
+}) => OxcEmitResult;
+export declare const emitOxcCommonJS: (code: string, filename: string) => OxcEmitResult;
+export {};

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/evalStrategy.d.ts

@@ -0,0 +1,3 @@
+import type { OxcPreevalOptions } from './types';
+export declare const getEvalStrategy: (options: OxcPreevalOptions) => import("@wyw-in-js/shared").EvalStrategy;
+export declare const usesStaticEvaluation: (options: OxcPreevalOptions) => boolean;

package/types/utils/oxcPreevalStage/evalStrategy.js

@@ -0,0 +1,2 @@
+export const getEvalStrategy = (options) => options.eval?.strategy ?? 'hybrid';
+export const usesStaticEvaluation = (options) => getEvalStrategy(options) !== 'execute';

package/types/utils/oxcPreevalStage/prepareCode.d.ts

@@ -0,0 +1,3 @@
+import type { EventEmitter } from '../EventEmitter';
+import type { OxcPreevalOptions } from './types';
+export declare const prepareOxcPreevalCode: (code: string, filename: string, options: OxcPreevalOptions, eventEmitter: EventEmitter) => string;

package/types/utils/oxcPreevalStage/prepareCode.js

@@ -0,0 +1,20 @@
+import { isFeatureEnabled } from '@wyw-in-js/shared';
+import { removeDangerousCodeWithOxc, replaceImportMetaEnvWithOxc, rewriteDynamicImportsAndAddRequireFallbackWithOxc, } from '../oxcPreevalTransforms';
+const DYNAMIC_IMPORT_RE = /\bimport(?:\s|\/\*[\s\S]*?\*\/)*\(/;
+const REQUIRE_CALL_RE = /\brequire(?:\s|\/\*[\s\S]*?\*\/)*\(/;
+export const prepareOxcPreevalCode = (code, filename, options, eventEmitter) => {
+    let nextCode = eventEmitter.perf('transform:preeval:importMetaEnv', () => replaceImportMetaEnvWithOxc(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,
+        });
+    }
+    return nextCode;
+};

package/types/utils/oxcPreevalStage/prevalExport.d.ts

@@ -0,0 +1 @@
+export declare const appendOxcWywPreval: (code: string, filename: string, dependencyNames: string[]) => string;

package/types/utils/oxcPreevalStage/prevalExport.js

@@ -0,0 +1,22 @@
+import { parseSync } from 'oxc-parser';
+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};`;
+};

package/types/utils/oxcPreevalStage/processors.d.ts

@@ -0,0 +1,10 @@
+import type { IFileContext } from '@wyw-in-js/processor-utils';
+import type { EventEmitter } from '../EventEmitter';
+import type { ApplyOxcProcessorsResult } from '../applyOxcProcessors/types';
+import type { OxcPreevalOptions } from './types';
+type PreevalProcessorCollection = {
+    dependencyNames: string[];
+    processed: ApplyOxcProcessorsResult;
+};
+export declare const collectPreevalProcessors: (code: string, fileContext: IFileContext, options: OxcPreevalOptions, eventEmitter: EventEmitter) => PreevalProcessorCollection;
+export {};