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

package/types/utils/collectOxcTemplateDependencies/types.d.ts

@@ -0,0 +1,116 @@
+import type { ExpressionValue, ValueType } from '@wyw-in-js/shared';
+import type { AssignmentExpression, Expression, Node, TemplateLiteral, UpdateExpression, VariableDeclaration, VariableDeclarator } from 'oxc-parser';
+import type { OxcValueReplacement } from '../oxc/replacements';
+import type { OxcLocationLookup } from '../oxc/sourceLocations';
+export type OxcFunctionLikeNode = Node & {
+    async: boolean;
+    body: Node | null;
+    id?: {
+        name: string;
+    } | null;
+    params: Node[];
+};
+export type BindingKind = 'function' | 'import' | 'param' | 'variable';
+export type ScopedDeclarationKind = 'const' | 'let' | 'var';
+export type Binding = {
+    declarationKind?: ScopedDeclarationKind;
+    declaredAt: number;
+    declaration: VariableDeclaration | null;
+    declarator: VariableDeclarator | null;
+    functionNode?: OxcFunctionLikeNode | null;
+    imported?: 'default' | '*' | string;
+    importedFrom?: string;
+    isRoot: boolean;
+    kind: BindingKind;
+    name: string;
+    scope: Scope;
+};
+export type Replacement = OxcValueReplacement;
+export type SpanLookup = Set<string> | null;
+export type LocationLookup = OxcLocationLookup;
+export type ExpressionSpan = {
+    end: number;
+    start: number;
+};
+export type Scope = {
+    bindings: Map<string, Binding>;
+    depth: number;
+    end: number;
+    functionBoundary: boolean;
+    params: Set<string>;
+    parent: Scope | null;
+    root: boolean;
+    start: number;
+};
+export type ReferenceIdentifier = {
+    end: number;
+    name: string;
+    start: number;
+};
+export type OxcStaticImportReference = {
+    imported: 'default' | string;
+    importLocal?: string;
+    local: string;
+    source: string;
+};
+export type OxcStaticValue = {
+    name: string;
+    value: unknown;
+};
+export type OxcStaticValueCandidate = {
+    imports: OxcStaticImportReference[];
+    inlineConstants?: Record<string, unknown>;
+    name: string;
+    source: string;
+};
+export type TemplateExtractionResult = {
+    code: string;
+    dependencyNames: string[];
+    expressionValues: Omit<ExpressionValue, 'buildCodeFrameError'>[];
+    staticValueCandidates: OxcStaticValueCandidate[];
+    staticValues: OxcStaticValue[];
+};
+export type StaticBindings = Record<string, Record<string, unknown>>;
+export type ExtractedExpression = {
+    expressionCode: string;
+    hasInlinableLocalReference?: boolean;
+    importedFrom: string[];
+    kind: ValueType.FUNCTION | ValueType.LAZY;
+    staticExpressionCode?: string;
+    staticImports: OxcStaticImportReference[];
+    staticValue?: unknown;
+};
+export type StaticLocalExpression = {
+    importedFrom: string[];
+    imports: OxcStaticImportReference[];
+    source: string;
+};
+export type ProgramAnalysis = {
+    bindingsByName: Map<string, Binding[]>;
+    rootMutationsByBinding: Map<string, Array<AssignmentExpression | UpdateExpression>>;
+    targetExpressions: Expression[];
+    templateLiterals: TemplateLiteral[];
+    usedNames: Set<string>;
+};
+export type ExtractionContext = {
+    bindingResolutionCache: Map<string, Map<number, Binding | null>>;
+    bindingsByName: Map<string, Binding[]>;
+    code: string;
+    currentInsertionPoint: number;
+    currentExpressionStart: number;
+    dependencyNames: Set<string>;
+    expressionValues: Omit<ExpressionValue, 'buildCodeFrameError'>[];
+    filename: string;
+    hoistedBindingNames: Map<string, string>;
+    hoistedDeclarations: Map<string, string>;
+    hoistedDeclarationsByInsertionPoint: Map<number, string[]>;
+    loc: LocationLookup;
+    referencesByNode: WeakMap<Node, ReferenceIdentifier[]>;
+    replacements: Replacement[];
+    rootMutationsByBinding: Map<string, Array<AssignmentExpression | UpdateExpression>>;
+    staticBindings?: StaticBindings;
+    staticImportAliases: Map<string, string>;
+    staticValueCandidates: OxcStaticValueCandidate[];
+    staticValues: OxcStaticValue[];
+    usedNames: Set<string>;
+};

