redscript-mc 2.0.0 → 2.1.0

package/dist/__tests__/entity-types.test.js

@@ -1,203 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const entity_hierarchy_1 = require("../types/entity-hierarchy");
-const lexer_1 = require("../lexer");
-const parser_1 = require("../parser");
-const lowering_1 = require("../lowering");
-function compileWithWarnings(source, namespace = 'test') {
-    const tokens = new lexer_1.Lexer(source).tokenize();
-    const ast = new parser_1.Parser(tokens).parse(namespace);
-    const lowering = new lowering_1.Lowering(namespace);
-    return { ir: lowering.lower(ast), warnings: lowering.warnings };
-}
-// ---------------------------------------------------------------------------
-// Entity hierarchy utilities
-// ---------------------------------------------------------------------------
-describe('Entity type hierarchy', () => {
-    test('isSubtype: Zombie is a subtype of Mob', () => {
-        expect((0, entity_hierarchy_1.isSubtype)('Zombie', 'Mob')).toBe(true);
-    });
-    test('isSubtype: Player is NOT a subtype of Mob', () => {
-        expect((0, entity_hierarchy_1.isSubtype)('Player', 'Mob')).toBe(false);
-    });
-    test('isSubtype: Zombie is a subtype of Entity (transitive)', () => {
-        expect((0, entity_hierarchy_1.isSubtype)('Zombie', 'Entity')).toBe(true);
-    });
-    test('isSubtype: identity — Zombie is subtype of Zombie', () => {
-        expect((0, entity_hierarchy_1.isSubtype)('Zombie', 'Zombie')).toBe(true);
-    });
-    test('areCompatibleTypes: Player and Zombie are NOT compatible', () => {
-        expect((0, entity_hierarchy_1.areCompatibleTypes)('Player', 'Zombie')).toBe(false);
-    });
-    test('areCompatibleTypes: Zombie and Mob are compatible', () => {
-        expect((0, entity_hierarchy_1.areCompatibleTypes)('Zombie', 'Mob')).toBe(true);
-    });
-    test('areCompatibleTypes: Mob and Zombie are compatible (reverse)', () => {
-        expect((0, entity_hierarchy_1.areCompatibleTypes)('Mob', 'Zombie')).toBe(true);
-    });
-    test('getConcreteSubtypes: HostileMob includes Zombie, Skeleton, Creeper', () => {
-        const subtypes = (0, entity_hierarchy_1.getConcreteSubtypes)('HostileMob');
-        const names = subtypes.map(n => n.name);
-        expect(names).toContain('Zombie');
-        expect(names).toContain('Skeleton');
-        expect(names).toContain('Creeper');
-        expect(names).toContain('Blaze');
-        expect(names).toContain('CaveSpider');
-        // Should NOT include passive mobs
-        expect(names).not.toContain('Pig');
-        expect(names).not.toContain('Player');
-    });
-    test('getConcreteSubtypes: PassiveMob includes Pig, Cow, Villager', () => {
-        const subtypes = (0, entity_hierarchy_1.getConcreteSubtypes)('PassiveMob');
-        const names = subtypes.map(n => n.name);
-        expect(names).toContain('Pig');
-        expect(names).toContain('Cow');
-        expect(names).toContain('Villager');
-        expect(names).toContain('WanderingTrader');
-        expect(names).not.toContain('Zombie');
-    });
-    test('getSelectorEntityType: parses type=zombie', () => {
-        expect((0, entity_hierarchy_1.getSelectorEntityType)('@e[type=zombie]')).toBe('Zombie');
-    });
-    test('getSelectorEntityType: parses type=minecraft:skeleton', () => {
-        expect((0, entity_hierarchy_1.getSelectorEntityType)('@e[type=minecraft:skeleton]')).toBe('Skeleton');
-    });
-    test('getBaseSelectorType: @a → Player', () => {
-        expect((0, entity_hierarchy_1.getBaseSelectorType)('@a')).toBe('Player');
-    });
-    test('getBaseSelectorType: @e → Entity', () => {
-        expect((0, entity_hierarchy_1.getBaseSelectorType)('@e')).toBe('Entity');
-    });
-    test('getBaseSelectorType: @e[type=zombie] → Zombie', () => {
-        expect((0, entity_hierarchy_1.getBaseSelectorType)('@e[type=zombie]')).toBe('Zombie');
-    });
-    test('getBaseSelectorType: @s → null', () => {
-        expect((0, entity_hierarchy_1.getBaseSelectorType)('@s')).toBeNull();
-    });
-});
-// ---------------------------------------------------------------------------
-// W_IMPOSSIBLE_AS warning
-// ---------------------------------------------------------------------------
-describe('W_IMPOSSIBLE_AS warning', () => {
-    test('foreach @a with as @e[type=zombie] produces warning', () => {
-        const source = `
-      fn main() {
-        foreach (p in @a) {
-          as @e[type=minecraft:zombie] {
-            kill(@s);
-          }
-        }
-      }
-    `;
-        const { warnings } = compileWithWarnings(source);
-        const impossible = warnings.filter(w => w.code === 'W_IMPOSSIBLE_AS');
-        expect(impossible.length).toBe(1);
-        expect(impossible[0].message).toContain('Player');
-        expect(impossible[0].message).toContain('Zombie');
-    });
-    test('foreach @e[type=zombie] with as @e[type=zombie] produces NO warning', () => {
-        const source = `
-      fn main() {
-        foreach (z in @e[type=minecraft:zombie]) {
-          as @e[type=minecraft:zombie] {
-            kill(@s);
-          }
-        }
-      }
-    `;
-        const { warnings } = compileWithWarnings(source);
-        const impossible = warnings.filter(w => w.code === 'W_IMPOSSIBLE_AS');
-        expect(impossible.length).toBe(0);
-    });
-    test('foreach @e (generic) with as @e[type=zombie] produces NO warning', () => {
-        const source = `
-      fn main() {
-        foreach (e in @e) {
-          as @e[type=minecraft:zombie] {
-            kill(@s);
-          }
-        }
-      }
-    `;
-        const { warnings } = compileWithWarnings(source);
-        const impossible = warnings.filter(w => w.code === 'W_IMPOSSIBLE_AS');
-        expect(impossible.length).toBe(0);
-    });
-});
-// ---------------------------------------------------------------------------
-// is_check with abstract types
-// ---------------------------------------------------------------------------
-describe('is_check compilation', () => {
-    test('concrete is_check emits single execute if entity', () => {
-        const source = `
-      fn main() {
-        foreach (e in @e) {
-          if (e is Zombie) {
-            kill(@s);
-          }
-        }
-      }
-    `;
-        const { ir } = compileWithWarnings(source);
-        const thenFn = ir.functions.find(f => f.name.includes('then_'));
-        expect(thenFn).toBeDefined();
-        // The parent foreach function should contain the execute if entity command
-        const foreachFn = ir.functions.find(f => f.name.includes('foreach_'));
-        expect(foreachFn).toBeDefined();
-        const rawCmds = foreachFn.blocks.flatMap(b => b.instrs)
-            .filter((i) => i.op === 'raw')
-            .map(i => i.cmd);
-        expect(rawCmds.some(c => c.includes('type=minecraft:zombie'))).toBe(true);
-    });
-    test('abstract is_check (HostileMob) emits multiple type checks', () => {
-        const source = `
-      fn main() {
-        foreach (e in @e) {
-          if (e is HostileMob) {
-            kill(@s);
-          }
-        }
-      }
-    `;
-        const { ir } = compileWithWarnings(source);
-        const foreachFn = ir.functions.find(f => f.name.includes('foreach_'));
-        expect(foreachFn).toBeDefined();
-        const rawCmds = foreachFn.blocks.flatMap(b => b.instrs)
-            .filter((i) => i.op === 'raw')
-            .map(i => i.cmd);
-        // Should have scoreboard setup and multiple type checks
-        expect(rawCmds.some(c => c.includes('scoreboard players set __is_result rs:temp 0'))).toBe(true);
-        expect(rawCmds.some(c => c.includes('type=minecraft:zombie'))).toBe(true);
-        expect(rawCmds.some(c => c.includes('type=minecraft:skeleton'))).toBe(true);
-        expect(rawCmds.some(c => c.includes('type=minecraft:creeper'))).toBe(true);
-        expect(rawCmds.some(c => c.includes('if score __is_result rs:temp matches 1'))).toBe(true);
-    });
-});
-// ---------------------------------------------------------------------------
-// selector<T> type annotation
-// ---------------------------------------------------------------------------
-describe('selector<T> type annotation', () => {
-    test('parses selector<Player> type', () => {
-        const source = `
-      fn greet(target: selector<Player>) {
-        say("hello");
-      }
-    `;
-        const tokens = new lexer_1.Lexer(source).tokenize();
-        const ast = new parser_1.Parser(tokens).parse('test');
-        const fn = ast.declarations[0];
-        expect(fn.params[0].type).toEqual({ kind: 'selector', entityType: 'Player' });
-    });
-    test('parses plain selector type', () => {
-        const source = `
-      fn greet(target: selector) {
-        say("hello");
-      }
-    `;
-        const tokens = new lexer_1.Lexer(source).tokenize();
-        const ast = new parser_1.Parser(tokens).parse('test');
-        const fn = ast.declarations[0];
-        expect(fn.params[0].type).toEqual({ kind: 'selector' });
-    });
-});
-//# sourceMappingURL=entity-types.test.js.map

