@a2ui-sdk/utils 0.1.1 → 0.2.1

package/dist/0.9/interpolation/lexer.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Tests for the lexer (tokenizer).
- */
-export {};

package/dist/0.9/interpolation/lexer.test.js

@@ -1,360 +0,0 @@
-/**
- * Tests for the lexer (tokenizer).
- */
-import { describe, it, expect } from 'vitest';
-import { tokenize } from './lexer.js';
-import { TokenType } from './types.js';
-describe('Lexer', () => {
-    describe('TEXT tokens', () => {
-        it('should tokenize plain text', () => {
-            const tokens = tokenize('Hello World');
-            expect(tokens).toHaveLength(2); // TEXT + EOF
-            expect(tokens[0]).toMatchObject({
-                type: TokenType.TEXT,
-                value: 'Hello World',
-                start: 0,
-                end: 11,
-            });
-        });
-        it('should return only EOF for empty string', () => {
-            const tokens = tokenize('');
-            expect(tokens).toHaveLength(1);
-            expect(tokens[0].type).toBe(TokenType.EOF);
-        });
-        it('should handle text with special characters', () => {
-            const tokens = tokenize('Hello @world! #123');
-            expect(tokens[0]).toMatchObject({
-                type: TokenType.TEXT,
-                value: 'Hello @world! #123',
-            });
-        });
-        it('should handle multi-line text', () => {
-            const tokens = tokenize('Line 1\nLine 2');
-            expect(tokens[0]).toMatchObject({
-                type: TokenType.TEXT,
-                value: 'Line 1\nLine 2',
-            });
-        });
-    });
-    describe('EXPR_START and EXPR_END tokens', () => {
-        it('should tokenize expression delimiters', () => {
-            const tokens = tokenize('${/path}');
-            expect(tokens[0]).toMatchObject({
-                type: TokenType.EXPR_START,
-                value: '${',
-            });
-            expect(tokens[1]).toMatchObject({ type: TokenType.PATH, value: '/path' });
-            expect(tokens[2]).toMatchObject({ type: TokenType.EXPR_END, value: '}' });
-        });
-        it('should handle multiple expressions', () => {
-            const tokens = tokenize('${/a} ${/b}');
-            const types = tokens.map((t) => t.type);
-            expect(types).toEqual([
-                TokenType.EXPR_START,
-                TokenType.PATH,
-                TokenType.EXPR_END,
-                TokenType.TEXT,
-                TokenType.EXPR_START,
-                TokenType.PATH,
-                TokenType.EXPR_END,
-                TokenType.EOF,
-            ]);
-        });
-        it('should handle expression at start of string', () => {
-            const tokens = tokenize('${/name} is here');
-            expect(tokens[0].type).toBe(TokenType.EXPR_START);
-        });
-        it('should handle expression at end of string', () => {
-            const tokens = tokenize('Name: ${/name}');
-            expect(tokens[tokens.length - 2].type).toBe(TokenType.EXPR_END);
-        });
-    });
-    describe('PATH tokens', () => {
-        it('should tokenize absolute paths', () => {
-            const tokens = tokenize('${/user/name}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.PATH,
-                value: '/user/name',
-            });
-        });
-        it('should tokenize root path', () => {
-            const tokens = tokenize('${/}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.PATH,
-                value: '/',
-            });
-        });
-        it('should tokenize paths with array indices', () => {
-            const tokens = tokenize('${/items/0}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.PATH,
-                value: '/items/0',
-            });
-        });
-        it('should tokenize relative paths', () => {
-            const tokens = tokenize('${name}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.PATH,
-                value: 'name',
-            });
-        });
-        it('should tokenize nested relative paths', () => {
-            const tokens = tokenize('${profile/name}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.PATH,
-                value: 'profile/name',
-            });
-        });
-        it('should tokenize paths with hyphens', () => {
-            const tokens = tokenize('${/user-data/first-name}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.PATH,
-                value: '/user-data/first-name',
-            });
-        });
-        it('should tokenize paths with underscores', () => {
-            const tokens = tokenize('${/user_data/first_name}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.PATH,
-                value: '/user_data/first_name',
-            });
-        });
-    });
-    describe('IDENTIFIER, LPAREN, RPAREN, COMMA tokens', () => {
-        it('should tokenize no-argument function call', () => {
-            const tokens = tokenize('${now()}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.IDENTIFIER,
-                value: 'now',
-            });
-            expect(tokens[2]).toMatchObject({ type: TokenType.LPAREN, value: '(' });
-            expect(tokens[3]).toMatchObject({ type: TokenType.RPAREN, value: ')' });
-        });
-        it('should tokenize function with single argument', () => {
-            const tokens = tokenize("${upper('hello')}");
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.IDENTIFIER,
-                value: 'upper',
-            });
-            expect(tokens[2]).toMatchObject({ type: TokenType.LPAREN, value: '(' });
-            expect(tokens[3]).toMatchObject({
-                type: TokenType.STRING,
-                value: 'hello',
-            });
-            expect(tokens[4]).toMatchObject({ type: TokenType.RPAREN, value: ')' });
-        });
-        it('should tokenize function with multiple arguments', () => {
-            const tokens = tokenize('${add(1, 2, 3)}');
-            const types = tokens.map((t) => t.type);
-            expect(types).toContain(TokenType.COMMA);
-            // Count commas
-            const commaCount = tokens.filter((t) => t.type === TokenType.COMMA).length;
-            expect(commaCount).toBe(2);
-        });
-        it('should handle whitespace around function parts', () => {
-            const tokens = tokenize('${ upper ( 1 , 2 ) }');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.IDENTIFIER,
-                value: 'upper',
-            });
-            expect(tokens[2]).toMatchObject({ type: TokenType.LPAREN });
-            expect(tokens[3]).toMatchObject({ type: TokenType.NUMBER, value: '1' });
-            expect(tokens[4]).toMatchObject({ type: TokenType.COMMA });
-            expect(tokens[5]).toMatchObject({ type: TokenType.NUMBER, value: '2' });
-            expect(tokens[6]).toMatchObject({ type: TokenType.RPAREN });
-        });
-        it('should tokenize function names with underscores', () => {
-            const tokens = tokenize('${format_date()}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.IDENTIFIER,
-                value: 'format_date',
-            });
-        });
-    });
-    describe('STRING, NUMBER, BOOLEAN literal tokens', () => {
-        it('should tokenize string literals', () => {
-            const tokens = tokenize("${'hello'}");
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.STRING,
-                value: 'hello',
-            });
-        });
-        it('should tokenize string with spaces', () => {
-            const tokens = tokenize("${'hello world'}");
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.STRING,
-                value: 'hello world',
-            });
-        });
-        it('should handle escaped quotes in strings', () => {
-            const tokens = tokenize("${'it\\'s here'}");
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.STRING,
-                value: "it's here",
-            });
-        });
-        it('should tokenize integer numbers', () => {
-            const tokens = tokenize('${42}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.NUMBER,
-                value: '42',
-            });
-        });
-        it('should tokenize negative numbers', () => {
-            const tokens = tokenize('${-5}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.NUMBER,
-                value: '-5',
-            });
-        });
-        it('should tokenize decimal numbers', () => {
-            const tokens = tokenize('${3.14}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.NUMBER,
-                value: '3.14',
-            });
-        });
-        it('should tokenize negative decimal numbers', () => {
-            const tokens = tokenize('${-3.14}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.NUMBER,
-                value: '-3.14',
-            });
-        });
-        it('should tokenize boolean true', () => {
-            const tokens = tokenize('${true}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.BOOLEAN,
-                value: 'true',
-            });
-        });
-        it('should tokenize boolean false', () => {
-            const tokens = tokenize('${false}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.BOOLEAN,
-                value: 'false',
-            });
-        });
-        it('should not tokenize partial boolean words', () => {
-            const tokens = tokenize('${trueValue}');
-            // Should be PATH, not BOOLEAN
-            expect(tokens[1].type).toBe(TokenType.PATH);
-            expect(tokens[1].value).toBe('trueValue');
-        });
-    });
-    describe('escape sequence handling', () => {
-        it('should convert \\${ to literal ${', () => {
-            const tokens = tokenize('\\${escaped}');
-            expect(tokens[0]).toMatchObject({
-                type: TokenType.TEXT,
-                value: '${escaped}',
-            });
-        });
-        it('should handle multiple escapes', () => {
-            const tokens = tokenize('\\${a} \\${b}');
-            expect(tokens[0]).toMatchObject({
-                type: TokenType.TEXT,
-                value: '${a} ${b}',
-            });
-        });
-        it('should handle mix of escaped and unescaped', () => {
-            const tokens = tokenize('\\${escaped} ${/real}');
-            expect(tokens[0]).toMatchObject({
-                type: TokenType.TEXT,
-                value: '${escaped} ',
-            });
-            expect(tokens[1]).toMatchObject({ type: TokenType.EXPR_START });
-            expect(tokens[2]).toMatchObject({ type: TokenType.PATH, value: '/real' });
-        });
-        it('should handle escape at end of string', () => {
-            const tokens = tokenize('text \\${end}');
-            expect(tokens[0]).toMatchObject({
-                type: TokenType.TEXT,
-                value: 'text ${end}',
-            });
-        });
-        it('should handle backslash not followed by ${', () => {
-            const tokens = tokenize('back\\slash');
-            expect(tokens[0]).toMatchObject({
-                type: TokenType.TEXT,
-                value: 'back\\slash',
-            });
-        });
-    });
-    describe('JSON Pointer escapes in PATH tokens', () => {
-        it('should preserve ~1 escape (forward slash) in path', () => {
-            const tokens = tokenize('${/a~1b}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.PATH,
-                value: '/a~1b',
-            });
-        });
-        it('should preserve ~0 escape (tilde) in path', () => {
-            const tokens = tokenize('${/m~0n}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.PATH,
-                value: '/m~0n',
-            });
-        });
-        it('should preserve multiple escapes in path', () => {
-            const tokens = tokenize('${/a~1b~0c}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.PATH,
-                value: '/a~1b~0c',
-            });
-        });
-        it('should handle tilde without following 0 or 1', () => {
-            const tokens = tokenize('${/path~other}');
-            expect(tokens[1]).toMatchObject({
-                type: TokenType.PATH,
-                value: '/path~other',
-            });
-        });
-    });
-    describe('nested expressions', () => {
-        it('should tokenize nested expression in function arg', () => {
-            const tokens = tokenize('${upper(${/name})}');
-            const types = tokens.map((t) => t.type);
-            expect(types).toEqual([
-                TokenType.EXPR_START, // ${
-                TokenType.IDENTIFIER, // upper
-                TokenType.LPAREN, // (
-                TokenType.EXPR_START, // ${
-                TokenType.PATH, // /name
-                TokenType.EXPR_END, // }
-                TokenType.RPAREN, // )
-                TokenType.EXPR_END, // }
-                TokenType.EOF,
-            ]);
-        });
-        it('should tokenize deeply nested expressions', () => {
-            const tokens = tokenize('${a(${b(${/c})})}');
-            // Count nested ${ tokens
-            const exprStartCount = tokens.filter((t) => t.type === TokenType.EXPR_START).length;
-            expect(exprStartCount).toBe(3);
-        });
-    });
-    describe('complex expressions', () => {
-        it('should tokenize text with expression in middle', () => {
-            const tokens = tokenize('Hello, ${/user/name}!');
-            expect(tokens[0]).toMatchObject({
-                type: TokenType.TEXT,
-                value: 'Hello, ',
-            });
-            expect(tokens[1]).toMatchObject({ type: TokenType.EXPR_START });
-            expect(tokens[2]).toMatchObject({
-                type: TokenType.PATH,
-                value: '/user/name',
-            });
-            expect(tokens[3]).toMatchObject({ type: TokenType.EXPR_END });
-            expect(tokens[4]).toMatchObject({ type: TokenType.TEXT, value: '!' });
-        });
-        it('should tokenize multiple expressions in text', () => {
-            const tokens = tokenize('${/a} + ${/b} = ${/c}');
-            const textTokens = tokens.filter((t) => t.type === TokenType.TEXT);
-            const pathTokens = tokens.filter((t) => t.type === TokenType.PATH);
-            expect(textTokens.length).toBe(2); // ' + ' and ' = '
-            expect(pathTokens.length).toBe(3);
-        });
-    });
-});

