@loopdive/js2 0.57.0

package/dist/ir/types.d.ts

@@ -0,0 +1,832 @@
+export type FuncHandle = number;
+export type GlobalHandle = number;
+export type TypeHandle = number;
+export interface ExternClassMeta {
+    importPrefix: string;
+    namespacePath: string[];
+    className: string;
+    constructorParams: ValType[];
+    methods: Map<string, {
+        params: ValType[];
+        results: ValType[];
+    }>;
+    properties: Map<string, {
+        type: ValType;
+        readonly: boolean;
+    }>;
+}
+export interface WasmModule {
+    types: TypeDef[];
+    imports: Import[];
+    functions: WasmFunction[];
+    exports: WasmExport[];
+    tables: Table[];
+    elements: Element[];
+    globals: GlobalDef[];
+    tags: TagDef[];
+    stringPool: string[];
+    /** Extern class metadata (for .d.ts and imports helper generation) */
+    externClasses: ExternClassMeta[];
+    /** Node builtin module names detected from imports (#1044) */
+    nodeBuiltinModules: Set<string>;
+    /**
+     * JSX runtime import specifier detected during import preprocessing (#1540).
+     * `"react/jsx-runtime"` by default; `preact/jsx-runtime`, etc. for other
+     * configured `jsxImportSource` values. Recorded so the import manifest
+     * classifier can attach it to `jsx_runtime` ImportIntent entries.
+     */
+    jsxImportSource?: string;
+    /** Map from import func name → string literal value (e.g. "__str_0" → "Hello") */
+    stringLiteralValues: Map<string, string>;
+    /** Set of function names that are async (for .d.ts generation) */
+    asyncFunctions: Set<string>;
+    /** Function indices referenced by ref.func that need declarative element segments */
+    declaredFuncRefs: FuncHandle[];
+    /** Linear memory definitions */
+    memories: {
+        min: number;
+        max?: number;
+    }[];
+    /** Data segments for linear memory (string literals, etc.) */
+    dataSegments: {
+        offset: number;
+        bytes: Uint8Array;
+    }[];
+    /** Whether the module has top-level executable statements (module init code) */
+    hasTopLevelStatements?: boolean;
+    /** Wasm start function index — runs automatically on instantiation (#907) */
+    startFuncIdx?: FuncHandle;
+    /**
+     * Per-export TS-level type annotations (#1700). Surfaced so the JS-host
+     * `wrapExports` can faithfully marshal `Uint8Array` (and other TypedArray)
+     * params/results that share the same Wasm signature as `number[]`. Keyed
+     * by export name. Only populated for exports whose params/result reference
+     * TypedArray types.
+     */
+    exportSignatures?: Record<string, ExportSignature>;
+    /**
+     * Codegen diagnostics produced while lowering this module (#1868). The
+     * linear-memory backend (`generateLinearModule` / `generateLinearMultiModule`)
+     * accumulates unsupported-construct errors into its `ctx.errors` array; it
+     * surfaces them here so `compiler.ts` can fail the compile instead of
+     * emitting a structurally invalid binary (e.g. a stack-underflowing
+     * `local.set` after an unhandled `String.prototype.repeat`).
+     */
+    codegenErrors?: {
+        message: string;
+        line: number;
+        column: number;
+        severity?: "error" | "warning" | "degrade";
+    }[];
+}
+/** TS-level kind hint for a single export parameter or result (#1700). */
+export type TypedArrayKind = "uint8array" | "typed-array" | "other";
+export interface ExportSignature {
+    params: TypedArrayKind[];
+    result: TypedArrayKind;
+}
+export type TypeDef = FuncTypeDef | StructTypeDef | ArrayTypeDef | RecGroupDef | SubTypeDef;
+export interface FuncTypeDef {
+    kind: "func";
+    name?: string;
+    params: ValType[];
+    results: ValType[];
+}
+export interface StructTypeDef {
+    kind: "struct";
+    name: string;
+    fields: FieldDef[];
+    /** Type index of the parent struct (for class inheritance sub-typing) */
+    superTypeIdx?: TypeHandle;
+    /** When true and superTypeIdx is set, emit sub_final instead of sub (leaf types in hierarchy) */
+    final?: boolean;
+}
+export interface ArrayTypeDef {
+    kind: "array";
+    name: string;
+    element: ValType;
+    mutable: boolean;
+}
+export interface RecGroupDef {
+    kind: "rec";
+    types: TypeDef[];
+}
+export interface SubTypeDef {
+    kind: "sub";
+    name: string;
+    superType: TypeHandle | null;
+    final: boolean;
+    type: StructTypeDef | ArrayTypeDef | FuncTypeDef;
+}
+export interface FieldDef {
+    name: string;
+    type: ValType;
+    mutable: boolean;
+}
+export type ValType = {
+    kind: "i32";
+    boolean?: true;
+} | {
+    kind: "i64";
+    bigint?: boolean;
+} | {
+    kind: "f32";
+} | {
+    kind: "f64";
+} | {
+    kind: "v128";
+} | {
+    kind: "i8";
+} | {
+    kind: "i16";
+} | {
+    kind: "ref";
+    typeIdx: TypeHandle;
+} | {
+    kind: "ref_null";
+    typeIdx: TypeHandle;
+} | {
+    kind: "funcref";
+} | {
+    kind: "externref";
+} | {
+    kind: "ref_extern";
+} | {
+    kind: "eqref";
+} | {
+    kind: "anyref";
+};
+export interface WasmFunction {
+    name: string;
+    typeIdx: TypeHandle;
+    locals: LocalDef[];
+    body: Instr[];
+    exported: boolean;
+}
+export interface LocalDef {
+    name: string;
+    type: ValType;
+}
+/** Source position for source map generation */
+export interface SourcePos {
+    file: string;
+    line: number;
+    column: number;
+}
+type InstrBase = {
+    op: "local.get";
+    index: number;
+} | {
+    op: "local.set";
+    index: number;
+} | {
+    op: "local.tee";
+    index: number;
+} | {
+    op: "global.get";
+    index: GlobalHandle;
+} | {
+    op: "global.set";
+    index: GlobalHandle;
+} | {
+    op: "i32.const";
+    value: number;
+} | {
+    op: "i64.const";
+    value: bigint;
+} | {
+    op: "i64.add";
+} | {
+    op: "i64.sub";
+} | {
+    op: "i64.mul";
+} | {
+    op: "i64.div_s";
+} | {
+    op: "i64.div_u";
+} | {
+    op: "i64.rem_s";
+} | {
+    op: "i64.rem_u";
+} | {
+    op: "i64.eq";
+} | {
+    op: "i64.ne";
+} | {
+    op: "i64.lt_s";
+} | {
+    op: "i64.lt_u";
+} | {
+    op: "i64.le_s";
+} | {
+    op: "i64.le_u";
+} | {
+    op: "i64.gt_s";
+} | {
+    op: "i64.gt_u";
+} | {
+    op: "i64.ge_s";
+} | {
+    op: "i64.ge_u";
+} | {
+    op: "i64.eqz";
+} | {
+    op: "i64.and";
+} | {
+    op: "i64.or";
+} | {
+    op: "i64.xor";
+} | {
+    op: "i64.shl";
+} | {
+    op: "i64.shr_s";
+} | {
+    op: "i64.shr_u";
+} | {
+    op: "i64.extend_i32_s";
+} | {
+    op: "i64.extend_i32_u";
+} | {
+    op: "i64.trunc_f64_s";
+} | {
+    op: "i64.reinterpret_f64";
+} | {
+    op: "i32.reinterpret_f32";
+} | {
+    op: "f32.reinterpret_i32";
+} | {
+    op: "f64.convert_i64_s";
+} | {
+    op: "f64.reinterpret_i64";
+} | {
+    op: "f64.const";
+    value: number;
+} | {
+    op: "f32.const";
+    value: number;
+} | {
+    op: "i32.add";
+} | {
+    op: "i32.sub";
+} | {
+    op: "i32.mul";
+} | {
+    op: "i32.eq";
+} | {
+    op: "i32.ne";
+} | {
+    op: "i32.lt_s";
+} | {
+    op: "i32.le_s";
+} | {
+    op: "i32.gt_s";
+} | {
+    op: "i32.ge_s";
+} | {
+    op: "i32.ge_u";
+} | {
+    op: "i32.eqz";
+} | {
+    op: "i32.and";
+} | {
+    op: "i32.or";
+} | {
+    op: "i32.xor";
+} | {
+    op: "i32.shl";
+} | {
+    op: "i32.shr_s";
+} | {
+    op: "i32.shr_u";
+} | {
+    op: "i32.clz";
+} | {
+    op: "i32.wrap_i64";
+} | {
+    op: "i32.trunc_f64_u";
+} | {
+    op: "i32.trunc_sat_f64_s";
+} | {
+    op: "i32.trunc_sat_f64_u";
+} | {
+    op: "i64.trunc_sat_f64_s";
+} | {
+    op: "f64.add";
+} | {
+    op: "f64.sub";
+} | {
+    op: "f64.mul";
+} | {
+    op: "f64.div";
+} | {
+    op: "f64.eq";
+} | {
+    op: "f64.ne";
+} | {
+    op: "f64.lt";
+} | {
+    op: "f64.le";
+} | {
+    op: "f64.gt";
+} | {
+    op: "f64.ge";
+} | {
+    op: "f64.sqrt";
+} | {
+    op: "f64.abs";
+} | {
+    op: "f64.neg";
+} | {
+    op: "f64.floor";
+} | {
+    op: "f64.ceil";
+} | {
+    op: "f64.trunc";
+} | {
+    op: "f64.nearest";
+} | {
+    op: "f64.copysign";
+} | {
+    op: "f64.min";
+} | {
+    op: "f64.max";
+} | {
+    op: "i32.trunc_f64_s";
+} | {
+    op: "f64.convert_i32_s";
+} | {
+    op: "f64.convert_i32_u";
+} | {
+    op: "block";
+    blockType: BlockType;
+    body: Instr[];
+} | {
+    op: "loop";
+    blockType: BlockType;
+    body: Instr[];
+} | {
+    op: "if";
+    blockType: BlockType;
+    then: Instr[];
+    else?: Instr[];
+} | {
+    op: "br";
+    depth: number;
+} | {
+    op: "br_if";
+    depth: number;
+} | {
+    op: "br_table";
+} | {
+    op: "return";
+} | {
+    op: "end";
+} | {
+    op: "call";
+    funcIdx: FuncHandle;
+} | {
+    op: "return_call";
+    funcIdx: FuncHandle;
+} | {
+    op: "call_indirect";
+    typeIdx: TypeHandle;
+    tableIdx: number;
+} | {
+    op: "drop";
+} | {
+    op: "select";
+} | {
+    op: "unreachable";
+} | {
+    op: "nop";
+} | {
+    op: "struct.new";
+    typeIdx: TypeHandle;
+} | {
+    op: "struct.get";
+    typeIdx: TypeHandle;
+    fieldIdx: number;
+} | {
+    op: "struct.set";
+    typeIdx: TypeHandle;
+    fieldIdx: number;
+} | {
+    op: "array.new";
+    typeIdx: TypeHandle;
+} | {
+    op: "array.new_fixed";
+    typeIdx: TypeHandle;
+    length: number;
+} | {
+    op: "array.new_default";
+    typeIdx: TypeHandle;
+} | {
+    op: "array.get";
+    typeIdx: TypeHandle;
+} | {
+    op: "array.get_s";
+    typeIdx: TypeHandle;
+} | {
+    op: "array.get_u";
+    typeIdx: TypeHandle;
+} | {
+    op: "array.set";
+    typeIdx: TypeHandle;
+} | {
+    op: "array.len";
+} | {
+    op: "array.copy";
+    dstTypeIdx: TypeHandle;
+    srcTypeIdx: TypeHandle;
+} | {
+    op: "array.fill";
+    typeIdx: TypeHandle;
+} | {
+    op: "ref.null";
+    typeIdx: TypeHandle;
+} | {
+    op: "ref.null.extern";
+} | {
+    op: "ref.null.eq";
+} | {
+    op: "ref.null.func";
+} | {
+    op: "ref.is_null";
+} | {
+    op: "ref.as_non_null";
+} | {
+    op: "ref.cast";
+    typeIdx: TypeHandle;
+} | {
+    op: "ref.cast_null";
+    typeIdx: TypeHandle;
+} | {
+    op: "ref.test";
+    typeIdx: TypeHandle;
+} | {
+    op: "ref.eq";
+} | {
+    op: "ref.func";
+    funcIdx: FuncHandle;
+} | {
+    op: "call_ref";
+    typeIdx: TypeHandle;
+} | {
+    op: "return_call_ref";
+    typeIdx: TypeHandle;
+} | {
+    op: "memory.size";
+} | {
+    op: "memory.grow";
+} | {
+    op: "try";
+    blockType: BlockType;
+    body: Instr[];
+    catches: CatchClause[];
+    catchAll?: Instr[];
+} | {
+    op: "throw";
+    tagIdx: number;
+} | {
+    op: "rethrow";
+    depth: number;
+} | {
+    op: "any.convert_extern";
+} | {
+    op: "extern.convert_any";
+} | {
+    op: "i32.load";
+    align: number;
+    offset: number;
+} | {
+    op: "i32.load8_u";
+    align: number;
+    offset: number;
+} | {
+    op: "i32.load8_s";
+    align: number;
+    offset: number;
+} | {
+    op: "i32.load16_u";
+    align: number;
+    offset: number;
+} | {
+    op: "i32.store";
+    align: number;
+    offset: number;
+} | {
+    op: "i64.store";
+    align: number;
+    offset: number;
+} | {
+    op: "i32.store8";
+    align: number;
+    offset: number;
+} | {
+    op: "i32.store16";
+    align: number;
+    offset: number;
+} | {
+    op: "i32.div_u";
+} | {
+    op: "i32.div_s";
+} | {
+    op: "i32.rem_u";
+} | {
+    op: "i32.rem_s";
+} | {
+    op: "i32.lt_u";
+} | {
+    op: "i32.le_u";
+} | {
+    op: "i32.gt_u";
+} | {
+    op: "f64.load";
+    align: number;
+    offset: number;
+} | {
+    op: "f64.store";
+    align: number;
+    offset: number;
+} | {
+    op: "f32.load";
+    align: number;
+    offset: number;
+} | {
+    op: "f32.store";
+    align: number;
+    offset: number;
+} | {
+    op: "f32.demote_f64";
+} | {
+    op: "f64.promote_f32";
+} | {
+    op: "v128.const";
+    bytes: Uint8Array;
+} | {
+    op: "v128.load";
+    align: number;
+    offset: number;
+} | {
+    op: "v128.store";
+    align: number;
+    offset: number;
+} | {
+    op: "v128.not";
+} | {
+    op: "v128.and";
+} | {
+    op: "v128.andnot";
+} | {
+    op: "v128.or";
+} | {
+    op: "v128.xor";
+} | {
+    op: "v128.bitselect";
+} | {
+    op: "v128.any_true";
+} | {
+    op: "i8x16.splat";
+} | {
+    op: "i8x16.extract_lane_s";
+    lane: number;
+} | {
+    op: "i8x16.extract_lane_u";
+    lane: number;
+} | {
+    op: "i8x16.replace_lane";
+    lane: number;
+} | {
+    op: "i8x16.eq";
+} | {
+    op: "i8x16.ne";
+} | {
+    op: "i8x16.all_true";
+} | {
+    op: "i8x16.bitmask";
+} | {
+    op: "i8x16.swizzle";
+} | {
+    op: "i8x16.shuffle";
+    lanes: number[];
+} | {
+    op: "i8x16.add";
+} | {
+    op: "i8x16.sub";
+} | {
+    op: "i8x16.min_u";
+} | {
+    op: "i8x16.max_u";
+} | {
+    op: "i16x8.splat";
+} | {
+    op: "i16x8.extract_lane_s";
+    lane: number;
+} | {
+    op: "i16x8.extract_lane_u";
+    lane: number;
+} | {
+    op: "i16x8.replace_lane";
+    lane: number;
+} | {
+    op: "i16x8.eq";
+} | {
+    op: "i16x8.ne";
+} | {
+    op: "i16x8.lt_s";
+} | {
+    op: "i16x8.gt_s";
+} | {
+    op: "i16x8.all_true";
+} | {
+    op: "i16x8.bitmask";
+} | {
+    op: "i16x8.add";
+} | {
+    op: "i16x8.sub";
+} | {
+    op: "i16x8.mul";
+} | {
+    op: "i16x8.shl";
+} | {
+    op: "i16x8.shr_u";
+} | {
+    op: "i32x4.splat";
+} | {
+    op: "i32x4.extract_lane";
+    lane: number;
+} | {
+    op: "i32x4.replace_lane";
+    lane: number;
+} | {
+    op: "i32x4.eq";
+} | {
+    op: "i32x4.ne";
+} | {
+    op: "i32x4.all_true";
+} | {
+    op: "i32x4.bitmask";
+} | {
+    op: "i32x4.add";
+} | {
+    op: "i32x4.sub";
+} | {
+    op: "i32x4.mul";
+} | {
+    op: "i32x4.shl";
+} | {
+    op: "i32x4.shr_s";
+} | {
+    op: "i32x4.shr_u";
+} | {
+    op: "i64x2.splat";
+} | {
+    op: "i64x2.extract_lane";
+    lane: number;
+} | {
+    op: "i64x2.replace_lane";
+    lane: number;
+} | {
+    op: "i64x2.add";
+} | {
+    op: "i64x2.sub";
+} | {
+    op: "i64x2.mul";
+} | {
+    op: "i64x2.eq";
+} | {
+    op: "i64x2.ne";
+} | {
+    op: "f32x4.splat";
+} | {
+    op: "f32x4.extract_lane";
+    lane: number;
+} | {
+    op: "f32x4.replace_lane";
+    lane: number;
+} | {
+    op: "f32x4.eq";
+} | {
+    op: "f32x4.add";
+} | {
+    op: "f32x4.sub";
+} | {
+    op: "f32x4.mul";
+} | {
+    op: "f32x4.div";
+} | {
+    op: "f64x2.splat";
+} | {
+    op: "f64x2.extract_lane";
+    lane: number;
+} | {
+    op: "f64x2.replace_lane";
+    lane: number;
+} | {
+    op: "f64x2.eq";
+} | {
+    op: "f64x2.ne";
+} | {
+    op: "f64x2.add";
+} | {
+    op: "f64x2.sub";
+} | {
+    op: "f64x2.mul";
+} | {
+    op: "f64x2.div";
+} | {
+    op: "v128.load8_splat";
+    align: number;
+    offset: number;
+} | {
+    op: "v128.load16_splat";
+    align: number;
+    offset: number;
+} | {
+    op: "v128.load32_splat";
+    align: number;
+    offset: number;
+} | {
+    op: "v128.load64_splat";
+    align: number;
+    offset: number;
+} | {
+    op: "v128.load32_zero";
+    align: number;
+    offset: number;
+} | {
+    op: "v128.load64_zero";
+    align: number;
+    offset: number;
+};
+export type Instr = InstrBase & {
+    sourcePos?: SourcePos;
+};
+export type BlockType = {
+    kind: "empty";
+} | {
+    kind: "val";
+    type: ValType;
+} | {
+    kind: "type";
+    typeIdx: TypeHandle;
+};
+export interface CatchClause {
+    tagIdx: number;
+    body: Instr[];
+}
+export interface TagDef {
+    name: string;
+    /** Type index of the tag's function signature (params = exception values) */
+    typeIdx: TypeHandle;
+}
+export interface Import {
+    module: string;
+    name: string;
+    desc: ImportDesc;
+}
+export type ImportDesc = {
+    kind: "func";
+    typeIdx: TypeHandle;
+} | {
+    kind: "table";
+    elementType: string;
+    min: number;
+    max?: number;
+} | {
+    kind: "global";
+    type: ValType;
+    mutable: boolean;
+} | {
+    kind: "memory";
+    min: number;
+    max?: number;
+} | {
+    kind: "tag";
+    typeIdx: TypeHandle;
+};
+export interface WasmExport {
+    name: string;
+    desc: {
+        kind: "func" | "table" | "memory" | "global" | "tag";
+        index: number;
+    };
+}
+export interface Table {
+    elementType: string;
+    min: number;
+    max?: number;
+}
+export interface Element {
+    tableIdx: number;
+    offset: Instr[];
+    funcIndices: FuncHandle[];
+}
+export interface GlobalDef {
+    name: string;
+    type: ValType;
+    mutable: boolean;
+    init: Instr[];
+}
+export declare function createEmptyModule(): WasmModule;
+export {};