@loopdive/js2 0.57.0

package/dist/emit/opcodes.d.ts

@@ -0,0 +1,464 @@
+export declare const OP: {
+    readonly unreachable: 0;
+    readonly nop: 1;
+    readonly block: 2;
+    readonly loop: 3;
+    readonly if: 4;
+    readonly else: 5;
+    readonly try: 6;
+    readonly catch: 7;
+    readonly throw: 8;
+    readonly rethrow: 9;
+    readonly end: 11;
+    readonly br: 12;
+    readonly br_if: 13;
+    readonly return: 15;
+    readonly call: 16;
+    readonly call_indirect: 17;
+    readonly return_call: 18;
+    readonly return_call_indirect: 19;
+    readonly delegate: 24;
+    readonly catch_all: 25;
+    readonly drop: 26;
+    readonly select: 27;
+    readonly local_get: 32;
+    readonly local_set: 33;
+    readonly local_tee: 34;
+    readonly global_get: 35;
+    readonly global_set: 36;
+    readonly table_get: 37;
+    readonly table_set: 38;
+    readonly i32_load: 40;
+    readonly i32_load8_s: 44;
+    readonly i32_load8_u: 45;
+    readonly i32_load16_u: 47;
+    readonly i32_store: 54;
+    readonly i64_store: 55;
+    readonly i32_store8: 58;
+    readonly i32_store16: 59;
+    readonly f32_load: 42;
+    readonly f64_load: 43;
+    readonly f32_store: 56;
+    readonly f64_store: 57;
+    readonly i32_const: 65;
+    readonly i64_const: 66;
+    readonly f32_const: 67;
+    readonly f64_const: 68;
+    readonly i32_eqz: 69;
+    readonly i32_eq: 70;
+    readonly i32_ne: 71;
+    readonly i32_lt_s: 72;
+    readonly i32_lt_u: 73;
+    readonly i32_gt_s: 74;
+    readonly i32_gt_u: 75;
+    readonly i32_le_s: 76;
+    readonly i32_le_u: 77;
+    readonly i32_ge_s: 78;
+    readonly i32_ge_u: 79;
+    readonly i32_add: 106;
+    readonly i32_sub: 107;
+    readonly i32_mul: 108;
+    readonly i32_div_s: 109;
+    readonly i32_div_u: 110;
+    readonly i32_rem_s: 111;
+    readonly i32_rem_u: 112;
+    readonly i32_and: 113;
+    readonly i32_or: 114;
+    readonly i32_xor: 115;
+    readonly i32_shl: 116;
+    readonly i32_shr_s: 117;
+    readonly i32_shr_u: 118;
+    readonly i32_clz: 103;
+    readonly f64_eq: 97;
+    readonly f64_ne: 98;
+    readonly f64_lt: 99;
+    readonly f64_gt: 100;
+    readonly f64_le: 101;
+    readonly f64_ge: 102;
+    readonly f64_abs: 153;
+    readonly f64_neg: 154;
+    readonly f64_ceil: 155;
+    readonly f64_floor: 156;
+    readonly f64_trunc: 157;
+    readonly f64_nearest: 158;
+    readonly f64_sqrt: 159;
+    readonly f64_add: 160;
+    readonly f64_sub: 161;
+    readonly f64_mul: 162;
+    readonly f64_div: 163;
+    readonly f64_min: 164;
+    readonly f64_max: 165;
+    readonly f64_copysign: 166;
+    readonly i32_wrap_i64: 167;
+    readonly i32_trunc_f64_s: 170;
+    readonly i32_trunc_f64_u: 171;
+    readonly f32_demote_f64: 182;
+    readonly f64_promote_f32: 187;
+    readonly i64_eqz: 80;
+    readonly i64_eq: 81;
+    readonly i64_ne: 82;
+    readonly i64_lt_s: 83;
+    readonly i64_lt_u: 84;
+    readonly i64_gt_s: 85;
+    readonly i64_gt_u: 86;
+    readonly i64_le_s: 87;
+    readonly i64_le_u: 88;
+    readonly i64_ge_s: 89;
+    readonly i64_ge_u: 90;
+    readonly i64_add: 124;
+    readonly i64_sub: 125;
+    readonly i64_mul: 126;
+    readonly i64_div_s: 127;
+    readonly i64_div_u: 128;
+    readonly i64_rem_s: 129;
+    readonly i64_rem_u: 130;
+    readonly i64_and: 131;
+    readonly i64_or: 132;
+    readonly i64_xor: 133;
+    readonly i64_shl: 134;
+    readonly i64_shr_s: 135;
+    readonly i64_shr_u: 136;
+    readonly i64_extend_i32_s: 172;
+    readonly i64_extend_i32_u: 173;
+    readonly i64_trunc_f64_s: 176;
+    readonly f64_convert_i64_s: 185;
+    readonly f64_convert_i32_s: 183;
+    readonly f64_convert_i32_u: 184;
+    readonly i32_reinterpret_f32: 188;
+    readonly i64_reinterpret_f64: 189;
+    readonly f32_reinterpret_i32: 190;
+    readonly f64_reinterpret_i64: 191;
+    readonly ref_null: 208;
+    readonly ref_is_null: 209;
+    readonly ref_eq: 211;
+    readonly ref_as_non_null: 212;
+    readonly ref_func: 210;
+    readonly call_ref: 20;
+    readonly return_call_ref: 21;
+    readonly memory_size: 63;
+    readonly memory_grow: 64;
+    readonly misc_prefix: 252;
+    readonly i32_trunc_sat_f64_s: 2;
+    readonly i32_trunc_sat_f64_u: 3;
+    readonly i64_trunc_sat_f64_s: 6;
+    readonly i64_trunc_sat_f64_u: 7;
+    /** SIMD prefix byte — all SIMD instructions start with 0xFD */
+    readonly simd_prefix: 253;
+};
+/**
+ * WASM SIMD opcodes (v128 / 128-bit SIMD).
+ * All are prefixed by OP.simd_prefix (0xFD), followed by a LEB128 opcode.
+ */
+export declare const SIMD: {
+    readonly v128_load: 0;
+    readonly v128_load8x8_s: 1;
+    readonly v128_load8x8_u: 2;
+    readonly v128_load16x4_s: 3;
+    readonly v128_load16x4_u: 4;
+    readonly v128_load32x2_s: 5;
+    readonly v128_load32x2_u: 6;
+    readonly v128_load8_splat: 7;
+    readonly v128_load16_splat: 8;
+    readonly v128_load32_splat: 9;
+    readonly v128_load64_splat: 10;
+    readonly v128_store: 11;
+    readonly v128_const: 12;
+    readonly i8x16_shuffle: 13;
+    readonly i8x16_swizzle: 14;
+    readonly i8x16_splat: 15;
+    readonly i16x8_splat: 16;
+    readonly i32x4_splat: 17;
+    readonly i64x2_splat: 18;
+    readonly f32x4_splat: 19;
+    readonly f64x2_splat: 20;
+    readonly i8x16_extract_lane_s: 21;
+    readonly i8x16_extract_lane_u: 22;
+    readonly i8x16_replace_lane: 23;
+    readonly i16x8_extract_lane_s: 24;
+    readonly i16x8_extract_lane_u: 25;
+    readonly i16x8_replace_lane: 26;
+    readonly i32x4_extract_lane: 27;
+    readonly i32x4_replace_lane: 28;
+    readonly i64x2_extract_lane: 29;
+    readonly i64x2_replace_lane: 30;
+    readonly f32x4_extract_lane: 31;
+    readonly f32x4_replace_lane: 32;
+    readonly f64x2_extract_lane: 33;
+    readonly f64x2_replace_lane: 34;
+    readonly i8x16_eq: 35;
+    readonly i8x16_ne: 36;
+    readonly i8x16_lt_s: 37;
+    readonly i8x16_lt_u: 38;
+    readonly i8x16_gt_s: 39;
+    readonly i8x16_gt_u: 40;
+    readonly i8x16_le_s: 41;
+    readonly i8x16_le_u: 42;
+    readonly i8x16_ge_s: 43;
+    readonly i8x16_ge_u: 44;
+    readonly i16x8_eq: 45;
+    readonly i16x8_ne: 46;
+    readonly i16x8_lt_s: 47;
+    readonly i16x8_lt_u: 48;
+    readonly i16x8_gt_s: 49;
+    readonly i16x8_gt_u: 50;
+    readonly i16x8_le_s: 51;
+    readonly i16x8_le_u: 52;
+    readonly i16x8_ge_s: 53;
+    readonly i16x8_ge_u: 54;
+    readonly i32x4_eq: 55;
+    readonly i32x4_ne: 56;
+    readonly i32x4_lt_s: 57;
+    readonly i32x4_lt_u: 58;
+    readonly i32x4_gt_s: 59;
+    readonly i32x4_gt_u: 60;
+    readonly i32x4_le_s: 61;
+    readonly i32x4_le_u: 62;
+    readonly i32x4_ge_s: 63;
+    readonly i32x4_ge_u: 64;
+    readonly f32x4_eq: 65;
+    readonly f32x4_ne: 66;
+    readonly f32x4_lt: 67;
+    readonly f32x4_gt: 68;
+    readonly f32x4_le: 69;
+    readonly f32x4_ge: 70;
+    readonly f64x2_eq: 71;
+    readonly f64x2_ne: 72;
+    readonly f64x2_lt: 73;
+    readonly f64x2_gt: 74;
+    readonly f64x2_le: 75;
+    readonly f64x2_ge: 76;
+    readonly v128_not: 77;
+    readonly v128_and: 78;
+    readonly v128_andnot: 79;
+    readonly v128_or: 80;
+    readonly v128_xor: 81;
+    readonly v128_bitselect: 82;
+    readonly v128_any_true: 83;
+    readonly i8x16_abs: 96;
+    readonly i8x16_neg: 97;
+    readonly i8x16_popcnt: 98;
+    readonly i8x16_all_true: 99;
+    readonly i8x16_bitmask: 100;
+    readonly i8x16_narrow_i16x8_s: 101;
+    readonly i8x16_narrow_i16x8_u: 102;
+    readonly i8x16_shl: 107;
+    readonly i8x16_shr_s: 108;
+    readonly i8x16_shr_u: 109;
+    readonly i8x16_add: 110;
+    readonly i8x16_add_sat_s: 111;
+    readonly i8x16_add_sat_u: 112;
+    readonly i8x16_sub: 113;
+    readonly i8x16_sub_sat_s: 114;
+    readonly i8x16_sub_sat_u: 115;
+    readonly i8x16_min_s: 118;
+    readonly i8x16_min_u: 119;
+    readonly i8x16_max_s: 120;
+    readonly i8x16_max_u: 121;
+    readonly i16x8_abs: 128;
+    readonly i16x8_neg: 129;
+    readonly i16x8_all_true: 131;
+    readonly i16x8_bitmask: 132;
+    readonly i16x8_narrow_i32x4_s: 133;
+    readonly i16x8_narrow_i32x4_u: 134;
+    readonly i16x8_extend_low_i8x16_s: 135;
+    readonly i16x8_extend_high_i8x16_s: 136;
+    readonly i16x8_extend_low_i8x16_u: 137;
+    readonly i16x8_extend_high_i8x16_u: 138;
+    readonly i16x8_shl: 139;
+    readonly i16x8_shr_s: 140;
+    readonly i16x8_shr_u: 141;
+    readonly i16x8_add: 142;
+    readonly i16x8_add_sat_s: 143;
+    readonly i16x8_add_sat_u: 144;
+    readonly i16x8_sub: 145;
+    readonly i16x8_sub_sat_s: 146;
+    readonly i16x8_sub_sat_u: 147;
+    readonly i16x8_mul: 149;
+    readonly i16x8_min_s: 150;
+    readonly i16x8_min_u: 151;
+    readonly i16x8_max_s: 152;
+    readonly i16x8_max_u: 153;
+    readonly i32x4_abs: 160;
+    readonly i32x4_neg: 161;
+    readonly i32x4_all_true: 163;
+    readonly i32x4_bitmask: 164;
+    readonly i32x4_extend_low_i16x8_s: 167;
+    readonly i32x4_extend_high_i16x8_s: 168;
+    readonly i32x4_extend_low_i16x8_u: 169;
+    readonly i32x4_extend_high_i16x8_u: 170;
+    readonly i32x4_shl: 171;
+    readonly i32x4_shr_s: 172;
+    readonly i32x4_shr_u: 173;
+    readonly i32x4_add: 174;
+    readonly i32x4_sub: 177;
+    readonly i32x4_mul: 181;
+    readonly i32x4_min_s: 182;
+    readonly i32x4_min_u: 183;
+    readonly i32x4_max_s: 184;
+    readonly i32x4_max_u: 185;
+    readonly i64x2_abs: 192;
+    readonly i64x2_neg: 193;
+    readonly i64x2_all_true: 195;
+    readonly i64x2_bitmask: 196;
+    readonly i64x2_shl: 203;
+    readonly i64x2_shr_s: 204;
+    readonly i64x2_shr_u: 205;
+    readonly i64x2_add: 206;
+    readonly i64x2_sub: 209;
+    readonly i64x2_mul: 213;
+    readonly i64x2_eq: 214;
+    readonly i64x2_ne: 215;
+    readonly i64x2_lt_s: 216;
+    readonly i64x2_gt_s: 217;
+    readonly i64x2_le_s: 218;
+    readonly i64x2_ge_s: 219;
+    readonly f32x4_abs: 224;
+    readonly f32x4_neg: 225;
+    readonly f32x4_sqrt: 227;
+    readonly f32x4_add: 228;
+    readonly f32x4_sub: 229;
+    readonly f32x4_mul: 230;
+    readonly f32x4_div: 231;
+    readonly f32x4_min: 232;
+    readonly f32x4_max: 233;
+    readonly f32x4_pmin: 234;
+    readonly f32x4_pmax: 235;
+    readonly f64x2_abs: 236;
+    readonly f64x2_neg: 237;
+    readonly f64x2_sqrt: 239;
+    readonly f64x2_add: 240;
+    readonly f64x2_sub: 241;
+    readonly f64x2_mul: 242;
+    readonly f64x2_div: 243;
+    readonly f64x2_min: 244;
+    readonly f64x2_max: 245;
+    readonly f64x2_pmin: 246;
+    readonly f64x2_pmax: 247;
+    readonly i32x4_trunc_sat_f32x4_s: 248;
+    readonly i32x4_trunc_sat_f32x4_u: 249;
+    readonly f32x4_convert_i32x4_s: 250;
+    readonly f32x4_convert_i32x4_u: 251;
+    readonly i32x4_trunc_sat_f64x2_s_zero: 252;
+    readonly i32x4_trunc_sat_f64x2_u_zero: 253;
+    readonly f64x2_convert_low_i32x4_s: 254;
+    readonly f64x2_convert_low_i32x4_u: 255;
+    readonly v128_load8_lane: 84;
+    readonly v128_load16_lane: 85;
+    readonly v128_load32_lane: 86;
+    readonly v128_load64_lane: 87;
+    readonly v128_store8_lane: 88;
+    readonly v128_store16_lane: 89;
+    readonly v128_store32_lane: 90;
+    readonly v128_store64_lane: 91;
+    readonly v128_load32_zero: 92;
+    readonly v128_load64_zero: 93;
+};
+export declare const GC: {
+    readonly prefix: 251;
+    readonly struct_new: 0;
+    readonly struct_new_default: 1;
+    readonly struct_get: 2;
+    readonly struct_get_s: 3;
+    readonly struct_get_u: 4;
+    readonly struct_set: 5;
+    readonly array_new: 6;
+    readonly array_new_default: 7;
+    readonly array_new_fixed: 8;
+    readonly array_get: 11;
+    readonly array_get_s: 12;
+    readonly array_get_u: 13;
+    readonly array_set: 14;
+    readonly array_len: 15;
+    readonly array_fill: 16;
+    readonly array_copy: 17;
+    readonly ref_test: 20;
+    readonly ref_test_null: 21;
+    readonly ref_cast: 22;
+    readonly ref_cast_null: 23;
+    readonly any_convert_extern: 26;
+    readonly extern_convert_any: 27;
+};
+export declare const TYPE: {
+    readonly i32: 127;
+    readonly i64: 126;
+    readonly f32: 125;
+    readonly f64: 124;
+    readonly funcref: 112;
+    readonly externref: 111;
+    readonly struct: 95;
+    readonly array: 94;
+    readonly func: 96;
+    readonly rec: 78;
+    readonly sub: 80;
+    readonly sub_final: 79;
+    readonly ref: 100;
+    readonly ref_null: 99;
+    readonly any: 110;
+    readonly eq: 109;
+    readonly i31: 108;
+    readonly struct_ht: 107;
+    readonly array_ht: 106;
+    readonly none: 113;
+    readonly noextern: 114;
+    readonly nofunc: 115;
+    readonly v128: 123;
+    readonly i8: 120;
+    readonly i16: 119;
+    readonly const_field: 0;
+    readonly mut_field: 1;
+};
+export declare const SECTION: {
+    readonly custom: 0;
+    readonly type: 1;
+    readonly import: 2;
+    readonly function: 3;
+    readonly table: 4;
+    readonly memory: 5;
+    readonly global: 6;
+    readonly export: 7;
+    readonly start: 8;
+    readonly element: 9;
+    readonly code: 10;
+    readonly data: 11;
+    readonly tag: 13;
+};
+/** LLVM-style Wasm relocation types */
+export declare const RELOC: {
+    readonly R_WASM_FUNCTION_INDEX_LEB: 0;
+    readonly R_WASM_TABLE_INDEX_SLEB: 1;
+    readonly R_WASM_TABLE_INDEX_I32: 2;
+    readonly R_WASM_MEMORY_ADDR_LEB: 3;
+    readonly R_WASM_MEMORY_ADDR_SLEB: 4;
+    readonly R_WASM_MEMORY_ADDR_I32: 5;
+    readonly R_WASM_TYPE_INDEX_LEB: 6;
+    readonly R_WASM_GLOBAL_INDEX_LEB: 7;
+    readonly R_WASM_FUNCTION_OFFSET_I32: 8;
+    readonly R_WASM_SECTION_OFFSET_I32: 9;
+    readonly R_WASM_TAG_INDEX_LEB: 10;
+};
+/** Symbol flags for the linking section symbol table */
+export declare const SYM_FLAGS: {
+    readonly WASM_SYM_BINDING_WEAK: 1;
+    readonly WASM_SYM_BINDING_LOCAL: 2;
+    readonly WASM_SYM_VISIBILITY_HIDDEN: 4;
+    readonly WASM_SYM_UNDEFINED: 16;
+    readonly WASM_SYM_EXPORTED: 32;
+    readonly WASM_SYM_EXPLICIT_NAME: 64;
+    readonly WASM_SYM_NO_STRIP: 128;
+};
+/** Symbol kinds for the linking section symbol table */
+export declare const SYMTAB: {
+    readonly SYMTAB_FUNCTION: 0;
+    readonly SYMTAB_DATA: 1;
+    readonly SYMTAB_GLOBAL: 2;
+    readonly SYMTAB_SECTION: 3;
+    readonly SYMTAB_EVENT: 4;
+    readonly SYMTAB_TABLE: 5;
+};
+/** Linking section subsection types */
+export declare const LINKING_SUBSECTION: {
+    readonly WASM_SEGMENT_INFO: 5;
+    readonly WASM_INIT_FUNCS: 6;
+    readonly WASM_COMDAT_INFO: 7;
+    readonly WASM_SYMBOL_TABLE: 8;
+};

