@prisma-next/psl-parser 0.14.0-dev.5 → 0.14.0-dev.51

package/dist/parse-3-vr14ej.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-3-vr14ej.mjs","names":["#text","#lineStarts","#lineIndexAt","#lineStartAt","#lineEndAt","#stack","#tokenizer","#sourceFile","#builder","#diagnostics","#offset","#depth","#advance"],"sources":["../src/source-file.ts","../src/syntax/green.ts","../src/syntax/green-builder.ts","../src/parse.ts"],"sourcesContent":["const CARRIAGE_RETURN = 13;\nconst LINE_FEED = 10;\n\nexport interface Position {\n  readonly line: number;\n  readonly character: number;\n}\n\nexport interface Range {\n  readonly start: Position;\n  readonly end: Position;\n}\n\nexport class SourceFile {\n  readonly #text: string;\n  readonly #lineStarts: readonly number[];\n\n  constructor(text: string) {\n    this.#text = text;\n    const lineStarts: number[] = [0];\n    for (let offset = 0; offset < text.length; offset++) {\n      if (text.charCodeAt(offset) === LINE_FEED) {\n        lineStarts.push(offset + 1);\n      }\n    }\n    this.#lineStarts = lineStarts;\n  }\n\n  get text(): string {\n    return this.#text;\n  }\n\n  get length(): number {\n    return this.#text.length;\n  }\n\n  get lineCount(): number {\n    return this.#lineStarts.length;\n  }\n\n  lineStartOffsets(): readonly number[] {\n    return this.#lineStarts;\n  }\n\n  lineStartOffset(line: number): number {\n    if (line <= 0) {\n      return 0;\n    }\n    return this.#lineStarts[line] ?? this.#text.length;\n  }\n\n  lineEndOffset(line: number): number {\n    if (line < 0) {\n      return 0;\n    }\n\n    const nextLineStart = this.#lineStarts[line + 1];\n    if (nextLineStart === undefined) {\n      return this.#text.length;\n    }\n\n    const lineFeedOffset = nextLineStart - 1;\n    const carriageReturnOffset = lineFeedOffset - 1;\n    return this.#text.charCodeAt(carriageReturnOffset) === CARRIAGE_RETURN\n      ? carriageReturnOffset\n      : lineFeedOffset;\n  }\n\n  positionAt(offset: number): Position {\n    const clamped = clamp(offset, 0, this.#text.length);\n    const line = this.#lineIndexAt(clamped);\n    return { line, character: clamped - this.#lineStartAt(line) };\n  }\n\n  offsetAt(position: Position): number {\n    const line = clamp(position.line, 0, this.#lineStarts.length - 1);\n    const lineStart = this.#lineStartAt(line);\n    const lineEnd = this.#lineEndAt(line);\n    return clamp(lineStart + position.character, lineStart, lineEnd);\n  }\n\n  #lineStartAt(line: number): number {\n    return this.#lineStarts[line] ?? 0;\n  }\n\n  #lineEndAt(line: number): number {\n    return line + 1 < this.#lineStarts.length ? this.#lineStartAt(line + 1) - 1 : this.#text.length;\n  }\n\n  #lineIndexAt(offset: number): number {\n    const lineStarts = this.#lineStarts;\n    let low = 0;\n    let high = lineStarts.length - 1;\n    while (low < high) {\n      const mid = (low + high + 1) >>> 1;\n      if ((lineStarts[mid] ?? 0) <= offset) {\n        low = mid;\n      } else {\n        high = mid - 1;\n      }\n    }\n    return low;\n  }\n}\n\nfunction clamp(value: number, min: number, max: number): number {\n  if (value < min) {\n    return min;\n  }\n  if (value > max) {\n    return max;\n  }\n  return value;\n}\n","import type { TokenKind } from '../tokenizer';\nimport type { SyntaxKind } from './syntax-kind';\n\nexport interface GreenToken {\n  readonly type: 'token';\n  readonly kind: TokenKind;\n  readonly text: string;\n}\n\nexport interface GreenNode {\n  readonly type: 'node';\n  readonly kind: SyntaxKind;\n  readonly children: ReadonlyArray<GreenElement>;\n  readonly textLength: number;\n}\n\nexport type GreenElement = GreenNode | GreenToken;\n\nexport function greenToken(kind: TokenKind, text: string): GreenToken {\n  return { type: 'token', kind, text };\n}\n\nexport function greenNode(kind: SyntaxKind, children: ReadonlyArray<GreenElement>): GreenNode {\n  let textLength = 0;\n  for (const child of children) {\n    textLength += child.type === 'token' ? child.text.length : child.textLength;\n  }\n  return { type: 'node', kind, children, textLength };\n}\n","import type { TokenKind } from '../tokenizer';\nimport type { GreenElement, GreenNode } from './green';\nimport { greenNode, greenToken } from './green';\nimport type { SyntaxKind } from './syntax-kind';\n\nexport class GreenNodeBuilder {\n  readonly #stack: Array<{ kind: SyntaxKind; children: GreenElement[] }> = [];\n\n  startNode(kind: SyntaxKind): void {\n    this.#stack.push({ kind, children: [] });\n  }\n\n  token(kind: TokenKind, text: string): void {\n    const current = this.#stack.at(-1);\n    if (!current) {\n      throw new Error('GreenNodeBuilder: token() called with no open node');\n    }\n    current.children.push(greenToken(kind, text));\n  }\n\n  finishNode(): GreenNode {\n    const completed = this.#stack.pop();\n    if (!completed) {\n      throw new Error('GreenNodeBuilder: finishNode() called with no open node');\n    }\n    const node = greenNode(completed.kind, completed.children);\n    const parent = this.#stack.at(-1);\n    if (parent) {\n      parent.children.push(node);\n    }\n    return node;\n  }\n}\n","import type { PslDiagnosticCode } from '@prisma-next/framework-components/psl-ast';\nimport { UNSPECIFIED_PSL_NAMESPACE_ID } from '@prisma-next/framework-components/psl-ast';\nimport { type Range, SourceFile } from './source-file';\nimport { DocumentAst } from './syntax/ast/declarations';\nimport type { GreenNode } from './syntax/green';\nimport { GreenNodeBuilder } from './syntax/green-builder';\nimport { createSyntaxTree } from './syntax/red';\nimport type { SyntaxKind } from './syntax/syntax-kind';\nimport { isTerminatedStringLiteral, type Token, Tokenizer, type TokenKind } from './tokenizer';\n\nexport interface ParseDiagnostic {\n  readonly code: PslDiagnosticCode;\n  readonly message: string;\n  readonly range: Range;\n}\n\nexport interface ParseResult {\n  readonly document: DocumentAst;\n  readonly diagnostics: readonly ParseDiagnostic[];\n  readonly sourceFile: SourceFile;\n}\n\nconst TRIVIA_KINDS: ReadonlySet<TokenKind> = new Set<TokenKind>([\n  'Whitespace',\n  'Newline',\n  'Comment',\n]);\n\n/**\n * The source span of a token, captured eagerly so it stays valid after the\n * cursor advances past the token it points at.\n */\nexport interface DiagnosticMark {\n  readonly offset: number;\n  readonly length: number;\n}\n\n/**\n * The fault-tolerant parser substrate the grammars drive. Trivia is flushed\n * into the enclosing open node, so every child node spans exactly its first\n * through last significant token.\n */\nexport class Cursor {\n  readonly #tokenizer: Tokenizer;\n  readonly #sourceFile: SourceFile;\n  readonly #builder = new GreenNodeBuilder();\n  readonly #diagnostics: ParseDiagnostic[] = [];\n  #offset = 0;\n  #depth = 0;\n\n  constructor(source: string) {\n    this.#tokenizer = new Tokenizer(source);\n    this.#sourceFile = new SourceFile(source);\n  }\n\n  get diagnostics(): readonly ParseDiagnostic[] {\n    return this.#diagnostics;\n  }\n\n  get sourceFile(): SourceFile {\n    return this.#sourceFile;\n  }\n\n  peekKind(ahead = 0): TokenKind {\n    return this.peekToken(ahead).kind;\n  }\n\n  peekToken(ahead = 0): Token {\n    let rawIndex = 0;\n    let remaining = ahead;\n    for (;;) {\n      const token = this.#tokenizer.peek(rawIndex);\n      if (token.kind === 'Eof') return token;\n      if (TRIVIA_KINDS.has(token.kind)) {\n        rawIndex++;\n        continue;\n      }\n      if (remaining === 0) return token;\n      remaining--;\n      rawIndex++;\n    }\n  }\n\n  /** Span of the significant token `lookahead` positions ahead (`mark(0)` = the next). */\n  mark(lookahead = 0): DiagnosticMark {\n    let rawIndex = 0;\n    let offset = this.#offset;\n    let remaining = lookahead;\n    for (;;) {\n      const token = this.#tokenizer.peek(rawIndex);\n      if (token.kind === 'Eof') {\n        return { offset, length: token.text.length };\n      }\n      if (!TRIVIA_KINDS.has(token.kind) && remaining === 0) {\n        return { offset, length: token.text.length };\n      }\n      if (!TRIVIA_KINDS.has(token.kind)) {\n        remaining--;\n      }\n      offset += token.text.length;\n      rawIndex++;\n    }\n  }\n\n  /**\n   * Zero-width mark just past the last consumed significant token — anchors an\n   * \"expected here\" diagnostic, e.g. the `{` missing after a declaration's name.\n   */\n  markAfterLastToken(): DiagnosticMark {\n    return { offset: this.#offset, length: 0 };\n  }\n\n  startNode(kind: SyntaxKind): void {\n    if (this.#depth > 0) {\n      this.flushTrivia();\n    }\n    this.#builder.startNode(kind);\n    this.#depth++;\n  }\n\n  finishNode(): GreenNode {\n    this.#depth--;\n    return this.#builder.finishNode();\n  }\n\n  bump(): Token {\n    this.flushTrivia();\n    const token = this.#tokenizer.peek();\n    if (token.kind === 'Eof') return token;\n    this.#builder.token(token.kind, token.text);\n    this.#advance();\n    return token;\n  }\n\n  recoverToSyncPoint(): void {\n    for (;;) {\n      const token = this.#tokenizer.peek();\n      if (token.kind === 'Eof' || token.kind === 'Newline' || token.kind === 'RBrace') {\n        return;\n      }\n      this.#builder.token(token.kind, token.text);\n      this.#advance();\n    }\n  }\n\n  flushTrivia(): void {\n    for (;;) {\n      const token = this.#tokenizer.peek();\n      if (!TRIVIA_KINDS.has(token.kind)) return;\n      this.#builder.token(token.kind, token.text);\n      this.#advance();\n    }\n  }\n\n  diagnostic(code: PslDiagnosticCode, message: string, mark: DiagnosticMark): void {\n    const start = mark.offset;\n    const end = start + mark.length;\n    this.#diagnostics.push({\n      code,\n      message,\n      range: {\n        start: this.#sourceFile.positionAt(start),\n        end: this.#sourceFile.positionAt(end),\n      },\n    });\n  }\n\n  #advance(): void {\n    this.#offset += this.#tokenizer.next().text.length;\n  }\n}\n\nfunction parseIdentifier(cursor: Cursor): void {\n  cursor.startNode('Identifier');\n  cursor.bump();\n  cursor.finishNode();\n}\n\n/**\n * Returns `undefined` when the next significant token does not start a\n * recognised expression, leaving recovery to the caller.\n */\nexport function parseExpression(cursor: Cursor): GreenNode | undefined {\n  return (\n    parseStringLiteralExpr(cursor) ??\n    parseNumberLiteralExpr(cursor) ??\n    parseArrayLiteral(cursor) ??\n    parseObjectLiteralExpr(cursor) ??\n    parseFunctionCall(cursor) ??\n    parseBooleanLiteralExpr(cursor) ??\n    parseIdentifierExpr(cursor)\n  );\n}\n\nexport function parseStringLiteralExpr(cursor: Cursor): GreenNode | undefined {\n  if (cursor.peekKind() !== 'StringLiteral') return undefined;\n  const stringMark = cursor.mark();\n  const text = cursor.peekToken().text;\n  cursor.startNode('StringLiteralExpr');\n  cursor.bump();\n  if (!isTerminatedStringLiteral(text)) {\n    cursor.diagnostic('PSL_UNTERMINATED_STRING', 'Unterminated string literal', stringMark);\n  }\n  return cursor.finishNode();\n}\n\nexport function parseNumberLiteralExpr(cursor: Cursor): GreenNode | undefined {\n  if (cursor.peekKind() !== 'NumberLiteral') return undefined;\n  cursor.startNode('NumberLiteralExpr');\n  cursor.bump();\n  return cursor.finishNode();\n}\n\n/**\n * Parses a namespace-qualified name `[space ':']? Ident ('.' Ident)*`. The\n * caller guarantees a leading `Ident`.\n *\n * Parsing the whole chain up front lets a position decide\n * constructor-vs-reference by peeking exactly one token for `(`, with no scan of\n * the dotted chain's length.\n */\nexport function parseQualifiedName(cursor: Cursor): void {\n  cursor.startNode('QualifiedName');\n  parseIdentifier(cursor); // first segment: the space, namespace, or bare name\n  parseQualifiedSegments(cursor, 'Colon');\n  parseQualifiedSegments(cursor, 'Dot');\n  cursor.finishNode();\n}\n\n/**\n * A well-formed name carries at most one colon space and one dot namespace, so\n * each separator past the first of its kind reports `PSL_INVALID_QUALIFIED_NAME`.\n * The separator is consumed regardless, keeping the lossless round-trip intact.\n */\nfunction parseQualifiedSegments(cursor: Cursor, separator: 'Colon' | 'Dot'): void {\n  let seen = 0;\n  while (cursor.peekKind() === separator) {\n    seen++;\n    const separatorMark = cursor.mark();\n    cursor.bump();\n    if (seen > 1) {\n      cursor.diagnostic(\n        'PSL_INVALID_QUALIFIED_NAME',\n        'Qualified name has too many segments',\n        separatorMark,\n      );\n    }\n    if (cursor.peekKind() === 'Ident') {\n      parseIdentifier(cursor);\n    } else {\n      cursor.diagnostic(\n        'PSL_INVALID_QUALIFIED_NAME',\n        'Qualified name is missing a name after the separator',\n        cursor.mark(),\n      );\n    }\n  }\n}\n\n// Ordering among the `Ident`-leading alternatives is load-bearing: the\n// `LParen`/`Dot` lookahead of `parseCall` must win before the boolean check, so\n// `true(` stays a function call named `true` rather than a boolean literal.\nexport function parseBooleanLiteralExpr(cursor: Cursor): GreenNode | undefined {\n  if (cursor.peekKind() !== 'Ident') return undefined;\n  const text = cursor.peekToken().text;\n  if (text !== 'true' && text !== 'false') return undefined;\n  cursor.startNode('BooleanLiteralExpr');\n  cursor.bump();\n  return cursor.finishNode();\n}\n\nexport function parseIdentifierExpr(cursor: Cursor): GreenNode | undefined {\n  if (cursor.peekKind() !== 'Ident') return undefined;\n  cursor.startNode('Identifier');\n  cursor.bump();\n  return cursor.finishNode();\n}\n\nexport function parseArrayLiteral(cursor: Cursor): GreenNode | undefined {\n  if (cursor.peekKind() !== 'LBracket') return undefined;\n  cursor.startNode('ArrayLiteral');\n  cursor.bump();\n  while (cursor.peekKind() !== 'RBracket' && cursor.peekKind() !== 'Eof') {\n    const element = parseExpression(cursor);\n    if (!element) break;\n    if (cursor.peekKind() === 'Comma') {\n      cursor.bump();\n    } else {\n      break;\n    }\n  }\n  if (cursor.peekKind() === 'RBracket') {\n    cursor.bump();\n  }\n  return cursor.finishNode();\n}\n\nexport function parseObjectLiteralExpr(cursor: Cursor): GreenNode | undefined {\n  if (cursor.peekKind() !== 'LBrace') return undefined;\n  const braceMark = cursor.mark();\n  cursor.startNode('ObjectLiteralExpr');\n  cursor.bump();\n  while (cursor.peekKind() !== 'RBrace' && cursor.peekKind() !== 'Eof') {\n    parseObjectField(cursor);\n    if (cursor.peekKind() === 'Comma') {\n      cursor.bump();\n    } else if (cursor.peekKind() === 'Ident') {\n      // A following identifier key with no comma re-enters the loop; the next\n      // parseObjectField consumes ≥1 token, so progress is guaranteed.\n      cursor.diagnostic(\n        'PSL_INVALID_OBJECT_LITERAL',\n        'Expected \",\" between object-literal fields',\n        cursor.markAfterLastToken(),\n      );\n    } else {\n      break;\n    }\n  }\n  if (cursor.peekKind() === 'RBrace') {\n    cursor.bump();\n  } else {\n    cursor.diagnostic('PSL_INVALID_OBJECT_LITERAL', 'Unterminated object literal', braceMark);\n  }\n  return cursor.finishNode();\n}\n\nexport function parseObjectField(cursor: Cursor): GreenNode {\n  cursor.startNode('ObjectField');\n  const keyMark = cursor.mark();\n  const keyText = cursor.peekToken().text;\n  if (cursor.peekKind() === 'Ident') {\n    parseIdentifier(cursor);\n  } else if (cursor.peekKind() === 'StringLiteral') {\n    // A string-literal key (e.g. `{ \"length\": 35 }`) is accepted; its logical\n    // name is the unquoted string.\n    parseStringLiteralExpr(cursor);\n  }\n  if (cursor.peekKind() === 'Colon') {\n    cursor.bump(); // Colon\n    const value = parseExpression(cursor);\n    if (!value) {\n      cursor.diagnostic('PSL_INVALID_OBJECT_LITERAL', 'Expected a value after \":\"', cursor.mark());\n    }\n  } else {\n    cursor.diagnostic('PSL_INVALID_OBJECT_LITERAL', `Expected \":\" after \"${keyText}\"`, keyMark);\n    const followsWithKey = cursor.peekKind() === 'Ident' && cursor.peekKind(1) === 'Colon';\n    if (!followsWithKey) {\n      parseExpression(cursor); // best-effort: consume a value if one follows\n    }\n  }\n  return cursor.finishNode();\n}\n\n/**\n * Whether the next tokens open a call: a bare `Ident(` or a namespace-qualified\n * `Ident.Ident(`. The lookahead is deliberately bounded so a bare dotted\n * reference like `a.b` is not mistaken for a call, rather than scanning an\n * unbounded dotted chain ahead to find the paren.\n */\nfunction isCallAhead(cursor: Cursor): boolean {\n  if (cursor.peekKind() !== 'Ident') return false;\n  if (cursor.peekKind(1) === 'LParen') return true;\n  return (\n    cursor.peekKind(1) === 'Dot' &&\n    cursor.peekKind(2) === 'Ident' &&\n    cursor.peekKind(3) === 'LParen'\n  );\n}\n\n/**\n * Parses a function/constructor call — bare `autoincrement()` or qualified\n * `temporal.updatedAt()`. Returns `undefined` unless {@link isCallAhead}\n * confirms a trailing `(`, so the `parseExpression` chain falls through to the\n * boolean and bare-identifier forms.\n */\nexport function parseFunctionCall(cursor: Cursor): GreenNode | undefined {\n  if (!isCallAhead(cursor)) return undefined;\n  cursor.startNode('FunctionCall');\n  parseQualifiedName(cursor);\n  if (cursor.peekKind() === 'LParen') {\n    parseParenArgs(cursor);\n  }\n  return cursor.finishNode();\n}\n\n/** Parses a parenthesised, comma-separated `AttributeArg` list into the currently open node. */\nfunction parseParenArgs(cursor: Cursor): void {\n  cursor.bump();\n  while (cursor.peekKind() !== 'RParen' && cursor.peekKind() !== 'Eof') {\n    parseAttributeArg(cursor);\n    if (cursor.peekKind() === 'Comma') {\n      cursor.bump();\n    } else {\n      break;\n    }\n  }\n  if (cursor.peekKind() === 'RParen') {\n    cursor.bump();\n  }\n}\n\nexport function parseAttributeArg(cursor: Cursor): void {\n  const kind = cursor.peekKind();\n  if (\n    kind !== 'Ident' &&\n    kind !== 'StringLiteral' &&\n    kind !== 'NumberLiteral' &&\n    kind !== 'LBracket' &&\n    kind !== 'LBrace'\n  ) {\n    return;\n  }\n  cursor.startNode('AttributeArg');\n  if (cursor.peekKind() === 'Ident' && cursor.peekKind(1) === 'Colon') {\n    parseIdentifier(cursor);\n    cursor.bump();\n  }\n  parseArgValue(cursor);\n  cursor.finishNode();\n}\n\nfunction parseArgValue(cursor: Cursor): void {\n  parseExpression(cursor);\n}\n\nexport function parseAttributeArgList(cursor: Cursor): GreenNode {\n  cursor.startNode('AttributeArgList');\n  parseParenArgs(cursor);\n  return cursor.finishNode();\n}\n\nexport function parseAttribute(cursor: Cursor): GreenNode {\n  const isBlockAttribute = cursor.peekKind() === 'DoubleAt';\n  const attributeMark = cursor.mark();\n  cursor.startNode(isBlockAttribute ? 'ModelAttribute' : 'FieldAttribute');\n  cursor.bump();\n  if (cursor.peekKind() === 'Ident') {\n    parseQualifiedName(cursor);\n  } else {\n    cursor.diagnostic('PSL_INVALID_ATTRIBUTE_SYNTAX', 'Attribute name expected', attributeMark);\n  }\n  if (cursor.peekKind() === 'LParen') {\n    parseAttributeArgList(cursor);\n  }\n  return cursor.finishNode();\n}\n\n/**\n * A type annotation: `QualifiedName (argList)? ([])? (?)?`, e.g.\n * `pgvector.Vector(1536)[]?`. When the field has no type, no node is emitted —\n * a missing type is the absence of a `TypeAnnotation`, not a zero-width one.\n */\nexport function parseTypeAnnotation(cursor: Cursor): void {\n  const kind = cursor.peekKind();\n  if (kind !== 'Ident' && kind !== 'LBracket' && kind !== 'Question') {\n    return;\n  }\n  cursor.startNode('TypeAnnotation');\n  if (cursor.peekKind() === 'Ident') {\n    parseQualifiedName(cursor);\n    if (cursor.peekKind() === 'LParen') {\n      parseAttributeArgList(cursor);\n    }\n  }\n  if (cursor.peekKind() === 'LBracket') {\n    cursor.bump();\n    if (cursor.peekKind() === 'RBracket') {\n      cursor.bump();\n    }\n  }\n  if (cursor.peekKind() === 'Question') {\n    cursor.bump();\n  }\n  cursor.finishNode();\n}\n\ntype MemberParser = (cursor: Cursor) => void;\n\n/**\n * Parses a full PSL document. Never throws — malformed input yields diagnostics\n * and a recovered tree, not an exception.\n */\nexport function parse(source: string): ParseResult {\n  const cursor = new Cursor(source);\n  const green = parseDocument(cursor);\n  const root = createSyntaxTree(green);\n  const document = DocumentAst.cast(root) ?? new DocumentAst(root);\n  return { document, diagnostics: cursor.diagnostics, sourceFile: cursor.sourceFile };\n}\n\nfunction parseDocument(cursor: Cursor): GreenNode {\n  cursor.startNode('Document');\n  while (cursor.peekKind() !== 'Eof') {\n    parseDeclaration(cursor, false);\n  }\n  cursor.flushTrivia(); // attach trailing trivia so the round-trip stays lossless\n  return cursor.finishNode();\n}\n\nconst RESERVED_BLOCK_KEYWORDS: ReadonlySet<string> = new Set([\n  'model',\n  'namespace',\n  'type',\n  'types',\n]);\n\nfunction keywordIs(cursor: Cursor, keyword: string): boolean {\n  return cursor.peekKind() === 'Ident' && cursor.peekToken().text === keyword;\n}\n\n/**\n * Each alternative is a no-op on non-match, consuming nothing, so the\n * forward-only cursor is never left half-consumed by a rejected alternative.\n * Recovery runs via the `if (!node)` tail rather than as a `??` arm, because it\n * appends raw tokens to the open parent instead of returning a child node.\n */\nfunction parseDeclaration(cursor: Cursor, insideNamespace: boolean): void {\n  const name = cursor.peekKind(1) === 'Ident' ? cursor.peekToken(1).text : '';\n  if (insideNamespace && keywordIs(cursor, 'namespace')) {\n    cursor.diagnostic(\n      'PSL_INVALID_NAMESPACE_BLOCK',\n      `Recursive \"namespace ${name}\" block is not allowed; namespace blocks may not nest`,\n      cursor.mark(),\n    );\n  } else if (insideNamespace && keywordIs(cursor, 'types')) {\n    cursor.diagnostic(\n      'PSL_INVALID_NAMESPACE_BLOCK',\n      '`types` blocks must be declared at the document top level, not inside a namespace block',\n      cursor.mark(),\n    );\n  } else if (keywordIs(cursor, 'namespace') && name === UNSPECIFIED_PSL_NAMESPACE_ID) {\n    cursor.diagnostic(\n      'PSL_INVALID_NAMESPACE_BLOCK',\n      `Namespace name \"${UNSPECIFIED_PSL_NAMESPACE_ID}\" is reserved for the parser-synthesised bucket for top-level declarations`,\n      cursor.mark(1),\n    );\n  }\n\n  const node =\n    parseModel(cursor) ??\n    parseNamespace(cursor) ??\n    parseCompositeType(cursor) ??\n    parseTypesBlock(cursor) ??\n    parseGenericBlock(cursor);\n  if (!node) {\n    parseUnsupportedTopLevel(cursor);\n  }\n}\n\n/**\n * Reports only the first missing piece — a missing name suppresses the\n * missing-brace diagnostic. `nameRequired` is false only for the `types` block.\n */\nfunction parseBlock(\n  cursor: Cursor,\n  kind: SyntaxKind,\n  nameRequired: boolean,\n  parseMember: MemberParser,\n): GreenNode {\n  const keyword = cursor.peekToken().text;\n  const keywordMark = cursor.mark();\n  cursor.startNode(kind);\n  cursor.bump();\n  const hasName = nameRequired && cursor.peekKind() === 'Ident';\n  if (hasName) {\n    parseIdentifier(cursor);\n  }\n  if (nameRequired && !hasName) {\n    cursor.diagnostic('PSL_INVALID_DECLARATION', `Expected a name after \"${keyword}\"`, keywordMark);\n  } else if (cursor.peekKind() !== 'LBrace') {\n    cursor.diagnostic(\n      'PSL_INVALID_DECLARATION',\n      `Expected \"{\" to open the \"${keyword}\" block`,\n      cursor.markAfterLastToken(),\n    );\n  }\n  if (cursor.peekKind() === 'LBrace') {\n    parseBlockBody(cursor, parseMember);\n  } else {\n    cursor.recoverToSyncPoint();\n  }\n  return cursor.finishNode();\n}\n\nexport function parseModel(cursor: Cursor): GreenNode | undefined {\n  if (!keywordIs(cursor, 'model')) return undefined;\n  return parseBlock(cursor, 'ModelDeclaration', true, parseModelMember);\n}\n\n/**\n * Excluding the reserved keywords keeps a malformed reserved block (e.g. `model\n * {` with no name) routed to its dedicated parser. The generic keyword set is\n * open, so a bare identifier with no brace (e.g. `oops`) is read as an unfinished\n * custom declaration rather than unsupported content.\n */\nexport function parseGenericBlock(cursor: Cursor): GreenNode | undefined {\n  if (cursor.peekKind() !== 'Ident') return undefined;\n  const keyword = cursor.peekToken().text;\n  if (RESERVED_BLOCK_KEYWORDS.has(keyword)) return undefined;\n  const hasName = cursor.peekKind(1) === 'Ident' && cursor.peekKind(2) === 'LBrace';\n  cursor.startNode('GenericBlockDeclaration');\n  cursor.bump();\n  if (hasName) {\n    parseIdentifier(cursor);\n  }\n  if (cursor.peekKind() === 'LBrace') {\n    parseBlockBody(cursor, parseKeyValueMember);\n  } else {\n    cursor.diagnostic(\n      'PSL_INVALID_DECLARATION',\n      `Expected \"{\" to open the \"${keyword}\" block`,\n      cursor.markAfterLastToken(),\n    );\n    cursor.recoverToSyncPoint();\n  }\n  return cursor.finishNode();\n}\n\nexport function parseNamespace(cursor: Cursor): GreenNode | undefined {\n  if (!keywordIs(cursor, 'namespace')) return undefined;\n  return parseBlock(cursor, 'Namespace', true, (inner) => parseDeclaration(inner, true));\n}\n\nexport function parseCompositeType(cursor: Cursor): GreenNode | undefined {\n  if (!keywordIs(cursor, 'type')) return undefined;\n  return parseBlock(cursor, 'CompositeTypeDeclaration', true, parseModelMember);\n}\n\n/** `types` (plural) is the no-name types block; the singular `type` is the composite type above. */\nexport function parseTypesBlock(cursor: Cursor): GreenNode | undefined {\n  if (!keywordIs(cursor, 'types')) return undefined;\n  return parseBlock(cursor, 'TypesBlock', false, parseNamedTypeMember);\n}\n\n/** Every `parseMember` consumes at least one significant token, so the loop always terminates. */\nfunction parseBlockBody(cursor: Cursor, parseMember: MemberParser): void {\n  const braceMark = cursor.mark();\n  cursor.bump();\n  for (;;) {\n    const kind = cursor.peekKind();\n    if (kind === 'RBrace' || kind === 'Eof') break;\n    parseMember(cursor);\n  }\n  if (cursor.peekKind() === 'RBrace') {\n    cursor.bump();\n  } else {\n    cursor.diagnostic('PSL_UNTERMINATED_BLOCK', 'Unterminated block declaration', braceMark);\n  }\n}\n\nfunction parseUnsupportedTopLevel(cursor: Cursor): void {\n  const offending = cursor.peekToken().text;\n  const message =\n    cursor.peekKind(1) === 'LBrace'\n      ? `Unsupported top-level block \"${offending}\"`\n      : `Unsupported top-level declaration \"${offending}\"`;\n  cursor.diagnostic('PSL_UNSUPPORTED_TOP_LEVEL_BLOCK', message, cursor.mark());\n  cursor.bump();\n  cursor.recoverToSyncPoint();\n}\n\n/**\n * Matches a leading `@@` block attribute, a no-op otherwise. Single-`@`\n * attributes belong to fields and are parsed inside `parseField`.\n */\nexport function parseBlockAttribute(cursor: Cursor): GreenNode | undefined {\n  if (cursor.peekKind() !== 'DoubleAt') return undefined;\n  return parseAttribute(cursor);\n}\n\nfunction parseModelMember(cursor: Cursor): void {\n  const node = parseBlockAttribute(cursor) ?? parseField(cursor);\n  if (!node) {\n    invalidMember(\n      cursor,\n      'PSL_INVALID_MODEL_MEMBER',\n      `Invalid model member declaration \"${cursor.peekToken().text}\"`,\n    );\n  }\n}\n\nfunction parseNamedTypeMember(cursor: Cursor): void {\n  const node = parseNamedType(cursor);\n  if (!node) {\n    invalidMember(\n      cursor,\n      'PSL_INVALID_TYPES_MEMBER',\n      `Invalid types declaration \"${cursor.peekToken().text}\"`,\n    );\n  }\n}\n\n/**\n * A generic-block member is either a `@@`-block attribute or a `key = value`\n * entry. The block-attribute alternative is purely syntactic — it does not judge\n * whether the attribute is valid for the block's kind.\n */\nfunction parseKeyValueMember(cursor: Cursor): void {\n  const node = parseBlockAttribute(cursor) ?? parseKeyValue(cursor);\n  if (!node) {\n    invalidMember(cursor, 'PSL_INVALID_EXTENSION_BLOCK_MEMBER', 'Invalid block entry');\n  }\n}\n\nfunction invalidMember(cursor: Cursor, code: PslDiagnosticCode, message: string): void {\n  cursor.diagnostic(code, message, cursor.mark());\n  cursor.bump(); // consume the offending token so the member loop makes progress\n  cursor.recoverToSyncPoint();\n}\n\nexport function parseField(cursor: Cursor): GreenNode | undefined {\n  if (cursor.peekKind() !== 'Ident') return undefined;\n  cursor.startNode('FieldDeclaration');\n  const nameMark = cursor.mark();\n  const nameText = cursor.peekToken().text;\n  parseIdentifier(cursor);\n  if (cursor.peekKind() !== 'Ident') {\n    cursor.diagnostic(\n      'PSL_INVALID_MODEL_MEMBER',\n      `Expected a type after field \"${nameText}\"`,\n      nameMark,\n    );\n  }\n  parseTypeAnnotation(cursor);\n  while (cursor.peekKind() === 'At') {\n    parseAttribute(cursor);\n  }\n  return cursor.finishNode();\n}\n\nexport function parseNamedType(cursor: Cursor): GreenNode | undefined {\n  if (cursor.peekKind() !== 'Ident') return undefined;\n  cursor.startNode('NamedTypeDeclaration');\n  const nameMark = cursor.mark();\n  const nameText = cursor.peekToken().text;\n  parseIdentifier(cursor);\n  if (cursor.peekKind() === 'Equals') {\n    cursor.bump();\n  } else {\n    cursor.diagnostic('PSL_INVALID_TYPES_MEMBER', `Expected \"=\" after \"${nameText}\"`, nameMark);\n  }\n  parseTypeAnnotation(cursor);\n  while (cursor.peekKind() === 'At') {\n    parseAttribute(cursor);\n  }\n  return cursor.finishNode();\n}\n\n/**\n * A generic-block entry is either `key = value` or a bare `key` (committing a\n * `KeyValuePair` carrying only the key). A `key =` with no following expression\n * is flagged.\n */\nexport function parseKeyValue(cursor: Cursor): GreenNode | undefined {\n  if (cursor.peekKind() !== 'Ident') return undefined;\n  cursor.startNode('KeyValuePair');\n  parseIdentifier(cursor);\n  if (cursor.peekKind() === 'Equals') {\n    cursor.bump();\n    if (!parseExpression(cursor)) {\n      cursor.diagnostic(\n        'PSL_INVALID_EXTENSION_BLOCK_MEMBER',\n        'Expected a value after \"=\"',\n        cursor.mark(),\n      );\n    }\n  }\n  return cursor.finishNode();\n}\n"],"mappings":"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"}

