xbintsc 0.3.15 → 0.3.16

package/dist/tests/e2e/compile-control-flow.test.js

@@ -0,0 +1,190 @@
+/**
+ * End-to-end tests for control flow: exceptions, equality, labels and optional chains.
+ */
+import { expect, it } from "vitest";
+import { describeE2E } from "./harness.js";
+describeE2E("end-to-end control flow", (harness) => {
+    const { runProgram } = harness;
+    it("supports try/catch/finally including returns and loop breaks", () => {
+        const source = `
+      function safe(n: number): number {
+        try {
+          if (n < 0) throw "negative";
+          return n * 2;
+        } catch (err) {
+          return -1;
+        }
+      }
+      function cleanup(): string {
+        let log = "";
+        try {
+          log += "try;";
+          throw "boom";
+        } catch (e) {
+          log += "catch:" + e + ";";
+        } finally {
+          log += "finally";
+        }
+        return log;
+      }
+      console.log(safe(5), safe(-2), cleanup());
+    `;
+        expect(runProgram(source)).toBe("10 -1 try;catch:boom;finally");
+    });
+    it("runs finally blocks on early return, break and continue", () => {
+        const source = `
+      const events: string[] = [];
+      function f(n: number): string {
+        try {
+          events.push("try" + n);
+          if (n === 1) return "ret1";
+          if (n === 2) throw "boom" + n;
+        } catch (e) {
+          events.push("catch" + e);
+          if (n === 3) return "ret3";
+        } finally {
+          events.push("finally" + n);
+        }
+        return "done" + n;
+      }
+      console.log(f(0), f(1), f(2), f(3));
+      console.log(events.join("|"));
+      const loop: string[] = [];
+      for (let i = 0; i < 5; i++) {
+        try {
+          if (i === 2) break;
+          if (i === 4) continue;
+          loop.push("i" + i);
+        } finally {
+          loop.push("F" + i);
+        }
+      }
+      console.log(loop.join("|"));
+      function nested(): string {
+        try {
+          try {
+            return "inner";
+          } finally {
+            events.push("innerFinally");
+          }
+        } finally {
+          events.push("outerFinally");
+        }
+      }
+      console.log(nested(), events[events.length - 2], events[events.length - 1]);
+    `;
+        expect(runProgram(source)).toBe([
+            "done0 ret1 done2 done3",
+            "try0|finally0|try1|finally1|try2|catchboom2|finally2|try3|finally3",
+            "i0|F0|i1|F1|F2",
+            "inner innerFinally outerFinally",
+        ].join("\n"));
+    });
+    it("implements abstract equality with ToPrimitive", () => {
+        const source = `
+      console.log(([] as any) == 0, ([] as any) == "", ([1] as any) == 1, ([1, 2] as any) == "1,2");
+      console.log(({} as any) == "[object Object]");
+      console.log(([1] as any) == [1], ([] as any) == false, ([] as any) == null);
+      console.log(0 == "0", 0 == false, "" == false, null == undefined, null == 0, undefined == 0);
+      console.log(NaN == NaN, (1 as any) == "1");
+    `;
+        expect(runProgram(source)).toBe([
+            "true true true true",
+            "true",
+            "false true false",
+            "true true true true false false",
+            "false true",
+        ].join("\n"));
+    });
+    it("supports labeled break and continue across nested loops", () => {
+        const source = `
+      const out: string[] = [];
+      outer: for (let i = 0; i < 3; i++) {
+        inner: for (let j = 0; j < 3; j++) {
+          if (j === 1) continue outer;
+          if (i === 2) break outer;
+          out.push(i + "," + j);
+        }
+      }
+      block: {
+        out.push("before");
+        if (out.length > 0) break block;
+        out.push("unreachable");
+      }
+      out.push("after");
+      function f(): number {
+        let total = 0;
+        loop: for (let i = 0; i < 5; i++) {
+          try {
+            if (i === 2) continue loop;
+            if (i === 4) break loop;
+            total += i;
+          } finally {
+            total += 100;
+          }
+        }
+        return total;
+      }
+      console.log(out.join("|"), f());
+    `;
+        expect(runProgram(source)).toBe("0,0|1,0|before|after 504");
+    });
+    it("supports optional chaining", () => {
+        const source = `
+      const obj = { a: { b: 5 }, m: (x: number) => x + 1 };
+      const empty: any = null;
+      console.log(obj?.a?.b, empty?.a?.b, obj?.m?.(10), empty?.m?.(10));
+      const arr = [1, 2, 3];
+      console.log(arr?.length, arr?.map((x) => x * 2).join(","), empty?.length);
+    `;
+        expect(runProgram(source)).toBe("5 undefined 11 undefined\n3 2,4,6 undefined");
+    });
+    it("short-circuits a whole optional chain but throws past the guard", () => {
+        const source = `
+      const empty: any = null;
+      const nested: any = { a: { b: null } };
+      // A \`?.\` short-circuits every later member, so nothing past it is evaluated.
+      console.log("A", empty?.a.b.c);
+      console.log("B", (nested?.a)?.b);
+      console.log("C", nested.a?.b?.c);
+      // Once the chain has started, a non-optional member on null throws.
+      try {
+        console.log(nested?.b.c);
+        console.log("D-ok");
+      } catch (e) {
+        console.log("D-threw");
+      }
+      try {
+        console.log(nested.a?.b.c);
+        console.log("E-ok");
+      } catch (e) {
+        console.log("E-threw");
+      }
+    `;
+        expect(runProgram(source)).toBe("A undefined\nB null\nC undefined\nD-threw\nE-threw");
+    });
+    it("defaults Array.sort to string order and reveals circular references", () => {
+        const source = `
+      console.log([10, 1, 2, 20].sort().join(","));
+      console.log(["banana", "apple", "cherry"].sort().join(","));
+      console.log(JSON.stringify([3, undefined, 1, 2, undefined].sort()));
+      console.log([5, 3, 8, 1].sort((a, b) => a - b).join(","));
+      const o: any = { name: "x" };
+      o.self = o;
+      o.child = { parent: o };
+      console.log(o);
+      const arr: any = [1, 2];
+      arr.push(arr);
+      console.log(arr);
+    `;
+        expect(runProgram(source)).toBe([
+            "1,10,2,20",
+            "apple,banana,cherry",
+            "[1,2,3,null,null]",
+            "1,3,5,8",
+            "{ name: 'x', self: [Circular *1], child: { parent: [Circular *1] } }",
+            "[ 1, 2, [Circular *1] ]",
+        ].join("\n"));
+    });
+});
+//# sourceMappingURL=compile-control-flow.test.js.map