package/dist/emit/sourcemap.d.ts

@@ -0,0 +1,33 @@
+import { SourceMapEntry } from './binary.js';
+/** Source map v3 JSON structure */
+export interface SourceMapV3 {
+    version: 3;
+    sources: string[];
+    sourcesContent: (string | null)[];
+    names: string[];
+    mappings: string;
+}
+/** Encode a signed integer as a Base64 VLQ string */
+export declare function encodeVLQ(value: number): string;
+/** Decode a Base64 VLQ string back to a signed integer (for testing) */
+export declare function decodeVLQ(encoded: string): {
+    value: number;
+    rest: string;
+};
+/**
+ * Decode all VLQ segments from a mappings string.
+ * Returns an array of segments, where each segment is an array of decoded values.
+ * Groups are separated by semicolons (;) and segments within a group by commas (,).
+ */
+export declare function decodeMappings(mappings: string): number[][][];
+/**
+ * Generate a source map from wasm binary emission entries.
+ *
+ * Each entry maps a wasm byte offset to a source file position.
+ * The generated source map uses the wasm-specific convention where
+ * each mapping segment is on a separate "line" (separated by ;).
+ *
+ * @param entries Source map entries from binary emission
+ * @param sourcesContent Optional map from file name to source content
+ */
+export declare function generateSourceMap(entries: SourceMapEntry[], sourcesContent?: Map<string, string>): SourceMapV3;

