@thomasfosterau/effect-parse 0.4.1 → 0.5.0

package/dist/internal/compiler/wasmAsm.d.ts

@@ -0,0 +1,199 @@
+/**
+ * A small WebAssembly assembler for the WASM compiler: function bodies with
+ * structured labels, and the binary module around them. It writes only the
+ * instructions and sections that compiler uses.
+ */
+/** Value types. */
+export declare const I32 = 127;
+export declare const I64 = 126;
+export declare const F64 = 124;
+export declare const V128 = 123;
+/** Opcodes used by the compiler. */
+export declare const Op: {
+  readonly unreachable: 0;
+  readonly block: 2;
+  readonly loop: 3;
+  readonly if: 4;
+  readonly else: 5;
+  readonly end: 11;
+  readonly br: 12;
+  readonly brIf: 13;
+  readonly brTable: 14;
+  readonly return: 15;
+  readonly call: 16;
+  readonly drop: 26;
+  readonly select: 27;
+  readonly localGet: 32;
+  readonly localSet: 33;
+  readonly localTee: 34;
+  readonly globalGet: 35;
+  readonly globalSet: 36;
+  readonly i32Load: 40;
+  readonly i64Load: 41;
+  readonly f64Load: 43;
+  readonly i32Load8U: 45;
+  readonly i32Load16U: 47;
+  readonly i32Store: 54;
+  readonly i64Store: 55;
+  readonly i32Store8: 58;
+  readonly i32Store16: 59;
+  readonly f64Store: 57;
+  readonly i32Const: 65;
+  readonly i64Const: 66;
+  readonly f64Const: 68;
+  readonly i32Eqz: 69;
+  readonly i32Eq: 70;
+  readonly i32Ne: 71;
+  readonly i32LtS: 72;
+  readonly i32LtU: 73;
+  readonly i32GtS: 74;
+  readonly i32GtU: 75;
+  readonly i32LeS: 76;
+  readonly i32LeU: 77;
+  readonly i32GeS: 78;
+  readonly i32GeU: 79;
+  readonly i64Eqz: 80;
+  readonly i64Ne: 82;
+  readonly f64Eq: 97;
+  readonly f64Ne: 98;
+  readonly i32Add: 106;
+  readonly i32Sub: 107;
+  readonly i32Mul: 108;
+  readonly i32And: 113;
+  readonly i32Or: 114;
+  readonly i32Xor: 115;
+  readonly i32Shl: 116;
+  readonly i32ShrU: 118;
+  readonly i32Ctz: 104;
+  readonly i64And: 131;
+  readonly i64Or: 132;
+  readonly i64Shl: 134;
+  readonly i64ShrU: 136;
+  readonly f64Abs: 153;
+  readonly f64Neg: 154;
+  readonly f64Add: 160;
+  readonly f64Sub: 161;
+  readonly f64Mul: 162;
+  readonly f64Div: 163;
+  readonly f64ConvertI32U: 184;
+};
+/** Unsigned LEB128. */
+export declare const uleb: (n: number, out?: Array<number>) => Array<number>;
+/** Signed LEB128 of a 32-bit integer. */
+export declare const sleb: (n: number, out?: Array<number>) => Array<number>;
+/** SIMD opcodes, after the `0xfd` prefix. */
+export declare const Simd: {
+  readonly v128Load: 0;
+  readonly v128Store: 11;
+  readonly v128Const: 12;
+  readonly i8x16Swizzle: 14;
+  readonly i8x16Splat: 15;
+  readonly i8x16Eq: 35;
+  readonly i8x16Ne: 36;
+  readonly v128Not: 77;
+  readonly v128And: 78;
+  readonly v128Or: 80;
+  readonly v128AnyTrue: 83;
+  readonly i8x16AllTrue: 99;
+  readonly i8x16Bitmask: 100;
+  readonly i8x16ShrU: 109;
+  readonly i8x16RelaxedSwizzle: 256;
+  readonly i16x8ExtendLowI8x16U: 137;
+  readonly i16x8ExtendHighI8x16U: 138;
+};
+/** A branch target: a block, a loop or an `if`. */
+export declare class Label {
+  readonly _label = true;
+}
+/**
+ * The body of a function being written: its code, its locals (after the
+ * parameters) and the stack of labels that branches refer to.
+ */
+export declare class Body {
+  readonly params: number;
+  readonly code: Array<number>;
+  /** The types of the locals after the parameters. */
+  private readonly types;
+  private readonly labels;
+  private next;
+  /** Trace writes since the last check that dominates the code that follows (see the compiler). */
+  writes: number;
+  /** The local holding the trace pointer, in the compiler's rule functions. */
+  tp: number;
+  /** The local holding the end of the input, in the compiler's rule functions (-1: read the global). */
+  endLocal: number;
+  constructor(params: number);
+  /** A new local of type `i32`. */
+  local(): number;
+  /** A new local of type `i64`. */
+  localI64(): number;
+  /** A new local of type `v128`. */
+  localV128(): number;
+  /** A new local of type `f64`. */
+  localF64(): number;
+  /** The locals declaration, in index order (runs of one type each). */
+  locals(): Array<number>;
+  op(...bytes: ReadonlyArray<number>): this;
+  i32(n: number): this;
+  i64(n: bigint): this;
+  f64(x: number): this;
+  get(l: number): this;
+  set(l: number): this;
+  tee(l: number): this;
+  gget(g: number): this;
+  gset(g: number): this;
+  call(f: number): this;
+  /** `v128.const` of sixteen bytes. */
+  v128(bytes: ArrayLike<number>): this;
+  /** A SIMD instruction, with a memory access's alignment and offset for loads and stores. */
+  simd(op: number, align?: number, offset?: number): this;
+  /** A memory access with an alignment exponent and a constant offset. */
+  mem(op: number, align: number, offset: number): this;
+  /** `block ... end`: a branch to its label exits the block. */
+  block(body: (exit: Label) => void): this;
+  /** `loop ... end`: a branch to its label restarts the loop. */
+  loop(body: (again: Label) => void): this;
+  /** `if ... (else ...) end` on the `i32` at the top of the stack. */
+  if(then: () => void, otherwise?: () => void): this;
+  /** `if (result i32) ... else ... end`. */
+  ifI32(then: () => void, otherwise: () => void): this;
+  private structured;
+  /**
+   * Whether a branch went to a label out of scope: a bug in the compiler,
+   * which then refuses the function (see the WebAssembly compiler).
+   */
+  invalid: boolean;
+  private depth;
+  br(label: Label): this;
+  brIf(label: Label): this;
+  /** `br_table`: `targets[i]` for the index at the top of the stack, `otherwise` out of range. */
+  brTable(targets: ReadonlyArray<Label>, otherwise: Label): this;
+}
+/** A function type: parameter and result types. */
+export interface FuncType {
+  readonly params: ReadonlyArray<number>;
+  readonly results: ReadonlyArray<number>;
+}
+/** A global: its type, whether it is mutable, and its initial value. */
+export interface Global {
+  readonly type: number;
+  readonly init: number;
+}
+/** What a module is made of. */
+export interface ModuleSpec {
+  readonly types: ReadonlyArray<FuncType>;
+  /** Imported functions: module, name, type index. */
+  readonly imports: ReadonlyArray<readonly [string, string, number]>;
+  /** The imported memory (module "env", name "mem"). */
+  readonly memoryPages: number;
+  /** Defined functions: type index and body. */
+  readonly functions: ReadonlyArray<readonly [number, Body]>;
+  readonly globals: ReadonlyArray<Global>;
+  /** Exported functions and globals: name, kind (0 function, 3 global), index. */
+  readonly exports: ReadonlyArray<readonly [string, 0 | 3, number]>;
+  /** Active data segments: offset and bytes. */
+  readonly data: ReadonlyArray<readonly [number, Uint8Array]>;
+}
+/** The binary module. */
+export declare const encodeModule: (spec: ModuleSpec) => Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=wasmAsm.d.ts.map

