@a2ui-sdk/utils 0.0.0

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

@@ -0,0 +1,314 @@
+/**
+ * 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);
+        });
+    });
+});

package/dist/0.9/interpolation/types.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Type definitions for the string interpolation parser.
+ *
+ * This module defines tokens, AST nodes, and evaluation context types
+ * used throughout the lexer, parser, and evaluator.
+ */
+/**
+ * Token types produced by the lexer.
+ */
+export declare enum TokenType {
+    /** Literal text outside ${...} expressions */
+    TEXT = "TEXT",
+    /** Expression start delimiter: ${ */
+    EXPR_START = "EXPR_START",
+    /** Expression end delimiter: } */
+    EXPR_END = "EXPR_END",
+    /** JSON Pointer path: /foo/bar or foo/bar */
+    PATH = "PATH",
+    /** Function name identifier */
+    IDENTIFIER = "IDENTIFIER",
+    /** Left parenthesis: ( */
+    LPAREN = "LPAREN",
+    /** Right parenthesis: ) */
+    RPAREN = "RPAREN",
+    /** Comma separator: , */
+    COMMA = "COMMA",
+    /** Single-quoted string literal: 'value' */
+    STRING = "STRING",
+    /** Numeric literal: 42, -3.14 */
+    NUMBER = "NUMBER",
+    /** Boolean literal: true, false */
+    BOOLEAN = "BOOLEAN",
+    /** End of input */
+    EOF = "EOF"
+}
+/**
+ * A token produced by the lexer.
+ */
+export interface Token {
+    /** The type of token */
+    type: TokenType;
+    /** The raw text value of the token */
+    value: string;
+    /** Start position in the input string */
+    start: number;
+    /** End position in the input string (exclusive) */
+    end: number;
+}
+/**
+ * Literal node - represents static text outside expressions.
+ */
+export interface LiteralNode {
+    type: 'literal';
+    value: string;
+}
+/**
+ * Path node - represents a JSON Pointer (RFC 6901) path reference.
+ *
+ * The path string may contain escape sequences (~0 for ~, ~1 for /)
+ * that are decoded at evaluation time.
+ */
+export interface PathNode {
+    type: 'path';
+    /** The raw path string (may contain ~0, ~1 escape sequences) */
+    path: string;
+    /** True if path starts with '/' (absolute path) */
+    absolute: boolean;
+}
+/**
+ * Function call node - represents a client-side function invocation.
+ */
+export interface FunctionCallNode {
+    type: 'functionCall';
+    /** Function name (identifier) */
+    name: string;
+    /** Arguments (can be literals, paths, or nested function calls) */
+    args: ASTNode[];
+}
+/**
+ * Interpolated string node - root node representing mixed content.
+ */
+export interface InterpolatedStringNode {
+    type: 'interpolatedString';
+    /** Sequence of literals and expressions */
+    parts: ASTNode[];
+}
+/**
+ * Discriminated union of all AST node types.
+ */
+export type ASTNode = LiteralNode | PathNode | FunctionCallNode | InterpolatedStringNode;
+/**
+ * Parse error information.
+ */
+export interface ParseError {
+    /** Human-readable error description */
+    message: string;
+    /** Character position in input where error occurred */
+    position: number;
+    /** Length of the problematic text */
+    length: number;
+}
+/**
+ * Data model type - hierarchical key-value store.
+ */
+export type DataModel = Record<string, unknown>;
+/**
+ * Interpolation function signature.
+ */
+export type InterpolationFunction = (...args: unknown[]) => unknown;
+/**
+ * Registry of available interpolation functions.
+ */
+export type FunctionRegistry = Record<string, InterpolationFunction>;
+/**
+ * Context provided to the evaluator for resolving paths and function calls.
+ */
+export interface EvaluationContext {
+    /** The data model for path resolution */
+    dataModel: DataModel;
+    /** Base path for relative path resolution (null for root scope) */
+    basePath: string | null;
+    /** Optional custom function registry */
+    functions?: FunctionRegistry;
+}