package/dist/tests/e2e/compile-control-flow.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-control-flow.test.js","sourceRoot":"","sources":["../../../tests/e2e/compile-control-flow.test.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,WAAW,CAAC,yBAAyB,EAAE,CAAC,OAAO,EAAE,EAAE;IACjD,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;IAE/B,EAAE,CAAC,8DAA8D,EAAE,GAAG,EAAE;QACtE,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;KAsBd,CAAC;QACF,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;QACjE,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwCd,CAAC;QACF,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAC7B;YACE,wBAAwB;YACxB,oEAAoE;YACpE,gBAAgB;YAChB,iCAAiC;SAClC,CAAC,IAAI,CAAC,IAAI,CAAC,CACb,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+CAA+C,EAAE,GAAG,EAAE;QACvD,MAAM,MAAM,GAAG;;;;;;KAMd,CAAC;QACF,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAC7B;YACE,qBAAqB;YACrB,MAAM;YACN,kBAAkB;YAClB,iCAAiC;YACjC,YAAY;SACb,CAAC,IAAI,CAAC,IAAI,CAAC,CACb,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;QACjE,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6Bd,CAAC;QACF,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;IAC9D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4BAA4B,EAAE,GAAG,EAAE;QACpC,MAAM,MAAM,GAAG;;;;;;KAMd,CAAC;QACF,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,6CAA6C,CAAC,CAAC;IACjF,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iEAAiE,EAAE,GAAG,EAAE;QACzE,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;KAoBd,CAAC;QACF,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,oDAAoD,CAAC,CAAC;IACxF,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qEAAqE,EAAE,GAAG,EAAE;QAC7E,MAAM,MAAM,GAAG;;;;;;;;;;;;KAYd,CAAC;QACF,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAC7B;YACE,WAAW;YACX,qBAAqB;YACrB,mBAAmB;YACnB,SAAS;YACT,sEAAsE;YACtE,yBAAyB;SAC1B,CAAC,IAAI,CAAC,IAAI,CAAC,CACb,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/tests/e2e/compile-modules.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * End-to-end tests for the module bundler.
+ */
+export {};