package/dist/emit/wat.d.ts

@@ -0,0 +1,6 @@
+import { WasmModule } from '../ir/types.js';
+/** Escape a string for WAT text format (inside double quotes).
+ *  Handles backslash, double-quote, and control characters. */
+export declare function escapeWatString(s: string): string;
+/** Emit a WAT text representation of the IR module */
+export declare function emitWat(mod: WasmModule): string;

package/dist/env.d.ts

@@ -0,0 +1,46 @@
+import type * as fsType from "node:fs";
+import type * as pathType from "node:path";
+import type * as urlType from "node:url";
+import type * as moduleType from "node:module";
+/**
+ * Adapter for the host environment's filesystem and module-resolution APIs.
+ *
+ * Each field is `null` when the corresponding capability isn't available
+ * (e.g. browser builds get `null` for `fs`, `path`, `url`, `module`).
+ *
+ * Core compiler modules **must not** probe the runtime directly — they should
+ * receive an `Environment` and use whichever capabilities it provides.
+ */
+export interface Environment {
+    /** node:fs equivalent (or null in browsers) */
+    fs: typeof fsType | null;
+    /** node:path equivalent (or null in browsers) */
+    path: typeof pathType | null;
+    /** node:url equivalent (or null in browsers) */
+    url: typeof urlType | null;
+    /** node:module equivalent (or null in browsers) */
+    module: typeof moduleType | null;
+}
+/**
+ * Return a default `Environment` for the current runtime, computing it
+ * synchronously on first call and caching the result.
+ *
+ * - Browser-like runtimes get an environment with all capabilities `null`.
+ * - Node runtimes load `fs`, `path`, `url`, and `module` synchronously via
+ *   `process.getBuiltinModule` (Node 22+) or a CJS `require` fallback.
+ * - If neither sync loader is available (e.g. older Node ESM contexts), the
+ *   environment will have `null` capabilities; embedders can override via
+ *   `setDefaultEnvironment()`.
+ *
+ * **No top-level `await`** — this function is fully synchronous, which is
+ * why core compiler modules can keep calling it lazily without forcing the
+ * whole module graph through async initialization.
+ */
+export declare function getDefaultEnvironment(): Environment;
+/**
+ * Override the default environment. Useful for:
+ * - Embedding contexts where the runtime can't be probed (e.g. Wasm host).
+ * - Test harnesses that want to inject mocked filesystem behavior.
+ * - Resetting cached state between tests (pass `null`).
+ */
+export declare function setDefaultEnvironment(env: Environment | null): void;

