@prisma/orm-framework 0.16.0-dev.36

package/dist/parse-0ZJjj_2N-WZZ1nlrv.d.mts

@@ -0,0 +1,427 @@
+import { F as PslDiagnosticCode } from "./framework-authoring-7YMP9TwM-C9P-N6_a.mjs";
+import "./psl-ast-BEwO80EH.mjs";
+import { n as TokenKind, t as Token } from "./tokenizer-DcYI0Xrq-C-nNE9mE.mjs";
+//#region ../../../1-framework/2-authoring/psl-parser/dist/parse-0ZJjj_2N.d.mts
+//#region src/source-file.d.ts
+interface Position {
+  readonly line: number;
+  readonly character: number;
+}
+interface Range {
+  readonly start: Position;
+  readonly end: Position;
+}
+declare class SourceFile {
+  #private;
+  constructor(text: string);
+  get text(): string;
+  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;
+}
+//#endregion
+//#region src/syntax/syntax-kind.d.ts
+type SyntaxKind = 'Document' | 'ModelDeclaration' | 'CompositeTypeDeclaration' | 'Namespace' | 'TypesBlock' | 'GenericBlockDeclaration' | 'FieldDeclaration' | 'NamedTypeDeclaration' | 'KeyValuePair' | 'FieldAttribute' | 'ModelAttribute' | 'AttributeArgList' | 'AttributeArg' | 'TypeAnnotation' | 'Identifier' | 'QualifiedName' | 'FunctionCall' | 'ArrayLiteral' | 'StringLiteralExpr' | 'NumberLiteralExpr' | 'BooleanLiteralExpr' | 'ObjectLiteralExpr' | 'ObjectField';
+//#endregion
+//#region src/syntax/green.d.ts
+interface GreenToken {
+  readonly type: 'token';
+  readonly kind: TokenKind;
+  readonly text: string;
+}
+interface GreenNode {
+  readonly type: 'node';
+  readonly kind: SyntaxKind;
+  readonly children: ReadonlyArray<GreenElement>;
+  readonly textLength: number;
+}
+type GreenElement = GreenNode | GreenToken;
+declare function greenToken(kind: TokenKind, text: string): GreenToken;
+declare function greenNode(kind: SyntaxKind, children: ReadonlyArray<GreenElement>): GreenNode;
+//#endregion
+//#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 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.
+ */
+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;
+  /** 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
+//#region src/syntax/ast-helpers.d.ts
+interface AstNode {
+  readonly syntax: SyntaxNode;
+}
+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.
+ */
+declare function printSyntax(node: SyntaxNode): string;
+//#endregion
+//#region src/syntax/ast/identifier.d.ts
+declare class IdentifierAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  token(): SyntaxToken | undefined;
+  name(): string | undefined;
+  static cast(node: SyntaxNode): IdentifierAst | undefined;
+}
+//#endregion
+//#region src/syntax/ast/qualified-name.d.ts
+/** A namespace-qualified name, e.g. `pgvector.Vector` or `supabase:auth.User`. */
+declare class QualifiedNameAst implements AstNode {
+  #private;
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  colon(): SyntaxToken | undefined;
+  dot(): SyntaxToken | undefined;
+  space(): IdentifierAst | undefined;
+  namespace(): IdentifierAst | undefined;
+  identifier(): IdentifierAst | undefined;
+  /**
+   * Every identifier segment, in source order. A bare `Vector` yields
+   * `['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).
+   */
+  isOverQualified(): boolean;
+  static cast(node: SyntaxNode): QualifiedNameAst | undefined;
+}
+//#endregion
+//#region src/syntax/ast/expressions.d.ts
+declare class FunctionCallAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  /** The qualified-name callee, or `undefined` when identifier segments sit directly under the node. */
+  name(): QualifiedNameAst | undefined;
+  /**
+   * The dotted call path, in source order. A bare `Vector(…)` yields
+   * `['Vector']`; a namespace-qualified `pgvector.Vector(…)` yields
+   * `['pgvector', 'Vector']`. Empty when the call carries no identifier.
+   */
+  path(): readonly string[];
+  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(): 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(): SyntaxToken | undefined;
+  value(): string | undefined;
+  static cast(node: SyntaxNode): StringLiteralExprAst | undefined;
+}
+declare class NumberLiteralExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  token(): SyntaxToken | undefined;
+  value(): number | undefined;
+  static cast(node: SyntaxNode): NumberLiteralExprAst | undefined;
+}
+declare class BooleanLiteralExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  token(): SyntaxToken | undefined;
+  value(): boolean | undefined;
+  static cast(node: SyntaxNode): BooleanLiteralExprAst | undefined;
+}
+declare class ObjectLiteralExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
+  fields(): Iterable<ObjectFieldAst>;
+  static cast(node: SyntaxNode): ObjectLiteralExprAst | undefined;
+}
+declare class ObjectFieldAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  key(): IdentifierAst | undefined;
+  /**
+   * The field's logical key name, unquoted. An identifier key (`length:`) yields
+   * its text; a string-literal key (`"length":`) yields the decoded string.
+   * `undefined` when the field carries no key node.
+   */
+  keyName(): string | undefined;
+  colon(): SyntaxToken | undefined;
+  value(): ExpressionAst | undefined;
+  static cast(node: SyntaxNode): ObjectFieldAst | undefined;
+}
+type ExpressionAst = FunctionCallAst | ArrayLiteralAst | StringLiteralExprAst | NumberLiteralExprAst | BooleanLiteralExprAst | ObjectLiteralExprAst | IdentifierAst;
+declare function castExpression(node: SyntaxNode): ExpressionAst | undefined;
+declare class AttributeArgAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  name(): IdentifierAst | undefined;
+  colon(): SyntaxToken | undefined;
+  value(): ExpressionAst | undefined;
+  static cast(node: SyntaxNode): AttributeArgAst | undefined;
+}
+//#endregion
+//#region src/syntax/ast/attributes.d.ts
+declare class AttributeArgListAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  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(): SyntaxToken | undefined;
+  name(): QualifiedNameAst | undefined;
+  argList(): AttributeArgListAst | undefined;
+  static cast(node: SyntaxNode): FieldAttributeAst | undefined;
+}
+declare class ModelAttributeAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  doubleAt(): SyntaxToken | undefined;
+  name(): QualifiedNameAst | undefined;
+  argList(): AttributeArgListAst | undefined;
+  static cast(node: SyntaxNode): ModelAttributeAst | undefined;
+}
+//#endregion
+//#region src/syntax/ast/type-annotation.d.ts
+declare class TypeAnnotationAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  /** The annotation's reference, doubling as the constructor callee when an {@link argList} follows. */
+  name(): QualifiedNameAst | undefined;
+  /** Present when the annotation is a constructor (`Vector(1536)`) rather than a plain reference. */
+  argList(): AttributeArgListAst | undefined;
+  isConstructor(): boolean;
+  lbracket(): SyntaxToken | undefined;
+  rbracket(): SyntaxToken | undefined;
+  questionMark(): SyntaxToken | undefined;
+  isList(): boolean;
+  isOptional(): boolean;
+  static cast(node: SyntaxNode): TypeAnnotationAst | undefined;
+}
+//#endregion
+//#region src/syntax/ast/declarations.d.ts
+/**
+ * What may appear inside a `namespace` block: models, composite types, and
+ * extension (block) declarations. `types {}` blocks and nested `namespace`
+ * 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<DeclarationAst>;
+  static cast(node: SyntaxNode): DocumentAst | undefined;
+}
+declare class ModelDeclarationAst implements BracedBlock {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  keyword(): SyntaxToken | undefined;
+  name(): IdentifierAst | 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 BracedBlock {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  keyword(): SyntaxToken | undefined;
+  name(): IdentifierAst | 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 BracedBlock {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  keyword(): SyntaxToken | undefined;
+  name(): IdentifierAst | undefined;
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
+  declarations(): Iterable<NamespaceMemberAst>;
+  static cast(node: SyntaxNode): NamespaceDeclarationAst | undefined;
+}
+declare class TypesBlockAst implements BracedBlock {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  keyword(): SyntaxToken | undefined;
+  lbrace(): SyntaxToken | undefined;
+  rbrace(): SyntaxToken | undefined;
+  declarations(): Iterable<NamedTypeDeclarationAst>;
+  static cast(node: SyntaxNode): TypesBlockAst | undefined;
+}
+declare class GenericBlockDeclarationAst implements BracedBlock {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  keyword(): SyntaxToken | undefined;
+  name(): IdentifierAst | 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(): SyntaxToken | undefined;
+  value(): ExpressionAst | undefined;
+  static cast(node: SyntaxNode): KeyValuePairAst | undefined;
+}
+declare class FieldDeclarationAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  name(): IdentifierAst | undefined;
+  typeAnnotation(): TypeAnnotationAst | undefined;
+  attributes(): Iterable<FieldAttributeAst>;
+  static cast(node: SyntaxNode): FieldDeclarationAst | undefined;
+}
+declare class NamedTypeDeclarationAst implements AstNode {
+  readonly syntax: SyntaxNode;
+  constructor(syntax: SyntaxNode);
+  name(): IdentifierAst | undefined;
+  equals(): SyntaxToken | undefined;
+  typeAnnotation(): TypeAnnotationAst | undefined;
+  attributes(): Iterable<FieldAttributeAst>;
+  static cast(node: SyntaxNode): NamedTypeDeclarationAst | undefined;
+}
+//#endregion
+//#region src/parse.d.ts
+interface ParseDiagnostic {
+  readonly code: PslDiagnosticCode;
+  readonly message: string;
+  readonly range: Range;
+}
+interface ParseResult {
+  readonly document: DocumentAst;
+  readonly diagnostics: readonly ParseDiagnostic[];
+  readonly sourceFile: SourceFile;
+}
+/**
+ * Parses a full PSL document. Never throws — malformed input yields diagnostics
+ * and a recovered tree, not an exception.
+ */
+declare function parse(source: string): ParseResult;
+//#endregion
+export { parse as $, ObjectLiteralExprAst as A, SyntaxNode as B, ModelAttributeAst as C, NamespaceMemberAst as D, NamespaceDeclarationAst as E, Range as F, any as G, TokenAtOffset as H, SourceFile as I, filterChildren as J, castExpression as K, StringLiteralExprAst as L, ParseResult as M, Position as N, NumberLiteralExprAst as O, QualifiedNameAst as P, greenToken as Q, SyntaxElement as R, KeyValuePairAst as S, NamedTypeDeclarationAst as T, TypeAnnotationAst as U, SyntaxToken as V, TypesBlockAst as W, findFirstChild as X, findChildToken as Y, greenNode as Z, GenericBlockMemberAst as _, AttributeAst as a, GreenToken as b, BracedBlock as c, DocumentAst as d, printSyntax as et, ExpressionAst as f, GenericBlockDeclarationAst as g, FunctionCallAst as h, AttributeArgListAst as i, ParseDiagnostic as j, ObjectFieldAst as k, CompositeTypeDeclarationAst as l, FieldDeclarationAst as m, AstNode as n, BlockMemberAst as o, FieldAttributeAst as p, createSyntaxTree as q, AttributeArgAst as r, BooleanLiteralExprAst as s, ArrayLiteralAst as t, DeclarationAst as u, GreenElement as v, ModelDeclarationAst as w, IdentifierAst as x, GreenNode as y, SyntaxKind as z };
+//# sourceMappingURL=parse-0ZJjj_2N-WZZ1nlrv.d.mts.map

package/dist/parse-0ZJjj_2N-WZZ1nlrv.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-0ZJjj_2N-WZZ1nlrv.d.mts","names":[],"sources":["../../../../1-framework/2-authoring/psl-parser/dist/parse-0ZJjj_2N.d.mts"],"mappings":"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"}