package/dist/tests/e2e/compile-modules.test.js

@@ -0,0 +1,48 @@
+/**
+ * End-to-end tests for the module bundler.
+ */
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { expect, it } from "vitest";
+import { describeE2E } from "./harness.js";
+describeE2E("end-to-end module bundling", (harness) => {
+    const { runProgram } = harness;
+    it("supports import and export across modules", () => {
+        writeFileSync(join(harness.workdir, "math_dep.ts"), `
+      export const PI = 3.14;
+      export function add(a: number, b: number): number {
+        return a + b;
+      }
+      export default function greet(name: string): string {
+        return "hi " + name;
+      }
+      `);
+        const source = `
+      import greet, { add, PI } from "./math_dep";
+      console.log(add(2, 3), PI);
+      console.log(greet("ada"));
+    `;
+        expect(runProgram(source)).toBe("5 3.14\nhi ada");
+    });
+    it("resolves `.js` specifiers to their TypeScript sources", () => {
+        writeFileSync(join(harness.workdir, "esm_dep.ts"), `export const value = 42;`);
+        const source = `
+      import { value } from "./esm_dep.js";
+      console.log(value);
+    `;
+        expect(runProgram(source)).toBe("42");
+    });
+    it("bundles JavaScript modules through extension-less imports", () => {
+        const source = `
+      import { add } from "./js_dep";
+      console.log(add(2, 3));
+    `;
+        expect(runProgram(source, {
+            files: {
+                "js_dep.js": 'export { add } from "./js_math";',
+                "js_math.js": "export function add(a, b) { return a + b; }",
+            },
+        })).toBe("5");
+    });
+});
+//# sourceMappingURL=compile-modules.test.js.map

package/dist/tests/e2e/compile-modules.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-modules.test.js","sourceRoot":"","sources":["../../../tests/e2e/compile-modules.test.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,WAAW,CAAC,4BAA4B,EAAE,CAAC,OAAO,EAAE,EAAE;IACpD,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;IAE/B,EAAE,CAAC,2CAA2C,EAAE,GAAG,EAAE;QACnD,aAAa,CACX,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,CAAC,EACpC;;;;;;;;OAQC,CACF,CAAC;QACF,MAAM,MAAM,GAAG;;;;KAId,CAAC;QACF,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;QAC/D,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,EAAE,0BAA0B,CAAC,CAAC;QAC/E,MAAM,MAAM,GAAG;;;KAGd,CAAC;QACF,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2DAA2D,EAAE,GAAG,EAAE;QACnE,MAAM,MAAM,GAAG;;;KAGd,CAAC;QACF,MAAM,CACJ,UAAU,CAAC,MAAM,EAAE;YACjB,KAAK,EAAE;gBACL,WAAW,EAAE,kCAAkC;gBAC/C,YAAY,EAAE,6CAA6C;aAC5D;SACF,CAAC,CACH,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACd,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/tests/e2e/compile-objects-classes.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * End-to-end tests for closures, classes, destructuring and function semantics.
+ */
+export {};

package/dist/tests/e2e/compile-objects-classes.test.js