package/dist/{parse-BjZ1LPe6.d.mts → parse-BazJr7Ye.d.mts}

@@ -17,6 +17,8 @@ declare class SourceFile {
   get length(): number;
   get lineCount(): number;
   lineStartOffsets(): readonly number[];
+  lineStartOffset(line: number): number;
+  lineEndOffset(line: number): number;
   positionAt(offset: number): Position;
   offsetAt(position: Position): number;
 }
@@ -43,29 +45,89 @@ declare function greenNode(kind: SyntaxKind, children: ReadonlyArray<GreenElemen
 //#region src/syntax/red.d.ts
 /**
  * A token in the red tree. Unlike the green-layer {@link Token} (kind + text
- * only), a red token also carries its absolute `offset` within the source,
- * computed lazily as the tree is walked.
+ * only), a red token also carries its absolute `offset` within the source and a
+ * link back to its `parent` {@link SyntaxNode}, so a cursor anchored on a token
+ * can walk outward (parent, previous/next token, siblings) without re-scanning
+ * from the document root.
  */
-interface SyntaxToken extends Token {
+declare class SyntaxToken implements Token {
+  readonly green: GreenToken;
+  readonly kind: TokenKind;
+  readonly text: string;
   readonly offset: number;
+  readonly parent: SyntaxNode;
+  /** Position within the parent's children, enabling O(1) sibling navigation without rescanning the green layer. */
+  readonly index: number;
+  constructor(green: GreenToken, offset: number, parent: SyntaxNode, index: number);
+  get textLength(): number;
+  get endOffset(): number;
+  /** Whether `offset` falls within this token, inclusive of both ends. */
+  isInside(offset: number): boolean;
+  isOutside(offset: number): boolean;
+  /** The sibling element immediately after this token within its parent. */
+  get nextSiblingOrToken(): SyntaxElement | undefined;
+  /** The sibling element immediately before this token within its parent. */
+  get prevSiblingOrToken(): SyntaxElement | undefined;
+  /** The next token in document order, crossing node boundaries. */
+  get nextToken(): SyntaxToken | undefined;
+  /** The previous token in document order, crossing node boundaries. */
+  get prevToken(): SyntaxToken | undefined;
 }
 type SyntaxElement = SyntaxNode | SyntaxToken;
+declare class TokenAtOffset {
+  #private;
+  private constructor();
+  static none(): TokenAtOffset;
+  static single(token: SyntaxToken): TokenAtOffset;
+  static between(left: SyntaxToken, right: SyntaxToken): TokenAtOffset;
+  get isEmpty(): boolean;
+  get isBetween(): boolean;
+  leftBiased(): SyntaxToken | undefined;
+  rightBiased(): SyntaxToken | undefined;
+}
 declare class SyntaxNode {
   readonly green: GreenNode;
   readonly offset: number;
   readonly parent: SyntaxNode | undefined;
-  constructor(green: GreenNode, offset: number, parent: SyntaxNode | undefined);
+  /** Position within the parent's children, enabling O(1) sibling navigation without rescanning the green layer. */
+  readonly index: number;
+  constructor(green: GreenNode, offset: number, parent: SyntaxNode | undefined, index: number);
   get kind(): SyntaxKind;
   get textLength(): number;
+  get endOffset(): number;
+  /** Whether `offset` falls within this node, inclusive of both ends. */
+  isInside(offset: number): boolean;
+  isOutside(offset: number): boolean;
   get firstChild(): SyntaxElement | undefined;
   get lastChild(): SyntaxElement | undefined;
   get nextSibling(): SyntaxElement | undefined;
   get prevSibling(): SyntaxElement | undefined;
+  /** The sibling element immediately after this node within its parent. */
+  get nextSiblingOrToken(): SyntaxElement | undefined;
+  /** The sibling element immediately before this node within its parent. */
+  get prevSiblingOrToken(): SyntaxElement | undefined;
+  /** The first token in this subtree (depth-first), or `undefined` if empty. */
+  get firstToken(): SyntaxToken | undefined;
+  /** The last token in this subtree (depth-first), or `undefined` if empty. */
+  get lastToken(): SyntaxToken | undefined;
   children(): Iterable<SyntaxElement>;
   childNodes(): Iterable<SyntaxNode>;
   ancestors(): Iterable<SyntaxNode>;
+  /** The nearest match, testing this node itself before walking its ancestors. */
+  findAncestor<T>(cast: (node: SyntaxNode) => T | undefined): T | undefined;
   descendants(): Iterable<SyntaxElement>;
   tokens(): Iterable<SyntaxToken>;
+  /**
+   * The token(s) at `offset`. The between-two-tokens case (offset exactly on a
+   * token seam) is represented explicitly so callers can left/right bias.
+   */
+  tokenAtOffset(offset: number): TokenAtOffset;
+  /**
+   * The smallest element fully containing the range `[start, end]`. At a seam
+   * (and for empty ranges) the left-hand element is preferred, matching
+   * {@link containsOffset}'s inclusive span.
+   */
+  coveringElement(start: number, end: number): SyntaxElement;
 }
 declare function createSyntaxTree(green: GreenNode): SyntaxNode;
 //#endregion
@@ -73,9 +135,15 @@ declare function createSyntaxTree(green: GreenNode): SyntaxNode;
 interface AstNode {
   readonly syntax: SyntaxNode;
 }
-declare function findChildToken(node: SyntaxNode, kind: TokenKind): Token | undefined;
+interface BracedBlock extends AstNode {
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
+}
+declare function findChildToken(node: SyntaxNode, kind: TokenKind): SyntaxToken | undefined;
 declare function findFirstChild<T>(node: SyntaxNode, cast: (node: SyntaxNode) => T | undefined): T | undefined;
 declare function filterChildren<T>(node: SyntaxNode, cast: (node: SyntaxNode) => T | undefined): Iterable<T>;
+type CastTarget<C> = C extends ((node: SyntaxNode) => infer R) ? Exclude<R, undefined> : never;
+declare function any<Casts extends readonly ((node: SyntaxNode) => unknown)[]>(...casts: Casts): (node: SyntaxNode) => CastTarget<Casts[number]> | undefined;
 /**
  * Raw source text of a CST node, verbatim (quotes and brackets preserved). For
  * the decoded value of a string literal, decode it instead.
@@ -86,7 +154,7 @@ declare function printSyntax(node: SyntaxNode): string;
 declare class IdentifierAst implements AstNode {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  token(): Token | undefined;
+  token(): SyntaxToken | undefined;
   name(): string | undefined;
   static cast(node: SyntaxNode): IdentifierAst | undefined;
 }
@@ -97,8 +165,8 @@ declare class QualifiedNameAst implements AstNode {
   #private;
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  colon(): Token | undefined;
-  dot(): Token | undefined;
+  colon(): SyntaxToken | undefined;
+  dot(): SyntaxToken | undefined;
   space(): IdentifierAst | undefined;
   namespace(): IdentifierAst | undefined;
   identifier(): IdentifierAst | undefined;
@@ -107,6 +175,8 @@ declare class QualifiedNameAst implements AstNode {
    * `['Vector']`; a qualified `pgvector.Vector` yields `['pgvector', 'Vector']`.
    */
   path(): readonly string[];
+  /** True iff this is a single unqualified identifier whose text equals `name`. */
+  isSimpleName(name: string): boolean;
   /**
    * Flags a malformed name with more qualifier segments than allowed (a second
    * `:`-space or a second `.`-namespace).
@@ -127,45 +197,45 @@ declare class FunctionCallAst implements AstNode {
    * `['pgvector', 'Vector']`. Empty when the call carries no identifier.
    */
   path(): readonly string[];
-  lparen(): Token | undefined;
-  rparen(): Token | undefined;
+  lparen(): SyntaxToken | undefined;
+  rparen(): SyntaxToken | undefined;
   args(): Iterable<AttributeArgAst>;
   static cast(node: SyntaxNode): FunctionCallAst | undefined;
 }
 declare class ArrayLiteralAst implements AstNode {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  lbracket(): Token | undefined;
-  rbracket(): Token | undefined;
+  lbracket(): SyntaxToken | undefined;
+  rbracket(): SyntaxToken | undefined;
   elements(): Iterable<ExpressionAst>;
   static cast(node: SyntaxNode): ArrayLiteralAst | undefined;
 }
 declare class StringLiteralExprAst implements AstNode {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  token(): Token | undefined;
+  token(): SyntaxToken | undefined;
   value(): string | undefined;
   static cast(node: SyntaxNode): StringLiteralExprAst | undefined;
 }
 declare class NumberLiteralExprAst implements AstNode {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  token(): Token | undefined;
+  token(): SyntaxToken | undefined;
   value(): number | undefined;
   static cast(node: SyntaxNode): NumberLiteralExprAst | undefined;
 }
 declare class BooleanLiteralExprAst implements AstNode {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  token(): Token | undefined;
+  token(): SyntaxToken | undefined;
   value(): boolean | undefined;
   static cast(node: SyntaxNode): BooleanLiteralExprAst | undefined;
 }
 declare class ObjectLiteralExprAst implements AstNode {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  lbrace(): Token | undefined;
-  rbrace(): Token | undefined;
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
   fields(): Iterable<ObjectFieldAst>;
   static cast(node: SyntaxNode): ObjectLiteralExprAst | undefined;
 }
@@ -179,7 +249,7 @@ declare class ObjectFieldAst implements AstNode {
    * `undefined` when the field carries no key node.
    */
   keyName(): string | undefined;
-  colon(): Token | undefined;
+  colon(): SyntaxToken | undefined;
   value(): ExpressionAst | undefined;
   static cast(node: SyntaxNode): ObjectFieldAst | undefined;
 }
@@ -189,7 +259,7 @@ declare class AttributeArgAst implements AstNode {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
   name(): IdentifierAst | undefined;
-  colon(): Token | undefined;
+  colon(): SyntaxToken | undefined;
   value(): ExpressionAst | undefined;
   static cast(node: SyntaxNode): AttributeArgAst | undefined;
 }
@@ -198,15 +268,15 @@ declare class AttributeArgAst implements AstNode {
 declare class AttributeArgListAst implements AstNode {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  lparen(): Token | undefined;
-  rparen(): Token | undefined;
+  lparen(): SyntaxToken | undefined;
+  rparen(): SyntaxToken | undefined;
   args(): Iterable<AttributeArgAst>;
   static cast(node: SyntaxNode): AttributeArgListAst | undefined;
 }
 declare class FieldAttributeAst implements AstNode {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  at(): Token | undefined;
+  at(): SyntaxToken | undefined;
   name(): QualifiedNameAst | undefined;
   argList(): AttributeArgListAst | undefined;
   static cast(node: SyntaxNode): FieldAttributeAst | undefined;
@@ -214,7 +284,7 @@ declare class FieldAttributeAst implements AstNode {
 declare class ModelAttributeAst implements AstNode {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  doubleAt(): Token | undefined;
+  doubleAt(): SyntaxToken | undefined;
   name(): QualifiedNameAst | undefined;
   argList(): AttributeArgListAst | undefined;
   static cast(node: SyntaxNode): ModelAttributeAst | undefined;
@@ -229,9 +299,9 @@ declare class TypeAnnotationAst implements AstNode {
   /** Present when the annotation is a constructor (`Vector(1536)`) rather than a plain reference. */
   argList(): AttributeArgListAst | undefined;
   isConstructor(): boolean;
-  lbracket(): Token | undefined;
-  rbracket(): Token | undefined;
-  questionMark(): Token | undefined;
+  lbracket(): SyntaxToken | undefined;
+  rbracket(): SyntaxToken | undefined;
+  questionMark(): SyntaxToken | undefined;
   isList(): boolean;
   isOptional(): boolean;
   static cast(node: SyntaxNode): TypeAnnotationAst | undefined;
@@ -244,69 +314,76 @@ declare class TypeAnnotationAst implements AstNode {
  * blocks are document-only, so they are not namespace members.
  */
 type NamespaceMemberAst = ModelDeclarationAst | CompositeTypeDeclarationAst | GenericBlockDeclarationAst;
+type DeclarationAst = NamespaceMemberAst | TypesBlockAst | NamespaceDeclarationAst;
+type AttributeAst = FieldAttributeAst | ModelAttributeAst;
+type BlockMemberAst = FieldDeclarationAst | ModelAttributeAst;
+type GenericBlockMemberAst = KeyValuePairAst | ModelAttributeAst;
 declare class DocumentAst implements AstNode {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  declarations(): Iterable<NamespaceMemberAst | TypesBlockAst | NamespaceDeclarationAst>;
+  declarations(): Iterable<DeclarationAst>;
   static cast(node: SyntaxNode): DocumentAst | undefined;
 }
-declare class ModelDeclarationAst implements AstNode {
+declare class ModelDeclarationAst implements BracedBlock {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  keyword(): Token | undefined;
+  keyword(): SyntaxToken | undefined;
   name(): IdentifierAst | undefined;
-  lbrace(): Token | undefined;
-  rbrace(): Token | undefined;
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
   fields(): Iterable<FieldDeclarationAst>;
   attributes(): Iterable<ModelAttributeAst>;
+  members(): Iterable<BlockMemberAst>;
   static cast(node: SyntaxNode): ModelDeclarationAst | undefined;
 }
-declare class CompositeTypeDeclarationAst implements AstNode {
+declare class CompositeTypeDeclarationAst implements BracedBlock {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  keyword(): Token | undefined;
+  keyword(): SyntaxToken | undefined;
   name(): IdentifierAst | undefined;
-  lbrace(): Token | undefined;
-  rbrace(): Token | undefined;
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
   fields(): Iterable<FieldDeclarationAst>;
   attributes(): Iterable<ModelAttributeAst>;
+  members(): Iterable<BlockMemberAst>;
   static cast(node: SyntaxNode): CompositeTypeDeclarationAst | undefined;
 }
-declare class NamespaceDeclarationAst implements AstNode {
+declare class NamespaceDeclarationAst implements BracedBlock {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  keyword(): Token | undefined;
+  keyword(): SyntaxToken | undefined;
   name(): IdentifierAst | undefined;
-  lbrace(): Token | undefined;
-  rbrace(): Token | undefined;
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
   declarations(): Iterable<NamespaceMemberAst>;
   static cast(node: SyntaxNode): NamespaceDeclarationAst | undefined;
 }
-declare class TypesBlockAst implements AstNode {
+declare class TypesBlockAst implements BracedBlock {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  keyword(): Token | undefined;
-  lbrace(): Token | undefined;
-  rbrace(): Token | undefined;
+  keyword(): SyntaxToken | undefined;
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
   declarations(): Iterable<NamedTypeDeclarationAst>;
   static cast(node: SyntaxNode): TypesBlockAst | undefined;
 }
-declare class GenericBlockDeclarationAst implements AstNode {
+declare class GenericBlockDeclarationAst implements BracedBlock {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
-  keyword(): Token | undefined;
+  keyword(): SyntaxToken | undefined;
   name(): IdentifierAst | undefined;
-  lbrace(): Token | undefined;
-  rbrace(): Token | undefined;
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
   entries(): Iterable<KeyValuePairAst>;
   attributes(): Iterable<ModelAttributeAst>;
+  members(): Iterable<GenericBlockMemberAst>;
   static cast(node: SyntaxNode): GenericBlockDeclarationAst | undefined;
 }
 declare class KeyValuePairAst implements AstNode {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
   key(): IdentifierAst | undefined;
-  equals(): Token | undefined;
+  equals(): SyntaxToken | undefined;
   value(): ExpressionAst | undefined;
   static cast(node: SyntaxNode): KeyValuePairAst | undefined;
 }
@@ -322,7 +399,7 @@ declare class NamedTypeDeclarationAst implements AstNode {
   readonly syntax: SyntaxNode;
   constructor(syntax: SyntaxNode);
   name(): IdentifierAst | undefined;
-  equals(): Token | undefined;
+  equals(): SyntaxToken | undefined;
   typeAnnotation(): TypeAnnotationAst | undefined;
   attributes(): Iterable<FieldAttributeAst>;
   static cast(node: SyntaxNode): NamedTypeDeclarationAst | undefined;
@@ -345,5 +422,5 @@ interface ParseResult {
  */
 declare function parse(source: string): ParseResult;
 //#endregion
-export { AstNode as A, GreenNode as B, NumberLiteralExprAst as C, castExpression as D, StringLiteralExprAst as E, SyntaxElement as F, Position as G, greenNode as H, SyntaxNode as I, Range as K, SyntaxToken as L, findChildToken as M, findFirstChild as N, QualifiedNameAst as O, printSyntax as P, createSyntaxTree as R, FunctionCallAst as S, ObjectLiteralExprAst as T, greenToken as U, GreenToken as V, SyntaxKind as W, ModelAttributeAst as _, DocumentAst as a, BooleanLiteralExprAst as b, KeyValuePairAst as c, NamespaceDeclarationAst as d, NamespaceMemberAst as f, FieldAttributeAst as g, AttributeArgListAst as h, CompositeTypeDeclarationAst as i, filterChildren as j, IdentifierAst as k, ModelDeclarationAst as l, TypeAnnotationAst as m, ParseResult as n, FieldDeclarationAst as o, TypesBlockAst as p, SourceFile as q, parse as r, GenericBlockDeclarationAst as s, ParseDiagnostic as t, NamedTypeDeclarationAst as u, ArrayLiteralAst as v, ObjectFieldAst as w, ExpressionAst as x, AttributeArgAst as y, GreenElement as z };
-//# sourceMappingURL=parse-BjZ1LPe6.d.mts.map
+export { Range as $, StringLiteralExprAst as A, printSyntax as B, AttributeArgAst as C, NumberLiteralExprAst as D, FunctionCallAst as E, BracedBlock as F, createSyntaxTree as G, SyntaxNode as H, any as I, GreenToken as J, GreenElement as K, filterChildren as L, QualifiedNameAst as M, IdentifierAst as N, ObjectFieldAst as O, AstNode as P, Position as Q, findChildToken as R, ArrayLiteralAst as S, ExpressionAst as T, SyntaxToken as U, SyntaxElement as V, TokenAtOffset as W, greenToken as X, greenNode as Y, SyntaxKind as Z, TypesBlockAst as _, BlockMemberAst as a, FieldAttributeAst as b, DocumentAst as c, GenericBlockMemberAst as d, SourceFile as et, KeyValuePairAst as f, NamespaceMemberAst as g, NamespaceDeclarationAst as h, AttributeAst as i, castExpression as j, ObjectLiteralExprAst as k, FieldDeclarationAst as l, NamedTypeDeclarationAst as m, ParseResult as n, CompositeTypeDeclarationAst as o, ModelDeclarationAst as p, GreenNode as q, parse as r, DeclarationAst as s, ParseDiagnostic as t, GenericBlockDeclarationAst as u, TypeAnnotationAst as v, BooleanLiteralExprAst as w, ModelAttributeAst as x, AttributeArgListAst as y, findFirstChild as z };
+//# sourceMappingURL=parse-BazJr7Ye.d.mts.map

package/dist/parse-BazJr7Ye.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-BazJr7Ye.d.mts","names":[],"sources":["../src/source-file.ts","../src/syntax/syntax-kind.ts","../src/syntax/green.ts","../src/syntax/red.ts","../src/syntax/ast-helpers.ts","../src/syntax/ast/identifier.ts","../src/syntax/ast/qualified-name.ts","../src/syntax/ast/expressions.ts","../src/syntax/ast/attributes.ts","../src/syntax/ast/type-annotation.ts","../src/syntax/ast/declarations.ts","../src/parse.ts"],"mappings":"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"}

package/dist/syntax.d.mts

@@ -1,4 +1,4 @@
-import { A as AstNode, B as GreenNode, C as NumberLiteralExprAst, D as castExpression, E as StringLiteralExprAst, F as SyntaxElement, G as Position, H as greenNode, I as SyntaxNode, K as Range, L as SyntaxToken, M as findChildToken, N as findFirstChild, O as QualifiedNameAst, P as printSyntax, R as createSyntaxTree, S as FunctionCallAst, T as ObjectLiteralExprAst, U as greenToken, V as GreenToken, W as SyntaxKind, _ as ModelAttributeAst, a as DocumentAst, b as BooleanLiteralExprAst, c as KeyValuePairAst, d as NamespaceDeclarationAst, f as NamespaceMemberAst, g as FieldAttributeAst, h as AttributeArgListAst, i as CompositeTypeDeclarationAst, j as filterChildren, k as IdentifierAst, l as ModelDeclarationAst, m as TypeAnnotationAst, n as ParseResult, o as FieldDeclarationAst, p as TypesBlockAst, q as SourceFile, r as parse, s as GenericBlockDeclarationAst, t as ParseDiagnostic, u as NamedTypeDeclarationAst, v as ArrayLiteralAst, w as ObjectFieldAst, x as ExpressionAst, y as AttributeArgAst, z as GreenElement } from "./parse-BjZ1LPe6.mjs";
+import { $ as Range, A as StringLiteralExprAst, B as printSyntax, C as AttributeArgAst, D as NumberLiteralExprAst, E as FunctionCallAst, F as BracedBlock, G as createSyntaxTree, H as SyntaxNode, I as any, J as GreenToken, K as GreenElement, L as filterChildren, M as QualifiedNameAst, N as IdentifierAst, O as ObjectFieldAst, P as AstNode, Q as Position, R as findChildToken, S as ArrayLiteralAst, T as ExpressionAst, U as SyntaxToken, V as SyntaxElement, W as TokenAtOffset, X as greenToken, Y as greenNode, Z as SyntaxKind, _ as TypesBlockAst, a as BlockMemberAst, b as FieldAttributeAst, c as DocumentAst, d as GenericBlockMemberAst, et as SourceFile, f as KeyValuePairAst, g as NamespaceMemberAst, h as NamespaceDeclarationAst, i as AttributeAst, j as castExpression, k as ObjectLiteralExprAst, l as FieldDeclarationAst, m as NamedTypeDeclarationAst, n as ParseResult, o as CompositeTypeDeclarationAst, p as ModelDeclarationAst, q as GreenNode, r as parse, s as DeclarationAst, t as ParseDiagnostic, u as GenericBlockDeclarationAst, v as TypeAnnotationAst, w as BooleanLiteralExprAst, x as ModelAttributeAst, y as AttributeArgListAst, z as findFirstChild } from "./parse-BazJr7Ye.mjs";
 import { n as TokenKind } from "./tokenizer-DcYI0Xrq.mjs";
 
 //#region src/syntax/green-builder.d.ts
@@ -9,5 +9,23 @@ declare class GreenNodeBuilder {
   finishNode(): GreenNode;
 }
 //#endregion
-export { ArrayLiteralAst, type AstNode, AttributeArgAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, DocumentAst, type ExpressionAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, type GreenElement, type GreenNode, GreenNodeBuilder, type GreenToken, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamedTypeDeclarationAst, NamespaceDeclarationAst, type NamespaceMemberAst, NumberLiteralExprAst, ObjectFieldAst, ObjectLiteralExprAst, type ParseDiagnostic, type ParseResult, type Position, QualifiedNameAst, type Range, SourceFile, StringLiteralExprAst, type SyntaxElement, type SyntaxKind, SyntaxNode, type SyntaxToken, TypeAnnotationAst, TypesBlockAst, castExpression, createSyntaxTree, filterChildren, findChildToken, findFirstChild, greenNode, greenToken, parse, printSyntax };
+//#region src/syntax/navigation.d.ts
+/** Direction of a sibling/token walk. */
+type Direction = 'next' | 'prev';
+/** Whether a token kind is trivia (whitespace, newline, or comment). */
+declare function isTriviaKind(kind: TokenKind): boolean;
+/** Whether a token is trivia. */
+declare function isTrivia(token: SyntaxToken): boolean;
+/**
+ * The first non-trivia token at or beyond `token` in `direction`. Returns
+ * `token` itself when it is already significant.
+ */
+declare function skipTriviaToken(token: SyntaxToken, direction: Direction): SyntaxToken | undefined;
+/**
+ * The nearest sibling of `element` (within the same parent) in `direction` that
+ * is not a trivia token. Nodes are always significant.
+ */
+declare function nonTriviaSibling(element: SyntaxElement, direction: Direction): SyntaxElement | undefined;
+//#endregion
+export { ArrayLiteralAst, type AstNode, AttributeArgAst, AttributeArgListAst, type AttributeAst, type BlockMemberAst, BooleanLiteralExprAst, type BracedBlock, CompositeTypeDeclarationAst, type DeclarationAst, type Direction, DocumentAst, type ExpressionAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, type GenericBlockMemberAst, type GreenElement, type GreenNode, GreenNodeBuilder, type GreenToken, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamedTypeDeclarationAst, NamespaceDeclarationAst, type NamespaceMemberAst, NumberLiteralExprAst, ObjectFieldAst, ObjectLiteralExprAst, type ParseDiagnostic, type ParseResult, type Position, QualifiedNameAst, type Range, SourceFile, StringLiteralExprAst, type SyntaxElement, type SyntaxKind, SyntaxNode, SyntaxToken, TokenAtOffset, TypeAnnotationAst, TypesBlockAst, any, castExpression, createSyntaxTree, filterChildren, findChildToken, findFirstChild, greenNode, greenToken, isTrivia, isTriviaKind, nonTriviaSibling, parse, printSyntax, skipTriviaToken };
 //# sourceMappingURL=syntax.d.mts.map

package/dist/syntax.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"syntax.d.mts","names":[],"sources":["../src/syntax/green-builder.ts"],"mappings":";;;;cAKa,gBAAA;EAAA;EAGX,SAAA,CAAU,IAAA,EAAM,UAAA;EAIhB,KAAA,CAAM,IAAA,EAAM,SAAA,EAAW,IAAA;EAQvB,UAAA,IAAc,SAAA;AAAA"}
+{"version":3,"file":"syntax.d.mts","names":[],"sources":["../src/syntax/green-builder.ts","../src/syntax/navigation.ts"],"mappings":";;;;cAKa,gBAAA;EAAA;EAGX,SAAA,CAAU,IAAA,EAAM,UAAA;EAIhB,KAAA,CAAM,IAAA,EAAM,SAAA,EAAW,IAAA;EAQvB,UAAA,IAAc,SAAA;AAAA;;;;KChBJ,SAAA;ADCZ;AAAA,iBCQgB,YAAA,CAAa,IAAe,EAAT,SAAS;;iBAK5B,QAAA,CAAS,KAAkB,EAAX,WAAW;;;;;iBAQ3B,eAAA,CAAgB,KAAA,EAAO,WAAA,EAAa,SAAA,EAAW,SAAA,GAAY,WAAA;;;;;iBAY3D,gBAAA,CACd,OAAA,EAAS,aAAA,EACT,SAAA,EAAW,SAAA,GACV,aAAA"}

package/dist/syntax.mjs

@@ -1,2 +1,43 @@
-import { A as findChildToken, C as ObjectFieldAst, D as QualifiedNameAst, E as castExpression, F as SourceFile, M as printSyntax, N as SyntaxNode, O as IdentifierAst, P as createSyntaxTree, S as NumberLiteralExprAst, T as StringLiteralExprAst, _ as ModelAttributeAst, a as CompositeTypeDeclarationAst, b as BooleanLiteralExprAst, c as GenericBlockDeclarationAst, d as NamedTypeDeclarationAst, f as NamespaceDeclarationAst, g as FieldAttributeAst, h as AttributeArgListAst, i as greenToken, j as findFirstChild, k as filterChildren, l as KeyValuePairAst, m as TypeAnnotationAst, n as GreenNodeBuilder, o as DocumentAst, p as TypesBlockAst, r as greenNode, s as FieldDeclarationAst, t as parse, u as ModelDeclarationAst, v as ArrayLiteralAst, w as ObjectLiteralExprAst, x as FunctionCallAst, y as AttributeArgAst } from "./parse-B_3gIEFd.mjs";
-export { ArrayLiteralAst, AttributeArgAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, DocumentAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, GreenNodeBuilder, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamedTypeDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectFieldAst, ObjectLiteralExprAst, QualifiedNameAst, SourceFile, StringLiteralExprAst, SyntaxNode, TypeAnnotationAst, TypesBlockAst, castExpression, createSyntaxTree, filterChildren, findChildToken, findFirstChild, greenNode, greenToken, parse, printSyntax };
+import { A as SyntaxNode, C as QualifiedNameAst, D as findChildToken, E as filterChildren, M as TokenAtOffset, N as createSyntaxTree, O as findFirstChild, S as castExpression, T as any, _ as FunctionCallAst, a as KeyValuePairAst, b as ObjectLiteralExprAst, c as NamespaceDeclarationAst, d as AttributeArgListAst, f as FieldAttributeAst, g as BooleanLiteralExprAst, h as AttributeArgAst, i as GenericBlockDeclarationAst, j as SyntaxToken, k as printSyntax, l as TypesBlockAst, m as ArrayLiteralAst, n as DocumentAst, o as ModelDeclarationAst, p as ModelAttributeAst, r as FieldDeclarationAst, s as NamedTypeDeclarationAst, t as CompositeTypeDeclarationAst, u as TypeAnnotationAst, v as NumberLiteralExprAst, w as IdentifierAst, x as StringLiteralExprAst, y as ObjectFieldAst } from "./declarations-DR6To8_k.mjs";
+import { a as SourceFile, i as greenToken, n as GreenNodeBuilder, r as greenNode, t as parse } from "./parse-3-vr14ej.mjs";
+//#region src/syntax/navigation.ts
+const TRIVIA_KINDS = new Set([
+	"Whitespace",
+	"Newline",
+	"Comment"
+]);
+/** Whether a token kind is trivia (whitespace, newline, or comment). */
+function isTriviaKind(kind) {
+	return TRIVIA_KINDS.has(kind);
+}
+/** Whether a token is trivia. */
+function isTrivia(token) {
+	return isTriviaKind(token.kind);
+}
+/**
+* The first non-trivia token at or beyond `token` in `direction`. Returns
+* `token` itself when it is already significant.
+*/
+function skipTriviaToken(token, direction) {
+	let current = token;
+	while (current !== void 0 && isTrivia(current)) current = direction === "next" ? current.nextToken : current.prevToken;
+	return current;
+}
+/**
+* The nearest sibling of `element` (within the same parent) in `direction` that
+* is not a trivia token. Nodes are always significant.
+*/
+function nonTriviaSibling(element, direction) {
+	let sibling = step(element, direction);
+	while (sibling !== void 0) {
+		if (!(sibling instanceof SyntaxToken) || !isTrivia(sibling)) return sibling;
+		sibling = step(sibling, direction);
+	}
+}
+function step(element, direction) {
+	return direction === "next" ? element.nextSiblingOrToken : element.prevSiblingOrToken;
+}
+//#endregion
+export { ArrayLiteralAst, AttributeArgAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, DocumentAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, GreenNodeBuilder, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamedTypeDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectFieldAst, ObjectLiteralExprAst, QualifiedNameAst, SourceFile, StringLiteralExprAst, SyntaxNode, SyntaxToken, TokenAtOffset, TypeAnnotationAst, TypesBlockAst, any, castExpression, createSyntaxTree, filterChildren, findChildToken, findFirstChild, greenNode, greenToken, isTrivia, isTriviaKind, nonTriviaSibling, parse, printSyntax, skipTriviaToken };
+
+//# sourceMappingURL=syntax.mjs.map

package/dist/syntax.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"syntax.mjs","names":[],"sources":["../src/syntax/navigation.ts"],"sourcesContent":["import type { TokenKind } from '../tokenizer';\nimport { type SyntaxElement, SyntaxToken } from './red';\n\n/** Direction of a sibling/token walk. */\nexport type Direction = 'next' | 'prev';\n\nconst TRIVIA_KINDS: ReadonlySet<TokenKind> = new Set<TokenKind>([\n  'Whitespace',\n  'Newline',\n  'Comment',\n]);\n\n/** Whether a token kind is trivia (whitespace, newline, or comment). */\nexport function isTriviaKind(kind: TokenKind): boolean {\n  return TRIVIA_KINDS.has(kind);\n}\n\n/** Whether a token is trivia. */\nexport function isTrivia(token: SyntaxToken): boolean {\n  return isTriviaKind(token.kind);\n}\n\n/**\n * The first non-trivia token at or beyond `token` in `direction`. Returns\n * `token` itself when it is already significant.\n */\nexport function skipTriviaToken(token: SyntaxToken, direction: Direction): SyntaxToken | undefined {\n  let current: SyntaxToken | undefined = token;\n  while (current !== undefined && isTrivia(current)) {\n    current = direction === 'next' ? current.nextToken : current.prevToken;\n  }\n  return current;\n}\n\n/**\n * The nearest sibling of `element` (within the same parent) in `direction` that\n * is not a trivia token. Nodes are always significant.\n */\nexport function nonTriviaSibling(\n  element: SyntaxElement,\n  direction: Direction,\n): SyntaxElement | undefined {\n  let sibling = step(element, direction);\n  while (sibling !== undefined) {\n    if (!(sibling instanceof SyntaxToken) || !isTrivia(sibling)) {\n      return sibling;\n    }\n    sibling = step(sibling, direction);\n  }\n  return undefined;\n}\n\nfunction step(element: SyntaxElement, direction: Direction): SyntaxElement | undefined {\n  return direction === 'next' ? element.nextSiblingOrToken : element.prevSiblingOrToken;\n}\n"],"mappings":";;;AAMA,MAAM,eAAuC,IAAI,IAAe;CAC9D;CACA;CACA;AACF,CAAC;;AAGD,SAAgB,aAAa,MAA0B;CACrD,OAAO,aAAa,IAAI,IAAI;AAC9B;;AAGA,SAAgB,SAAS,OAA6B;CACpD,OAAO,aAAa,MAAM,IAAI;AAChC;;;;;AAMA,SAAgB,gBAAgB,OAAoB,WAA+C;CACjG,IAAI,UAAmC;CACvC,OAAO,YAAY,KAAA,KAAa,SAAS,OAAO,GAC9C,UAAU,cAAc,SAAS,QAAQ,YAAY,QAAQ;CAE/D,OAAO;AACT;;;;;AAMA,SAAgB,iBACd,SACA,WAC2B;CAC3B,IAAI,UAAU,KAAK,SAAS,SAAS;CACrC,OAAO,YAAY,KAAA,GAAW;EAC5B,IAAI,EAAE,mBAAmB,gBAAgB,CAAC,SAAS,OAAO,GACxD,OAAO;EAET,UAAU,KAAK,SAAS,SAAS;CACnC;AAEF;AAEA,SAAS,KAAK,SAAwB,WAAiD;CACrF,OAAO,cAAc,SAAS,QAAQ,qBAAqB,QAAQ;AACrE"}