package/dist/internal/compiler/wasmAsm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasmAsm.d.ts","names":[],"sources":["../../../src/internal/compiler/wasmAsm.ts"],"mappings":";;;;;;qBAOa;qBACA;qBACA;qBACA;;qBAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsEA,OAAQ,WAAW,MAAK,kBAAqB;;qBAY7C,OAAQ,WAAW,MAAK,kBAAqB;;qBAc7C;;;;;;;;;;;;;;;;;;;;qBAmCA;WACF;;;;;;qBAOE;WAaU;WAZZ,MAAM;;mBAEE;mBACA;UACT;;EAER;;EAEA;;EAEA;EAEqB,YAAA;;EAKrB;;EAMA;;EAMA;;EAMA;;EAMA,UAAU;EAeV,MAAM,OAAO;EAKb,IAAI;EAMJ,IAAI;EAMJ,IAAI;EAOJ,IAAI;EAMJ,IAAI;EAMJ,IAAI;EAMJ,KAAK;EAML,KAAK;EAML,KAAK;;EAOL,KAAK,OAAO;;EAQZ,KAAK,YAAY,gBAAY;;EAW7B,IAAI,YAAY,eAAe;;EAQ/B,MAAM,OAAO,MAAM;;EAKnB,KAAK,OAAO,OAAO;;EAKnB,GAAG,kBAAkB;;EAcrB,MAAM,kBAAkB;UAWhB;;;;;EAcR;UAEQ;EAMR,GAAG,OAAO;EAMV,KAAK,OAAO;;EAOZ,QAAQ,SAAS,cAAc,QAAQ,WAAW;;;iBAUnC;WACN,QAAQ;WACR,SAAS;;;iBAIH;WACN;WACA;;;iBAIM;WACN,OAAO,cAAc;;WAErB,SAAS;;WAET;;WAEA,WAAW,gCAAgC;WAC3C,SAAS,cAAc;;WAEvB,SAAS;;WAET,MAAM,gCAAgC;;;qBAkCpC,eAAgB,MAAM,eAAa,WAAW"}

package/dist/internal/compiler/wasmAsm.js