package/dist/0.9/interpolation/types.js

@@ -0,0 +1,36 @@
+/**
+ * Type definitions for the string interpolation parser.
+ *
+ * This module defines tokens, AST nodes, and evaluation context types
+ * used throughout the lexer, parser, and evaluator.
+ */
+/**
+ * Token types produced by the lexer.
+ */
+export var TokenType;
+(function (TokenType) {
+    /** Literal text outside ${...} expressions */
+    TokenType["TEXT"] = "TEXT";
+    /** Expression start delimiter: ${ */
+    TokenType["EXPR_START"] = "EXPR_START";
+    /** Expression end delimiter: } */
+    TokenType["EXPR_END"] = "EXPR_END";
+    /** JSON Pointer path: /foo/bar or foo/bar */
+    TokenType["PATH"] = "PATH";
+    /** Function name identifier */
+    TokenType["IDENTIFIER"] = "IDENTIFIER";
+    /** Left parenthesis: ( */
+    TokenType["LPAREN"] = "LPAREN";
+    /** Right parenthesis: ) */
+    TokenType["RPAREN"] = "RPAREN";
+    /** Comma separator: , */
+    TokenType["COMMA"] = "COMMA";
+    /** Single-quoted string literal: 'value' */
+    TokenType["STRING"] = "STRING";
+    /** Numeric literal: 42, -3.14 */
+    TokenType["NUMBER"] = "NUMBER";
+    /** Boolean literal: true, false */
+    TokenType["BOOLEAN"] = "BOOLEAN";
+    /** End of input */
+    TokenType["EOF"] = "EOF";
+})(TokenType || (TokenType = {}));

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

@@ -0,0 +1,5 @@
+/**
+ * Tests for the public interpolation API.
+ * Tests the new refactored parser module.
+ */
+export {};

package/dist/0.9/interpolation.test.js