@@ -0,0 +1,362 @@
+/**
+ * End-to-end tests for closures, classes, destructuring and function semantics.
+ */
+import { expect, it } from "vitest";
+import { describeE2E } from "./harness.js";
+describeE2E("end-to-end objects, functions and classes", (harness) => {
+    const { runProgram } = harness;
+    it("implements closures with by-reference captures", () => {
+        const source = `
+      const makeCounter = () => {
+        let count = 0;
+        return () => {
+          count += 1;
+          return count;
+        };
+      };
+      const next = makeCounter();
+      console.log(next(), next(), next());
+    `;
+        expect(runProgram(source)).toBe("1 2 3");
+    });
+    it("supports #private fields, methods and static members", () => {
+        const source = `
+      class Counter {
+        #count = 0;
+        static #instances = 0;
+        constructor() { Counter.#bumpStatic(); }
+        #bump(by: number): void { this.#count += by; }
+        static #bumpStatic(): void { Counter.#instances++; }
+        inc(by: number): number { this.#bump(by); return this.#count; }
+        get count(): number { return this.#count; }
+        set count(v: number) { this.#count = v; }
+        static instances(): number { return Counter.#instances; }
+      }
+      class Sub extends Counter {
+        #label = "sub";
+        constructor() { super(); this.inc(5); }
+        describe(): string { return this.#label + ":" + this.count; }
+      }
+      const a = new Counter();
+      const b = new Counter();
+      a.inc(3);
+      a.count = 10;
+      console.log(a.count, b.count, Counter.instances());
+      console.log(new Sub().describe());
+    `;
+        expect(runProgram(source)).toBe("10 0 2\nsub:5");
+    });
+    it("supports classes with new, this, statics, inheritance and instanceof", () => {
+        const source = `
+      class Animal {
+        name: string;
+        constructor(name: string) {
+          this.name = name;
+        }
+        speak(): string {
+          return this.name + " makes a sound";
+        }
+        static kind(): string {
+          return "animal";
+        }
+      }
+      class Dog extends Animal {
+        constructor(name: string) {
+          super(name);
+        }
+        speak(): string {
+          return super.speak() + " (woof)";
+        }
+      }
+      const dog = new Dog("Rex");
+      console.log(dog.speak());
+      console.log(Animal.kind(), dog instanceof Dog, dog instanceof Animal);
+    `;
+        expect(runProgram(source)).toBe("Rex makes a sound (woof)\nanimal true true");
+    });
+    it("supports destructuring bindings, enums, regexes and Error", () => {
+        const source = `
+      const [a, b = 7, ...rest] = [1, undefined, 3, 4];
+      const { x, y: z = 9 } = { x: 5 };
+      enum Color { Red, Green = 5, Blue }
+      const re = /^-[0-9]+/;
+      console.log(a, b, rest.join(","), x, z);
+      console.log(Color.Red, Color.Green, Color.Blue, Color[5]);
+      console.log(re.test("-42abc"), re.test("nope"));
+      try { throw new Error("boom"); } catch (e) { console.log(e.name + ": " + e.message); }
+    `;
+        expect(runProgram(source)).toBe("1 7 3,4 5 9\n0 5 6 Green\ntrue false\nError: boom");
+    });
+    it("supports destructuring assignments", () => {
+        const source = `
+      let a = 1, b = 2;
+      [a, b] = [b, a];
+      console.log(a, b);
+
+      let c = 0, d = 0, rest: number[] = [];
+      [c, d = 5, ...rest] = [10, undefined, 30, 40];
+      console.log(c, d, rest.join(","));
+
+      let x = 0, y = 0;
+      [[x], [y]] = [[100], [200]];
+      let p = 0, q = 0, r = 0;
+      ({ p, q = 9, p: r } = { q: 7, p: 8 });
+      console.log(x, y, p, q, r);
+
+      const target = { v: 0 } as any;
+      const list = [0, 0];
+      [target.v, list[0]] = [5, 6];
+      console.log(target.v, list[0]);
+
+      const pairs = [[1, 2], [3, 4]];
+      let u = 0, v = 0;
+      for ([u, v] of pairs) console.log(u, v);
+      for (const [f, s] of pairs) console.log(f + s);
+    `;
+        expect(runProgram(source)).toBe("2 1\n10 5 30,40\n100 200 8 7 8\n5 6\n1 2\n3 4\n3\n7");
+    });
+    it("supports destructuring parameters", () => {
+        const source = `
+      const pairs = [["a", 1], ["b", 2]];
+      const mapped = pairs.map(([name, value]) => [name, { value }]);
+      console.log(mapped[0][0], mapped[1][0]);
+      console.log(mapped[0][1].value, mapped[1][1].value);
+
+      function sum([a, b]: [number, number]) { return a + b; }
+      console.log(sum([3, 4]));
+
+      function greet({ name, greeting = "Hello" }: { name: string; greeting?: string }) {
+        return greeting + ", " + name;
+      }
+      console.log(greet({ name: "Ada" }), greet({ name: "Bob", greeting: "Hi" }));
+
+      const withDefault = ([a, b] = [10, 20]) => a + b;
+      console.log(withDefault(), withDefault([1, 2]));
+    `;
+        expect(runProgram(source)).toBe("a b\n1 2\n7\nHello, Ada Hi, Bob\n30 3");
+    });
+    it("supports Function.prototype.call, apply and bind", () => {
+        const source = `
+      function add(a: number, b: number): number { return a + b; }
+      console.log(add.call(null, 1, 2), add.apply(null, [5, 6]));
+
+      const obj = {
+        base: 10,
+        sum(a: number, b: number): number { return this.base + a + b; },
+      };
+      console.log(obj.sum.call(obj, 1, 2), obj.sum.apply(obj, [3, 4]));
+
+      const bound = obj.sum.bind(obj, 1);
+      console.log(bound(2));
+      const bound2 = add.bind(null, 10);
+      console.log(bound2(5));
+
+      class Greeter {
+        prefix = "hi";
+        greet(name: string): string { return this.prefix + " " + name; }
+      }
+      const g = new Greeter();
+      console.log(g.greet.call(g, "ada"), g.greet.bind(g)("cy"));
+    `;
+        expect(runProgram(source)).toBe("3 11\n13 17\n13\n15\nhi ada hi cy");
+    });
+    it("supports object-literal getters and setters", () => {
+        const source = `
+      const obj = {
+        _x: 0,
+        get x(): number { return this._x; },
+        set x(v: number) { this._x = v * 2; },
+        get double(): number { return this._x * 2; },
+        method(a: number, b: number) { return a + b; },
+      };
+      obj.x = 5;
+      console.log(obj.x, obj.double);
+      console.log(obj.method(2, 3));
+      console.log(Object.keys(obj).join(","));
+
+      const base = 7;
+      const o2 = { base, get next() { return base + 1; } };
+      console.log(o2.base, o2.next);
+
+      const o3 = { get ["dyn" + "amic"]() { return 42; } };
+      console.log(o3.dynamic);
+    `;
+        expect(runProgram(source)).toBe("10 20\n5\n_x,x,double,method\n7 8\n42");
+    });
+    it("supports first-class built-in method values", () => {
+        const source = `
+      const arr = [1, 2, 3];
+      console.log(typeof arr.map, arr.map.name, arr.map.length);
+      console.log(arr.map?.((x: number) => x * 2).join(","));
+
+      const text = "abc";
+      console.log(typeof text.slice, text.slice(1), text.split?.("").join("-"));
+
+      const obj = { base: 10, add(n: number) { return this.base + n; } };
+      console.log(obj.add?.(5));
+
+      const detached = arr.map;
+      try {
+        (detached as any)((x: number) => x);
+        console.log("no throw");
+      } catch (e) {
+        console.log("threw");
+      }
+    `;
+        expect(runProgram(source)).toBe("function map 1\n2,4,6\nfunction bc a-b-c\n15\nthrew");
+    });
+    it("calls functions through computed and indexed element access", () => {
+        const source = `
+      const fns = [(n: number) => n + 1, (n: number) => n * 2];
+      console.log(fns[0](10), fns[1](10));
+      let total = 0;
+      for (let i = 0; i < fns.length; i++) total += fns[i](3);
+      const table: any = { a: () => "A", b: () => "B" };
+      const key = "b";
+      console.log(total, table[key]());
+    `;
+        expect(runProgram(source)).toBe("11 20\n10 B");
+    });
+    it("supports the Error family as first-class constructors", () => {
+        const source = `
+      console.log(typeof Error, typeof TypeError, typeof AggregateError);
+      console.log(new Error("a") instanceof Error);
+      console.log(new TypeError("b") instanceof TypeError);
+      console.log(new TypeError("b") instanceof Error);
+      console.log(new RangeError("c") instanceof TypeError);
+      const e = new Error("boom");
+      console.log(String(e), e.toString(), e.name, e.message);
+
+      class MyErr extends Error {
+        constructor(m: string) { super(m); this.name = "MyErr"; }
+      }
+      const m = new MyErr("m");
+      console.log(m.name, m.message, m instanceof MyErr, m instanceof Error);
+
+      class CustomRange extends RangeError {}
+      const r = new CustomRange("too big");
+      console.log(r.name, r.message, r instanceof RangeError, r instanceof Error);
+
+      const agg = new AggregateError([1, 2], "all failed");
+      console.log(agg.name, agg.message, JSON.stringify(agg.errors), agg instanceof Error);
+
+      Promise.any([Promise.reject("x"), Promise.reject("y")]).catch((reason) => {
+        const err = reason as { name: string; errors: unknown[] };
+        console.log(err.name, JSON.stringify(err.errors));
+      });
+    `;
+        expect(runProgram(source)).toBe("function function function\ntrue\ntrue\ntrue\nfalse\n" +
+            "Error: boom Error: boom Error boom\n" +
+            "MyErr m true true\nRangeError too big true true\n" +
+            "AggregateError all failed [1,2] true\nAggregateError [\"x\",\"y\"]");
+    });
+    it("supports generator functions", () => {
+        const source = `
+      function* nums() { yield 1; yield 2; yield 3; }
+      const g = nums();
+      console.log(typeof nums, g.next().value, g.next().value, g.next().value);
+      console.log(JSON.stringify(g.next()));
+
+      function* counter(start: number) {
+        let x = start;
+        while (true) {
+          const step = yield x;
+          x = step === undefined ? x + 1 : step;
+        }
+      }
+      const c = counter(10);
+      console.log(c.next().value, c.next().value, c.next(100).value, c.next().value);
+
+      class Box {
+        private n = 0;
+        *gen(): Generator<number> { yield this.n++; yield this.n++; }
+      }
+      const box = new Box();
+      console.log([...box.gen()].join(","), [...box.gen()].join(","));
+
+      function* inner() { yield 1; yield 2; }
+      function* outer() { yield* inner(); yield 9; }
+      console.log([...outer()].join("-"), [...outer()].join("-"));
+
+      function* echo() { const a = yield "first"; const b = yield a; return b; }
+      const e = echo();
+      console.log(e.next().value, e.next("A").value, JSON.stringify(e.next("B")));
+
+      function* guarded() {
+        try { yield "x"; } catch (err) { yield "caught:" + (err as Error).message; }
+        yield "end";
+      }
+      const t = guarded();
+      console.log(t.next().value, t.throw(new Error("E")).value, t.next().value);
+
+      function* once() { yield 1; }
+      const o = once();
+      o.next();
+      console.log(JSON.stringify(o.next()), typeof o);
+
+      function* naturals() { let i = 0; while (true) yield i++; }
+      const seen: number[] = [];
+      for (const v of naturals()) { if (v >= 3) break; seen.push(v); }
+      console.log(seen.join(","));
+    `;
+        expect(runProgram(source)).toBe("function 1 2 3\n{\"done\":true}\n10 11 100 101\n0,1 2,3\n" +
+            "1-2-9 1-2-9\nfirst A {\"value\":\"B\",\"done\":true}\n" +
+            "x caught:E end\n{\"done\":true} object\n0,1,2");
+    });
+    it("supports symbols and the well-known symbol protocol", () => {
+        const source = `
+      const a = Symbol("desc");
+      const b = Symbol("desc");
+      console.log(typeof Symbol, typeof a, a === a, a === b);
+      console.log(a.toString(), String(a), a.description, String(Symbol()));
+      console.log(String(Symbol.iterator), typeof Symbol.iterator);
+
+      const holder: Record<string, unknown> = {};
+      (holder as any)[a] = 1;
+      (holder as any)[b] = 2;
+      holder.x = 3;
+      console.log(Object.keys(holder).join(","));
+      console.log(Object.getOwnPropertySymbols(holder).length);
+      console.log((holder as any)[a], (holder as any)[b], (holder as any)[Symbol("desc")]);
+      console.log(JSON.stringify(holder), JSON.stringify(a), JSON.stringify([a, 1]));
+      console.log(holder);
+
+      const reg = Symbol.for("shared");
+      console.log(reg === Symbol.for("shared"), Symbol.keyFor(reg), Symbol.keyFor(a));
+
+      class Range {
+        start: number;
+        end: number;
+        constructor(start: number, end: number) {
+          this.start = start;
+          this.end = end;
+        }
+        [Symbol.iterator]() {
+          let i = this.start;
+          const end = this.end;
+          return {
+            next() {
+              return i < end ? { value: i++, done: false } : { value: undefined, done: true };
+            },
+          };
+        }
+      }
+      console.log([...new Range(1, 4)].join(","));
+      const walked: number[] = [];
+      for (const x of new Range(10, 13)) walked.push(x);
+      console.log(walked.join(","));
+
+      function* delegates() { yield* new Range(5, 7); }
+      console.log([...delegates()].join(","));
+    `;
+        expect(runProgram(source)).toBe("function symbol true false\n" +
+            "Symbol(desc) Symbol(desc) desc Symbol()\n" +
+            "Symbol(Symbol.iterator) symbol\n" +
+            "x\n2\n1 2 undefined\n" +
+            '{"x":3} undefined [null,1]\n' +
+            "{ x: 3, Symbol(desc): 1, Symbol(desc): 2 }\n" +
+            "true shared undefined\n" +
+            "1,2,3\n10,11,12\n5,6");
+    });
+});
+//# sourceMappingURL=compile-objects-classes.test.js.map

