Something went wrong. Try again.
MIRROR: javascript for 🐜's, a tiny runtime with big ambitions ant.themackabu.dev
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332const assert = require('node:assert');
const N = 20000;
class P { constructor(x, y) { this.x = x; this.y = y; } add(o) { return new P(this.x + o.x, this.y + o.y); }}
function sumPoints(n) { let p = new P(0, 0); const one = new P(1, 2); for (let i = 0; i < n; i++) p = p.add(one); return p;}
const summed = sumPoints(N);assert.strictEqual(summed.x, N);assert.strictEqual(summed.y, 2 * N);assert.ok(summed instanceof P);assert.strictEqual(Object.getPrototypeOf(summed), P.prototype);assert.deepStrictEqual(Object.keys(summed), ['x', 'y']);
class Target { constructor() { this.target = new.target; }}
function makeTargets(n) { let last; for (let i = 0; i < n; i++) last = new Target(); return last;}assert.strictEqual(makeTargets(N).target, Target);
const returned = { tag: 'returned' };class ReturnsObject { constructor(flag) { this.ignored = true; return flag ? returned : 7; }}
function constructReturning(n) { let objects = 0; let instances = 0; for (let i = 0; i < n; i++) { const r = new ReturnsObject(i & 1); if (r === returned) objects++; else if (r instanceof ReturnsObject && r.ignored === true) instances++; } return [objects, instances];}assert.deepStrictEqual(constructReturning(N), [N / 2, N / 2]);
function Plain(a) { this.a = a;}
function constructPlain(n) { let s = 0; let last; for (let i = 0; i < n; i++) { last = new Plain(i); s += last.a; } return [s, last];}const [plainSum, plainLast] = constructPlain(N);assert.strictEqual(plainSum, (N * (N - 1)) / 2);assert.strictEqual(Object.getPrototypeOf(plainLast), Plain.prototype);
function Swapped(v) { this.v = v;}const protoA = { kind: 'a' };const protoB = { kind: 'b' };
function constructSwapped(n) { const kinds = { a: 0, b: 0 }; for (let i = 0; i < n; i++) { Swapped.prototype = i < n / 2 ? protoA : protoB; kinds[new Swapped(i).kind]++; } return kinds;}assert.deepStrictEqual(constructSwapped(N), { a: N / 2, b: N / 2 });
class Other { constructor(x, y) { this.other = x - y; }}
function constructVarying(n, ctors) { let s = 0; for (let i = 0; i < n; i++) { const C = ctors[i < n - 3 ? 0 : i % ctors.length]; const o = new C(i, 1); s += o instanceof P ? o.x : o.other; } return s;}assert.strictEqual(constructVarying(N, [P, Other]), constructVarying(N, [P, Other]));
function factory(base) { return class { constructor(v) { this.v = v + base; } };}const Ten = factory(10);const Hundred = factory(100);
function constructFactory(n) { let s = 0; for (let i = 0; i < n; i++) { const C = i & 1 ? Hundred : Ten; s += new C(1).v; } return s;}assert.strictEqual(constructFactory(N), (N / 2) * 11 + (N / 2) * 101);
class ReadsArg { constructor(o) { this.v = o.v; }}
function constructThrowing(n) { let made = 0; for (let i = 0; i < n; i++) { new ReadsArg(i === n - 1 ? null : { v: i }); made++; } return made;}assert.throws(() => constructThrowing(N), TypeError);
function constructCatching(n) { let caught = 0; for (let i = 0; i < n; i++) { try { new ReadsArg(i % 100 === 0 ? undefined : { v: i }); } catch (e) { if (e instanceof TypeError) caught++; } } return caught;}assert.strictEqual(constructCatching(N), N / 100);
function callWithoutNew() { return P(1, 2);}
function callClassHot(n) { let thrown = 0; for (let i = 0; i < n; i++) { try { callWithoutNew(); } catch (e) { if (e instanceof TypeError) thrown++; } } return thrown;}assert.strictEqual(callClassHot(N), N);
function constructMixed(n) { const Bound = P.bind(null, 5); const Proxied = new Proxy(P, {}); let s = 0; for (let i = 0; i < n; i++) { const C = i < n - 10 ? P : i & 1 ? Bound : Proxied; const o = new C(i, 3); s += o.x + o.y; assert.ok(o instanceof P); } return s;}const mixed = constructMixed(N);let mixedExpected = 0;for (let i = 0; i < N; i++) { if (i < N - 10 || !(i & 1)) mixedExpected += i + 3; else mixedExpected += 5 + i;}assert.strictEqual(mixed, mixedExpected);
class Base { constructor(x) { this.base = x; }}class Derived extends Base { constructor(x) { super(x); this.derived = x * 2; }}
function constructDerived(n) { let s = 0; let last; for (let i = 0; i < n; i++) { last = new Derived(i); s += last.base + last.derived; } return [s, last];}const [derivedSum, derivedLast] = constructDerived(N);assert.strictEqual(derivedSum, 3 * ((N * (N - 1)) / 2));assert.ok(derivedLast instanceof Derived && derivedLast instanceof Base);
let sideEffects = 0;class Effectful { constructor(v) { sideEffects++; this.v = v; }}
function constructEffectful(n) { for (let i = 0; i < n; i++) new Effectful(i);}constructEffectful(N);assert.strictEqual(sideEffects, N);
class Holder { constructor(i) { this.obj = { v: i }; this.arr = [i, i + 1]; this.str = 'v' + i; this.fn = () => i; }}
function constructHolders(n) { const kept = []; for (let i = 0; i < n; i++) { const h = new Holder(i); if (i % 997 === 0) kept.push(h); } return kept;}
const holders = constructHolders(200000);const churn = [];for (let i = 0; i < 200000; i++) churn.push({ i });for (const h of holders) { const i = h.obj.v; assert.strictEqual(h.arr[0], i); assert.strictEqual(h.arr[1], i + 1); assert.strictEqual(h.str, 'v' + i); assert.strictEqual(h.fn(), i);}
class Late { constructor(v) { this.v = v; this.w = v + 1; }}
function constructLate(n) { let s = 0; for (let i = 0; i < n; i++) { const o = new Late(i); s += Object.prototype.hasOwnProperty.call(o, 'v') ? o.v : -1; } return s;}constructLate(N);let setterRuns = 0;Object.defineProperty(Late.prototype, 'v', { set(value) { setterRuns++; this._v = value; }, get() { return this._v; }, configurable: true,});assert.strictEqual(constructLate(100), -100);assert.strictEqual(setterRuns, 100);const late = new Late(5);assert.strictEqual(late._v, 5);assert.strictEqual(late.w, 6);assert.ok(!Object.prototype.hasOwnProperty.call(late, 'v'));
delete Late.prototype.v;Object.defineProperty(Late.prototype, 'w', { value: 0, writable: false, configurable: true });function constructFrozen(n) { let thrown = 0; for (let i = 0; i < n; i++) { try { new Late(i); } catch (e) { if (e instanceof TypeError) thrown++; } } return thrown;}assert.strictEqual(constructFrozen(100), 100);delete Late.prototype.w;assert.strictEqual(constructLate(100), 4950);
const counter = { n: 0 };class Counts { constructor(c) { c.n = c.n + 1; this.c = c; }}
function constructCounts(n) { for (let i = 0; i < n; i++) new Counts(counter); return counter.n;}assert.strictEqual(constructCounts(N), N);
console.log('ok');