@@ -0,0 +1,427 @@
+// src/internal/compiler/wasmAsm.ts
+/**
+* A small WebAssembly assembler for the WASM compiler: function bodies with
+* structured labels, and the binary module around them. It writes only the
+* instructions and sections that compiler uses.
+*/
+/** Value types. */
+const I32 = 127;
+const I64 = 126;
+const F64 = 124;
+const V128 = 123;
+const Void = 64;
+/** Opcodes used by the compiler. */
+const Op = {
+	unreachable: 0,
+	block: 2,
+	loop: 3,
+	if: 4,
+	else: 5,
+	end: 11,
+	br: 12,
+	brIf: 13,
+	brTable: 14,
+	return: 15,
+	call: 16,
+	drop: 26,
+	select: 27,
+	localGet: 32,
+	localSet: 33,
+	localTee: 34,
+	globalGet: 35,
+	globalSet: 36,
+	i32Load: 40,
+	i64Load: 41,
+	f64Load: 43,
+	i32Load8U: 45,
+	i32Load16U: 47,
+	i32Store: 54,
+	i64Store: 55,
+	i32Store8: 58,
+	i32Store16: 59,
+	f64Store: 57,
+	i32Const: 65,
+	i64Const: 66,
+	f64Const: 68,
+	i32Eqz: 69,
+	i32Eq: 70,
+	i32Ne: 71,
+	i32LtS: 72,
+	i32LtU: 73,
+	i32GtS: 74,
+	i32GtU: 75,
+	i32LeS: 76,
+	i32LeU: 77,
+	i32GeS: 78,
+	i32GeU: 79,
+	i64Eqz: 80,
+	i64Ne: 82,
+	f64Eq: 97,
+	f64Ne: 98,
+	i32Add: 106,
+	i32Sub: 107,
+	i32Mul: 108,
+	i32And: 113,
+	i32Or: 114,
+	i32Xor: 115,
+	i32Shl: 116,
+	i32ShrU: 118,
+	i32Ctz: 104,
+	i64And: 131,
+	i64Or: 132,
+	i64Shl: 134,
+	i64ShrU: 136,
+	f64Abs: 153,
+	f64Neg: 154,
+	f64Add: 160,
+	f64Sub: 161,
+	f64Mul: 162,
+	f64Div: 163,
+	f64ConvertI32U: 184
+};
+/** Unsigned LEB128. */
+const uleb = (n, out = []) => {
+	let v = n >>> 0;
+	do {
+		let b = v & 127;
+		v >>>= 7;
+		if (v !== 0) b |= 128;
+		out.push(b);
+	} while (v !== 0);
+	return out;
+};
+/** Signed LEB128 of a 32-bit integer. */
+const sleb = (n, out = []) => {
+	let v = n | 0;
+	for (;;) {
+		const b = v & 127;
+		v >>= 7;
+		if (v === 0 && (b & 64) === 0 || v === -1 && (b & 64) !== 0) {
+			out.push(b);
+			return out;
+		}
+		out.push(b | 128);
+	}
+};
+/** SIMD opcodes, after the `0xfd` prefix. */
+const Simd = {
+	v128Load: 0,
+	v128Store: 11,
+	v128Const: 12,
+	i8x16Swizzle: 14,
+	i8x16Splat: 15,
+	i8x16Eq: 35,
+	i8x16Ne: 36,
+	v128Not: 77,
+	v128And: 78,
+	v128Or: 80,
+	v128AnyTrue: 83,
+	i8x16AllTrue: 99,
+	i8x16Bitmask: 100,
+	i8x16ShrU: 109,
+	i8x16RelaxedSwizzle: 256,
+	i16x8ExtendLowI8x16U: 137,
+	i16x8ExtendHighI8x16U: 138
+};
+/** Signed LEB128 of a 64-bit integer. */
+const sleb64 = (n, out) => {
+	let v = BigInt.asIntN(64, n);
+	for (;;) {
+		const b = Number(v & 127n);
+		v >>= 7n;
+		if (v === 0n && (b & 64) === 0 || v === -1n && (b & 64) !== 0) {
+			out.push(b);
+			return out;
+		}
+		out.push(b | 128);
+	}
+};
+/** A branch target: a block, a loop or an `if`. */
+var Label = class {
+	_label = true;
+};
+/**
+* The body of a function being written: its code, its locals (after the
+* parameters) and the stack of labels that branches refer to.
+*/
+var Body = class {
+	params;
+	code = [];
+	/** The types of the locals after the parameters. */
+	types = [];
+	labels = [];
+	next;
+	/** Trace writes since the last check that dominates the code that follows (see the compiler). */
+	writes = 0;
+	/** The local holding the trace pointer, in the compiler's rule functions. */
+	tp = -1;
+	/** The local holding the end of the input, in the compiler's rule functions (-1: read the global). */
+	endLocal = -1;
+	constructor(params) {
+		this.params = params;
+		this.next = params;
+	}
+	/** A new local of type `i32`. */
+	local() {
+		this.types.push(127);
+		return this.next++;
+	}
+	/** A new local of type `i64`. */
+	localI64() {
+		this.types.push(126);
+		return this.next++;
+	}
+	/** A new local of type `v128`. */
+	localV128() {
+		this.types.push(123);
+		return this.next++;
+	}
+	/** A new local of type `f64`. */
+	localF64() {
+		this.types.push(124);
+		return this.next++;
+	}
+	/** The locals declaration, in index order (runs of one type each). */
+	locals() {
+		const groups = [];
+		for (const type of this.types) {
+			const last = groups[groups.length - 1];
+			if (last !== void 0 && last[1] === type) last[0]++;
+			else groups.push([1, type]);
+		}
+		const out = uleb(groups.length);
+		for (const [n, type] of groups) {
+			uleb(n, out);
+			out.push(type);
+		}
+		return out;
+	}
+	op(...bytes) {
+		for (const b of bytes) this.code.push(b);
+		return this;
+	}
+	i32(n) {
+		this.code.push(Op.i32Const);
+		sleb(n, this.code);
+		return this;
+	}
+	i64(n) {
+		this.code.push(Op.i64Const);
+		sleb64(n, this.code);
+		return this;
+	}
+	f64(x) {
+		this.code.push(Op.f64Const);
+		const bytes = new Uint8Array(new Float64Array([x]).buffer);
+		for (const b of bytes) this.code.push(b);
+		return this;
+	}
+	get(l) {
+		this.code.push(Op.localGet);
+		uleb(l, this.code);
+		return this;
+	}
+	set(l) {
+		this.code.push(Op.localSet);
+		uleb(l, this.code);
+		return this;
+	}
+	tee(l) {
+		this.code.push(Op.localTee);
+		uleb(l, this.code);
+		return this;
+	}
+	gget(g) {
+		this.code.push(Op.globalGet);
+		uleb(g, this.code);
+		return this;
+	}
+	gset(g) {
+		this.code.push(Op.globalSet);
+		uleb(g, this.code);
+		return this;
+	}
+	call(f) {
+		this.code.push(Op.call);
+		uleb(f, this.code);
+		return this;
+	}
+	/** `v128.const` of sixteen bytes. */
+	v128(bytes) {
+		this.code.push(253);
+		uleb(Simd.v128Const, this.code);
+		for (let i = 0; i < 16; i++) this.code.push((bytes[i] ?? 0) & 255);
+		return this;
+	}
+	/** A SIMD instruction, with a memory access's alignment and offset for loads and stores. */
+	simd(op, align = -1, offset = 0) {
+		this.code.push(253);
+		uleb(op, this.code);
+		if (align >= 0) {
+			uleb(align, this.code);
+			uleb(offset, this.code);
+		}
+		return this;
+	}
+	/** A memory access with an alignment exponent and a constant offset. */
+	mem(op, align, offset) {
+		this.code.push(op);
+		uleb(align, this.code);
+		uleb(offset, this.code);
+		return this;
+	}
+	/** `block ... end`: a branch to its label exits the block. */
+	block(body) {
+		return this.structured(Op.block, body);
+	}
+	/** `loop ... end`: a branch to its label restarts the loop. */
+	loop(body) {
+		return this.structured(Op.loop, body);
+	}
+	/** `if ... (else ...) end` on the `i32` at the top of the stack. */
+	if(then, otherwise) {
+		this.code.push(Op.if, Void);
+		this.labels.push(new Label());
+		then();
+		if (otherwise !== void 0) {
+			this.code.push(Op.else);
+			otherwise();
+		}
+		this.labels.pop();
+		this.code.push(Op.end);
+		return this;
+	}
+	/** `if (result i32) ... else ... end`. */
+	ifI32(then, otherwise) {
+		this.code.push(Op.if, 127);
+		this.labels.push(new Label());
+		then();
+		this.code.push(Op.else);
+		otherwise();
+		this.labels.pop();
+		this.code.push(Op.end);
+		return this;
+	}
+	structured(op, body) {
+		const label = new Label();
+		this.code.push(op, Void);
+		this.labels.push(label);
+		body(label);
+		this.labels.pop();
+		this.code.push(Op.end);
+		return this;
+	}
+	/**
+	* Whether a branch went to a label out of scope: a bug in the compiler,
+	* which then refuses the function (see the WebAssembly compiler).
+	*/
+	invalid = false;
+	depth(label) {
+		const i = this.labels.lastIndexOf(label);
+		if (i < 0) this.invalid = true;
+		return this.labels.length - 1 - i;
+	}
+	br(label) {
+		this.code.push(Op.br);
+		uleb(this.depth(label), this.code);
+		return this;
+	}
+	brIf(label) {
+		this.code.push(Op.brIf);
+		uleb(this.depth(label), this.code);
+		return this;
+	}
+	/** `br_table`: `targets[i]` for the index at the top of the stack, `otherwise` out of range. */
+	brTable(targets, otherwise) {
+		this.code.push(Op.brTable);
+		uleb(targets.length, this.code);
+		for (const t of targets) uleb(this.depth(t), this.code);
+		uleb(this.depth(otherwise), this.code);
+		return this;
+	}
+};
+const utf8Encoder = /*#__PURE__*/ new TextEncoder();
+/** Appends `bytes` to `out`. */
+const append = (out, bytes) => {
+	for (let i = 0; i < bytes.length; i++) out.push(bytes[i]);
+};
+/** Appends a name: its length and its UTF-8 bytes. */
+const name = (out, s) => {
+	const bytes = utf8Encoder.encode(s);
+	uleb(bytes.length, out);
+	append(out, bytes);
+};
+/** Appends a section: its id, its size, the number of its items and the items `write` appends. */
+const section = (out, id, items, write) => {
+	const body = uleb(items.length);
+	for (const item of items) write(body, item);
+	out.push(id);
+	uleb(body.length, out);
+	append(out, body);
+};
+const f64Bytes = (x) => new Uint8Array(new Float64Array([x]).buffer);
+/** The binary module. */
+const encodeModule = (spec) => {
+	const out = [
+		0,
+		97,
+		115,
+		109,
+		1,
+		0,
+		0,
+		0
+	];
+	section(out, 1, spec.types, (body, t) => {
+		body.push(96);
+		uleb(t.params.length, body);
+		append(body, t.params);
+		uleb(t.results.length, body);
+		append(body, t.results);
+	});
+	const memory = [
+		"env",
+		"mem",
+		-1
+	];
+	section(out, 2, [...spec.imports, memory], (body, [m, n, t]) => {
+		name(body, m);
+		name(body, n);
+		if (t < 0) body.push(2, 0, ...uleb(spec.memoryPages));
+		else body.push(0, ...uleb(t));
+	});
+	section(out, 3, spec.functions, (body, [t]) => uleb(t, body));
+	section(out, 6, spec.globals, (body, g) => {
+		if (g.type === 124) {
+			body.push(124, 1, Op.f64Const);
+			append(body, f64Bytes(g.init));
+		} else {
+			body.push(127, 1, Op.i32Const);
+			sleb(g.init, body);
+		}
+		body.push(Op.end);
+	});
+	section(out, 7, spec.exports, (body, [n, kind, i]) => {
+		name(body, n);
+		body.push(kind);
+		uleb(i, body);
+	});
+	section(out, 10, spec.functions, (body, [, fn]) => {
+		const locals = fn.locals();
+		uleb(locals.length + fn.code.length + 1, body);
+		append(body, locals);
+		append(body, fn.code);
+		body.push(Op.end);
+	});
+	section(out, 11, spec.data, (body, [offset, bytes]) => {
+		body.push(0, Op.i32Const);
+		sleb(offset, body);
+		body.push(Op.end);
+		uleb(bytes.length, body);
+		append(body, bytes);
+	});
+	return new Uint8Array(out);
+};
+export { Body, F64, I32, I64, Label, Op, Simd, V128, encodeModule, sleb, uleb };
+
+//# sourceMappingURL=wasmAsm.js.map

