sf-agentpmd 0.1.0 → 0.1.2

package/vendor/agentscript-parser-javascript/dist/expressions.js

@@ -1,682 +0,0 @@
-/*
- * Copyright (c) 2026, Salesforce, Inc.
- * All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- * For full license text, see the LICENSE file in the repo root or https://www.apache.org/licenses/LICENSE-2.0
- */
-/**
- * Pratt expression parser for AgentScript.
- *
- * Precedence levels (matching grammar.js):
- *  0: ternary (X if C else Y) — right-associative
- *  1: or
- *  2: and
- *  3: not (prefix)
- *  4: ==, !=, <, >, <=, >=, is, is not, = (comparison)
- *  5: +, - (binary)
- *  6: *, /
- *  7: +, - (unary prefix)
- *  8: call, member, subscript (postfix)
- *  9: parenthesized (atomic)
- */
-import { TokenKind } from './token.js';
-import { CSTNode } from './cst-node.js';
-// Hoisted constants — avoid per-call allocation
-// Must match ESCAPE_TABLE in @agentscript/language (packages/language/src/core/string-escapes.ts)
-const VALID_ESCAPES = new Set(['"', "'", '\\', 'n', 'r', 't', '0']);
-const KEY_STOP_KEYWORDS = new Set([
-    'if',
-    'elif',
-    'else',
-    'run',
-    'set',
-    'with',
-    'to',
-    'transition',
-    'available',
-    'and',
-    'or',
-    'not',
-    'is',
-    'True',
-    'False',
-    'None',
-    'mutable',
-    'linked',
-    'empty',
-]);
-/** Create a MISSING id wrapped in atom → expression at the current parser position. */
-function makeMissingArgument(ctx) {
-    const offset = ctx.peekOffset();
-    const pos = ctx.peek().start;
-    const missingId = new CSTNode('id', ctx.source, offset, offset, pos, pos, true, false, true);
-    const atom = new CSTNode('atom', ctx.source, offset, offset, pos, pos);
-    atom.appendChild(missingId);
-    const expr = new CSTNode('expression', ctx.source, offset, offset, pos, pos);
-    expr.appendChild(atom);
-    return expr;
-}
-/** Create an empty ERROR node at the current parser position. */
-function makeEmptyError(ctx) {
-    const tok = ctx.peek();
-    const offset = ctx.peekOffset();
-    return new CSTNode('ERROR', ctx.source, offset, offset, tok.start, tok.start, true, true);
-}
-export function parseExpression(ctx, minPrec = 0) {
-    let left = parsePrefix(ctx);
-    if (!left)
-        return null;
-    while (true) {
-        // Fast path: sync points (NEWLINE/DEDENT/EOF) are never infix operators.
-        // This avoids the infixPrecedence() lookup in the most common case for mappings.
-        const nextKind = ctx.peekKind();
-        if (nextKind === TokenKind.NEWLINE ||
-            nextKind === TokenKind.DEDENT ||
-            nextKind === TokenKind.EOF)
-            break;
-        const prec = infixPrecedence(ctx);
-        if (prec < minPrec)
-            break;
-        const result = parseInfix(ctx, left, prec);
-        if (!result)
-            break;
-        left = result;
-    }
-    return left;
-}
-function parsePrefix(ctx) {
-    const tok = ctx.peek();
-    // not (precedence 3)
-    if (tok.kind === TokenKind.ID && tok.text === 'not') {
-        return parseUnary(ctx, 'not', 3);
-    }
-    // Unary + / - (precedence 7)
-    if (tok.kind === TokenKind.PLUS || tok.kind === TokenKind.MINUS) {
-        const op = tok.text;
-        return parseUnary(ctx, op, 7);
-    }
-    // Spread *expr (precedence 7)
-    if (tok.kind === TokenKind.STAR) {
-        return parseSpread(ctx);
-    }
-    // Parenthesized expression
-    if (tok.kind === TokenKind.LPAREN) {
-        return parseParenthesized(ctx);
-    }
-    // Atom
-    return parseAtom(ctx);
-}
-function parseUnary(ctx, _op, prec) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('unary_expression');
-    ctx.addAnonymousChild(node, ctx.consume()); // operator
-    const operand = parseExpression(ctx, prec + 1);
-    if (operand) {
-        node.appendChild(wrapExpression(ctx, operand));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseSpread(ctx) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('spread_expression');
-    ctx.addAnonymousChild(node, ctx.consume()); // *
-    // Bind at precedence 8 (same as postfix call/member/subscript) so
-    // *@variables.x parses as *(variables.x), not (*variables).x
-    const operand = parseExpression(ctx, 8);
-    if (operand) {
-        node.appendChild(wrapExpression(ctx, operand), 'expression');
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseParenthesized(ctx) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('parenthesized_expression');
-    ctx.addAnonymousChild(node, ctx.consume()); // (
-    const expr = parseExpression(ctx, 0);
-    if (expr) {
-        node.appendChild(wrapExpression(ctx, expr), 'expression');
-    }
-    else if (ctx.peekKind() === TokenKind.RPAREN) {
-        // Empty parens () → insert MISSING id
-        node.appendChild(makeMissingArgument(ctx), 'expression');
-    }
-    if (ctx.peekKind() === TokenKind.RPAREN) {
-        ctx.addAnonymousChild(node, ctx.consume()); // )
-    }
-    else {
-        // Unclosed paren → add ERROR node
-        node.appendChild(makeEmptyError(ctx));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseAtom(ctx) {
-    const tok = ctx.peek();
-    // Boolean / None constants
-    if (tok.kind === TokenKind.ID &&
-        (tok.text === 'True' || tok.text === 'False' || tok.text === 'None')) {
-        const node = ctx.startNode('atom');
-        ctx.addAnonymousChild(node, ctx.consume());
-        ctx.finishNode(node, tok);
-        return node;
-    }
-    // empty keyword
-    if (tok.kind === TokenKind.ID && tok.text === 'empty') {
-        const node = ctx.startNode('empty_keyword');
-        ctx.addAnonymousChild(node, ctx.consume());
-        ctx.finishNode(node, tok);
-        return node;
-    }
-    // @id
-    if (tok.kind === TokenKind.AT) {
-        return parseAtId(ctx);
-    }
-    // id
-    if (tok.kind === TokenKind.ID) {
-        return ctx.consumeNamed('id');
-    }
-    // number
-    if (tok.kind === TokenKind.NUMBER) {
-        return ctx.consumeNamed('number');
-    }
-    // datetime
-    if (tok.kind === TokenKind.DATETIME) {
-        return ctx.consumeNamed('datetime_literal');
-    }
-    // string
-    if (tok.kind === TokenKind.STRING) {
-        return parseString(ctx);
-    }
-    // ellipsis
-    if (tok.kind === TokenKind.ELLIPSIS) {
-        return ctx.consumeNamed('ellipsis');
-    }
-    // list [...]
-    if (tok.kind === TokenKind.LBRACKET) {
-        return parseList(ctx);
-    }
-    // dictionary {...}
-    if (tok.kind === TokenKind.LBRACE) {
-        return parseDictionary(ctx);
-    }
-    return null;
-}
-function parseAtId(ctx) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('at_id');
-    ctx.addAnonymousChild(node, ctx.consume()); // @
-    if (ctx.peekKind() === TokenKind.ID) {
-        node.appendChild(ctx.consumeNamed('id'));
-    }
-    else {
-        // @ with no identifier → ERROR
-        node.appendChild(makeEmptyError(ctx));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-export function parseString(ctx) {
-    const tok = ctx.peek();
-    const startTok = tok;
-    const node = ctx.startNode('string');
-    // The lexer gives us the whole string as one token.
-    // We need to break it into children: opening quote, string_content/escape_sequence, closing quote.
-    const text = tok.text;
-    const tokenOffset = ctx.peekOffset();
-    ctx.consume(); // consume the full string token
-    const baseRow = startTok.start.row;
-    const baseCol = startTok.start.column;
-    // Opening quote
-    node.appendChild(new CSTNode('"', ctx.source, tokenOffset, tokenOffset + 1, { row: baseRow, column: baseCol }, { row: baseRow, column: baseCol + 1 }, false));
-    // Parse content between quotes
-    let i = 1; // skip opening "
-    const quoteChar = text[0]; // " or '
-    const hasClosingQuote = text.length > 1 && text[text.length - 1] === quoteChar;
-    const contentEnd = hasClosingQuote ? text.length - 1 : text.length;
-    let contentStart = i;
-    while (i < contentEnd) {
-        if (text[i] === '\\' &&
-            i + 1 < contentEnd &&
-            VALID_ESCAPES.has(text[i + 1])) {
-            // Emit any accumulated content before the escape
-            if (i > contentStart) {
-                node.appendChild(new CSTNode('string_content', ctx.source, tokenOffset + contentStart, tokenOffset + i, { row: baseRow, column: baseCol + contentStart }, { row: baseRow, column: baseCol + i }));
-            }
-            // Emit escape sequence
-            const escLen = 2;
-            node.appendChild(new CSTNode('escape_sequence', ctx.source, tokenOffset + i, tokenOffset + i + escLen, { row: baseRow, column: baseCol + i }, { row: baseRow, column: baseCol + i + escLen }));
-            i += escLen;
-            contentStart = i;
-        }
-        else if (text[i] === '\\' &&
-            i + 1 < contentEnd &&
-            !VALID_ESCAPES.has(text[i + 1])) {
-            // Invalid escape sequence — emit accumulated content, then ERROR
-            if (i > contentStart) {
-                node.appendChild(new CSTNode('string_content', ctx.source, tokenOffset + contentStart, tokenOffset + i, { row: baseRow, column: baseCol + contentStart }, { row: baseRow, column: baseCol + i }));
-            }
-            // Find the extent of the invalid escape: \x followed by remaining word chars
-            const escStart = i;
-            i += 2; // skip \ and the invalid char
-            while (i < contentEnd && /[a-zA-Z0-9_]/.test(text[i])) {
-                i++;
-            }
-            const errNode = new CSTNode('ERROR', ctx.source, tokenOffset + escStart, tokenOffset + i, { row: baseRow, column: baseCol + escStart }, { row: baseRow, column: baseCol + i }, true, true);
-            node.appendChild(errNode);
-            contentStart = i;
-        }
-        else {
-            i++;
-        }
-    }
-    // Emit remaining content
-    if (i > contentStart) {
-        node.appendChild(new CSTNode('string_content', ctx.source, tokenOffset + contentStart, tokenOffset + i, { row: baseRow, column: baseCol + contentStart }, { row: baseRow, column: baseCol + i }));
-    }
-    // Closing quote
-    if (hasClosingQuote) {
-        node.appendChild(new CSTNode(quoteChar, ctx.source, tokenOffset + text.length - 1, tokenOffset + text.length, { row: baseRow, column: baseCol + text.length - 1 }, { row: baseRow, column: baseCol + text.length }, false));
-    }
-    else {
-        // Unclosed string → MISSING closing quote
-        // Position at end of string content (where the quote should have been),
-        // not at the next token which may be on the next line.
-        const missingOffset = tokenOffset + text.length;
-        const missingPos = { row: baseRow, column: baseCol + text.length };
-        node.appendChild(new CSTNode(quoteChar, ctx.source, missingOffset, missingOffset, missingPos, missingPos, false, false, true));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseList(ctx) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('list');
-    ctx.addAnonymousChild(node, ctx.consume()); // [
-    // Lists can span multiple lines — skip whitespace tokens inside [...]
-    let _listIndentDepth = 0;
-    while (ctx.peekKind() !== TokenKind.RBRACKET &&
-        ctx.peekKind() !== TokenKind.EOF) {
-        if (ctx.peekKind() === TokenKind.NEWLINE) {
-            ctx.consume();
-            continue;
-        }
-        if (ctx.peekKind() === TokenKind.INDENT) {
-            _listIndentDepth++;
-            ctx.consume();
-            continue;
-        }
-        if (ctx.peekKind() === TokenKind.DEDENT) {
-            _listIndentDepth--;
-            ctx.consume();
-            continue;
-        }
-        const expr = parseExpression(ctx, 0);
-        if (expr) {
-            node.appendChild(wrapExpression(ctx, expr));
-        }
-        else {
-            break;
-        }
-        if (ctx.peekKind() === TokenKind.COMMA) {
-            ctx.addAnonymousChild(node, ctx.consume());
-        }
-        else {
-            break;
-        }
-    }
-    // Skip whitespace tokens to find the closing ]
-    while (ctx.peekKind() === TokenKind.NEWLINE ||
-        ctx.peekKind() === TokenKind.INDENT ||
-        ctx.peekKind() === TokenKind.DEDENT) {
-        ctx.consume();
-    }
-    if (ctx.peekKind() === TokenKind.RBRACKET) {
-        ctx.addAnonymousChild(node, ctx.consume());
-    }
-    else {
-        node.appendChild(makeEmptyError(ctx));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseDictionary(ctx) {
-    const startTok = ctx.peek();
-    const node = ctx.startNode('dictionary');
-    ctx.addAnonymousChild(node, ctx.consume()); // {
-    // Dictionaries can span multiple lines
-    while (ctx.peekKind() !== TokenKind.RBRACE &&
-        ctx.peekKind() !== TokenKind.EOF) {
-        if (ctx.peekKind() === TokenKind.NEWLINE ||
-            ctx.peekKind() === TokenKind.INDENT ||
-            ctx.peekKind() === TokenKind.DEDENT) {
-            ctx.consume();
-            continue;
-        }
-        const pair = parseDictionaryPair(ctx);
-        if (pair) {
-            node.appendChild(pair);
-        }
-        else {
-            break;
-        }
-        if (ctx.peekKind() === TokenKind.COMMA) {
-            ctx.addAnonymousChild(node, ctx.consume());
-        }
-        else {
-            break;
-        }
-    }
-    if (ctx.peekKind() === TokenKind.RBRACE) {
-        ctx.addAnonymousChild(node, ctx.consume());
-    }
-    else {
-        node.appendChild(makeEmptyError(ctx));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseDictionaryPair(ctx) {
-    const startTok = ctx.peek();
-    if (!isKeyStart(ctx))
-        return null;
-    const node = ctx.startNode('dictionary_pair');
-    const key = parseKey(ctx);
-    if (key)
-        node.appendChild(key, 'key');
-    if (ctx.peekKind() === TokenKind.COLON) {
-        ctx.addAnonymousChild(node, ctx.consume());
-    }
-    const value = parseExpression(ctx, 0);
-    if (value)
-        node.appendChild(wrapExpression(ctx, value), 'value');
-    ctx.finishNode(node, startTok);
-    return node;
-}
-// --- Infix parsing ---
-// Precedence lookup tables (O(1) instead of 20+ if-statements)
-const INFIX_PREC_BY_KIND = new Map([
-    [TokenKind.LPAREN, 8],
-    [TokenKind.DOT, 8],
-    [TokenKind.LBRACKET, 8],
-    [TokenKind.EQEQ, 4],
-    [TokenKind.NEQ, 4],
-    [TokenKind.LT, 4],
-    [TokenKind.GT, 4],
-    [TokenKind.LTE, 4],
-    [TokenKind.GTE, 4],
-    [TokenKind.PLUS, 5],
-    [TokenKind.MINUS, 5],
-    [TokenKind.STAR, 6],
-    [TokenKind.SLASH, 6],
-]);
-const INFIX_KEYWORD_PREC = new Map([
-    ['if', 0],
-    ['or', 1],
-    ['and', 2],
-    ['is', 4],
-]);
-function infixPrecedence(ctx) {
-    const tok = ctx.peek();
-    if (tok.kind === TokenKind.ID)
-        return INFIX_KEYWORD_PREC.get(tok.text) ?? -2;
-    return INFIX_PREC_BY_KIND.get(tok.kind) ?? -2;
-}
-function parseInfix(ctx, left, prec) {
-    const tok = ctx.peek();
-    // Call expression: expr(args)
-    if (tok.kind === TokenKind.LPAREN && prec === 8) {
-        return parseCall(ctx, left);
-    }
-    // Member expression: expr.id
-    if (tok.kind === TokenKind.DOT && prec === 8) {
-        return parseMember(ctx, left);
-    }
-    // Subscript expression: expr[expr]
-    if (tok.kind === TokenKind.LBRACKET && prec === 8) {
-        return parseSubscript(ctx, left);
-    }
-    // Ternary: consequence if condition else alternative
-    if (tok.kind === TokenKind.ID && tok.text === 'if') {
-        return parseTernary(ctx, left);
-    }
-    // "is not" compound operator
-    if (tok.kind === TokenKind.ID && tok.text === 'is') {
-        return parseIsExpression(ctx, left);
-    }
-    // Binary / comparison
-    return parseBinaryOrComparison(ctx, left, prec);
-}
-function parseCall(ctx, func) {
-    const startTok = ctx.peek();
-    const node = ctx.startNodeAt('call_expression', func);
-    node.appendChild(wrapExpression(ctx, func), 'function');
-    ctx.addAnonymousChild(node, ctx.consume()); // (
-    while (ctx.peekKind() !== TokenKind.RPAREN && !ctx.isAtSyncPoint()) {
-        const arg = parseExpression(ctx, 0);
-        if (arg) {
-            node.appendChild(wrapExpression(ctx, arg), 'argument');
-        }
-        else {
-            break;
-        }
-        if (ctx.peekKind() === TokenKind.COMMA) {
-            ctx.addAnonymousChild(node, ctx.consume());
-            // Trailing comma: if `)` follows, insert MISSING id argument
-            if (ctx.peekKind() === TokenKind.RPAREN) {
-                node.appendChild(makeMissingArgument(ctx), 'argument');
-                break;
-            }
-        }
-        else {
-            break;
-        }
-    }
-    if (ctx.peekKind() === TokenKind.RPAREN) {
-        ctx.addAnonymousChild(node, ctx.consume());
-    }
-    else {
-        node.appendChild(makeEmptyError(ctx));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseMember(ctx, object) {
-    const startTok = ctx.peek();
-    const node = ctx.startNodeAt('member_expression', object);
-    node.appendChild(wrapExpression(ctx, object));
-    ctx.addAnonymousChild(node, ctx.consume()); // .
-    if (ctx.peekKind() === TokenKind.ID) {
-        node.appendChild(ctx.consumeNamed('id'));
-    }
-    else if (ctx.peekKind() === TokenKind.NUMBER) {
-        // Error 19: member access with number like @var.123
-        const numNode = ctx.consumeNamed('number');
-        const errNode = new CSTNode('ERROR', ctx.source, numNode.startOffset, numNode.endOffset, numNode.startPosition, numNode.endPosition, true, true);
-        errNode.appendChild(numNode);
-        node.appendChild(errNode);
-    }
-    else {
-        // Trailing dot with nothing after → ERROR
-        node.appendChild(makeEmptyError(ctx));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseSubscript(ctx, object) {
-    const startTok = ctx.peek();
-    const node = ctx.startNodeAt('subscript_expression', object);
-    node.appendChild(wrapExpression(ctx, object));
-    ctx.addAnonymousChild(node, ctx.consume()); // [
-    const index = parseExpression(ctx, 0);
-    if (index) {
-        node.appendChild(wrapExpression(ctx, index));
-    }
-    if (ctx.peekKind() === TokenKind.RBRACKET) {
-        ctx.addAnonymousChild(node, ctx.consume());
-    }
-    else {
-        node.appendChild(makeEmptyError(ctx));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseTernary(ctx, consequence) {
-    const startTok = ctx.peek();
-    const node = ctx.startNodeAt('ternary_expression', consequence);
-    node.appendChild(wrapExpression(ctx, consequence), 'consequence');
-    ctx.addAnonymousChild(node, ctx.consume()); // if
-    const condition = parseExpression(ctx, 1); // above 'or'
-    if (condition) {
-        node.appendChild(wrapExpression(ctx, condition), 'condition');
-    }
-    if (ctx.peekKind() === TokenKind.ID && ctx.peek().text === 'else') {
-        ctx.addAnonymousChild(node, ctx.consume()); // else
-        const alt = parseExpression(ctx, 0); // right-associative: parse at 0
-        if (alt) {
-            node.appendChild(wrapExpression(ctx, alt), 'alternative');
-        }
-    }
-    else {
-        // Incomplete ternary: "a if condition" without else → ERROR
-        node.appendChild(makeEmptyError(ctx));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseIsExpression(ctx, left) {
-    const startTok = ctx.peek();
-    // Check for "is not"
-    const isNot = ctx.peekAt(1).kind === TokenKind.ID && ctx.peekAt(1).text === 'not';
-    const nodeType = 'comparison_expression';
-    const node = ctx.startNodeAt(nodeType, left);
-    node.appendChild(wrapExpression(ctx, left));
-    ctx.addAnonymousChild(node, ctx.consume()); // is
-    if (isNot) {
-        ctx.addAnonymousChild(node, ctx.consume()); // not
-    }
-    const right = parseExpression(ctx, 5); // above binary +/-
-    if (right) {
-        node.appendChild(wrapExpression(ctx, right));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-function parseBinaryOrComparison(ctx, left, prec) {
-    const tok = ctx.peek();
-    const startTok = tok;
-    // Determine if this is a comparison or binary expression
-    const isComparison = tok.kind === TokenKind.EQEQ ||
-        tok.kind === TokenKind.NEQ ||
-        tok.kind === TokenKind.LT ||
-        tok.kind === TokenKind.GT ||
-        tok.kind === TokenKind.LTE ||
-        tok.kind === TokenKind.GTE ||
-        tok.kind === TokenKind.EQ;
-    const nodeType = isComparison ? 'comparison_expression' : 'binary_expression';
-    const node = ctx.startNodeAt(nodeType, left);
-    node.appendChild(wrapExpression(ctx, left));
-    ctx.addAnonymousChild(node, ctx.consume()); // operator
-    const right = parseExpression(ctx, prec + 1); // left-associative
-    if (right) {
-        node.appendChild(wrapExpression(ctx, right));
-    }
-    else {
-        // Incomplete binary/comparison: `3 +` or `@var ==` with no right operand
-        node.appendChild(makeEmptyError(ctx));
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-// --- Helpers ---
-/**
- * Types that are already wrapped or structural — should NOT get an expression wrapper.
- * Everything else produced by expression parsing gets wrapped.
- */
-const SKIP_WRAP_TYPES = new Set(['expression', 'ERROR']);
-/**
- * Leaf/literal types that need an intermediate `atom` wrapper before the `expression` wrapper.
- */
-export const ATOM_TYPES = new Set([
-    'id',
-    'number',
-    'string',
-    'datetime_literal',
-    'at_id',
-    'list',
-    'dictionary',
-    'ellipsis',
-]);
-/**
- * Wrap an expression in an `expression` supertype node if it isn't already one.
- * Tree-sitter wraps most expression children in an (expression ...) wrapper.
- */
-export function wrapExpression(ctx, inner) {
-    if (SKIP_WRAP_TYPES.has(inner.type)) {
-        return inner;
-    }
-    // For atoms, wrap in atom first then expression
-    let wrapped = inner;
-    if (ATOM_TYPES.has(inner.type)) {
-        const atom = new CSTNode('atom', ctx.source, inner.startOffset, inner.endOffset, inner.startPosition, inner.endPosition);
-        atom.appendChild(inner);
-        wrapped = atom;
-    }
-    // Now wrap in expression
-    const expr = new CSTNode('expression', ctx.source, wrapped.startOffset, wrapped.endOffset, wrapped.startPosition, wrapped.endPosition);
-    expr.appendChild(wrapped);
-    return expr;
-}
-export function isKeyStart(ctx) {
-    const tok = ctx.peek();
-    return isKeyTokenStart(tok.kind);
-}
-/** Can this token kind begin a key? (ID, STRING, or NUMBER for digit-prefixed keys like `3var`) */
-export function isKeyTokenStart(kind) {
-    return (kind === TokenKind.ID ||
-        kind === TokenKind.STRING ||
-        kind === TokenKind.NUMBER);
-}
-/** Can this token kind appear within a multi-part key? (key-start tokens plus MINUS/DOT for `my-var`, `a.b`) */
-export function isKeyTokenContinuation(kind) {
-    return (isKeyTokenStart(kind) || kind === TokenKind.MINUS || kind === TokenKind.DOT);
-}
-export function parseKey(ctx) {
-    if (!isKeyStart(ctx))
-        return null;
-    const startTok = ctx.peek();
-    const node = ctx.startNode('key');
-    // First name — may be a number (digit-starting key like "3var")
-    if (ctx.peekKind() === TokenKind.NUMBER) {
-        // Digit-starting key: wrap number in ERROR
-        const numNode = ctx.consumeNamed('number');
-        const errNode = new CSTNode('ERROR', ctx.source, numNode.startOffset, numNode.endOffset, numNode.startPosition, numNode.endPosition, true, true);
-        node.appendChild(errNode);
-        // Consume the ID part if present
-        if (ctx.peekKind() === TokenKind.ID) {
-            node.appendChild(ctx.consumeNamed('id'));
-        }
-    }
-    else if (ctx.peekKind() === TokenKind.STRING) {
-        node.appendChild(parseString(ctx));
-    }
-    else {
-        node.appendChild(ctx.consumeNamed('id'));
-    }
-    // Optional second name (two-word keys like "topic greeting")
-    // The second word must be on the same line with exactly immediate adjacency
-    // (the grammar uses token.immediate(' '))
-    if (ctx.peekKind() === TokenKind.ID &&
-        !ctx.isAtSyncPoint() &&
-        ctx.peek().start.row === startTok.start.row) {
-        // Check if this could be a keyword that starts a value/statement
-        const nextText = ctx.peek().text;
-        if (!KEY_STOP_KEYWORDS.has(nextText)) {
-            node.appendChild(ctx.consumeNamed('id'));
-        }
-    }
-    ctx.finishNode(node, startTok);
-    return node;
-}
-//# sourceMappingURL=expressions.js.map

package/vendor/agentscript-parser-javascript/dist/highlighter.d.ts

@@ -1,24 +0,0 @@
-/**
- * CST-walk syntax highlighter for AgentScript.
- *
- * Produces QueryCapture[] matching the tree-sitter highlights.scm rules.
- * Replaces tree-sitter's Query engine with a direct CST walk.
- */
-import type { CSTNode } from './cst-node.js';
-export interface HighlightCapture {
-    name: string;
-    text: string;
-    startRow: number;
-    startCol: number;
-    endRow: number;
-    endCol: number;
-}
-/**
- * Walk the CST and produce highlight captures matching highlights.scm.
- *
- * Tree-sitter query priority: later patterns override earlier ones.
- * We replicate this by first assigning generic captures, then overriding
- * with contextual ones (e.g., id → variable, then key > id → property).
- */
-export declare function highlight(root: CSTNode): HighlightCapture[];
-//# sourceMappingURL=highlighter.d.ts.map