package/dist/tests/e2e/compile-objects-classes.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-objects-classes.test.js","sourceRoot":"","sources":["../../../tests/e2e/compile-objects-classes.test.ts"],"names":[],"mappings":"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"}

package/dist/tests/e2e/differential-helpers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared helpers for the differential suites: register one case per program and
+ * build programs that print canonical `JSON.stringify` output.
+ */
+import type { E2EHarness } from "./harness.js";
+export interface DifferentialKit {
+    /** Register one differential case from a complete program source. */
+    diff(name: string, source: string): void;
+    /** Wrap a list of expressions so each is printed as a `JSON.stringify` line. */
+    printAll(values: string[]): string;
+}
+export declare function makeDifferential(harness: E2EHarness): DifferentialKit;

package/dist/tests/e2e/differential-helpers.js

@@ -0,0 +1,16 @@
+/**
+ * Shared helpers for the differential suites: register one case per program and
+ * build programs that print canonical `JSON.stringify` output.
+ */
+import { it } from "vitest";
+export function makeDifferential(harness) {
+    const diff = (name, source) => {
+        it(name, () => {
+            harness.expectSameOutputAsNode(source, { name: `diff_${name.replace(/\W+/g, "_")}` });
+        });
+    };
+    const printAll = (values) => `const values: unknown[] = [\n${values.map((v) => `  ${v},`).join("\n")}\n];\n` +
+        `for (const v of values) console.log(JSON.stringify(v));\n`;
+    return { diff, printAll };
+}
+//# sourceMappingURL=differential-helpers.js.map

package/dist/tests/e2e/differential-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"differential-helpers.js","sourceRoot":"","sources":["../../../tests/e2e/differential-helpers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAU5B,MAAM,UAAU,gBAAgB,CAAC,OAAmB;IAClD,MAAM,IAAI,GAAG,CAAC,IAAY,EAAE,MAAc,EAAQ,EAAE;QAClD,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE;YACZ,OAAO,CAAC,sBAAsB,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;QACxF,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,MAAM,QAAQ,GAAG,CAAC,MAAgB,EAAU,EAAE,CAC5C,gCAAgC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ;QAC/E,2DAA2D,CAAC;IAE9D,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAC5B,CAAC"}

package/dist/tests/e2e/differential-language.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Differential tests for control flow, classes, regexes, generators and function semantics.
+ */
+export {};