@bardsballad/cadence 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { runCadence } from './runtime/runCadence';
+export * as CadenceHelpers from './runtime/functions';

package/dist/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CadenceHelpers = exports.runCadence = void 0;
+var runCadence_1 = require("./runtime/runCadence");
+Object.defineProperty(exports, "runCadence", { enumerable: true, get: function () { return runCadence_1.runCadence; } });
+exports.CadenceHelpers = __importStar(require("./runtime/functions"));

package/dist/lexer/tokenize.d.ts

@@ -0,0 +1,2 @@
+import { Token } from '../types/tokens';
+export declare function tokenize(source: string): Token[];

package/dist/lexer/tokenize.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenize = tokenize;
+const isDigit = (c) => c >= '0' && c <= '9';
+const isAlpha = (c) => /[A-Za-z_]/.test(c);
+const isAlnum = (c) => /[A-Za-z0-9_]/.test(c);
+function tokenize(source) {
+    const tokens = [];
+    let i = 0;
+    const push = (type, lexeme, position) => {
+        tokens.push({ type, lexeme, position });
+    };
+    while (i < source.length) {
+        const start = i;
+        const ch = source[i];
+        // whitespace and newlines
+        if (ch === ' ' || ch === '\t' || ch === '\r' || ch === '\n') {
+            i++;
+            continue;
+        }
+        // numbers (integer and decimals)
+        if (isDigit(ch) || (ch === '.' && isDigit(source[i + 1]))) {
+            let num = '';
+            let dotSeen = false;
+            while (i < source.length) {
+                const c = source[i];
+                if (isDigit(c)) {
+                    num += c;
+                    i++;
+                }
+                else if (c === '.' && !dotSeen && isDigit(source[i + 1])) {
+                    dotSeen = true;
+                    num += c;
+                    i++;
+                }
+                else {
+                    break;
+                }
+            }
+            push('NUMBER', num, start);
+            continue;
+        }
+        // strings: only support simple single or double quotes
+        if (ch === '"' || ch === '\'') {
+            const quote = ch;
+            i++; // skip opening quote
+            let str = '';
+            while (i < source.length && source[i] !== quote) {
+                const c = source[i];
+                if (c === '\\') {
+                    const next = source[i + 1];
+                    if (next === '"' || next === '\'' || next === '\\') {
+                        str += next;
+                        i += 2;
+                        continue;
+                    }
+                }
+                str += c;
+                i++;
+            }
+            if (source[i] !== quote) {
+                throw new Error(`Unterminated string at ${start}`);
+            }
+            i++; // closing quote
+            tokens.push({ type: 'STRING', lexeme: str, position: start });
+            continue;
+        }
+        // identifiers
+        if (isAlpha(ch)) {
+            let ident = '';
+            while (i < source.length && isAlnum(source[i])) {
+                ident += source[i++];
+            }
+            push('IDENT', ident, start);
+            continue;
+        }
+        // multi-char operators
+        const two = source.slice(i, i + 2);
+        if (two === '<=' || two === '>=') {
+            push(two === '<=' ? 'LTE' : 'GTE', two, start);
+            i += 2;
+            continue;
+        }
+        if (two === '==' || two === '!=') {
+            push(two === '==' ? 'EQ' : 'NEQ', two, start);
+            i += 2;
+            continue;
+        }
+        if (two === '&&' || two === '||') {
+            push(two === '&&' ? 'AND' : 'OR', two, start);
+            i += 2;
+            continue;
+        }
+        // single-char tokens
+        switch (ch) {
+            case '+':
+                push('PLUS', ch, start);
+                i++;
+                continue;
+            case '-':
+                push('MINUS', ch, start);
+                i++;
+                continue;
+            case '*':
+                push('STAR', ch, start);
+                i++;
+                continue;
+            case '/':
+                push('SLASH', ch, start);
+                i++;
+                continue;
+            case '^':
+                push('CARET', ch, start);
+                i++;
+                continue;
+            case '<':
+                push('LT', ch, start);
+                i++;
+                continue;
+            case '>':
+                push('GT', ch, start);
+                i++;
+                continue;
+            case '(':
+                push('LPAREN', ch, start);
+                i++;
+                continue;
+            case ')':
+                push('RPAREN', ch, start);
+                i++;
+                continue;
+            case '[':
+                push('LBRACK', ch, start);
+                i++;
+                continue;
+            case ']':
+                push('RBRACK', ch, start);
+                i++;
+                continue;
+            case ',':
+                push('COMMA', ch, start);
+                i++;
+                continue;
+            case ';':
+                push('SEMICOLON', ch, start);
+                i++;
+                continue;
+            case '?':
+                push('QUESTION', ch, start);
+                i++;
+                continue;
+            case ':':
+                push('COLON', ch, start);
+                i++;
+                continue;
+        }
+        throw new Error(`Unexpected character '${ch}' at ${i}`);
+    }
+    push('EOF', '', i);
+    return tokens;
+}