package/types/utils/collectOxcTemplateDependencies/types.js

@@ -0,0 +1 @@
+export {};

package/types/utils/collectOxcTemplateDependencies.d.ts

@@ -0,0 +1,4 @@
+export type { OxcStaticImportReference, OxcStaticValue, OxcStaticValueCandidate, StaticBindings, } from './collectOxcTemplateDependencies/types';
+export { lookupStaticBinding } from './collectOxcTemplateDependencies/staticBindings';
+export { createOxcStaticCallableValue } from './collectOxcTemplateDependencies/staticEvaluator';
+export { collectOxcExpressionDependencies, collectOxcTemplateDependencies, evaluateOxcStaticExpression, evaluateOxcStaticExpressionAt, isOxcStaticSerializableValue, } from './collectOxcTemplateDependencies/expressionExtraction';

package/types/utils/collectOxcTemplateDependencies.js

@@ -0,0 +1,3 @@
+export { lookupStaticBinding } from './collectOxcTemplateDependencies/staticBindings';
+export { createOxcStaticCallableValue } from './collectOxcTemplateDependencies/staticEvaluator';
+export { collectOxcExpressionDependencies, collectOxcTemplateDependencies, evaluateOxcStaticExpression, evaluateOxcStaticExpressionAt, isOxcStaticSerializableValue, } from './collectOxcTemplateDependencies/expressionExtraction';

package/types/utils/getFileIdx.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFileIdx = getFileIdx;
 let nextIdx = 1;
 const processed = new Map();