package/dist/0.9/interpolation/parser.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Tests for the parser.
- */
-export {};

package/dist/0.9/interpolation/parser.test.js

@@ -1,314 +0,0 @@
-/**
- * Tests for the parser.
- */
-import { describe, it, expect } from 'vitest';
-import { tokenize } from './lexer.js';
-import { parse } from './parser.js';
-describe('Parser', () => {
-    describe('US1: Simple path expressions', () => {
-        it('should parse simple absolute path', () => {
-            const tokens = tokenize('${/user/name}');
-            const ast = parse(tokens);
-            expect(ast.type).toBe('interpolatedString');
-            expect(ast.parts).toHaveLength(1);
-            const pathNode = ast.parts[0];
-            expect(pathNode.type).toBe('path');
-            expect(pathNode.path).toBe('/user/name');
-            expect(pathNode.absolute).toBe(true);
-        });
-        it('should parse root path', () => {
-            const tokens = tokenize('${/}');
-            const ast = parse(tokens);
-            const pathNode = ast.parts[0];
-            expect(pathNode.path).toBe('/');
-            expect(pathNode.absolute).toBe(true);
-        });
-        it('should parse path with array index', () => {
-            const tokens = tokenize('${/items/0}');
-            const ast = parse(tokens);
-            const pathNode = ast.parts[0];
-            expect(pathNode.path).toBe('/items/0');
-        });
-        it('should parse mixed literal and path content', () => {
-            const tokens = tokenize('Hello, ${/user/name}!');
-            const ast = parse(tokens);
-            expect(ast.parts).toHaveLength(3);
-            expect(ast.parts[0].type).toBe('literal');
-            expect(ast.parts[0].value).toBe('Hello, ');
-            expect(ast.parts[1].type).toBe('path');
-            expect(ast.parts[1].path).toBe('/user/name');
-            expect(ast.parts[2].type).toBe('literal');
-            expect(ast.parts[2].value).toBe('!');
-        });
-        it('should parse multiple path expressions', () => {
-            const tokens = tokenize('${/user/name} is ${/user/age} years old');
-            const ast = parse(tokens);
-            expect(ast.parts).toHaveLength(4);
-            expect(ast.parts[0].path).toBe('/user/name');
-            expect(ast.parts[1].value).toBe(' is ');
-            expect(ast.parts[2].path).toBe('/user/age');
-            expect(ast.parts[3].value).toBe(' years old');
-        });
-        it('should parse adjacent expressions', () => {
-            const tokens = tokenize('${/a}${/b}${/c}');
-            const ast = parse(tokens);
-            expect(ast.parts).toHaveLength(3);
-            expect(ast.parts[0].path).toBe('/a');
-            expect(ast.parts[1].path).toBe('/b');
-            expect(ast.parts[2].path).toBe('/c');
-        });
-        it('should parse path with JSON Pointer escapes', () => {
-            const tokens = tokenize('${/a~1b}');
-            const ast = parse(tokens);
-            const pathNode = ast.parts[0];
-            expect(pathNode.path).toBe('/a~1b');
-        });
-    });
-    describe('US2: Function call expressions', () => {
-        it('should parse no-argument function call', () => {
-            const tokens = tokenize('${now()}');
-            const ast = parse(tokens);
-            expect(ast.parts).toHaveLength(1);
-            const funcNode = ast.parts[0];
-            expect(funcNode.type).toBe('functionCall');
-            expect(funcNode.name).toBe('now');
-            expect(funcNode.args).toHaveLength(0);
-        });
-        it('should parse function with string argument', () => {
-            const tokens = tokenize("${upper('hello')}");
-            const ast = parse(tokens);
-            const funcNode = ast.parts[0];
-            expect(funcNode.name).toBe('upper');
-            expect(funcNode.args).toHaveLength(1);
-            const arg = funcNode.args[0];
-            expect(arg.type).toBe('literal');
-            expect(arg.value).toBe('hello');
-        });
-        it('should parse function with number argument', () => {
-            const tokens = tokenize('${abs(-5)}');
-            const ast = parse(tokens);
-            const funcNode = ast.parts[0];
-            expect(funcNode.name).toBe('abs');
-            const arg = funcNode.args[0];
-            expect(arg.value).toBe('-5');
-        });
-        it('should parse function with boolean argument', () => {
-            const tokens = tokenize('${if(true)}');
-            const ast = parse(tokens);
-            const funcNode = ast.parts[0];
-            const arg = funcNode.args[0];
-            expect(arg.value).toBe('true');
-        });
-        it('should parse function with multiple arguments', () => {
-            const tokens = tokenize('${add(1, 2, 3)}');
-            const ast = parse(tokens);
-            const funcNode = ast.parts[0];
-            expect(funcNode.name).toBe('add');
-            expect(funcNode.args).toHaveLength(3);
-            expect(funcNode.args[0].value).toBe('1');
-            expect(funcNode.args[1].value).toBe('2');
-            expect(funcNode.args[2].value).toBe('3');
-        });
-        it('should parse function with path argument', () => {
-            const tokens = tokenize('${upper(${/name})}');
-            const ast = parse(tokens);
-            const funcNode = ast.parts[0];
-            expect(funcNode.name).toBe('upper');
-            expect(funcNode.args).toHaveLength(1);
-            const arg = funcNode.args[0];
-            expect(arg.type).toBe('path');
-            expect(arg.path).toBe('/name');
-        });
-        it('should parse function with mixed argument types', () => {
-            const tokens = tokenize("${format(${/value}, 'prefix', 10)}");
-            const ast = parse(tokens);
-            const funcNode = ast.parts[0];
-            expect(funcNode.args).toHaveLength(3);
-            expect(funcNode.args[0].type).toBe('path');
-            expect(funcNode.args[1].type).toBe('literal');
-            expect(funcNode.args[2].type).toBe('literal');
-        });
-    });
-    describe('US3: Nested expressions', () => {
-        it('should parse nested path in function argument', () => {
-            const tokens = tokenize('${upper(${/name})}');
-            const ast = parse(tokens);
-            const funcNode = ast.parts[0];
-            const arg = funcNode.args[0];
-            expect(arg.path).toBe('/name');
-        });
-        it('should parse nested function call in argument', () => {
-            const tokens = tokenize('${upper(${lower(${/name})})}');
-            const ast = parse(tokens);
-            const outerFunc = ast.parts[0];
-            expect(outerFunc.name).toBe('upper');
-            const innerFunc = outerFunc.args[0];
-            expect(innerFunc.name).toBe('lower');
-            const pathArg = innerFunc.args[0];
-            expect(pathArg.path).toBe('/name');
-        });
-        it('should parse deeply nested expressions (3+ levels)', () => {
-            const tokens = tokenize('${a(${b(${c(${/x})})})}');
-            const ast = parse(tokens);
-            const level1 = ast.parts[0];
-            expect(level1.name).toBe('a');
-            const level2 = level1.args[0];
-            expect(level2.name).toBe('b');
-            const level3 = level2.args[0];
-            expect(level3.name).toBe('c');
-            const path = level3.args[0];
-            expect(path.path).toBe('/x');
-        });
-        it('should handle max nesting depth gracefully', () => {
-            // Create expression with 11 nesting levels (exceeds MAX_DEPTH of 10)
-            let expr = '${/x}';
-            for (let i = 0; i < 11; i++) {
-                expr = `\${wrap(${expr})}`;
-            }
-            const tokens = tokenize(expr);
-            const ast = parse(tokens);
-            // Should still return valid AST (with warning logged)
-            expect(ast.type).toBe('interpolatedString');
-        });
-    });
-    describe('US4: Escaped expressions', () => {
-        it('should parse escaped expression as literal text', () => {
-            const tokens = tokenize('\\${escaped}');
-            const ast = parse(tokens);
-            expect(ast.parts).toHaveLength(1);
-            expect(ast.parts[0].type).toBe('literal');
-            expect(ast.parts[0].value).toBe('${escaped}');
-        });
-        it('should parse mixed escaped and unescaped', () => {
-            const tokens = tokenize('\\${escaped} ${/real}');
-            const ast = parse(tokens);
-            expect(ast.parts).toHaveLength(2);
-            expect(ast.parts[0].value).toBe('${escaped} ');
-            expect(ast.parts[1].path).toBe('/real');
-        });
-    });
-    describe('US5: Relative paths', () => {
-        it('should parse relative path', () => {
-            const tokens = tokenize('${name}');
-            const ast = parse(tokens);
-            const pathNode = ast.parts[0];
-            expect(pathNode.type).toBe('path');
-            expect(pathNode.path).toBe('name');
-            expect(pathNode.absolute).toBe(false);
-        });
-        it('should parse nested relative path', () => {
-            const tokens = tokenize('${profile/name}');
-            const ast = parse(tokens);
-            const pathNode = ast.parts[0];
-            expect(pathNode.path).toBe('profile/name');
-            expect(pathNode.absolute).toBe(false);
-        });
-        it('should parse mixed absolute and relative paths', () => {
-            const tokens = tokenize('${name} and ${/absolute}');
-            const ast = parse(tokens);
-            const relativePath = ast.parts[0];
-            expect(relativePath.absolute).toBe(false);
-            const absolutePath = ast.parts[2];
-            expect(absolutePath.absolute).toBe(true);
-        });
-    });
-    describe('Additional edge cases', () => {
-        it('should parse function with direct path argument (not nested)', () => {
-            const tokens = tokenize('${upper(/name)}');
-            const ast = parse(tokens);
-            const funcNode = ast.parts[0];
-            expect(funcNode.type).toBe('functionCall');
-            expect(funcNode.name).toBe('upper');
-            // Direct path in function args (without ${})
-            expect(funcNode.args).toHaveLength(1);
-        });
-        it('should parse function call inside function argument', () => {
-            // Test nested function call recognized via IDENTIFIER token
-            const tokens = tokenize('${outer(inner())}');
-            const ast = parse(tokens);
-            const outerFunc = ast.parts[0];
-            expect(outerFunc.name).toBe('outer');
-            expect(outerFunc.args).toHaveLength(1);
-            const innerFunc = outerFunc.args[0];
-            expect(innerFunc.type).toBe('functionCall');
-            expect(innerFunc.name).toBe('inner');
-        });
-        it('should handle function argument with EOF', () => {
-            const tokens = tokenize('${func(');
-            const ast = parse(tokens);
-            const funcNode = ast.parts[0];
-            expect(funcNode.type).toBe('functionCall');
-            expect(funcNode.name).toBe('func');
-        });
-        it('should handle nested EXPR_START at depth limit in parseArgument', () => {
-            // Create expression with exactly MAX_DEPTH nestings in function arg context
-            let expr = '${/x}';
-            for (let i = 0; i < 9; i++) {
-                expr = `\${f(${expr})}`;
-            }
-            // One more nesting should trigger the max depth in parseArgument
-            expr = `\${f(${expr})}`;
-            expr = `\${f(${expr})}`;
-            const tokens = tokenize(expr);
-            const ast = parse(tokens);
-            // Should still return valid AST
-            expect(ast.type).toBe('interpolatedString');
-        });
-        it('should handle literal in parseExpression', () => {
-            // When a literal token appears in an expression context
-            const tokens = tokenize("${'string'}");
-            const ast = parse(tokens);
-            const literalNode = ast.parts[0];
-            expect(literalNode.type).toBe('literal');
-            expect(literalNode.value).toBe('string');
-        });
-        it('should handle number in parseExpression', () => {
-            const tokens = tokenize('${42}');
-            const ast = parse(tokens);
-            const literalNode = ast.parts[0];
-            expect(literalNode.type).toBe('literal');
-            expect(literalNode.value).toBe('42');
-        });
-        it('should handle boolean in parseExpression', () => {
-            const tokens = tokenize('${true}');
-            const ast = parse(tokens);
-            const literalNode = ast.parts[0];
-            expect(literalNode.type).toBe('literal');
-            expect(literalNode.value).toBe('true');
-        });
-        it('should handle unexpected EXPR_END at top level', () => {
-            // This simulates finding } outside of expression context
-            const tokens = tokenize('text}more');
-            const ast = parse(tokens);
-            expect(ast.type).toBe('interpolatedString');
-            expect(ast.parts).toHaveLength(1);
-            expect(ast.parts[0].value).toBe('text}more');
-        });
-    });
-    describe('Error handling', () => {
-        it('should return empty literal for empty expression', () => {
-            const tokens = tokenize('${}');
-            const ast = parse(tokens);
-            // Should not crash, may have empty parts
-            expect(ast.type).toBe('interpolatedString');
-        });
-        it('should handle unclosed expression', () => {
-            const tokens = tokenize('${/path');
-            const ast = parse(tokens);
-            // Should return partial AST
-            expect(ast.type).toBe('interpolatedString');
-        });
-        it('should handle plain text without expressions', () => {
-            const tokens = tokenize('Hello World');
-            const ast = parse(tokens);
-            expect(ast.parts).toHaveLength(1);
-            expect(ast.parts[0].value).toBe('Hello World');
-        });
-        it('should handle empty string', () => {
-            const tokens = tokenize('');
-            const ast = parse(tokens);
-            expect(ast.type).toBe('interpolatedString');
-            expect(ast.parts.length).toBeGreaterThanOrEqual(1);
-        });
-    });
-});