package/dist/internal/compiler/wasmAsm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasmAsm.js","names":[],"sources":["../../../src/internal/compiler/wasmAsm.ts"],"sourcesContent":["/**\n * A small WebAssembly assembler for the WASM compiler: function bodies with\n * structured labels, and the binary module around them. It writes only the\n * instructions and sections that compiler uses.\n */\n\n/** Value types. */\nexport const I32 = 0x7f\nexport const I64 = 0x7e\nexport const F64 = 0x7c\nexport const V128 = 0x7b\nconst Void = 0x40\n\n/** Opcodes used by the compiler. */\nexport const Op = {\n  unreachable: 0x00,\n  block: 0x02,\n  loop: 0x03,\n  if: 0x04,\n  else: 0x05,\n  end: 0x0b,\n  br: 0x0c,\n  brIf: 0x0d,\n  brTable: 0x0e,\n  return: 0x0f,\n  call: 0x10,\n  drop: 0x1a,\n  select: 0x1b,\n  localGet: 0x20,\n  localSet: 0x21,\n  localTee: 0x22,\n  globalGet: 0x23,\n  globalSet: 0x24,\n  i32Load: 0x28,\n  i64Load: 0x29,\n  f64Load: 0x2b,\n  i32Load8U: 0x2d,\n  i32Load16U: 0x2f,\n  i32Store: 0x36,\n  i64Store: 0x37,\n  i32Store8: 0x3a,\n  i32Store16: 0x3b,\n  f64Store: 0x39,\n  i32Const: 0x41,\n  i64Const: 0x42,\n  f64Const: 0x44,\n  i32Eqz: 0x45,\n  i32Eq: 0x46,\n  i32Ne: 0x47,\n  i32LtS: 0x48,\n  i32LtU: 0x49,\n  i32GtS: 0x4a,\n  i32GtU: 0x4b,\n  i32LeS: 0x4c,\n  i32LeU: 0x4d,\n  i32GeS: 0x4e,\n  i32GeU: 0x4f,\n  i64Eqz: 0x50,\n  i64Ne: 0x52,\n  f64Eq: 0x61,\n  f64Ne: 0x62,\n  i32Add: 0x6a,\n  i32Sub: 0x6b,\n  i32Mul: 0x6c,\n  i32And: 0x71,\n  i32Or: 0x72,\n  i32Xor: 0x73,\n  i32Shl: 0x74,\n  i32ShrU: 0x76,\n  i32Ctz: 0x68,\n  i64And: 0x83,\n  i64Or: 0x84,\n  i64Shl: 0x86,\n  i64ShrU: 0x88,\n  f64Abs: 0x99,\n  f64Neg: 0x9a,\n  f64Add: 0xa0,\n  f64Sub: 0xa1,\n  f64Mul: 0xa2,\n  f64Div: 0xa3,\n  f64ConvertI32U: 0xb8\n} as const\n\n/** Unsigned LEB128. */\nexport const uleb = (n: number, out: Array<number> = []): Array<number> => {\n  let v = n >>> 0\n  do {\n    let b = v & 0x7f\n    v >>>= 7\n    if (v !== 0) b |= 0x80\n    out.push(b)\n  } while (v !== 0)\n  return out\n}\n\n/** Signed LEB128 of a 32-bit integer. */\nexport const sleb = (n: number, out: Array<number> = []): Array<number> => {\n  let v = n | 0\n  for (;;) {\n    const b = v & 0x7f\n    v >>= 7\n    if ((v === 0 && (b & 0x40) === 0) || (v === -1 && (b & 0x40) !== 0)) {\n      out.push(b)\n      return out\n    }\n    out.push(b | 0x80)\n  }\n}\n\n/** SIMD opcodes, after the `0xfd` prefix. */\nexport const Simd = {\n  v128Load: 0x00,\n  v128Store: 0x0b,\n  v128Const: 0x0c,\n  i8x16Swizzle: 0x0e,\n  i8x16Splat: 0x0f,\n  i8x16Eq: 0x23,\n  i8x16Ne: 0x24,\n  v128Not: 0x4d,\n  v128And: 0x4e,\n  v128Or: 0x50,\n  v128AnyTrue: 0x53,\n  i8x16AllTrue: 0x63,\n  i8x16Bitmask: 0x64,\n  i8x16ShrU: 0x6d,\n  i8x16RelaxedSwizzle: 0x100,\n  i16x8ExtendLowI8x16U: 0x89,\n  i16x8ExtendHighI8x16U: 0x8a\n} as const\n\n/** Signed LEB128 of a 64-bit integer. */\nconst sleb64 = (n: bigint, out: Array<number>): Array<number> => {\n  let v = BigInt.asIntN(64, n)\n  for (;;) {\n    const b = Number(v & 0x7fn)\n    v >>= 7n\n    if ((v === 0n && (b & 0x40) === 0) || (v === -1n && (b & 0x40) !== 0)) {\n      out.push(b)\n      return out\n    }\n    out.push(b | 0x80)\n  }\n}\n\n/** A branch target: a block, a loop or an `if`. */\nexport class Label {\n  readonly _label = true\n}\n\n/**\n * The body of a function being written: its code, its locals (after the\n * parameters) and the stack of labels that branches refer to.\n */\nexport class Body {\n  readonly code: Array<number> = []\n  /** The types of the locals after the parameters. */\n  private readonly types: Array<number> = []\n  private readonly labels: Array<Label> = []\n  private next: number\n  /** Trace writes since the last check that dominates the code that follows (see the compiler). */\n  writes = 0\n  /** The local holding the trace pointer, in the compiler's rule functions. */\n  tp = -1\n  /** The local holding the end of the input, in the compiler's rule functions (-1: read the global). */\n  endLocal = -1\n\n  constructor(readonly params: number) {\n    this.next = params\n  }\n\n  /** A new local of type `i32`. */\n  local(): number {\n    this.types.push(I32)\n    return this.next++\n  }\n\n  /** A new local of type `i64`. */\n  localI64(): number {\n    this.types.push(I64)\n    return this.next++\n  }\n\n  /** A new local of type `v128`. */\n  localV128(): number {\n    this.types.push(V128)\n    return this.next++\n  }\n\n  /** A new local of type `f64`. */\n  localF64(): number {\n    this.types.push(F64)\n    return this.next++\n  }\n\n  /** The locals declaration, in index order (runs of one type each). */\n  locals(): Array<number> {\n    const groups: Array<[number, number]> = []\n    for (const type of this.types) {\n      const last = groups[groups.length - 1]\n      if (last !== undefined && last[1] === type) last[0]++\n      else groups.push([1, type])\n    }\n    const out = uleb(groups.length)\n    for (const [n, type] of groups) {\n      uleb(n, out)\n      out.push(type)\n    }\n    return out\n  }\n\n  op(...bytes: ReadonlyArray<number>): this {\n    for (const b of bytes) this.code.push(b)\n    return this\n  }\n\n  i32(n: number): this {\n    this.code.push(Op.i32Const)\n    sleb(n, this.code)\n    return this\n  }\n\n  i64(n: bigint): this {\n    this.code.push(Op.i64Const)\n    sleb64(n, this.code)\n    return this\n  }\n\n  f64(x: number): this {\n    this.code.push(Op.f64Const)\n    const bytes = new Uint8Array(new Float64Array([x]).buffer)\n    for (const b of bytes) this.code.push(b)\n    return this\n  }\n\n  get(l: number): this {\n    this.code.push(Op.localGet)\n    uleb(l, this.code)\n    return this\n  }\n\n  set(l: number): this {\n    this.code.push(Op.localSet)\n    uleb(l, this.code)\n    return this\n  }\n\n  tee(l: number): this {\n    this.code.push(Op.localTee)\n    uleb(l, this.code)\n    return this\n  }\n\n  gget(g: number): this {\n    this.code.push(Op.globalGet)\n    uleb(g, this.code)\n    return this\n  }\n\n  gset(g: number): this {\n    this.code.push(Op.globalSet)\n    uleb(g, this.code)\n    return this\n  }\n\n  call(f: number): this {\n    this.code.push(Op.call)\n    uleb(f, this.code)\n    return this\n  }\n\n  /** `v128.const` of sixteen bytes. */\n  v128(bytes: ArrayLike<number>): this {\n    this.code.push(0xfd)\n    uleb(Simd.v128Const, this.code)\n    for (let i = 0; i < 16; i++) this.code.push((bytes[i] ?? 0) & 0xff)\n    return this\n  }\n\n  /** A SIMD instruction, with a memory access's alignment and offset for loads and stores. */\n  simd(op: number, align = -1, offset = 0): this {\n    this.code.push(0xfd)\n    uleb(op, this.code)\n    if (align >= 0) {\n      uleb(align, this.code)\n      uleb(offset, this.code)\n    }\n    return this\n  }\n\n  /** A memory access with an alignment exponent and a constant offset. */\n  mem(op: number, align: number, offset: number): this {\n    this.code.push(op)\n    uleb(align, this.code)\n    uleb(offset, this.code)\n    return this\n  }\n\n  /** `block ... end`: a branch to its label exits the block. */\n  block(body: (exit: Label) => void): this {\n    return this.structured(Op.block, body)\n  }\n\n  /** `loop ... end`: a branch to its label restarts the loop. */\n  loop(body: (again: Label) => void): this {\n    return this.structured(Op.loop, body)\n  }\n\n  /** `if ... (else ...) end` on the `i32` at the top of the stack. */\n  if(then: () => void, otherwise?: () => void): this {\n    this.code.push(Op.if, Void)\n    this.labels.push(new Label())\n    then()\n    if (otherwise !== undefined) {\n      this.code.push(Op.else)\n      otherwise()\n    }\n    this.labels.pop()\n    this.code.push(Op.end)\n    return this\n  }\n\n  /** `if (result i32) ... else ... end`. */\n  ifI32(then: () => void, otherwise: () => void): this {\n    this.code.push(Op.if, I32)\n    this.labels.push(new Label())\n    then()\n    this.code.push(Op.else)\n    otherwise()\n    this.labels.pop()\n    this.code.push(Op.end)\n    return this\n  }\n\n  private structured(op: number, body: (label: Label) => void): this {\n    const label = new Label()\n    this.code.push(op, Void)\n    this.labels.push(label)\n    body(label)\n    this.labels.pop()\n    this.code.push(Op.end)\n    return this\n  }\n\n  /**\n   * Whether a branch went to a label out of scope: a bug in the compiler,\n   * which then refuses the function (see the WebAssembly compiler).\n   */\n  invalid = false\n\n  private depth(label: Label): number {\n    const i = this.labels.lastIndexOf(label)\n    if (i < 0) this.invalid = true\n    return this.labels.length - 1 - i\n  }\n\n  br(label: Label): this {\n    this.code.push(Op.br)\n    uleb(this.depth(label), this.code)\n    return this\n  }\n\n  brIf(label: Label): this {\n    this.code.push(Op.brIf)\n    uleb(this.depth(label), this.code)\n    return this\n  }\n\n  /** `br_table`: `targets[i]` for the index at the top of the stack, `otherwise` out of range. */\n  brTable(targets: ReadonlyArray<Label>, otherwise: Label): this {\n    this.code.push(Op.brTable)\n    uleb(targets.length, this.code)\n    for (const t of targets) uleb(this.depth(t), this.code)\n    uleb(this.depth(otherwise), this.code)\n    return this\n  }\n}\n\n/** A function type: parameter and result types. */\nexport interface FuncType {\n  readonly params: ReadonlyArray<number>\n  readonly results: ReadonlyArray<number>\n}\n\n/** A global: its type, whether it is mutable, and its initial value. */\nexport interface Global {\n  readonly type: number\n  readonly init: number\n}\n\n/** What a module is made of. */\nexport interface ModuleSpec {\n  readonly types: ReadonlyArray<FuncType>\n  /** Imported functions: module, name, type index. */\n  readonly imports: ReadonlyArray<readonly [string, string, number]>\n  /** The imported memory (module \"env\", name \"mem\"). */\n  readonly memoryPages: number\n  /** Defined functions: type index and body. */\n  readonly functions: ReadonlyArray<readonly [number, Body]>\n  readonly globals: ReadonlyArray<Global>\n  /** Exported functions and globals: name, kind (0 function, 3 global), index. */\n  readonly exports: ReadonlyArray<readonly [string, 0 | 3, number]>\n  /** Active data segments: offset and bytes. */\n  readonly data: ReadonlyArray<readonly [number, Uint8Array]>\n}\n\nconst utf8Encoder = /*#__PURE__*/ new TextEncoder()\n\n/** Appends `bytes` to `out`. */\nconst append = (out: Array<number>, bytes: ArrayLike<number>): void => {\n  for (let i = 0; i < bytes.length; i++) out.push(bytes[i])\n}\n\n/** Appends a name: its length and its UTF-8 bytes. */\nconst name = (out: Array<number>, s: string): void => {\n  const bytes = utf8Encoder.encode(s)\n  uleb(bytes.length, out)\n  append(out, bytes)\n}\n\n/** Appends a section: its id, its size, the number of its items and the items `write` appends. */\nconst section = <A>(\n  out: Array<number>,\n  id: number,\n  items: ReadonlyArray<A>,\n  write: (body: Array<number>, item: A) => void\n) => {\n  const body = uleb(items.length)\n  for (const item of items) write(body, item)\n  out.push(id)\n  uleb(body.length, out)\n  append(out, body)\n}\n\nconst f64Bytes = (x: number): Uint8Array => new Uint8Array(new Float64Array([x]).buffer)\n\n/** The binary module. */\nexport const encodeModule = (spec: ModuleSpec): Uint8Array<ArrayBuffer> => {\n  const out = [0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00]\n  section(out, 1, spec.types, (body, t) => {\n    body.push(0x60)\n    uleb(t.params.length, body)\n    append(body, t.params)\n    uleb(t.results.length, body)\n    append(body, t.results)\n  })\n  const memory: readonly [string, string, number] = [\"env\", \"mem\", -1]\n  section(out, 2, [...spec.imports, memory], (body, [m, n, t]) => {\n    name(body, m)\n    name(body, n)\n    if (t < 0) body.push(0x02, 0x00, ...uleb(spec.memoryPages))\n    else body.push(0x00, ...uleb(t))\n  })\n  section(out, 3, spec.functions, (body, [t]) => uleb(t, body))\n  section(out, 6, spec.globals, (body, g) => {\n    if (g.type === F64) {\n      body.push(F64, 0x01, Op.f64Const)\n      append(body, f64Bytes(g.init))\n    } else {\n      body.push(I32, 0x01, Op.i32Const)\n      sleb(g.init, body)\n    }\n    body.push(Op.end)\n  })\n  section(out, 7, spec.exports, (body, [n, kind, i]) => {\n    name(body, n)\n    body.push(kind)\n    uleb(i, body)\n  })\n  section(out, 10, spec.functions, (body, [, fn]) => {\n    const locals = fn.locals()\n    uleb(locals.length + fn.code.length + 1, body)\n    append(body, locals)\n    append(body, fn.code)\n    body.push(Op.end)\n  })\n  section(out, 11, spec.data, (body, [offset, bytes]) => {\n    body.push(0x00, Op.i32Const)\n    sleb(offset, body)\n    body.push(Op.end)\n    uleb(bytes.length, body)\n    append(body, bytes)\n  })\n  return new Uint8Array(out)\n}\n"],"mappings":"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"}