@@ -0,0 +1,154 @@
+/**
+ * Tests for the public interpolation API.
+ * Tests the new refactored parser module.
+ */
+import { describe, it, expect } from 'vitest';
+import { parseInterpolation, interpolate } from './interpolation';
+describe('parseInterpolation', () => {
+    it('should parse simple path expression', () => {
+        const ast = parseInterpolation('${/user/name}');
+        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 mixed content', () => {
+        const ast = parseInterpolation('Hello, ${/user/name}!');
+        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 function call', () => {
+        const ast = parseInterpolation('${now()}');
+        const funcNode = ast.parts[0];
+        expect(funcNode.type).toBe('functionCall');
+        expect(funcNode.name).toBe('now');
+        expect(funcNode.args).toHaveLength(0);
+    });
+    it('should parse nested expressions', () => {
+        const ast = parseInterpolation('${upper(${/name})}');
+        const funcNode = ast.parts[0];
+        expect(funcNode.type).toBe('functionCall');
+        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 handle escaped expressions', () => {
+        const ast = parseInterpolation('\\${escaped}');
+        expect(ast.parts).toHaveLength(1);
+        expect(ast.parts[0].value).toBe('${escaped}');
+    });
+    it('should parse relative paths', () => {
+        const ast = parseInterpolation('${name}');
+        const pathNode = ast.parts[0];
+        expect(pathNode.type).toBe('path');
+        expect(pathNode.path).toBe('name');
+        expect(pathNode.absolute).toBe(false);
+    });
+});
+describe('interpolate', () => {
+    const dataModel = {
+        user: {
+            name: 'John',
+            age: 30,
+        },
+        stats: {
+            count: 42,
+            active: true,
+        },
+        items: ['a', 'b', 'c'],
+    };
+    it('should interpolate single value', () => {
+        expect(interpolate('Hello, ${/user/name}!', dataModel)).toBe('Hello, John!');
+    });
+    it('should interpolate multiple values', () => {
+        expect(interpolate('${/user/name} is ${/user/age} years old', dataModel)).toBe('John is 30 years old');
+    });
+    it('should handle number values', () => {
+        expect(interpolate('Count: ${/stats/count}', dataModel)).toBe('Count: 42');
+    });
+    it('should handle boolean values', () => {
+        expect(interpolate('Active: ${/stats/active}', dataModel)).toBe('Active: true');
+    });
+    it('should handle array values as JSON', () => {
+        expect(interpolate('Items: ${/items}', dataModel)).toBe('Items: ["a","b","c"]');
+    });
+    it('should handle object values as JSON', () => {
+        expect(interpolate('User: ${/user}', dataModel)).toBe('User: {"name":"John","age":30}');
+    });
+    it('should handle undefined values as empty string', () => {
+        expect(interpolate('Missing: ${/nonexistent}', dataModel)).toBe('Missing: ');
+        expect(interpolate('${/a}${/b}${/c}', dataModel)).toBe('');
+    });
+    it('should handle null values as empty string', () => {
+        const modelWithNull = { value: null };
+        expect(interpolate('Value: ${/value}', modelWithNull)).toBe('Value: ');
+    });
+    it('should preserve text without interpolation', () => {
+        expect(interpolate('Hello, World!', dataModel)).toBe('Hello, World!');
+        expect(interpolate('No variables here', dataModel)).toBe('No variables here');
+    });
+    it('should unescape escaped expressions', () => {
+        expect(interpolate('Escaped \\${/user/name}', dataModel)).toBe('Escaped ${/user/name}');
+        expect(interpolate('\\${a} and \\${b}', dataModel)).toBe('${a} and ${b}');
+    });
+    it('should handle mix of escaped and unescaped', () => {
+        expect(interpolate('\\${escaped} ${/user/name}', dataModel)).toBe('${escaped} John');
+    });
+    describe('with basePath', () => {
+        it('should resolve relative paths with basePath', () => {
+            expect(interpolate('Name: ${name}', dataModel, '/user')).toBe('Name: John');
+            expect(interpolate('Age: ${age}', dataModel, '/user')).toBe('Age: 30');
+        });
+        it('should handle absolute paths even with basePath', () => {
+            expect(interpolate('Count: ${/stats/count}', dataModel, '/user')).toBe('Count: 42');
+        });
+        it('should handle mix of relative and absolute', () => {
+            expect(interpolate('${name} has ${/stats/count} items', dataModel, '/user')).toBe('John has 42 items');
+        });
+    });
+    describe('function calls', () => {
+        const testFunctions = {
+            upper: (str) => String(str).toUpperCase(),
+            lower: (str) => String(str).toLowerCase(),
+            add: (...args) => args.reduce((sum, val) => sum + Number(val), 0),
+        };
+        it('should invoke functions from context', () => {
+            expect(interpolate("${upper('hello')}", {}, null, testFunctions)).toBe('HELLO');
+            expect(interpolate("${lower('HELLO')}", {}, null, testFunctions)).toBe('hello');
+            expect(interpolate('${add(1, 2, 3)}', {}, null, testFunctions)).toBe('6');
+        });
+        it('should handle function with path arguments', () => {
+            expect(interpolate('${upper(${/user/name})}', dataModel, null, testFunctions)).toBe('JOHN');
+        });
+        it('should handle nested function calls', () => {
+            expect(interpolate('${add(${/user/age}, 10)}', dataModel, null, testFunctions)).toBe('40');
+        });
+    });
+    describe('JSON Pointer escapes', () => {
+        it('should resolve keys with forward slash', () => {
+            const model = { 'a/b': 'value' };
+            expect(interpolate('${/a~1b}', model)).toBe('value');
+        });
+        it('should resolve keys with tilde', () => {
+            const model = { 'm~n': 'value' };
+            expect(interpolate('${/m~0n}', model)).toBe('value');
+        });
+    });
+    describe('custom functions', () => {
+        it('should use custom functions', () => {
+            const customFunctions = {
+                greet: (name) => `Hello, ${name}!`,
+            };
+            expect(interpolate("${greet('World')}", {}, null, customFunctions)).toBe('Hello, World!');
+        });
+    });
+});