package/dist/parser/ast.d.ts

@@ -0,0 +1,52 @@
+export type NumberLiteral = {
+    type: 'NumberLiteral';
+    value: number;
+};
+export type StringLiteral = {
+    type: 'StringLiteral';
+    value: string;
+};
+export type Identifier = {
+    type: 'Identifier';
+    name: string;
+};
+export type BooleanLiteral = {
+    type: 'BooleanLiteral';
+    value: boolean;
+};
+export type UnaryExpression = {
+    type: 'UnaryExpression';
+    operator: '-' | '+';
+    argument: Expression;
+};
+export type BinaryExpression = {
+    type: 'BinaryExpression';
+    operator: '+' | '-' | '*' | '/' | '^' | '<' | '<=' | '>' | '>=' | '==' | '!=' | '&&' | '||';
+    left: Expression;
+    right: Expression;
+};
+export type ConditionalExpression = {
+    type: 'ConditionalExpression';
+    test: Expression;
+    consequent: Expression;
+    alternate: Expression;
+};
+export type CallExpression = {
+    type: 'CallExpression';
+    callee: Identifier;
+    args: Expression[];
+};
+export type Grouping = {
+    type: 'Grouping';
+    expression: Expression;
+};
+export type Expression = NumberLiteral | StringLiteral | BooleanLiteral | Identifier | UnaryExpression | BinaryExpression | ConditionalExpression | CallExpression | Grouping;
+export type Statement = {
+    type: 'Statement';
+    expression: Expression;
+    assignTo?: string;
+};
+export type Program = {
+    type: 'Program';
+    body: Statement[];
+};

package/dist/parser/ast.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/parser/parser.d.ts

@@ -0,0 +1,20 @@
+import { Program } from './ast';
+export declare class Parser {
+    private tokens;
+    private pos;
+    constructor(source: string);
+    private peek;
+    private advance;
+    private expect;
+    parseProgram(): Program;
+    private parseStatement;
+    private parseExpression;
+    private nudFor;
+    private ledFor;
+    private lbpOf;
+    private prefixBindingPower;
+    private infixRightBindingPower;
+    private tokenToOperator;
+    private operatorToTokenType;
+}
+export declare function parse(source: string): Program;