package/dist/__tests__/formatter.test.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const formatter_1 = require("../formatter");
-describe('formatter', () => {
-    it('normalizes indentation to 4 spaces', () => {
-        const input = 'fn main() {\n  let x: int = 1;\n}';
-        const result = (0, formatter_1.format)(input);
-        expect(result).toBe('fn main() {\n    let x: int = 1;\n}\n');
-    });
-    it('handles nested blocks', () => {
-        const input = 'fn main() {\nif true {\nlet x: int = 1;\n}\n}';
-        const result = (0, formatter_1.format)(input);
-        expect(result).toBe('fn main() {\n    if true {\n        let x: int = 1;\n    }\n}\n');
-    });
-    it('trims trailing whitespace', () => {
-        const input = 'fn main() {   \n    let x: int = 1;   \n}   ';
-        const result = (0, formatter_1.format)(input);
-        expect(result).toBe('fn main() {\n    let x: int = 1;\n}\n');
-    });
-    it('ensures single newline at end of file', () => {
-        const input = 'fn main() {\n}\n\n\n';
-        const result = (0, formatter_1.format)(input);
-        expect(result).toBe('fn main() {\n}\n');
-    });
-    it('preserves blank lines', () => {
-        const input = 'fn a() {\n}\n\nfn b() {\n}';
-        const result = (0, formatter_1.format)(input);
-        expect(result).toBe('fn a() {\n}\n\nfn b() {\n}\n');
-    });
-    it('handles already formatted code', () => {
-        const input = 'fn main() {\n    let x: int = 1;\n}\n';
-        const result = (0, formatter_1.format)(input);
-        expect(result).toBe(input);
-    });
-    it('handles empty input', () => {
-        expect((0, formatter_1.format)('')).toBe('\n');
-        expect((0, formatter_1.format)('\n\n')).toBe('\n');
-    });
-});
-//# sourceMappingURL=formatter.test.js.map

