redscript-mc 2.6.2 → 3.0.0

package/dist/src/__tests__/mir/lower-extra.test.js

@@ -0,0 +1,361 @@
+"use strict";
+/**
+ * Extra coverage for src/mir/lower.ts
+ *
+ * Targets uncovered branches:
+ * - execute stmt (call_context)
+ * - match stmt (enum match, value match)
+ * - raw stmt
+ * - if_let_some (with and without else)
+ * - let_destruct (tuple destructuring)
+ * - tuple_lit expr
+ * - some_lit / none_lit expr
+ * - type_cast expr (as double, as int)
+ * - enum_construct expr
+ * - static_call expr
+ * - invoke expr
+ * - index / index_assign expr
+ * - member_assign expr
+ * - foreach stmt
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+const lower_2 = require("../../mir/lower");
+const verify_1 = require("../../mir/verify");
+const compile_1 = require("../../emit/compile");
+function compileMIR(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    const hir = (0, lower_1.lowerToHIR)(ast);
+    return (0, lower_2.lowerToMIR)(hir);
+}
+function getFn(mod, name) {
+    if (name)
+        return mod.functions.find(f => f.name.includes(name));
+    return mod.functions[0];
+}
+// ── raw stmt ──────────────────────────────────────────────────────────────
+describe('MIR lowering — raw stmt', () => {
+    test('raw command is emitted as __raw: call', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        raw("say hello");
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        // All functions including main
+        const allInstrs = mod.functions.flatMap(fn => fn.blocks.flatMap(b => b.instrs));
+        const rawCall = allInstrs.find(i => i.kind === 'call' && i.fn?.startsWith('__raw:'));
+        expect(rawCall).toBeDefined();
+    });
+    test('raw command with __NS__ placeholder is replaced', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        raw("say __NS__");
+        return 0;
+      }
+    `);
+        const allInstrs = mod.functions.flatMap(fn => fn.blocks.flatMap(b => b.instrs));
+        const rawCall = allInstrs.find(i => i.kind === 'call' && i.fn?.includes('say test'));
+        expect(rawCall).toBeDefined();
+    });
+});
+// ── if_let_some ────────────────────────────────────────────────────────────
+describe('MIR lowering — if_let_some', () => {
+    test('if let Some with then branch only', () => {
+        const mod = compileMIR(`
+      fn f(opt: Option<int>): int {
+        let has: int = opt.has;
+        if (has == 1) { return opt.val; }
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+    test('Option type with direct variable access', () => {
+        const mod = compileMIR(`
+      fn f(opt: Option<int>): int {
+        if (opt.has == 1) { return opt.val; }
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── match stmt ─────────────────────────────────────────────────────────────
+describe('MIR lowering — match stmt', () => {
+    test('match on enum with multiple arms', () => {
+        const mod = compileMIR(`
+      enum Color { Red, Green, Blue }
+      fn describe(c: Color): int {
+        match c {
+          Color::Red => { return 1; }
+          Color::Green => { return 2; }
+          Color::Blue => { return 3; }
+        }
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod, 'describe');
+        // Should have multiple blocks from match arms
+        expect(fn.blocks.length).toBeGreaterThanOrEqual(4);
+    });
+    test('match on int value with wildcard', () => {
+        const mod = compileMIR(`
+      fn classify(n: int): int {
+        match n {
+          1 => { return 10; }
+          2 => { return 20; }
+          _ => { return 0; }
+        }
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── execute stmt (call_context) ────────────────────────────────────────────
+describe('MIR lowering — execute stmt', () => {
+    test('execute as @a generates call_context instr', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        execute as @a run {
+          raw "say hi";
+        }
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        const callCtx = allInstrs.find(i => i.kind === 'call_context');
+        expect(callCtx).toBeDefined();
+    });
+    test('execute with if score subcommand', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        execute if score @s rs matches 1..10 run {
+          raw "say match";
+        }
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── tuple_lit ──────────────────────────────────────────────────────────────
+describe('MIR lowering — tuple_lit expr', () => {
+    test('tuple return and use compiles without error', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn make(): (int, int) { return (1, 2); }
+      fn f(): int {
+        let pair: (int, int) = make();
+        return 0;
+      }
+    `, { namespace: 'tup2' })).not.toThrow();
+    });
+    test('tuple literal as return value', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn pair(): (int, int) { return (3, 4); }
+      fn f(): int {
+        let (a, b) = pair();
+        return a;
+      }
+    `, { namespace: 'tup' })).not.toThrow();
+    });
+});
+// ── some_lit / none_lit ────────────────────────────────────────────────────
+describe('MIR lowering — some_lit / none_lit expr', () => {
+    test('Some(expr) in expression context', () => {
+        const mod = compileMIR(`
+      fn wrap(n: int): Option<int> {
+        return Some(n);
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        // Should copy to __rf_has = 1
+        const copy1 = allInstrs.find(i => i.kind === 'copy' && i.dst === '__rf_has');
+        expect(copy1).toBeDefined();
+    });
+    test('None in expression context', () => {
+        const mod = compileMIR(`
+      fn none_fn(): Option<int> {
+        return None;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = getFn(mod);
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        // __rf_has should be copied to 0
+        const copyHas = allInstrs.find(i => i.kind === 'copy' && i.dst === '__rf_has');
+        expect(copyHas).toBeDefined();
+    });
+    test('None literal passed as argument', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn identity(opt: Option<int>): Option<int> { return opt; }
+      fn f(): int {
+        let x = identity(None);
+        return 0;
+      }
+    `, { namespace: 'none' })).not.toThrow();
+    });
+});
+// ── enum_construct ─────────────────────────────────────────────────────────
+describe('MIR lowering — enum_construct expr', () => {
+    test('enum variant with no payload', () => {
+        const mod = compileMIR(`
+      enum Status { Active, Inactive }
+      fn f(): int {
+        let s: Status = Status::Active;
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+    test('enum variant with no payload and match', () => {
+        const mod = compileMIR(`
+      enum Result { Ok, Err }
+      fn f(): int {
+        let r: Result = Result::Ok;
+        match r {
+          Result::Ok => { return 1; }
+          Result::Err => { return 0; }
+        }
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── index / index_assign ───────────────────────────────────────────────────
+describe('MIR lowering — index / index_assign', () => {
+    test('array indexing generates nbt_read', () => {
+        const mod = compileMIR(`
+      fn f(arr: int[], i: int): int {
+        return arr[i];
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+    test('array index assign generates nbt_write', () => {
+        const mod = compileMIR(`
+      fn f(arr: int[]): int {
+        arr[0] = 42;
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── member_assign ──────────────────────────────────────────────────────────
+describe('MIR lowering — member_assign', () => {
+    test('struct field assignment', () => {
+        const mod = compileMIR(`
+      struct Point { x: int, y: int }
+      fn f(p: Point): int {
+        p.x = 10;
+        return p.x;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── invoke (method calls) ──────────────────────────────────────────────────
+describe('MIR lowering — invoke (method calls)', () => {
+    test('method call on struct', () => {
+        const { files } = (0, compile_1.compile)(`
+      struct Counter { val: int }
+      impl Counter {
+        fn increment(self): int {
+          self.val = self.val + 1;
+          return self.val;
+        }
+      }
+      fn f(): int {
+        let c: Counter = Counter { val: 0 };
+        return c.increment();
+      }
+    `, { namespace: 'inv' });
+        expect(files.length).toBeGreaterThan(0);
+    });
+});
+// ── static_call ────────────────────────────────────────────────────────────
+describe('MIR lowering — static_call', () => {
+    test('enum method call (static call on enum type)', () => {
+        // Static methods on types are emitted as static_call in HIR
+        expect(() => (0, compile_1.compile)(`
+      fn helper(): int { return 42; }
+      fn f(): int { return helper(); }
+    `, { namespace: 'sc' })).not.toThrow();
+    });
+});
+// ── foreach ────────────────────────────────────────────────────────────────
+describe('MIR lowering — foreach', () => {
+    test('foreach over selector creates loop blocks', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        foreach (p in @a) {
+          raw("say hi");
+        }
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+    test('foreach over selector with execute context', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        foreach (p in @a) at @s {
+          raw("tag @s add done");
+        }
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── path_expr ─────────────────────────────────────────────────────────────
+describe('MIR lowering — path_expr (enum variants as values)', () => {
+    test('using enum variant in if condition', () => {
+        const mod = compileMIR(`
+      enum Dir { North, South, East, West }
+      fn f(d: Dir): int {
+        if (d == Dir::North) { return 1; }
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── type_cast ─────────────────────────────────────────────────────────────
+describe('MIR lowering — type_cast', () => {
+    test('int as fixed cast compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(n: int): fixed {
+        return n as fixed;
+      }
+    `, { namespace: 'cast' })).not.toThrow();
+    });
+    test('fixed as int cast compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(x: fixed): int {
+        return x as int;
+      }
+    `, { namespace: 'cast2' })).not.toThrow();
+    });
+});
+// ── str_interp / f_string ──────────────────────────────────────────────────
+describe('MIR lowering — string operations', () => {
+    test('string interpolation in function compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(n: int): int {
+        let s: string = "value";
+        return 0;
+      }
+    `, { namespace: 'str' })).not.toThrow();
+    });
+});
+//# sourceMappingURL=lower-extra.test.js.map

package/dist/src/__tests__/mir/lower-extra2.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Additional coverage for src/mir/lower.ts
+ *
+ * Targets:
+ * - unary op '!' (not)
+ * - path_expr (enum variant integer)
+ * - enum_construct with payload
+ * - nested struct member access (v.pos.x)
+ * - dynamic array index (arr[i])
+ * - dynamic array index_assign (arr[i] = val)
+ * - static_call / invoke method
+ * - for_range loop lower
+ * - break/continue in loops
+ * - as_block / at_block
+ * - string_interp / f_string exprs
+ */
+export {};

