sf-agentpmd 0.1.0 → 0.1.1

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

@@ -1,630 +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
- */
-/**
- * Indentation-aware lexer for AgentScript.
- *
- * Produces a flat Token[] array including synthetic INDENT, DEDENT, and NEWLINE
- * tokens. Keywords are emitted as ID — the parser checks token text.
- *
- * Indentation: space = 1 unit, tab = 3 units (matching scanner.c).
- */
-import invariant from 'tiny-invariant';
-import { TokenKind } from './token.js';
-// ---------------------------------------------------------------------------
-// Character classification via charCode (replaces regex hot-path checks)
-// ---------------------------------------------------------------------------
-const CH_TAB = 9; // \t
-const CH_LF = 10; // \n
-const CH_CR = 13; // \r
-const CH_SPACE = 32;
-const CH_BANG = 33; // !
-const CH_DQUOTE = 34; // "
-const CH_HASH = 35; // #
-const CH_DASH = 45; // -
-const CH_DOT = 46; // .
-const CH_0 = 48;
-const CH_9 = 57;
-const CH_LT = 60; // <
-const CH_EQ = 61; // =
-const CH_GT = 62; // >
-const CH_A = 65;
-const CH_Z = 90;
-const CH_BACKSLASH = 92; // \
-const CH_UNDERSCORE = 95; // _
-const CH_a = 97;
-const CH_z = 122;
-const CH_LBRACE = 123; // {
-const CH_NUL = 0;
-function isIdStart(c) {
-    return ((c >= CH_A && c <= CH_Z) || (c >= CH_a && c <= CH_z) || c === CH_UNDERSCORE);
-}
-function isIdCont(c) {
-    return isIdStart(c) || (c >= CH_0 && c <= CH_9);
-}
-function isDigit(c) {
-    return c >= CH_0 && c <= CH_9;
-}
-function isHorizontalWs(c) {
-    return c === CH_SPACE || c === CH_TAB;
-}
-// ---------------------------------------------------------------------------
-// charCode-indexed single-char token lookup (replaces Record<string, TokenKind>)
-// ---------------------------------------------------------------------------
-const SINGLE_CHAR_TOKENS = new Array(128).fill(0);
-SINGLE_CHAR_TOKENS[43] = TokenKind.PLUS; // +
-SINGLE_CHAR_TOKENS[CH_DASH] = TokenKind.MINUS; // -
-SINGLE_CHAR_TOKENS[42] = TokenKind.STAR; // *
-SINGLE_CHAR_TOKENS[47] = TokenKind.SLASH; // /
-// % is not a valid operator in AgentScript (tree-sitter parity)
-SINGLE_CHAR_TOKENS[CH_DOT] = TokenKind.DOT; // .
-SINGLE_CHAR_TOKENS[44] = TokenKind.COMMA; // ,
-SINGLE_CHAR_TOKENS[58] = TokenKind.COLON; // :
-SINGLE_CHAR_TOKENS[61] = TokenKind.EQ; // =
-SINGLE_CHAR_TOKENS[60] = TokenKind.LT; // <
-SINGLE_CHAR_TOKENS[CH_GT] = TokenKind.GT; // >
-SINGLE_CHAR_TOKENS[124] = TokenKind.PIPE; // |
-SINGLE_CHAR_TOKENS[64] = TokenKind.AT; // @
-SINGLE_CHAR_TOKENS[40] = TokenKind.LPAREN; // (
-SINGLE_CHAR_TOKENS[41] = TokenKind.RPAREN; // )
-SINGLE_CHAR_TOKENS[91] = TokenKind.LBRACKET; // [
-SINGLE_CHAR_TOKENS[93] = TokenKind.RBRACKET; // ]
-SINGLE_CHAR_TOKENS[CH_LBRACE] = TokenKind.LBRACE; // {
-SINGLE_CHAR_TOKENS[125] = TokenKind.RBRACE; // }
-export class Lexer {
-    source;
-    offset = 0;
-    row = 0;
-    col = 0;
-    tokens = [];
-    indentStack = [0];
-    /** True when the current line started with `|` (template line). */
-    onTemplateLine = false;
-    /** Indent level of the line containing `|`. Content deeper than this is template content. */
-    templateBaseIndent = -1;
-    /** Nested brace depth inside a template expression (for `{` inside `{!...}`). -1 means not inside a template expression. */
-    templateExprBraceDepth = -1;
-    get inTemplateExpr() {
-        return this.templateExprBraceDepth >= 0;
-    }
-    /** Parenthesis depth — suppresses INDENT/DEDENT/NEWLINE when > 0 to support multi-line call expressions. */
-    bracketDepth = 0;
-    constructor(source) {
-        this.source = source;
-    }
-    tokenize() {
-        // Pre-allocate token array backing store for large inputs
-        this.tokens = [];
-        const estimate = (this.source.length / 8) | 0;
-        if (estimate > 64) {
-            this.tokens.length = estimate;
-            this.tokens.length = 0;
-        }
-        this.offset = 0;
-        this.row = 0;
-        this.col = 0;
-        this.indentStack = [0];
-        this.bracketDepth = 0;
-        while (this.hasMore) {
-            this.tokenizeLine();
-        }
-        // Emit remaining DEDENTs
-        while (this.indentStack.length > 1) {
-            this.indentStack.pop();
-            this.emitVirtual(TokenKind.DEDENT);
-        }
-        this.emitVirtual(TokenKind.EOF);
-        return this.tokens;
-    }
-    tokenizeLine() {
-        // Note: onTemplateLine persists across continuation lines and is only
-        // reset when indentation decreases (DEDENT) in emitIndentation().
-        // Measure leading indentation
-        const indentLength = this.consumeIndentation();
-        if (this.consumeNewline()) {
-            return;
-        }
-        const c = this.peekCharCode();
-        // Comment-only line: tree-sitter's scanner skips past comment-only lines
-        // when deciding INDENT/DEDENT. If this comment is at deeper indent than
-        // current but no real content follows at that depth, emit NEWLINE instead.
-        // Similarly, if a comment is at shallower indent but the next real content
-        // is back at the current block's depth, suppress the DEDENT.
-        // When on a template line, only treat `#` as a comment if it's at or below
-        // the template's base indent (outside the template content area).
-        if (c === CH_HASH &&
-            (!this.onTemplateLine || indentLength <= this.templateBaseIndent)) {
-            const currentIndent = this.indentStack[this.indentStack.length - 1];
-            if (indentLength > currentIndent) {
-                const nextContentIndent = this.peekNextContentIndent();
-                if (nextContentIndent < indentLength) {
-                    // No real content at this depth — suppress INDENT
-                    this.emitIndentation(currentIndent);
-                    return this.tokenizeComment();
-                }
-            }
-            else if (indentLength < currentIndent) {
-                const nextContentIndent = this.peekNextContentIndent();
-                if (nextContentIndent > indentLength) {
-                    // Next real content is at a deeper indent than the comment.
-                    // Emit indentation based on where the next content is, not
-                    // where the comment sits, so we only close the blocks that
-                    // actually end (not the ones the comment just happens to be
-                    // outside of).
-                    this.emitIndentation(nextContentIndent);
-                    return this.tokenizeComment();
-                }
-            }
-            else {
-                // Comment at same indent as current block. If next real content
-                // is deeper (i.e. the comment sits between a key and its indented
-                // body), suppress NEWLINE so the body's INDENT fires on the next
-                // iteration. Example:
-                //   a:
-                //   # comment       ← same indent as current block
-                //       body: "x"   ← should INDENT into a's body
-                const nextContentIndent = this.peekNextContentIndent();
-                if (nextContentIndent > indentLength) {
-                    return this.tokenizeComment();
-                }
-            }
-            this.emitIndentation(indentLength);
-            return this.tokenizeComment();
-        }
-        // Normal line — emit indentation tokens.
-        // Template continuation lines (deeper than templateBaseIndent) should
-        // not cause INDENT/DEDENT when their indent varies relative to other
-        // template lines. The initial INDENT into the template block is needed
-        // (it establishes the template_content grammar rule), but subsequent
-        // indent variation within the template corrupts the indent stack and
-        // breaks downstream blocks. Detect "already inside template block" by
-        // checking if the indent stack top is already deeper than templateBaseIndent.
-        const currentIndent = this.indentStack[this.indentStack.length - 1];
-        if (this.onTemplateLine &&
-            indentLength > this.templateBaseIndent &&
-            currentIndent > this.templateBaseIndent &&
-            indentLength !== currentIndent) {
-            this.emitIndentation(currentIndent);
-        }
-        else {
-            this.emitIndentation(indentLength);
-        }
-        // Check for "- " sequence element at start of content
-        if (this.bracketDepth === 0 && c === CH_DASH) {
-            const nc = this.peekCharCode(1); // NaN at EOF — won't match any CH_*
-            const atEOF = this.offset + 1 >= this.source.length;
-            if (nc === CH_SPACE || this.atNewline(1) || atEOF) {
-                this.emit(TokenKind.DASH_SPACE, nc === CH_SPACE ? '- ' : '-');
-            }
-        }
-        // Tokenize the rest of the line
-        while (this.hasMore) {
-            const c = this.peekCharCode();
-            // Newline ends the line
-            if (this.consumeNewline()) {
-                return;
-            }
-            if (c === CH_CR) {
-                // Not followed with line feed (otherwise this.consumeLine() would be true)
-                invariant(!this.atNewline());
-                this.advance();
-                continue;
-            }
-            // Skip horizontal whitespace
-            if (isHorizontalWs(c)) {
-                this.advance();
-                continue;
-            }
-            // Line continuation
-            if (c === CH_BACKSLASH) {
-                if (this.atNewline(1)) {
-                    this.advance(); // skip backslash
-                    invariant(this.consumeNewline());
-                    // Skip leading whitespace on continuation line
-                    while (isHorizontalWs(this.peekCharCode())) {
-                        this.advance();
-                    }
-                    continue;
-                }
-            }
-            // Comment (but not on template content lines where # is literal text)
-            if (c === CH_HASH && !this.onTemplateLine) {
-                return this.tokenizeComment();
-            }
-            this.tokenizeToken();
-        }
-    }
-    emitIndentation(indentLength) {
-        if (this.bracketDepth > 0)
-            return;
-        const currentIndent = this.indentStack[this.indentStack.length - 1];
-        if (indentLength > currentIndent) {
-            this.indentStack.push(indentLength);
-            this.emitVirtual(TokenKind.INDENT);
-        }
-        else if (indentLength < currentIndent) {
-            // Emit DEDENTs and a NEWLINE; leave template context only when
-            // indentation drops to or below the template's base indent level.
-            if (indentLength <= this.templateBaseIndent) {
-                this.onTemplateLine = false;
-                this.templateExprBraceDepth = -1;
-            }
-            while (this.indentStack.length > 1 &&
-                this.indentStack[this.indentStack.length - 1] > indentLength) {
-                this.indentStack.pop();
-                this.emitVirtual(TokenKind.DEDENT);
-            }
-            this.emitVirtual(TokenKind.NEWLINE);
-        }
-        else {
-            // Same indent — emit NEWLINE (line separator) unless we're at the start.
-            // Leave template context only when at or below the template's base indent.
-            if (indentLength <= this.templateBaseIndent) {
-                this.onTemplateLine = false;
-                this.templateExprBraceDepth = -1;
-            }
-            if (this.tokens.length > 0) {
-                this.emitVirtual(TokenKind.NEWLINE);
-            }
-        }
-    }
-    tokenizeToken() {
-        const c = this.peekCharCode();
-        // Datetimes or numbers
-        if (isDigit(c)) {
-            // Datetime literal: YYYY-MM-DD...
-            // Must check before numbers since datetimes start with digits
-            if (this.tryDatetime()) {
-                return;
-            }
-            this.tokenizeNumber();
-            return;
-        }
-        // Identifier
-        if (isIdStart(c)) {
-            this.tokenizeId();
-            return;
-        }
-        // String (double-quoted always, single-quoted only if not a contraction)
-        // Inside template lines (after |), quotes are literal characters — don't
-        // start string tokenization unless we're inside a {!...} expression.
-        if (!this.onTemplateLine || this.inTemplateExpr) {
-            if (c === CH_DQUOTE) {
-                this.tokenizeString();
-                return;
-            }
-        }
-        // Template expression start {!
-        if (c === CH_LBRACE && this.peekCharCode(1) === CH_BANG) {
-            this.templateExprBraceDepth = 0;
-            this.emit(TokenKind.TEMPLATE_EXPR_START, '{!');
-            return;
-        }
-        // Tokens beginning with .
-        if (c === CH_DOT) {
-            if (this.peekCharCode(1) === CH_DOT && this.peekCharCode(2) === CH_DOT) {
-                this.emit(TokenKind.ELLIPSIS, '...');
-                return;
-            }
-            // Leading-dot number (e.g., .5, .123) — but not after identifiers
-            // (which would be member access like @variable.5)
-            if (isDigit(this.peekCharCode(1))) {
-                const prev = this.tokens[this.tokens.length - 1];
-                const isMemberAccess = prev !== undefined &&
-                    (prev.kind === TokenKind.ID ||
-                        prev.kind === TokenKind.NUMBER ||
-                        prev.kind === TokenKind.RPAREN ||
-                        prev.kind === TokenKind.RBRACKET);
-                if (!isMemberAccess) {
-                    this.tokenizeNumber();
-                    return;
-                }
-            }
-        }
-        if (c === CH_DASH) {
-            if (this.peekCharCode(1) === CH_GT) {
-                return this.emit(TokenKind.ARROW, '->');
-            }
-        }
-        // == != <= >=
-        const nc = this.peekCharCode(1);
-        if (nc === CH_EQ) {
-            // next is '='
-            if (c === CH_EQ) {
-                return this.emit(TokenKind.EQEQ, '==');
-            }
-            if (c === CH_BANG) {
-                return this.emit(TokenKind.NEQ, '!=');
-            }
-            if (c === CH_LT) {
-                return this.emit(TokenKind.LTE, '<=');
-            }
-            if (c === CH_GT) {
-                return this.emit(TokenKind.GTE, '>=');
-            }
-        }
-        // Single-char tokens (charCode-indexed lookup)
-        const kind = c < 128 ? SINGLE_CHAR_TOKENS[c] : 0;
-        if (kind) {
-            this.emitSpan(kind, 1);
-            switch (kind) {
-                // Track template lines: `|` starts a template context for this line
-                // and continuation lines indented deeper than this level.
-                case TokenKind.PIPE:
-                    this.onTemplateLine = true;
-                    this.templateBaseIndent =
-                        this.indentStack[this.indentStack.length - 1];
-                    break;
-                // Track parenthesis depth to suppress structural tokens inside
-                // multi-line call expressions.  Skip when inside a template line —
-                // parens in template content are literal text and must not suppress
-                // INDENT/DEDENT emission (unmatched parens would eat the rest of
-                // the file).
-                case TokenKind.LPAREN:
-                    if (!this.onTemplateLine)
-                        this.bracketDepth++;
-                    break;
-                case TokenKind.RPAREN:
-                    if (!this.onTemplateLine)
-                        this.bracketDepth--;
-                    break;
-                // Track brace depth inside {!...} template expressions so that nested
-                // braces (e.g. JSON objects) don't prematurely close the expression.
-                case TokenKind.LBRACE:
-                    if (this.inTemplateExpr) {
-                        this.templateExprBraceDepth++;
-                    }
-                    break;
-                case TokenKind.RBRACE:
-                    if (this.inTemplateExpr) {
-                        this.templateExprBraceDepth--;
-                    }
-                    break;
-            }
-            return;
-        }
-        // Unknown character — emit error token
-        this.emitSpan(TokenKind.ERROR_TOKEN, 1);
-    }
-    tokenizeId() {
-        let i = 0;
-        for (;; i++) {
-            const c = this.peekCharCode(i);
-            if (!isIdCont(c))
-                break;
-        }
-        this.emitSpan(TokenKind.ID, i);
-    }
-    tokenizeNumber() {
-        let tokenLength = 0;
-        // Leading dot (e.g., .5) — consume the `.` first
-        const leadingDot = this.peekCharCode(tokenLength) === CH_DOT;
-        if (leadingDot) {
-            tokenLength++;
-        }
-        // Integer part — inline advance (digits never contain newlines)
-        while (isDigit(this.peekCharCode(tokenLength))) {
-            tokenLength++;
-        }
-        // Decimal part — only consume `.` if followed by a digit (and no leading dot)
-        if (!leadingDot && this.peekCharCode(tokenLength) === CH_DOT) {
-            tokenLength++;
-        }
-        while (isDigit(this.peekCharCode(tokenLength))) {
-            tokenLength++;
-        }
-        this.emitSpan(TokenKind.NUMBER, tokenLength);
-    }
-    tryDatetime() {
-        // ISO 8601: YYYY-MM-DD optionally followed by time
-        // Need at least YYYY-MM-DD = 10 chars
-        const remaining = this.source.length - this.offset;
-        if (remaining < 10)
-            return false;
-        // Fast reject: most numbers aren't datetimes. Check the fixed '-' positions
-        // before allocating a slice or running the regex.
-        if (this.source.charCodeAt(this.offset + 4) !== CH_DASH ||
-            this.source.charCodeAt(this.offset + 7) !== CH_DASH) {
-            return false;
-        }
-        const slice = this.source.slice(this.offset, this.offset + 30);
-        const match = slice.match(/^\d{4}-\d{2}-\d{2}(T\d{1,2}(:\d{2})?(:\d{2})?(\.\d+)?Z?)?/);
-        if (!match)
-            return false;
-        // Only treat as datetime if it has the full YYYY-MM-DD pattern
-        // and the character after isn't an identifier character
-        const matchText = match[0];
-        if (matchText.length < 10)
-            return false; // Must have at least YYYY-MM-DD
-        this.emit(TokenKind.DATETIME, matchText);
-        return true;
-    }
-    tokenizeString() {
-        const start = this.position;
-        const startOffset = this.offset;
-        const quoteCode = this.peekCharCode(); // " or '
-        // Opening quote
-        this.advance();
-        while (this.hasMore) {
-            const c = this.peekCharCode();
-            if (c === quoteCode) {
-                this.advance(); // closing quote
-                const text = this.source.slice(startOffset, this.offset);
-                this.tokens.push(this.makeToken(TokenKind.STRING, text, start, this.position, startOffset));
-                return;
-            }
-            if (c === CH_BACKSLASH) {
-                this.advance(2);
-                continue;
-            }
-            if (this.atNewline()) {
-                // Unclosed string — stop at newline for error recovery
-                break;
-            }
-            if (c === CH_CR) {
-                // Bare \r inside string — treat as content
-                invariant(!this.atNewline());
-                this.advance();
-                continue;
-            }
-            if (c === CH_NUL) {
-                // Null byte — tree-sitter rejects these in string content
-                break;
-            }
-            this.advance();
-        }
-        // Unclosed string
-        const text = this.source.slice(startOffset, this.offset);
-        this.tokens.push(this.makeToken(TokenKind.STRING, text, start, this.position, startOffset));
-    }
-    tokenizeComment() {
-        const start = this.position;
-        const startOffset = this.offset;
-        // Consume # and everything until end of line or EOF
-        while (this.hasMore && !this.atNewline()) {
-            this.advance();
-        }
-        const text = this.source.slice(startOffset, this.offset);
-        this.tokens.push(this.makeToken(TokenKind.COMMENT, text, start, this.position, startOffset));
-        this.consumeNewline();
-    }
-    consumeIndentation() {
-        let indentLength = 0;
-        while (this.hasMore) {
-            const c = this.peekCharCode();
-            if (c === CH_SPACE) {
-                indentLength += 1;
-                this.advance();
-            }
-            else if (c === CH_TAB) {
-                indentLength += 3;
-                this.advance();
-            }
-            else if (c === CH_CR) {
-                // Bare \r (not followed by \n) resets indent to 0,
-                // matching tree-sitter scanner.c behavior (line 140-142)
-                indentLength = 0;
-                this.advance();
-            }
-            else {
-                break;
-            }
-        }
-        return indentLength;
-    }
-    /**
-     * Scan ahead (without advancing) past comment/blank lines to find the indent
-     * of the next line with real (non-comment) content. Returns -1 if only
-     * comments, blanks, or EOF remain. Matches tree-sitter scanner behavior which
-     * skips past comment-only lines when computing INDENT/DEDENT.
-     */
-    peekNextContentIndent() {
-        const startPosition = this.position;
-        const startOffset = this.offset;
-        // Skip past the current comment line
-        while (this.hasMore) {
-            if (this.consumeNewline())
-                break;
-            this.advance();
-        }
-        // Scan subsequent lines
-        while (this.hasMore) {
-            // Measure indent
-            const lineIndent = this.consumeIndentation();
-            // Blank line — skip
-            if (this.consumeNewline())
-                continue;
-            // Comment line — skip
-            const c = this.peekCharCode();
-            if (c === CH_HASH) {
-                while (this.hasMore) {
-                    if (this.consumeNewline())
-                        break;
-                    this.advance();
-                }
-                continue;
-            }
-            this.offset = startOffset;
-            this.row = startPosition.row;
-            this.col = startPosition.column;
-            // Real content — return its indent
-            return lineIndent;
-        }
-        this.offset = startOffset;
-        this.row = startPosition.row;
-        this.col = startPosition.column;
-        return -1;
-    }
-    // --- Utility methods ---
-    peekCharCode(additiveOffset = 0) {
-        return this.source.charCodeAt(this.offset + additiveOffset);
-    }
-    get hasMore() {
-        return this.offset < this.source.length && this.offset >= 0;
-    }
-    /**
-     * Attempt to advance n characters.
-     * @returns how many characters were advanced.
-     */
-    advance(n = 1) {
-        n = Math.max(0, Math.min(n, this.source.length - this.offset));
-        this.col += n;
-        for (let i = 0; i < n; i++) {
-            if (this.peekCharCode(i) === CH_LF) {
-                this.row++;
-                this.col = n - i - 1;
-            }
-        }
-        this.offset += n;
-        return n;
-    }
-    /**
-     * Attempt to consume a newline.
-     * @returns whether a newline was consumed.
-     */
-    consumeNewline() {
-        const newChars = this.atNewline();
-        if (newChars > 0) {
-            invariant(this.advance(newChars));
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Checks if the current position is at a newline.
-     * @param additiveOffset
-     * @returns 0 if not at a newline, 1 if at an LF newline, 2 if at a CR LF newline.
-     */
-    atNewline(additiveOffset = 0) {
-        const firstChar = this.peekCharCode(additiveOffset);
-        if (firstChar === CH_LF)
-            return 1;
-        if (firstChar === CH_CR && this.peekCharCode(additiveOffset + 1) === CH_LF)
-            return 2;
-        return 0;
-    }
-    get position() {
-        return { row: this.row, column: this.col };
-    }
-    emitSpan(kind, length) {
-        const text = this.source.slice(this.offset, this.offset + length);
-        return this.emit(kind, text);
-    }
-    emit(kind, text) {
-        const startPosition = this.position;
-        const startOffset = this.offset;
-        invariant(text === this.source.slice(startOffset, startOffset + text.length), `expected '${text}' but got ${this.source.slice(startOffset, startOffset + text.length)} at offset ${startOffset}`);
-        this.advance(text.length);
-        this.tokens.push(this.makeToken(kind, text, startPosition, this.position, startOffset));
-    }
-    emitVirtual(kind) {
-        return this.emit(kind, '');
-    }
-    makeToken(kind, text, start, end, startOffset) {
-        return { kind, text, start, end, startOffset };
-    }
-}
-//# sourceMappingURL=lexer.js.map

package/vendor/agentscript-parser-javascript/dist/parse-mapping.d.ts

@@ -1,46 +0,0 @@
-import { CSTNode } from './cst-node.js';
-import type { ParserContext } from './parser.js';
-/** Callback type for parseSequence to break circular dependency. */
-export type ParseSequenceFn = (ctx: ParserContext) => CSTNode;
-/**
- * Parse a mapping-or-expression at the top level.
- * If the current position starts a mapping, delegates to parseMapping;
- * otherwise parses an expression (possibly an assignment).
- */
-export declare function parseMappingOrExpression(ctx: ParserContext, parseSequence: ParseSequenceFn): CSTNode | null;
-/**
- * Lookahead to determine if the current position starts a mapping (key-value
- * pairs) rather than an expression.
- *
- * Keys are at most a few tokens (1-3 words, possibly with hyphens/dots), so
- * we only need a small lookahead window. The limit exists as a safety cap —
- * it should never be reached on valid input.
- */
-export declare function isMappingStart(ctx: ParserContext): boolean;
-/**
- * Parse a mapping (sequence of key-value pairs).
- */
-export declare function parseMapping(ctx: ParserContext, parseSequence: ParseSequenceFn): CSTNode;
-/**
- * Parse a single mapping item (statement, template, comment, or key:value element).
- */
-export declare function parseMappingItem(ctx: ParserContext, parseSequence: ParseSequenceFn): CSTNode | null;
-/**
- * Check if the current position starts a colinear mapping element (key: value
- * on same line after "- ").
- */
-export declare function isColinearMappingElement(ctx: ParserContext): boolean;
-/**
- * Parse a colinear mapping element (key: value on the same line as "- ").
- */
-export declare function parseColinearMappingElement(ctx: ParserContext): CSTNode;
-/**
- * Try to parse a colinear value (template, variable declaration, or expression).
- * Returns the parsed value node and optional error prefix, or null if nothing
- * can be parsed.
- */
-export declare function tryParseColinearValue(ctx: ParserContext): {
-    value: CSTNode;
-    errorPrefix?: CSTNode;
-} | null;
-//# sourceMappingURL=parse-mapping.d.ts.map