package/dist/import-resolver.d.ts

@@ -0,0 +1,68 @@
+import { PositionMap } from './position-map.js';
+/** Recognized Node.js builtin module specifiers (#1044). */
+export declare const NODE_BUILTIN_MODULES: Set<string>;
+/** Returns true if `spec` is a recognized Node.js builtin (with or without `node:` prefix). */
+export declare function isNodeBuiltin(spec: string): boolean;
+/**
+ * Recognized JSX runtime module specifiers (#1540).
+ *
+ * TypeScript emits auto-imports from these specifiers when
+ * `compilerOptions.jsx === "react-jsx"` (or `jsxImportSource` is set).
+ * The default is `"react"` so the specifier is `"react/jsx-runtime"`;
+ * Preact uses `"preact/jsx-runtime"`, SolidJS uses
+ * `"solid-js/h/jsx-runtime"`, etc.
+ */
+export declare const JSX_RUNTIME_SPECIFIERS: Set<string>;
+export declare function isJsxRuntime(spec: string): boolean;
+/**
+ * Local-binding names for a detected JSX runtime import (#1540).
+ *
+ * TypeScript usually emits these as `import { jsx as _jsx, jsxs as _jsxs,
+ * Fragment as _Fragment } from "react/jsx-runtime"`, but the aliases are
+ * configurable via the user's source / TS options. We record the *local*
+ * names so codegen can route identifier references to the right host
+ * imports without hardcoding `_jsx`/`_jsxs`/`_Fragment`.
+ */
+export interface JsxRuntimeImport {
+    /** The module specifier (e.g. `"react/jsx-runtime"`). */
+    specifier: string;
+    /** Local binding for the `jsx` named export, if imported. */
+    localJsx?: string;
+    /** Local binding for the `jsxs` named export, if imported. */
+    localJsxs?: string;
+    /** Local binding for the `Fragment` named export, if imported. */
+    localFragment?: string;
+    /** Local binding for the `jsxDEV` named export (dev runtime), if imported. */
+    localJsxDev?: string;
+}
+/** Normalizes a module specifier by stripping the `node:` prefix if present. */
+export declare function normalizeNodeBuiltin(spec: string): string;
+/** Info about a Node builtin import discovered during preprocessing. */
+export interface NodeBuiltinImport {
+    /** The local binding name (e.g., `http` from `import http from 'node:http'`). */
+    localName: string;
+    /** The normalized module name (e.g., `http`). */
+    moduleName: string;
+    /** Named bindings imported (e.g., `['createServer', 'get']` from `import { createServer, get } from 'http'`). */
+    namedBindings?: string[];
+}
+/** Result of `preprocessImports`. */
+export interface PreprocessResult {
+    /** The transformed source code with import stubs. */
+    source: string;
+    /** Node builtin modules detected during preprocessing. */
+    nodeBuiltins: NodeBuiltinImport[];
+    /** JSX runtime import (if any) detected during preprocessing (#1540). */
+    jsxRuntime?: JsxRuntimeImport;
+    /**
+     * #1928 — maps an offset in `source` (the processed output) back to an
+     * offset in the input this function consumed, covering the import-stub
+     * replacements and the prepended timer shim. Identity when neither fired.
+     * Lets the diagnostic layer report the user's line numbers, not the
+     * rewritten ones.
+     */
+    positionMap: PositionMap;
+}
+export declare function preprocessImports(source: string, opts?: {
+    wasi?: boolean;
+}): PreprocessResult;