package/dist/__tests__/lexer.test.js

@@ -1,343 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const lexer_1 = require("../lexer");
-function tokenize(source) {
-    return new lexer_1.Lexer(source).tokenize();
-}
-function kinds(tokens) {
-    return tokens.map(t => t.kind);
-}
-describe('Lexer', () => {
-    describe('keywords', () => {
-        it('recognizes all keywords', () => {
-            const tokens = tokenize('fn let const if else while for foreach match return as at in is struct impl enum trigger namespace');
-            expect(kinds(tokens)).toEqual([
-                'fn', 'let', 'const', 'if', 'else', 'while', 'for', 'foreach', 'match',
-                'return', 'as', 'at', 'in', 'is', 'struct', 'impl', 'enum', 'trigger', 'namespace', 'eof'
-            ]);
-        });
-        it('tokenizes is-check and impl syntax with their dedicated keywords', () => {
-            const tokens = tokenize('if (e is Player) { } impl Point { }');
-            expect(kinds(tokens)).toEqual([
-                'if', '(', 'ident', 'is', 'ident', ')', '{', '}', 'impl', 'ident', '{', '}', 'eof',
-            ]);
-        });
-        it('recognizes type keywords', () => {
-            const tokens = tokenize('int bool float string void BlockPos');
-            expect(kinds(tokens)).toEqual(['int', 'bool', 'float', 'string', 'void', 'BlockPos', 'eof']);
-        });
-        it('recognizes boolean literals', () => {
-            const tokens = tokenize('true false');
-            expect(kinds(tokens)).toEqual(['true', 'false', 'eof']);
-        });
-    });
-    describe('identifiers', () => {
-        it('tokenizes simple identifiers', () => {
-            const tokens = tokenize('foo bar_baz _private x1');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['ident', 'foo'],
-                ['ident', 'bar_baz'],
-                ['ident', '_private'],
-                ['ident', 'x1'],
-                ['eof', ''],
-            ]);
-        });
-    });
-    describe('literals', () => {
-        it('tokenizes integer literals', () => {
-            const tokens = tokenize('42 0 123');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['int_lit', '42'],
-                ['int_lit', '0'],
-                ['int_lit', '123'],
-                ['eof', ''],
-            ]);
-        });
-        it('tokenizes float literals', () => {
-            const tokens = tokenize('3.14 0.5 10.0');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['float_lit', '3.14'],
-                ['float_lit', '0.5'],
-                ['float_lit', '10.0'],
-                ['eof', ''],
-            ]);
-        });
-        it('tokenizes string literals', () => {
-            const tokens = tokenize('"hello" "world" "with \\"quotes\\""');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['string_lit', 'hello'],
-                ['string_lit', 'world'],
-                ['string_lit', 'with "quotes"'],
-                ['eof', ''],
-            ]);
-        });
-        it('tokenizes interpolated strings as a single string token', () => {
-            const tokens = tokenize('"hello ${name + 1}"');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['string_lit', 'hello ${name + 1}'],
-                ['eof', ''],
-            ]);
-        });
-        it('tokenizes f-strings as a dedicated token', () => {
-            const tokens = tokenize('f"Hello {name}!"');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['f_string', 'Hello {name}!'],
-                ['eof', ''],
-            ]);
-        });
-        it('tokenizes byte literals (b suffix)', () => {
-            const tokens = tokenize('20b 0B 127b');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['byte_lit', '20b'],
-                ['byte_lit', '0B'],
-                ['byte_lit', '127b'],
-                ['eof', ''],
-            ]);
-        });
-        it('tokenizes short literals (s suffix)', () => {
-            const tokens = tokenize('100s 0S 32767s');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['short_lit', '100s'],
-                ['short_lit', '0S'],
-                ['short_lit', '32767s'],
-                ['eof', ''],
-            ]);
-        });
-        it('tokenizes long literals (L suffix)', () => {
-            const tokens = tokenize('1000L 0l 999999L');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['long_lit', '1000L'],
-                ['long_lit', '0l'],
-                ['long_lit', '999999L'],
-                ['eof', ''],
-            ]);
-        });
-        it('tokenizes float literals with f suffix', () => {
-            const tokens = tokenize('3.14f 0.5F 10.0f');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['float_lit', '3.14f'],
-                ['float_lit', '0.5F'],
-                ['float_lit', '10.0f'],
-                ['eof', ''],
-            ]);
-        });
-        it('tokenizes double literals (d suffix)', () => {
-            const tokens = tokenize('3.14d 0.5D 10.0d');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['double_lit', '3.14d'],
-                ['double_lit', '0.5D'],
-                ['double_lit', '10.0d'],
-                ['eof', ''],
-            ]);
-        });
-        it('tokenizes integer with f/d suffix as float/double', () => {
-            const tokens = tokenize('5f 10d');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['float_lit', '5f'],
-                ['double_lit', '10d'],
-                ['eof', ''],
-            ]);
-        });
-        it('does not treat suffix-like letters in identifiers as NBT suffixes', () => {
-            // 1b2 should not be byte_lit — the 'b' is followed by a digit
-            const tokens = tokenize('1b2');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['int_lit', '1'],
-                ['ident', 'b2'],
-                ['eof', ''],
-            ]);
-        });
-        it('tokenizes range literals', () => {
-            const tokens = tokenize('..5 1.. 1..10');
-            expect(tokens.map(t => [t.kind, t.value])).toEqual([
-                ['range_lit', '..5'],
-                ['range_lit', '1..'],
-                ['range_lit', '1..10'],
-                ['eof', ''],
-            ]);
-        });
-    });
-    describe('operators', () => {
-        it('tokenizes arithmetic operators', () => {
-            const tokens = tokenize('+ - * / %');
-            expect(kinds(tokens)).toEqual(['+', '-', '*', '/', '%', 'eof']);
-        });
-        it('tokenizes relative and local coordinates', () => {
-            const tokens = tokenize('~ ~5 ~-3 ^ ^10 ^-2');
-            expect(kinds(tokens)).toEqual(['rel_coord', 'rel_coord', 'rel_coord', 'local_coord', 'local_coord', 'local_coord', 'eof']);
-            expect(tokens[0].value).toBe('~');
-            expect(tokens[1].value).toBe('~5');
-            expect(tokens[2].value).toBe('~-3');
-            expect(tokens[3].value).toBe('^');
-            expect(tokens[4].value).toBe('^10');
-            expect(tokens[5].value).toBe('^-2');
-        });
-        it('tokenizes comparison operators', () => {
-            const tokens = tokenize('== != < <= > >=');
-            expect(kinds(tokens)).toEqual(['==', '!=', '<', '<=', '>', '>=', 'eof']);
-        });
-        it('tokenizes logical operators', () => {
-            const tokens = tokenize('&& || !');
-            expect(kinds(tokens)).toEqual(['&&', '||', '!', 'eof']);
-        });
-        it('tokenizes assignment operators', () => {
-            const tokens = tokenize('= += -= *= /= %=');
-            expect(kinds(tokens)).toEqual(['=', '+=', '-=', '*=', '/=', '%=', 'eof']);
-        });
-        it('tokenizes arrow operator', () => {
-            const tokens = tokenize('->');
-            expect(kinds(tokens)).toEqual(['->', 'eof']);
-        });
-        it('tokenizes fat arrow operator', () => {
-            const tokens = tokenize('=>');
-            expect(kinds(tokens)).toEqual(['=>', 'eof']);
-        });
-        it('tokenizes static method separators for impl methods', () => {
-            const tokens = tokenize('Point::new()');
-            expect(kinds(tokens)).toEqual(['ident', '::', 'ident', '(', ')', 'eof']);
-        });
-    });
-    describe('delimiters', () => {
-        it('tokenizes all delimiters', () => {
-            const tokens = tokenize('{ } ( ) [ ] , ; : .');
-            expect(kinds(tokens)).toEqual(['{', '}', '(', ')', '[', ']', ',', ';', ':', '.', 'eof']);
-        });
-    });
-    describe('selectors', () => {
-        it('tokenizes simple selectors', () => {
-            const tokens = tokenize('@a @e @s @p @r @n');
-            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
-                ['selector', '@a'],
-                ['selector', '@e'],
-                ['selector', '@s'],
-                ['selector', '@p'],
-                ['selector', '@r'],
-                ['selector', '@n'],
-            ]);
-        });
-        it('tokenizes selectors with parameters', () => {
-            const tokens = tokenize('@e[type=zombie] @a[distance=..5]');
-            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
-                ['selector', '@e[type=zombie]'],
-                ['selector', '@a[distance=..5]'],
-            ]);
-        });
-        it('tokenizes selectors with complex NBT', () => {
-            const tokens = tokenize('@e[type=zombie, nbt={NoAI:1b}]');
-            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
-                ['selector', '@e[type=zombie, nbt={NoAI:1b}]'],
-            ]);
-        });
-        it('handles nested braces in selector NBT', () => {
-            const tokens = tokenize('@e[nbt={Items:[{id:"stone"}]}]');
-            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
-                ['selector', '@e[nbt={Items:[{id:"stone"}]}]'],
-            ]);
-        });
-    });
-    describe('decorators', () => {
-        it('tokenizes simple decorators', () => {
-            const tokens = tokenize('@tick @on_trigger');
-            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
-                ['decorator', '@tick'],
-                ['decorator', '@on_trigger'],
-            ]);
-        });
-        it('tokenizes decorators with arguments', () => {
-            const tokens = tokenize('@tick(rate=20)');
-            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
-                ['decorator', '@tick(rate=20)'],
-            ]);
-        });
-    });
-    describe('raw commands', () => {
-        it('tokenizes raw command', () => {
-            const tokens = tokenize('raw("say hello")');
-            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
-                ['raw_cmd', 'say hello'],
-            ]);
-        });
-    });
-    describe('comments', () => {
-        it('skips line comments', () => {
-            const tokens = tokenize('let x = 5 // this is a comment\nlet y = 10');
-            expect(kinds(tokens)).toEqual(['let', 'ident', '=', 'int_lit', 'let', 'ident', '=', 'int_lit', 'eof']);
-        });
-    });
-    describe('complex expressions', () => {
-        it('tokenizes function declaration', () => {
-            const source = 'fn add(a: int, b: int) -> int { return a + b; }';
-            const tokens = tokenize(source);
-            expect(kinds(tokens)).toEqual([
-                'fn', 'ident', '(', 'ident', ':', 'int', ',', 'ident', ':', 'int', ')',
-                '->', 'int', '{', 'return', 'ident', '+', 'ident', ';', '}', 'eof'
-            ]);
-        });
-        it('tokenizes foreach statement', () => {
-            const source = 'foreach (z in @e[type=zombie]) { kill(z); }';
-            const tokens = tokenize(source);
-            expect(kinds(tokens)).toEqual([
-                'foreach', '(', 'ident', 'in', 'selector', ')', '{', 'ident', '(', 'ident', ')', ';', '}', 'eof'
-            ]);
-        });
-        it('tokenizes decorated function', () => {
-            const source = '@tick(rate=20)\nfn heartbeat() { say("alive"); }';
-            const tokens = tokenize(source);
-            expect(kinds(tokens)).toEqual([
-                'decorator', 'fn', 'ident', '(', ')', '{', 'ident', '(', 'string_lit', ')', ';', '}', 'eof'
-            ]);
-        });
-    });
-    describe('line/column tracking', () => {
-        it('tracks line and column correctly', () => {
-            const source = 'let x\nlet y';
-            const tokens = tokenize(source);
-            expect(tokens[0]).toMatchObject({ kind: 'let', line: 1, col: 1 });
-            expect(tokens[1]).toMatchObject({ kind: 'ident', value: 'x', line: 1, col: 5 });
-            expect(tokens[2]).toMatchObject({ kind: 'let', line: 2, col: 1 });
-            expect(tokens[3]).toMatchObject({ kind: 'ident', value: 'y', line: 2, col: 5 });
-        });
-    });
-    describe('edge cases', () => {
-        it('handles empty input', () => {
-            const tokens = tokenize('');
-            expect(kinds(tokens)).toEqual(['eof']);
-        });
-        it('handles whitespace only', () => {
-            const tokens = tokenize('   \n\t  ');
-            expect(kinds(tokens)).toEqual(['eof']);
-        });
-        it('distinguishes selector from decorator', () => {
-            // @a is selector (single char followed by non-letter)
-            // @aa would be decorator
-            const tokens = tokenize('@a @aa');
-            expect(tokens.filter(t => t.kind !== 'eof').map(t => [t.kind, t.value])).toEqual([
-                ['selector', '@a'],
-                ['decorator', '@aa'],
-            ]);
-        });
-    });
-});
-describe('Block comments', () => {
-    it('skips single-line block comment', () => {
-        const src = `/* comment */ fn test() {}`;
-        const tokens = tokenize(src);
-        expect(tokens.map(t => t.kind)).not.toContain('/');
-        expect(tokens.find(t => t.kind === 'fn')).toBeDefined();
-    });
-    it('skips multi-line block comment', () => {
-        const src = `/**
- * JSDoc comment
- */
-fn test() {}`;
-        const tokens = tokenize(src);
-        expect(tokens.map(t => t.kind)).not.toContain('/');
-        expect(tokens.find(t => t.kind === 'fn')).toBeDefined();
-    });
-    it('handles block comment with asterisks', () => {
-        const src = `/*** stars ***/fn x(){}`;
-        const tokens = tokenize(src);
-        expect(tokens.find(t => t.kind === 'fn')).toBeDefined();
-    });
-});
-//# sourceMappingURL=lexer.test.js.map