package/dist/parser/parser.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+exports.parse = parse;
+const tokenize_1 = require("../lexer/tokenize");
+class Parser {
+    constructor(source) {
+        this.pos = 0;
+        this.tokens = (0, tokenize_1.tokenize)(source);
+    }
+    peek() {
+        return this.tokens[this.pos];
+    }
+    advance() {
+        return this.tokens[this.pos++];
+    }
+    expect(type, message) {
+        const t = this.peek();
+        if (t.type !== type)
+            throw new Error(message + ` at ${t.position}`);
+        return this.advance();
+    }
+    parseProgram() {
+        const body = [];
+        while (this.peek().type !== 'EOF') {
+            // allow stray semicolons
+            if (this.peek().type === 'SEMICOLON') {
+                this.advance();
+                continue;
+            }
+            const stmt = this.parseStatement();
+            body.push(stmt);
+            if (this.peek().type === 'SEMICOLON')
+                this.advance();
+        }
+        return { type: 'Program', body };
+    }
+    parseStatement() {
+        const expr = this.parseExpression(0);
+        let assignTo;
+        if (this.peek().type === 'LBRACK') {
+            this.advance();
+            const ident = this.expect('IDENT', 'Expected identifier in brackets').lexeme;
+            this.expect('RBRACK', 'Expected closing ] after identifier');
+            assignTo = ident;
+        }
+        return { type: 'Statement', expression: expr, assignTo };
+    }
+    parseExpression(rbp) {
+        let t = this.advance();
+        let left = this.nudFor(t);
+        while (rbp < this.lbpOf(this.peek())) {
+            t = this.advance();
+            left = this.ledFor(t, left);
+        }
+        return left;
+    }
+    nudFor(token) {
+        switch (token.type) {
+            case 'NUMBER':
+                return { type: 'NumberLiteral', value: Number(token.lexeme) };
+            case 'STRING':
+                return { type: 'StringLiteral', value: token.lexeme };
+            case 'IDENT': {
+                // function call or identifier
+                if (this.peek().type === 'LPAREN') {
+                    const name = token.lexeme;
+                    this.advance(); // (
+                    const args = [];
+                    if (this.peek().type !== 'RPAREN') {
+                        // parse comma-separated args
+                        args.push(this.parseExpression(0));
+                        while (this.peek().type === 'COMMA') {
+                            this.advance();
+                            args.push(this.parseExpression(0));
+                        }
+                    }
+                    this.expect('RPAREN', 'Expected ) after arguments');
+                    const callee = { type: 'Identifier', name: name };
+                    const call = { type: 'CallExpression', callee, args };
+                    return call;
+                }
+                if (token.lexeme === 'true' || token.lexeme === 'false') {
+                    return { type: 'BooleanLiteral', value: token.lexeme === 'true' };
+                }
+                return { type: 'Identifier', name: token.lexeme };
+            }
+            case 'LPAREN': {
+                const expr = this.parseExpression(0);
+                this.expect('RPAREN', 'Expected ) after expression');
+                return { type: 'Grouping', expression: expr };
+            }
+            case 'MINUS':
+            case 'PLUS': {
+                const op = token.type === 'MINUS' ? '-' : '+';
+                const argument = this.parseExpression(this.prefixBindingPower(op));
+                return { type: 'UnaryExpression', operator: op, argument };
+            }
+            default:
+                throw new Error(`Unexpected token ${token.type} at ${token.position}`);
+        }
+    }
+    ledFor(token, left) {
+        switch (token.type) {
+            case 'PLUS':
+            case 'MINUS':
+            case 'STAR':
+            case 'SLASH':
+            case 'CARET':
+            case 'LT':
+            case 'LTE':
+            case 'GT':
+            case 'GTE':
+            case 'EQ':
+            case 'NEQ':
+            case 'AND':
+            case 'OR': {
+                const op = this.tokenToOperator(token.type);
+                const rbp = this.infixRightBindingPower(op);
+                const right = this.parseExpression(rbp);
+                return { type: 'BinaryExpression', operator: op, left, right };
+            }
+            case 'QUESTION': {
+                // parse ternary conditional: left ? x : y
+                const consequent = this.parseExpression(0);
+                this.expect('COLON', 'Expected : in conditional expression');
+                const alternate = this.parseExpression(2); // bind weaker than most ops
+                return { type: 'ConditionalExpression', test: left, consequent, alternate };
+            }
+            default:
+                throw new Error(`Unexpected token in led: ${token.type} at ${token.position}`);
+        }
+    }
+    lbpOf(token) {
+        switch (token.type) {
+            case 'CARET': return 50; // right-associative handled via rbp
+            case 'STAR':
+            case 'SLASH': return 40;
+            case 'PLUS':
+            case 'MINUS': return 30;
+            case 'LT':
+            case 'LTE':
+            case 'GT':
+            case 'GTE': return 20;
+            case 'EQ':
+            case 'NEQ': return 15;
+            case 'AND': return 10;
+            case 'OR': return 9;
+            case 'QUESTION': return 2; // ternary
+            default: return 0;
+        }
+    }
+    prefixBindingPower(op) {
+        return 60; // higher than any infix
+    }
+    infixRightBindingPower(op) {
+        switch (op) {
+            case '^': return 49; // right-assoc: less than lbp 50
+            default: return this.lbpOf({ type: this.operatorToTokenType(op), lexeme: '', position: 0 });
+        }
+    }
+    tokenToOperator(type) {
+        switch (type) {
+            case 'PLUS': return '+';
+            case 'MINUS': return '-';
+            case 'STAR': return '*';
+            case 'SLASH': return '/';
+            case 'CARET': return '^';
+            case 'LT': return '<';
+            case 'LTE': return '<=';
+            case 'GT': return '>';
+            case 'GTE': return '>=';
+            case 'EQ': return '==';
+            case 'NEQ': return '!=';
+            case 'AND': return '&&';
+            case 'OR': return '||';
+            default: throw new Error('Unknown operator token ' + type);
+        }
+    }
+    operatorToTokenType(op) {
+        switch (op) {
+            case '+': return 'PLUS';
+            case '-': return 'MINUS';
+            case '*': return 'STAR';
+            case '/': return 'SLASH';
+            case '^': return 'CARET';
+            case '<': return 'LT';
+            case '<=': return 'LTE';
+            case '>': return 'GT';
+            case '>=': return 'GTE';
+            case '==': return 'EQ';
+            case '!=': return 'NEQ';
+            case '&&': return 'AND';
+            case '||': return 'OR';
+            default: throw new Error('Unknown operator ' + op);
+        }
+    }
+}
+exports.Parser = Parser;
+function parse(source) {
+    return new Parser(source).parseProgram();
+}