package/dist/internal/entries.d.ts

@@ -3,8 +3,9 @@
  * `[key, value]` pairs: the compilers use these when a parser maps a
  * repetition of pairs with `Object.fromEntries` (see `Parser.fromEntries`).
  */
+type FromEntries = <K extends PropertyKey, V>(entries: Iterable<readonly [K, V]>) => { [P in K]: V; };
 /** The built-in `Object.fromEntries`, which compiled parsers recognize. */
-export declare const fromEntries: <K extends PropertyKey, V>(entries: Iterable<readonly [K, V]>) => { [P in K]: V; };
+export declare const fromEntries: FromEntries;
 /**
  * Whether `o[key] = value` on a new plain object creates the same property
  * as `Object.fromEntries` (a writable, enumerable, configurable data
@@ -22,4 +23,5 @@ export declare const isPlainKey: (key: unknown) => key is string;
 export declare const addEntry: (o: object, deferred: Array<unknown> | undefined, key: unknown, value: unknown) => Array<unknown> | undefined;
 /** Adds the deferred entries of {@link addEntry} to `o`, in order. */
 export declare const flushEntries: (o: object, deferred: ReadonlyArray<unknown>) => void;
+export {};
 //# sourceMappingURL=entries.d.ts.map

package/dist/internal/entries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entries.d.ts","names":[],"sources":["../../src/internal/entries.ts"],"mappings":";;;;;;qBASa,cAAc,UAAU,aAAa,GAAG,SAAS,mBAAmB,GAAG,WAAW,KAAK,IAAI;;;;;;;qBAW3F,aAAc,iBAAe;;;;;;;;qBAc7B,WACX,WACA,UAAU,4BACV,cACA,mBACC;;qBAWU,eAAgB,WAAW,UAAU"}
+{"version":3,"file":"entries.d.ts","names":[],"sources":["../../src/internal/entries.ts"],"mappings":";;;;;KAQK,eAAe,UAAU,aAAa,GAAG,SAAS,mBAAmB,GAAG,WAAW,KAAK,IAAI;;qBAKpF,aAAa;;;;;;;qBAUb,aAAc,iBAAe;;;;;;;;qBAiB7B,WACX,WACA,UAAU,4BACV,cACA,mBACC;;qBAWU,eAAgB,WAAW,UAAU"}