-function getFileIdx(name) {
+export function getFileIdx(name) {
     if (!processed.has(name)) {
         // eslint-disable-next-line no-plusplus
         processed.set(name, nextIdx++);

package/types/utils/getPluginKey.d.ts

@@ -1,2 +1,5 @@
-import type { PluginItem } from '@babel/core';
-export declare const getPluginKey: (plugin: PluginItem) => string | null;
+type PluginItemLike = string | readonly [PluginItemLike, ...unknown[]] | {
+    key?: string | null;
+} | object | null | undefined;
+export declare const getPluginKey: (plugin: PluginItemLike) => string | null;
+export {};

package/types/utils/getPluginKey.js

@@ -1,16 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPluginKey = void 0;
-const getPluginKey = (plugin) => {
+export const getPluginKey = (plugin) => {
     if (typeof plugin === 'string') {
         return plugin;
     }
     if (Array.isArray(plugin)) {
-        return (0, exports.getPluginKey)(plugin[0]);
+        return getPluginKey(plugin[0]);
     }
     if (typeof plugin === 'object' && plugin !== null && 'key' in plugin) {
         return plugin.key ?? null;
     }
     return null;
 };
-exports.getPluginKey = getPluginKey;

package/types/utils/getVisitorKeys.d.ts

@@ -1,5 +1,5 @@
-import type { Node } from '@babel/types';
-export type VisitorKeys<T extends Node> = {
-    [K in keyof T]: Exclude<T[K], undefined> extends Node | Node[] | null ? K : never;
+import type { AstNode } from '@wyw-in-js/shared';
+export type VisitorKeys<T extends AstNode> = {
+    [K in keyof T]: Exclude<T[K], undefined> extends AstNode | AstNode[] | null ? K : never;
 }[keyof T] & string;
-export declare function getVisitorKeys<TNode extends Node>(node: TNode): VisitorKeys<TNode>[];
+export declare function getVisitorKeys<TNode extends AstNode>(node: TNode): VisitorKeys<TNode>[];

package/types/utils/getVisitorKeys.js

@@ -1,7 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVisitorKeys = getVisitorKeys;
-const core_1 = require("@babel/core");
-function getVisitorKeys(node) {
-    return core_1.types.VISITOR_KEYS[node.type];
+import { isNode } from './isNode';
+export function getVisitorKeys(node) {
+    return Object.keys(node).filter((key) => {
+        const value = node[key];
+        if (isNode(value)) {
+            return true;
+        }
+        return Array.isArray(value) && value.some(isNode);
+    });
 }

package/types/utils/hasCachedWywPrevalExport.d.ts

@@ -0,0 +1,14 @@
+import type { Services } from '../transform/types';
+type CachedEntrypointLike = {
+    evaluated?: boolean;
+    ignored?: boolean;
+    initialCode?: string;
+    loadedAndParsed?: {
+        code?: string;
+        evalConfig?: {
+            filename?: string;
+        };
+    };
+};
+export declare const hasCachedWywPrevalExport: (services: Services, resolved: string, cached: CachedEntrypointLike | undefined) => boolean;
+export type { CachedEntrypointLike };

package/types/utils/hasCachedWywPrevalExport.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import { collectOxcExportsAndImports } from './collectOxcExportsAndImports';
+import { stripQueryAndHash } from './parseRequest';
+export const hasCachedWywPrevalExport = (services, resolved, cached) => {
+    const knownExports = services.cache.get('exports', resolved);
+    if (knownExports) {
+        return knownExports.includes('__wywPreval') || knownExports.includes('*');
+    }
+    const filename = stripQueryAndHash(resolved);
+    const code = cached?.initialCode ??
+        cached?.loadedAndParsed?.code ??
+        fs.readFileSync(filename, 'utf-8');
+    try {
+        const analyzed = collectOxcExportsAndImports(code, filename);
+        if (analyzed.reexports.some((reexport) => reexport.exported === '*')) {
+            return true;
+        }
+        const exportNames = Array.from(new Set([
+            ...Object.keys(analyzed.exports),
+            ...analyzed.reexports
+                .filter((reexport) => reexport.exported !== '*')
+                .map((reexport) => reexport.exported),
+        ]));
+        services.cache.add('exports', resolved, exportNames);
+        return exportNames.includes('__wywPreval');
+    }
+    catch {
+        return true;
+    }
+};

package/types/utils/hasWywPreval.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = hasWywPreval;
-function hasWywPreval(exports) {
+export default function hasWywPreval(exports) {
     if (!exports || typeof exports !== 'object') {
         return false;
     }

package/types/utils/importOverrides.js

@@ -1,40 +1,30 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toCanonicalFileKey = toCanonicalFileKey;
-exports.toImportKey = toImportKey;
-exports.resolveMockSpecifier = resolveMockSpecifier;
-exports.applyImportOverrideToOnly = applyImportOverrideToOnly;
-exports.getImportOverride = getImportOverride;
-const path_1 = __importDefault(require("path"));
-const shared_1 = require("@wyw-in-js/shared");
-const minimatch_1 = require("minimatch");
-function toCanonicalFileKey(resolved, root) {
-    const rootDir = root ? path_1.default.resolve(root) : process.cwd();
-    const normalizedResolved = path_1.default.resolve(resolved);
-    let relative = path_1.default.relative(rootDir, normalizedResolved);
-    if (path_1.default.sep !== path_1.default.posix.sep) {
-        relative = relative.split(path_1.default.sep).join(path_1.default.posix.sep);
+import path from 'path';
+import { syncResolve, } from '@wyw-in-js/shared';
+import { Minimatch } from 'minimatch';
+export function toCanonicalFileKey(resolved, root) {
+    const rootDir = root ? path.resolve(root) : process.cwd();
+    const normalizedResolved = path.resolve(resolved);
+    let relative = path.relative(rootDir, normalizedResolved);
+    if (path.sep !== path.posix.sep) {
+        relative = relative.split(path.sep).join(path.posix.sep);
     }
     if (!relative.startsWith('.')) {
         relative = `./${relative}`;
     }
     return relative;
 }
-function toImportKey({ source, resolved, root, }) {
-    const isFileImport = source.startsWith('.') || path_1.default.isAbsolute(source);
+export function toImportKey({ source, resolved, root, }) {
+    const isFileImport = source.startsWith('.') || path.isAbsolute(source);
     if (isFileImport && resolved) {
         return { key: toCanonicalFileKey(resolved, root), kind: 'file' };
     }
     return { key: source, kind: 'package' };
 }
-function resolveMockSpecifier({ importer, mock, root, stack, }) {
-    const specifier = mock.startsWith('.') && root ? path_1.default.resolve(root, mock) : mock;
-    return (0, shared_1.syncResolve)(specifier, importer, stack);
+export function resolveMockSpecifier({ importer, mock, root, stack, }) {
+    const specifier = mock.startsWith('.') && root ? path.resolve(root, mock) : mock;
+    return syncResolve(specifier, importer, stack);
 }
-function applyImportOverrideToOnly(only, override) {
+export function applyImportOverrideToOnly(only, override) {
     if (override?.noShake) {
         return ['*'];
     }
@@ -66,7 +56,7 @@ function compileImportOverrides(importOverrides) {
     const matchers = Object.entries(importOverrides)
         .map(([pattern, override]) => {
         return {
-            matcher: new minimatch_1.Minimatch(pattern, minimatchOptions),
+            matcher: new Minimatch(pattern, minimatchOptions),
             override,
             pattern,
             specificity: getPatternSpecificity(pattern),
@@ -91,7 +81,7 @@ function getCompiledImportOverrides(importOverrides) {
     compiledImportOverridesCache.set(importOverrides, compiled);
     return compiled;
 }
-function getImportOverride(importOverrides, key) {
+export function getImportOverride(importOverrides, key) {
     if (!importOverrides) {
         return undefined;
     }

package/types/utils/isNode.d.ts

@@ -1,2 +1,2 @@
-import type { Node } from '@babel/types';
-export declare const isNode: (obj: unknown) => obj is Node;
+import type { AstNode } from '@wyw-in-js/shared';
+export declare const isNode: (obj: unknown) => obj is AstNode;

package/types/utils/isNode.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNode = void 0;
-const isNode = (obj) => typeof obj === 'object' &&
+export const isNode = (obj) => typeof obj === 'object' &&
     obj !== null &&
-    obj?.type !== undefined;
-exports.isNode = isNode;
+    typeof obj.type === 'string';

package/types/utils/isNotNull.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNotNull = isNotNull;
-function isNotNull(x) {
+export function isNotNull(x) {
     return x !== null;
 }

package/types/utils/isSerializable.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSerializable = isSerializable;
-const shared_1 = require("@wyw-in-js/shared");
-function isSerializable(o) {
+import { isBoxedPrimitive } from '@wyw-in-js/shared';
+export function isSerializable(o) {
     if (Array.isArray(o)) {
         return o.every(isSerializable);
     }
     if (o === null)
         return true;
-    if ((0, shared_1.isBoxedPrimitive)(o))
+    if (isBoxedPrimitive(o))
         return true;
     if (typeof o === 'object') {
         return Object.values(o).every(isSerializable);

package/types/utils/nativeResolver.d.ts

@@ -0,0 +1,13 @@
+import type { EvalResolverKind, OxcOptions, StrictOptions } from '@wyw-in-js/shared';
+export type NativeResolverParams = {
+    conditionNames?: string[];
+    extensions: StrictOptions['extensions'];
+    importer: string;
+    kind: EvalResolverKind;
+    oxcOptions?: OxcOptions;
+    specifier: string;
+};
+export declare const expandNativeResolverConditions: (kind: EvalResolverKind, conditionNames?: readonly string[]) => string[];
+export declare const clearNativeResolverCacheForTest: () => void;
+export declare const getNativeResolverCacheSizeForTest: () => number;
+export declare const resolveWithNativeResolver: ({ conditionNames, extensions, importer, kind, oxcOptions, specifier, }: NativeResolverParams) => string;

package/types/utils/nativeResolver.js

@@ -0,0 +1,91 @@
+import fs from 'fs';
+import path from 'path';
+import { ResolverFactory } from 'oxc-resolver';
+import { parseRequest } from './parseRequest';
+const CJS_DEFAULT_CONDITIONS = ['require', 'node', 'default'];
+const ESM_DEFAULT_CONDITIONS = ['node', 'import', 'default'];
+const FALLBACK_EXTENSIONS = ['.json', '.node'];
+const MAX_RESOLVER_CACHE_SIZE = 64;
+const resolverCache = new Map();
+const unique = (items) => Array.from(new Set(items));
+export const expandNativeResolverConditions = (kind, conditionNames) => {
+    const defaults = kind === 'require' ? CJS_DEFAULT_CONDITIONS : ESM_DEFAULT_CONDITIONS;
+    const names = conditionNames?.length ? conditionNames : ['...'];
+    const result = [];
+    names.forEach((name) => {
+        if (name === '...') {
+            defaults.forEach((condition) => result.push(condition));
+            return;
+        }
+        result.push(name);
+    });
+    return unique(result);
+};
+const createResolverOptions = ({ conditionNames, extensions, kind, oxcOptions, }) => {
+    const configuredResolver = (oxcOptions?.resolver ?? {});
+    const hasConfiguredTsconfig = Object.prototype.hasOwnProperty.call(configuredResolver, 'tsconfig');
+    const configuredConditionNames = Array.isArray(configuredResolver.conditionNames)
+        ? configuredResolver.conditionNames
+        : undefined;
+    const configuredExtensions = Array.isArray(configuredResolver.extensions)
+        ? configuredResolver.extensions
+        : [];
+    return {
+        ...configuredResolver,
+        ...(hasConfiguredTsconfig ? {} : { tsconfig: 'auto' }),
+        conditionNames: expandNativeResolverConditions(kind, conditionNames ?? configuredConditionNames),
+        extensions: unique([
+            ...configuredExtensions,
+            ...extensions,
+            ...FALLBACK_EXTENSIONS,
+        ]),
+    };
+};
+const getResolver = (options) => {
+    const key = JSON.stringify(options);
+    const cached = resolverCache.get(key);
+    if (cached) {
+        resolverCache.delete(key);
+        resolverCache.set(key, cached);
+        return cached;
+    }
+    const resolver = new ResolverFactory(options);
+    if (resolverCache.size >= MAX_RESOLVER_CACHE_SIZE) {
+        const oldestKey = resolverCache.keys().next().value;
+        if (oldestKey !== undefined) {
+            resolverCache.delete(oldestKey);
+        }
+    }
+    resolverCache.set(key, resolver);
+    return resolver;
+};
+export const clearNativeResolverCacheForTest = () => {
+    resolverCache.clear();
+};
+export const getNativeResolverCacheSizeForTest = () => resolverCache.size;
+const preferJsOverCjsForExtensionlessFileSpecifier = (specifier, resolved) => {
+    if ((specifier.startsWith('.') || path.isAbsolute(specifier)) &&
+        path.extname(specifier) === '' &&
+        resolved.endsWith('.cjs') &&
+        fs.existsSync(`${resolved.slice(0, -4)}.js`)) {
+        return `${resolved.slice(0, -4)}.js`;
+    }
+    return resolved;
+};
+export const resolveWithNativeResolver = ({ conditionNames, extensions, importer, kind, oxcOptions, specifier, }) => {
+    const { filename, query, hash } = parseRequest(specifier);
+    const options = createResolverOptions({
+        conditionNames,
+        extensions,
+        kind,
+        oxcOptions,
+    });
+    const resolver = getResolver(options);
+    const result = resolver.resolveFileSync(importer, filename);
+    if (!result.path) {
+        throw new Error(result.error ?? `Cannot resolve module ${specifier}`);
+    }
+    const resolved = preferJsOverCjsForExtensionlessFileSpecifier(filename, result.path);
+    const suffix = `${query ? `?${query}` : ''}${hash ? `#${hash}` : ''}`;
+    return `${resolved}${suffix}`;
+};

package/types/utils/oxc/ast.d.ts

@@ -0,0 +1,4 @@
+import type { Node } from 'oxc-parser';
+export declare const isOxcNode: (value: unknown) => value is Node;
+export declare const getOxcNodeChildren: (node: Node) => Node[];
+export declare const walkOxc: (node: Node, enter: (node: Node, parent: Node | null) => void, parent?: Node | null) => void;

package/types/utils/oxc/ast.js

@@ -0,0 +1,37 @@
+export const isOxcNode = (value) => !!value &&
+    typeof value === 'object' &&
+    'type' in value &&
+    typeof value.type === 'string';
+export const getOxcNodeChildren = (node) => {
+    const result = [];
+    const record = node;
+    Object.keys(record).forEach((key) => {
+        if (key === 'comments' ||
+            key === 'end' ||
+            key === 'errors' ||
+            key === 'parent' ||
+            key === 'range' ||
+            key === 'span' ||
+            key === 'start' ||
+            key === 'type') {
+            return;
+        }
+        const value = record[key];
+        if (isOxcNode(value)) {
+            result.push(value);
+            return;
+        }
+        if (Array.isArray(value)) {
+            value.forEach((item) => {
+                if (isOxcNode(item)) {
+                    result.push(item);
+                }
+            });
+        }
+    });
+    return result;
+};
+export const walkOxc = (node, enter, parent = null) => {
+    enter(node, parent);
+    getOxcNodeChildren(node).forEach((child) => walkOxc(child, enter, node));
+};

package/types/utils/oxc/parse.d.ts

@@ -0,0 +1,3 @@
+import type { Program } from 'oxc-parser';
+export type OxcSourceType = 'module' | 'unambiguous';
+export declare const parseOxcProgram: (code: string, filename: string, sourceType?: OxcSourceType) => Program;

package/types/utils/oxc/parse.js

@@ -0,0 +1,2 @@
+import { parseOxcProgramCached } from '../parseOxc';
+export const parseOxcProgram = (code, filename, sourceType = 'unambiguous') => parseOxcProgramCached(filename, code, sourceType);

package/types/utils/oxc/replacements.d.ts

@@ -0,0 +1,12 @@
+export type OxcValueReplacement = {
+    end: number;
+    start: number;
+    value: string;
+};
+export type OxcTextReplacement = {
+    end: number;
+    start: number;
+    text: string;
+};
+export type OxcReplacement = OxcTextReplacement | OxcValueReplacement;
+export declare const applyOxcReplacements: (code: string, replacements: OxcReplacement[]) => string;

package/types/utils/oxc/replacements.js

@@ -0,0 +1,18 @@
+const getReplacementValue = (replacement) => {
+    if ('value' in replacement) {
+        return replacement.value;
+    }
+    return replacement.text;
+};
+export const applyOxcReplacements = (code, replacements) => {
+    let result = code;
+    [...replacements]
+        .sort((a, b) => b.start - a.start)
+        .forEach((replacement) => {
+        result =
+            result.slice(0, replacement.start) +
+                getReplacementValue(replacement) +
+                result.slice(replacement.end);
+    });
+    return result;
+};

package/types/utils/oxc/sourceLocations.d.ts

@@ -0,0 +1,5 @@
+import type { SourceLocation } from '@wyw-in-js/shared';
+export type OxcLocationLookup = (offset: number) => SourceLocation['start'];
+export declare const createOxcLocationLookup: (code: string) => OxcLocationLookup;
+export declare const createOxcSourceLocation: (start: number, end: number, loc: OxcLocationLookup, filename?: string | null, identifierName?: string | null) => SourceLocation;
+export declare const buildOxcCodeFrameError: (code: string, location: SourceLocation, message: string) => Error;

package/types/utils/oxc/sourceLocations.js

@@ -0,0 +1,63 @@
+export const createOxcLocationLookup = (code) => {
+    const lineStarts = [0];
+    for (let idx = 0; idx < code.length; idx += 1) {
+        if (code[idx] === '\n') {
+            lineStarts.push(idx + 1);
+        }
+    }
+    return (offset) => {
+        let low = 0;
+        let high = lineStarts.length - 1;
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            const next = lineStarts[mid + 1] ?? Infinity;
+            if (lineStarts[mid] <= offset && offset < next) {
+                return {
+                    column: offset - lineStarts[mid],
+                    line: mid + 1,
+                };
+            }
+            if (offset < lineStarts[mid]) {
+                high = mid - 1;
+            }
+            else {
+                low = mid + 1;
+            }
+        }
+        const lastLine = lineStarts.length - 1;
+        return {
+            column: Math.max(0, offset - lineStarts[lastLine]),
+            line: lastLine + 1,
+        };
+    };
+};
+export const createOxcSourceLocation = (start, end, loc, filename, identifierName) => ({
+    end: loc(end),
+    filename: filename ?? undefined,
+    identifierName,
+    start: loc(start),
+});
+export const buildOxcCodeFrameError = (code, location, message) => {
+    const lines = code.split('\n');
+    const startLine = location.start.line;
+    const endLine = location.end.line;
+    const frameStart = Math.max(1, startLine - 2);
+    const frameEnd = Math.min(lines.length, endLine + 2);
+    const lineNoWidth = String(frameEnd).length;
+    const frame = [];
+    for (let lineNo = frameStart; lineNo <= frameEnd; lineNo += 1) {
+        const marker = lineNo === startLine ? '>' : ' ';
+        const line = lines[lineNo - 1] ?? '';
+        frame.push(line.length > 0
+            ? `${marker} ${String(lineNo).padStart(lineNoWidth)} | ${line}`
+            : `${marker} ${String(lineNo).padStart(lineNoWidth)} |`);
+        if (lineNo === startLine) {
+            const pointerLength = startLine === endLine
+                ? Math.max(1, location.end.column - location.start.column)
+                : 1;
+            frame.push(`  ${' '.repeat(lineNoWidth)} | ${' '.repeat(location.start.column)}${'^'.repeat(pointerLength)}`);
+        }
+    }
+    const prefix = location.filename ? `${location.filename}: ` : '';
+    return new Error(`${prefix}${message}\n${frame.join('\n')}`);
+};

package/types/utils/oxcAstService.d.ts

@@ -0,0 +1,11 @@
+import type { AstService } from '@wyw-in-js/processor-utils';
+export type AddedImport = {
+    imported: 'default' | string;
+    local: string;
+    source: string;
+};
+export type OxcAstService = AstService & {
+    getAddedImports(): AddedImport[];
+};
+export declare const createOxcAstService: (usedNames?: Iterable<string>) => OxcAstService;
+export declare const printOxcAstServiceImport: ({ imported, local, source, }: AddedImport) => string;