package/dist/runtime/context.d.ts

@@ -0,0 +1,2 @@
+export type Scope = Record<string, any>;
+export declare function createFrozenContext<T extends object>(input: T): Readonly<T>;

package/dist/runtime/context.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFrozenContext = createFrozenContext;
+function createFrozenContext(input) {
+    return deepFreeze({ ...input });
+}
+function deepFreeze(obj) {
+    Object.getOwnPropertyNames(obj).forEach((prop) => {
+        const value = obj[prop];
+        if (value && typeof value === 'object')
+            deepFreeze(value);
+    });
+    return Object.freeze(obj);
+}

package/dist/runtime/evaluator.d.ts

@@ -0,0 +1,5 @@
+import { Program } from '../parser/ast';
+export interface EvalOptions {
+    input: Readonly<Record<string, any>>;
+}
+export declare function evaluate(program: Program, options: EvalOptions): any;

package/dist/runtime/evaluator.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluate = evaluate;
+const functions_1 = require("./functions");
+function evaluate(program, options) {
+    const scope = Object.create(null);
+    let last;
+    for (const stmt of program.body) {
+        last = evalExpression(stmt.expression, scope, options.input);
+        if (stmt.assignTo) {
+            scope[stmt.assignTo] = last;
+        }
+    }
+    return last;
+}
+function evalExpression(expr, scope, input) {
+    switch (expr.type) {
+        case 'NumberLiteral': return expr.value;
+        case 'StringLiteral': return expr.value;
+        case 'BooleanLiteral': return expr.value;
+        case 'Identifier': {
+            if (Object.prototype.hasOwnProperty.call(scope, expr.name))
+                return scope[expr.name];
+            if (Object.prototype.hasOwnProperty.call(input, expr.name))
+                return input[expr.name];
+            throw new Error(`Unknown identifier: ${expr.name}`);
+        }
+        case 'Grouping':
+            return evalExpression(expr.expression, scope, input);
+        case 'UnaryExpression': {
+            const v = evalExpression(expr.argument, scope, input);
+            switch (expr.operator) {
+                case '+': return toNumber(v);
+                case '-': return -toNumber(v);
+            }
+            throw new Error('Unknown unary operator');
+        }
+        case 'BinaryExpression': {
+            if (expr.operator === '&&') {
+                const l = evalExpression(expr.left, scope, input);
+                return l ? evalExpression(expr.right, scope, input) : l;
+            }
+            if (expr.operator === '||') {
+                const l = evalExpression(expr.left, scope, input);
+                return l ? l : evalExpression(expr.right, scope, input);
+            }
+            const left = evalExpression(expr.left, scope, input);
+            const right = evalExpression(expr.right, scope, input);
+            switch (expr.operator) {
+                case '+':
+                    if (typeof left === 'string' || typeof right === 'string')
+                        return String(left) + String(right);
+                    return toNumber(left) + toNumber(right);
+                case '-': return toNumber(left) - toNumber(right);
+                case '*': return toNumber(left) * toNumber(right);
+                case '/': return toNumber(left) / toNumber(right);
+                case '^': return Math.pow(toNumber(left), toNumber(right));
+                case '<': return toNumber(left) < toNumber(right);
+                case '<=': return toNumber(left) <= toNumber(right);
+                case '>': return toNumber(left) > toNumber(right);
+                case '>=': return toNumber(left) >= toNumber(right);
+                case '==': return left === right;
+                case '!=': return left !== right;
+            }
+            throw new Error('Unknown binary operator');
+        }
+        case 'ConditionalExpression': {
+            const cond = evalExpression(expr.test, scope, input);
+            return cond ? evalExpression(expr.consequent, scope, input) : evalExpression(expr.alternate, scope, input);
+        }
+        case 'CallExpression': {
+            const fn = (0, functions_1.getHelper)(expr.callee.name);
+            if (expr.args.length !== 1)
+                throw new Error(`Function ${expr.callee.name} expects 1 argument`);
+            const argVal = evalExpression(expr.args[0], scope, input);
+            return fn(argVal);
+        }
+    }
+}
+function toNumber(v) {
+    if (typeof v === 'number')
+        return v;
+    if (typeof v === 'string' && v.trim() !== '' && !isNaN(Number(v)))
+        return Number(v);
+    throw new Error('Expected number');
+}