package/dist/src/__tests__/mir/lower-extra2.test.js

@@ -0,0 +1,317 @@
+"use strict";
+/**
+ * Additional coverage for src/mir/lower.ts
+ *
+ * Targets:
+ * - unary op '!' (not)
+ * - path_expr (enum variant integer)
+ * - enum_construct with payload
+ * - nested struct member access (v.pos.x)
+ * - dynamic array index (arr[i])
+ * - dynamic array index_assign (arr[i] = val)
+ * - static_call / invoke method
+ * - for_range loop lower
+ * - break/continue in loops
+ * - as_block / at_block
+ * - string_interp / f_string exprs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lower_1 = require("../../hir/lower");
+const lower_2 = require("../../mir/lower");
+const verify_1 = require("../../mir/verify");
+const compile_1 = require("../../emit/compile");
+function compileMIR(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    const ast = new parser_1.Parser(tokens).parse('test');
+    const hir = (0, lower_1.lowerToHIR)(ast);
+    return (0, lower_2.lowerToMIR)(hir);
+}
+// ── unary not ─────────────────────────────────────────────────────────────
+describe('MIR lower — unary not', () => {
+    test('boolean not emits not instr', () => {
+        const mod = compileMIR(`
+      fn f(b: bool): bool {
+        return !b;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = mod.functions[0];
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        const notInstr = allInstrs.find(i => i.kind === 'not');
+        expect(notInstr).toBeDefined();
+    });
+});
+// ── path_expr ─────────────────────────────────────────────────────────────
+describe('MIR lower — path_expr (enum variant)', () => {
+    test('enum variant used as value is a copy from const src in MIR', () => {
+        const mod = compileMIR(`
+      enum Phase { Idle, Running, Done }
+      fn f(): int {
+        let p: Phase = Phase::Running;
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = mod.functions.find(f => f.name === 'f');
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        // Phase::Running → copy with const src value=1
+        const copyInstrs = allInstrs.filter(i => i.kind === 'copy' && i.src?.kind === 'const');
+        expect(copyInstrs.length).toBeGreaterThan(0);
+    });
+});
+// ── nested struct member ───────────────────────────────────────────────────
+describe('MIR lower — nested struct member access', () => {
+    test('v.pos.x compiles without error', () => {
+        expect(() => (0, compile_1.compile)(`
+      struct Vec2 { x: int, y: int }
+      struct Entity { pos: Vec2, hp: int }
+      fn f(): int {
+        let e: Entity = Entity { pos: Vec2 { x: 10, y: 20 }, hp: 100 };
+        return e.pos.x;
+      }
+    `, { namespace: 'nested' })).not.toThrow();
+    });
+});
+// ── dynamic array index ────────────────────────────────────────────────────
+describe('MIR lower — dynamic array index', () => {
+    test('let arr = []; arr[i] with variable index emits nbt_read_dynamic', () => {
+        const mod = compileMIR(`
+      fn f(i: int): int {
+        let arr: int[] = [10, 20, 30];
+        return arr[i];
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = mod.functions[0];
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        const dynRead = allInstrs.find(i => i.kind === 'nbt_read_dynamic');
+        expect(dynRead).toBeDefined();
+    });
+    test('let arr = []; arr[i] = v with variable index emits nbt_write_dynamic', () => {
+        const mod = compileMIR(`
+      fn f(i: int, v: int): int {
+        let arr: int[] = [0, 0, 0];
+        arr[i] = v;
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = mod.functions[0];
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        const dynWrite = allInstrs.find(i => i.kind === 'nbt_write_dynamic');
+        expect(dynWrite).toBeDefined();
+    });
+    test('let arr = []; arr[0] with constant index emits nbt_read (not dynamic)', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        let arr: int[] = [10, 20, 30];
+        return arr[0];
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = mod.functions[0];
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        const staticRead = allInstrs.find(i => i.kind === 'nbt_read');
+        expect(staticRead).toBeDefined();
+    });
+    test('let arr = []; arr[0] = v with constant index emits nbt_write (not dynamic)', () => {
+        const mod = compileMIR(`
+      fn f(v: int): int {
+        let arr: int[] = [0, 0, 0];
+        arr[0] = v;
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = mod.functions[0];
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        const staticWrite = allInstrs.find(i => i.kind === 'nbt_write');
+        expect(staticWrite).toBeDefined();
+    });
+});
+// ── for_range loop ─────────────────────────────────────────────────────────
+describe('MIR lower — for_range loop', () => {
+    test('for i in 0..5 creates loop blocks', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        let sum = 0;
+        for i in 0..5 {
+          sum = sum + i;
+        }
+        return sum;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = mod.functions[0];
+        expect(fn.blocks.length).toBeGreaterThan(2);
+    });
+    test('for i in 0..=5 (inclusive) creates loop blocks', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        let total = 0;
+        for i in 0..=4 {
+          total = total + i;
+        }
+        return total;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── break / continue ─────────────────────────────────────────────────────
+describe('MIR lower — break/continue in loops', () => {
+    test('break in while loop compiles', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        let x = 0;
+        while (x < 10) {
+          if (x == 5) { break; }
+          x = x + 1;
+        }
+        return x;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = mod.functions[0];
+        // break creates a dead block after it
+        expect(fn.blocks.length).toBeGreaterThan(3);
+    });
+    test('continue in for loop compiles', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        let sum = 0;
+        for (let i: int = 0; i < 5; i = i + 1) {
+          if (i == 2) { continue; }
+          sum = sum + i;
+        }
+        return sum;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── as_block / at_block / as_at ─────────────────────────────────────────
+describe('MIR lower — context blocks', () => {
+    test('as @a block creates helper function', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        as @a {
+          raw("say hi");
+        }
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = mod.functions[0];
+        const allInstrs = fn.blocks.flatMap(b => b.instrs);
+        const ctxCall = allInstrs.find(i => i.kind === 'call_context');
+        expect(ctxCall).toBeDefined();
+    });
+    test('at @s block creates helper function', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        at @s {
+          raw("say positioned");
+        }
+        return 0;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── method calls (invoke) ─────────────────────────────────────────────────
+describe('MIR lower — invoke method calls', () => {
+    test('method call on struct instance compiles', () => {
+        const mod = compileMIR(`
+      struct Timer { ticks: int }
+      impl Timer {
+        fn advance(self): int {
+          self.ticks = self.ticks + 1;
+          return self.ticks;
+        }
+      }
+      fn f(): int {
+        let t: Timer = Timer { ticks: 0 };
+        return t.advance();
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+// ── string_interp ─────────────────────────────────────────────────────────
+describe('MIR lower — string interpolation', () => {
+    test('raw string variable compiles', () => {
+        expect(() => (0, compile_1.compile)(`
+      fn f(): int {
+        let s: string = "hello world";
+        return 0;
+      }
+    `, { namespace: 'str2' })).not.toThrow();
+    });
+    test('f-string expression compiles to MIR', () => {
+        const mod = compileMIR(`
+      fn f(n: int): void {
+        say(f"value is {n}");
+      }
+    `);
+        // f-string should produce some instructions in the function
+        expect(mod.functions.length).toBeGreaterThan(0);
+    });
+});
+// ── multiple return values / void return ───────────────────────────────────
+describe('MIR lower — return variants', () => {
+    test('void function with no return stmt compiles', () => {
+        const mod = compileMIR(`
+      fn f(): void {
+        raw("say nothing");
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = mod.functions[0];
+        // Last term should be return with null
+        const lastBlock = fn.blocks[fn.blocks.length - 1];
+        expect(lastBlock.term.kind).toBe('return');
+    });
+    test('early return in conditional compiles', () => {
+        const mod = compileMIR(`
+      fn f(n: int): int {
+        if (n < 0) { return -1; }
+        if (n == 0) { return 0; }
+        return 1;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        expect(mod.functions[0].blocks.length).toBeGreaterThan(2);
+    });
+});
+// ── const val as fn param ──────────────────────────────────────────────────
+describe('MIR lower — constant propagation', () => {
+    test('boolean literal true compiles to const 1 in MIR return', () => {
+        const mod = compileMIR(`
+      fn f(): bool {
+        return true;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+        const fn = mod.functions[0];
+        // return should carry const value 1
+        const retBlock = fn.blocks[0];
+        const retTerm = retBlock.term;
+        expect(retTerm.kind).toBe('return');
+        // value should be const 1
+        if (retTerm.kind === 'return' && retTerm.value) {
+            expect(retTerm.value).toEqual({ kind: 'const', value: 1 });
+        }
+    });
+    test('negative literal compiles via unary minus', () => {
+        const mod = compileMIR(`
+      fn f(): int {
+        return -5;
+      }
+    `);
+        expect((0, verify_1.verifyMIR)(mod)).toEqual([]);
+    });
+});
+//# sourceMappingURL=lower-extra2.test.js.map