package/dist/runtime/functions.d.ts

@@ -0,0 +1,3 @@
+export type HelperFn = (arg: any) => any;
+export declare const helpers: Record<string, HelperFn>;
+export declare function getHelper(name: string): HelperFn;

package/dist/runtime/functions.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.helpers = void 0;
+exports.getHelper = getHelper;
+function assertArray(name, v) {
+    if (!Array.isArray(v))
+        throw new Error(`${name} expects array`);
+}
+function assertNumber(name, v) {
+    if (typeof v !== 'number' || Number.isNaN(v))
+        throw new Error(`${name} expects number`);
+}
+exports.helpers = {
+    sum(arg) {
+        assertArray('sum', arg);
+        return arg.reduce((a, b) => a + (typeof b === 'number' ? b : 0), 0);
+    },
+    count(arg) {
+        assertArray('count', arg);
+        return arg.length;
+    },
+    min(arg) {
+        assertArray('min', arg);
+        if (arg.length === 0)
+            return Infinity;
+        return arg.reduce((m, v) => (typeof v === 'number' && v < m ? v : m), Infinity);
+    },
+    max(arg) {
+        assertArray('max', arg);
+        if (arg.length === 0)
+            return -Infinity;
+        return arg.reduce((m, v) => (typeof v === 'number' && v > m ? v : m), -Infinity);
+    },
+    avg(arg) {
+        assertArray('avg', arg);
+        if (arg.length === 0)
+            return 0;
+        const nums = arg.filter((v) => typeof v === 'number');
+        if (nums.length === 0)
+            return 0;
+        return nums.reduce((a, b) => a + b, 0) / nums.length;
+    },
+    any(arg) {
+        assertArray('any', arg);
+        return arg.some((v) => Boolean(v));
+    },
+    all(arg) {
+        assertArray('all', arg);
+        return arg.every((v) => Boolean(v));
+    },
+    floor(arg) {
+        assertNumber('floor', arg);
+        return Math.floor(arg);
+    },
+    ceil(arg) {
+        assertNumber('ceil', arg);
+        return Math.ceil(arg);
+    },
+    abs(arg) {
+        assertNumber('abs', arg);
+        return Math.abs(arg);
+    },
+};
+function getHelper(name) {
+    const fn = exports.helpers[name];
+    if (!fn)
+        throw new Error(`Unknown function: ${name}`);
+    return fn;
+}

package/dist/runtime/runCadence.d.ts

@@ -0,0 +1 @@
+export declare function runCadence(program: string, input: Record<string, any>): any;

package/dist/runtime/runCadence.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCadence = runCadence;
+const parser_1 = require("../parser/parser");
+const context_1 = require("./context");
+const evaluator_1 = require("./evaluator");
+function runCadence(program, input) {
+    const ast = (0, parser_1.parse)(program);
+    const frozen = (0, context_1.createFrozenContext)(input);
+    return (0, evaluator_1.evaluate)(ast, { input: frozen });
+}

package/dist/types/statements.d.ts

@@ -0,0 +1 @@
+export type { Statement } from '../parser/ast';

package/dist/types/statements.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/tokens.d.ts

@@ -0,0 +1,6 @@
+export type TokenType = 'NUMBER' | 'STRING' | 'IDENT' | 'LPAREN' | 'RPAREN' | 'LBRACK' | 'RBRACK' | 'COMMA' | 'SEMICOLON' | 'QUESTION' | 'COLON' | 'PLUS' | 'MINUS' | 'STAR' | 'SLASH' | 'CARET' | 'LT' | 'LTE' | 'GT' | 'GTE' | 'EQ' | 'NEQ' | 'AND' | 'OR' | 'EOF';
+export interface Token {
+    type: TokenType;
+    lexeme: string;
+    position: number;
+}

package/dist/types/tokens.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@bardsballad/cadence",
+  "version": "0.1.0",
+  "description": "Cadence: a safe, deterministic expression engine for user-generated content.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build",
+    "test": "jest"
+  },
+  "keywords": ["expression", "safe", "sandbox", "ttrpg"],
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.6.3"
+  }
+}