@prisma-next/psl-parser 0.13.0 → 0.14.0

package/dist/syntax.mjs

@@ -1,3 +1,66 @@
+import { n as isTerminatedStringLiteral, t as Tokenizer } from "./tokenizer-1hAHZzmp.mjs";
+import { UNSPECIFIED_PSL_NAMESPACE_ID } from "@prisma-next/framework-components/psl-ast";
+//#region src/source-file.ts
+const LINE_FEED = 10;
+var SourceFile = class {
+	#text;
+	#lineStarts;
+	constructor(text) {
+		this.#text = text;
+		const lineStarts = [0];
+		for (let offset = 0; offset < text.length; offset++) if (text.charCodeAt(offset) === LINE_FEED) lineStarts.push(offset + 1);
+		this.#lineStarts = lineStarts;
+	}
+	get text() {
+		return this.#text;
+	}
+	get length() {
+		return this.#text.length;
+	}
+	get lineCount() {
+		return this.#lineStarts.length;
+	}
+	lineStartOffsets() {
+		return this.#lineStarts;
+	}
+	positionAt(offset) {
+		const clamped = clamp(offset, 0, this.#text.length);
+		const line = this.#lineIndexAt(clamped);
+		return {
+			line,
+			character: clamped - this.#lineStartAt(line)
+		};
+	}
+	offsetAt(position) {
+		const line = clamp(position.line, 0, this.#lineStarts.length - 1);
+		const lineStart = this.#lineStartAt(line);
+		const lineEnd = this.#lineEndAt(line);
+		return clamp(lineStart + position.character, lineStart, lineEnd);
+	}
+	#lineStartAt(line) {
+		return this.#lineStarts[line] ?? 0;
+	}
+	#lineEndAt(line) {
+		return line + 1 < this.#lineStarts.length ? this.#lineStartAt(line + 1) - 1 : this.#text.length;
+	}
+	#lineIndexAt(offset) {
+		const lineStarts = this.#lineStarts;
+		let low = 0;
+		let high = lineStarts.length - 1;
+		while (low < high) {
+			const mid = low + high + 1 >>> 1;
+			if ((lineStarts[mid] ?? 0) <= offset) low = mid;
+			else high = mid - 1;
+		}
+		return low;
+	}
+};
+function clamp(value, min, max) {
+	if (value < min) return min;
+	if (value > max) return max;
+	return value;
+}
+//#endregion
 //#region src/syntax/red.ts
 var SyntaxNode = class SyntaxNode {
 	green;
@@ -127,6 +190,15 @@ function* filterChildren(node, cast) {
 		if (result !== void 0) yield result;
 	}
 }
+/**
+* Raw source text of a CST node, verbatim (quotes and brackets preserved). For
+* the decoded value of a string literal, decode it instead.
+*/
+function printSyntax(node) {
+	let text = "";
+	for (const token of node.tokens()) text += token.text;
+	return text;
+}
 //#endregion
 //#region src/syntax/ast/identifier.ts
 var IdentifierAst = class IdentifierAst {
@@ -137,19 +209,104 @@ var IdentifierAst = class IdentifierAst {
 	token() {
 		return findChildToken(this.syntax, "Ident");
 	}
+	name() {
+		return this.token()?.text;
+	}
 	static cast(node) {
 		return node.kind === "Identifier" ? new IdentifierAst(node) : void 0;
 	}
 };
 //#endregion
+//#region src/syntax/ast/qualified-name.ts
+/** A namespace-qualified name, e.g. `pgvector.Vector` or `supabase:auth.User`. */
+var QualifiedNameAst = class QualifiedNameAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	#lastSegment() {
+		let last;
+		for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) last = segment;
+		return last;
+	}
+	#penultimateSegment() {
+		let last;
+		let penultimate;
+		for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
+			penultimate = last;
+			last = segment;
+		}
+		return penultimate;
+	}
+	#separatorCount(kind) {
+		let count = 0;
+		for (const child of this.syntax.children()) if (!(child instanceof SyntaxNode) && child.kind === kind) count++;
+		return count;
+	}
+	colon() {
+		return findChildToken(this.syntax, "Colon");
+	}
+	dot() {
+		return findChildToken(this.syntax, "Dot");
+	}
+	space() {
+		if (!this.colon()) return void 0;
+		return findFirstChild(this.syntax, IdentifierAst.cast);
+	}
+	namespace() {
+		if (!this.dot()) return void 0;
+		return this.#penultimateSegment();
+	}
+	identifier() {
+		return this.#lastSegment();
+	}
+	/**
+	* Every identifier segment, in source order. A bare `Vector` yields
+	* `['Vector']`; a qualified `pgvector.Vector` yields `['pgvector', 'Vector']`.
+	*/
+	path() {
+		const segments = [];
+		for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
+			const text = segment.token()?.text;
+			if (text !== void 0) segments.push(text);
+		}
+		return segments;
+	}
+	/**
+	* Flags a malformed name with more qualifier segments than allowed (a second
+	* `:`-space or a second `.`-namespace).
+	*/
+	isOverQualified() {
+		return this.#separatorCount("Dot") > 1 || this.#separatorCount("Colon") > 1;
+	}
+	static cast(node) {
+		return node.kind === "QualifiedName" ? new QualifiedNameAst(node) : void 0;
+	}
+};
+//#endregion
 //#region src/syntax/ast/expressions.ts
 var FunctionCallAst = class FunctionCallAst {
 	syntax;
 	constructor(syntax) {
 		this.syntax = syntax;
 	}
+	/** The qualified-name callee, or `undefined` when identifier segments sit directly under the node. */
 	name() {
-		return findFirstChild(this.syntax, IdentifierAst.cast);
+		return findFirstChild(this.syntax, QualifiedNameAst.cast);
+	}
+	/**
+	* 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() {
+		const qualified = this.name();
+		const segments = [];
+		for (const segment of filterChildren(qualified?.syntax ?? this.syntax, IdentifierAst.cast)) {
+			const text = segment.token()?.text;
+			if (text !== void 0) segments.push(text);
+		}
+		return segments;
 	}
 	lparen() {
 		return findChildToken(this.syntax, "LParen");
@@ -182,6 +339,79 @@ var ArrayLiteralAst = class ArrayLiteralAst {
 		return node.kind === "ArrayLiteral" ? new ArrayLiteralAst(node) : void 0;
 	}
 };
+const HEX = /^[0-9a-fA-F]+$/;
+function decodeFixedHex(raw, start, width) {
+	if (start + width > raw.length) return void 0;
+	const hex = raw.slice(start, start + width);
+	if (!HEX.test(hex)) return void 0;
+	return String.fromCharCode(Number.parseInt(hex, 16));
+}
+function decodeStringLiteral(raw) {
+	let out = "";
+	let i = 0;
+	while (i < raw.length) {
+		const ch = raw.charAt(i);
+		if (ch !== "\\" || i + 1 >= raw.length) {
+			out += ch;
+			i++;
+			continue;
+		}
+		const next = raw.charAt(i + 1);
+		switch (next) {
+			case "n":
+				out += "\n";
+				i += 2;
+				continue;
+			case "r":
+				out += "\r";
+				i += 2;
+				continue;
+			case "t":
+				out += "	";
+				i += 2;
+				continue;
+			case "\"":
+				out += "\"";
+				i += 2;
+				continue;
+			case "'":
+				out += "'";
+				i += 2;
+				continue;
+			case "\\":
+				out += "\\";
+				i += 2;
+				continue;
+			case "x": {
+				const decoded = decodeFixedHex(raw, i + 2, 2);
+				if (decoded === void 0) {
+					out += "\\x";
+					i += 2;
+					continue;
+				}
+				out += decoded;
+				i += 4;
+				continue;
+			}
+			case "u": {
+				const decoded = decodeFixedHex(raw, i + 2, 4);
+				if (decoded === void 0) {
+					out += "\\u";
+					i += 2;
+					continue;
+				}
+				out += decoded;
+				i += 6;
+				continue;
+			}
+			default:
+				out += `\\${next}`;
+				i += 2;
+				continue;
+		}
+	}
+	return out;
+}
 var StringLiteralExprAst = class StringLiteralExprAst {
 	syntax;
 	constructor(syntax) {
@@ -193,16 +423,7 @@ var StringLiteralExprAst = class StringLiteralExprAst {
 	value() {
 		const tok = this.token();
 		if (!tok) return void 0;
-		return tok.text.slice(1, -1).replace(/\\(.)/g, (_match, char) => {
-			switch (char) {
-				case "n": return "\n";
-				case "r": return "\r";
-				case "t": return "	";
-				case "\"": return "\"";
-				case "\\": return "\\";
-				default: return `\\${char}`;
-			}
-		});
+		return decodeStringLiteral(tok.text.slice(1, -1));
 	}
 	static cast(node) {
 		return node.kind === "StringLiteralExpr" ? new StringLiteralExprAst(node) : void 0;
@@ -243,8 +464,82 @@ var BooleanLiteralExprAst = class BooleanLiteralExprAst {
 		return node.kind === "BooleanLiteralExpr" ? new BooleanLiteralExprAst(node) : void 0;
 	}
 };
+var ObjectLiteralExprAst = class ObjectLiteralExprAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	lbrace() {
+		return findChildToken(this.syntax, "LBrace");
+	}
+	rbrace() {
+		return findChildToken(this.syntax, "RBrace");
+	}
+	*fields() {
+		yield* filterChildren(this.syntax, ObjectFieldAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "ObjectLiteralExpr" ? new ObjectLiteralExprAst(node) : void 0;
+	}
+};
+var ObjectFieldAst = class ObjectFieldAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	key() {
+		for (const child of this.syntax.children()) {
+			if (!(child instanceof SyntaxNode)) {
+				if (child.kind === "Colon") break;
+				continue;
+			}
+			return IdentifierAst.cast(child);
+		}
+	}
+	/**
+	* 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() {
+		for (const child of this.syntax.children()) {
+			if (!(child instanceof SyntaxNode)) {
+				if (child.kind === "Colon") break;
+				continue;
+			}
+			const identifier = IdentifierAst.cast(child);
+			if (identifier) return identifier.token()?.text;
+			const stringKey = StringLiteralExprAst.cast(child);
+			if (stringKey) return stringKey.value();
+			return;
+		}
+	}
+	colon() {
+		return findChildToken(this.syntax, "Colon");
+	}
+	value() {
+		if (this.colon()) {
+			let pastColon = false;
+			for (const child of this.syntax.children()) {
+				if (!(child instanceof SyntaxNode)) {
+					if (child.kind === "Colon") pastColon = true;
+					continue;
+				}
+				if (pastColon) {
+					const expr = castExpression(child);
+					if (expr) return expr;
+				}
+			}
+			return;
+		}
+		return findFirstChild(this.syntax, castExpression);
+	}
+	static cast(node) {
+		return node.kind === "ObjectField" ? new ObjectFieldAst(node) : void 0;
+	}
+};
 function castExpression(node) {
-	return FunctionCallAst.cast(node) ?? ArrayLiteralAst.cast(node) ?? StringLiteralExprAst.cast(node) ?? NumberLiteralExprAst.cast(node) ?? BooleanLiteralExprAst.cast(node) ?? IdentifierAst.cast(node);
+	return FunctionCallAst.cast(node) ?? ArrayLiteralAst.cast(node) ?? StringLiteralExprAst.cast(node) ?? NumberLiteralExprAst.cast(node) ?? BooleanLiteralExprAst.cast(node) ?? ObjectLiteralExprAst.cast(node) ?? IdentifierAst.cast(node);
 }
 var AttributeArgAst = class AttributeArgAst {
 	syntax;
@@ -308,22 +603,7 @@ var FieldAttributeAst = class FieldAttributeAst {
 		return findChildToken(this.syntax, "At");
 	}
 	name() {
-		if (this.dot()) {
-			let count = 0;
-			for (const child of this.syntax.childNodes()) if (child.kind === "Identifier") {
-				count++;
-				if (count === 2) return new IdentifierAst(child);
-			}
-			return;
-		}
-		return findFirstChild(this.syntax, IdentifierAst.cast);
-	}
-	dot() {
-		return findChildToken(this.syntax, "Dot");
-	}
-	namespaceName() {
-		if (!this.dot()) return void 0;
-		return findFirstChild(this.syntax, IdentifierAst.cast);
+		return findFirstChild(this.syntax, QualifiedNameAst.cast);
 	}
 	argList() {
 		return findFirstChild(this.syntax, AttributeArgListAst.cast);
@@ -341,7 +621,7 @@ var ModelAttributeAst = class ModelAttributeAst {
 		return findChildToken(this.syntax, "DoubleAt");
 	}
 	name() {
-		return findFirstChild(this.syntax, IdentifierAst.cast);
+		return findFirstChild(this.syntax, QualifiedNameAst.cast);
 	}
 	argList() {
 		return findFirstChild(this.syntax, AttributeArgListAst.cast);
@@ -357,39 +637,16 @@ var TypeAnnotationAst = class TypeAnnotationAst {
 	constructor(syntax) {
 		this.syntax = syntax;
 	}
-	#lastSegment() {
-		let last;
-		for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) last = segment;
-		return last;
-	}
-	#penultimateSegment() {
-		let last;
-		let penultimate;
-		for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
-			penultimate = last;
-			last = segment;
-		}
-		return penultimate;
-	}
+	/** The annotation's reference, doubling as the constructor callee when an {@link argList} follows. */
 	name() {
-		return this.#lastSegment();
-	}
-	colon() {
-		return findChildToken(this.syntax, "Colon");
+		return findFirstChild(this.syntax, QualifiedNameAst.cast);
 	}
-	dot() {
-		return findChildToken(this.syntax, "Dot");
-	}
-	spaceName() {
-		if (!this.colon()) return void 0;
-		return findFirstChild(this.syntax, IdentifierAst.cast);
-	}
-	namespaceName() {
-		if (!this.dot()) return void 0;
-		return this.#penultimateSegment();
+	/** Present when the annotation is a constructor (`Vector(1536)`) rather than a plain reference. */
+	argList() {
+		return findFirstChild(this.syntax, AttributeArgListAst.cast);
 	}
-	constructorCall() {
-		return findFirstChild(this.syntax, FunctionCallAst.cast);
+	isConstructor() {
+		return this.argList() !== void 0;
 	}
 	lbracket() {
 		return findChildToken(this.syntax, "LBracket");
@@ -413,7 +670,7 @@ var TypeAnnotationAst = class TypeAnnotationAst {
 //#endregion
 //#region src/syntax/ast/declarations.ts
 function castNamespaceMember(node) {
-	return ModelDeclarationAst.cast(node) ?? EnumDeclarationAst.cast(node) ?? CompositeTypeDeclarationAst.cast(node) ?? BlockDeclarationAst.cast(node);
+	return ModelDeclarationAst.cast(node) ?? CompositeTypeDeclarationAst.cast(node) ?? GenericBlockDeclarationAst.cast(node);
 }
 var DocumentAst = class DocumentAst {
 	syntax;
@@ -454,33 +711,6 @@ var ModelDeclarationAst = class ModelDeclarationAst {
 		return node.kind === "ModelDeclaration" ? new ModelDeclarationAst(node) : void 0;
 	}
 };
-var EnumDeclarationAst = class EnumDeclarationAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	keyword() {
-		return findChildToken(this.syntax, "Ident");
-	}
-	name() {
-		return findFirstChild(this.syntax, IdentifierAst.cast);
-	}
-	lbrace() {
-		return findChildToken(this.syntax, "LBrace");
-	}
-	rbrace() {
-		return findChildToken(this.syntax, "RBrace");
-	}
-	*values() {
-		yield* filterChildren(this.syntax, EnumValueDeclarationAst.cast);
-	}
-	*attributes() {
-		yield* filterChildren(this.syntax, ModelAttributeAst.cast);
-	}
-	static cast(node) {
-		return node.kind === "EnumDeclaration" ? new EnumDeclarationAst(node) : void 0;
-	}
-};
 var CompositeTypeDeclarationAst = class CompositeTypeDeclarationAst {
 	syntax;
 	constructor(syntax) {
@@ -553,7 +783,7 @@ var TypesBlockAst = class TypesBlockAst {
 		return node.kind === "TypesBlock" ? new TypesBlockAst(node) : void 0;
 	}
 };
-var BlockDeclarationAst = class BlockDeclarationAst {
+var GenericBlockDeclarationAst = class GenericBlockDeclarationAst {
 	syntax;
 	constructor(syntax) {
 		this.syntax = syntax;
@@ -573,8 +803,11 @@ var BlockDeclarationAst = class BlockDeclarationAst {
 	*entries() {
 		yield* filterChildren(this.syntax, KeyValuePairAst.cast);
 	}
+	*attributes() {
+		yield* filterChildren(this.syntax, ModelAttributeAst.cast);
+	}
 	static cast(node) {
-		return node.kind === "BlockDeclaration" ? new BlockDeclarationAst(node) : void 0;
+		return node.kind === "GenericBlockDeclaration" ? new GenericBlockDeclarationAst(node) : void 0;
 	}
 };
 var KeyValuePairAst = class KeyValuePairAst {
@@ -623,21 +856,6 @@ var FieldDeclarationAst = class FieldDeclarationAst {
 		return node.kind === "FieldDeclaration" ? new FieldDeclarationAst(node) : void 0;
 	}
 };
-var EnumValueDeclarationAst = class EnumValueDeclarationAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	name() {
-		return findFirstChild(this.syntax, IdentifierAst.cast);
-	}
-	*attributes() {
-		yield* filterChildren(this.syntax, FieldAttributeAst.cast);
-	}
-	static cast(node) {
-		return node.kind === "EnumValueDeclaration" ? new EnumValueDeclarationAst(node) : void 0;
-	}
-};
 var NamedTypeDeclarationAst = class NamedTypeDeclarationAst {
 	syntax;
 	constructor(syntax) {
@@ -703,6 +921,498 @@ var GreenNodeBuilder = class {
 	}
 };
 //#endregion
-export { ArrayLiteralAst, AttributeArgAst, AttributeArgListAst, BlockDeclarationAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, DocumentAst, EnumDeclarationAst, EnumValueDeclarationAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GreenNodeBuilder, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamedTypeDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, StringLiteralExprAst, SyntaxNode, TypeAnnotationAst, TypesBlockAst, castExpression, createSyntaxTree, filterChildren, findChildToken, findFirstChild, greenNode, greenToken };
+//#region src/parse.ts
+const TRIVIA_KINDS = new Set([
+	"Whitespace",
+	"Newline",
+	"Comment"
+]);
+/**
+* The fault-tolerant parser substrate the grammars drive. Trivia is flushed
+* into the enclosing open node, so every child node spans exactly its first
+* through last significant token.
+*/
+var Cursor = class {
+	#tokenizer;
+	#sourceFile;
+	#builder = new GreenNodeBuilder();
+	#diagnostics = [];
+	#offset = 0;
+	#depth = 0;
+	constructor(source) {
+		this.#tokenizer = new Tokenizer(source);
+		this.#sourceFile = new SourceFile(source);
+	}
+	get diagnostics() {
+		return this.#diagnostics;
+	}
+	get sourceFile() {
+		return this.#sourceFile;
+	}
+	peekKind(ahead = 0) {
+		return this.peekToken(ahead).kind;
+	}
+	peekToken(ahead = 0) {
+		let rawIndex = 0;
+		let remaining = ahead;
+		for (;;) {
+			const token = this.#tokenizer.peek(rawIndex);
+			if (token.kind === "Eof") return token;
+			if (TRIVIA_KINDS.has(token.kind)) {
+				rawIndex++;
+				continue;
+			}
+			if (remaining === 0) return token;
+			remaining--;
+			rawIndex++;
+		}
+	}
+	/** Span of the significant token `lookahead` positions ahead (`mark(0)` = the next). */
+	mark(lookahead = 0) {
+		let rawIndex = 0;
+		let offset = this.#offset;
+		let remaining = lookahead;
+		for (;;) {
+			const token = this.#tokenizer.peek(rawIndex);
+			if (token.kind === "Eof") return {
+				offset,
+				length: token.text.length
+			};
+			if (!TRIVIA_KINDS.has(token.kind) && remaining === 0) return {
+				offset,
+				length: token.text.length
+			};
+			if (!TRIVIA_KINDS.has(token.kind)) remaining--;
+			offset += token.text.length;
+			rawIndex++;
+		}
+	}
+	/**
+	* Zero-width mark just past the last consumed significant token — anchors an
+	* "expected here" diagnostic, e.g. the `{` missing after a declaration's name.
+	*/
+	markAfterLastToken() {
+		return {
+			offset: this.#offset,
+			length: 0
+		};
+	}
+	startNode(kind) {
+		if (this.#depth > 0) this.flushTrivia();
+		this.#builder.startNode(kind);
+		this.#depth++;
+	}
+	finishNode() {
+		this.#depth--;
+		return this.#builder.finishNode();
+	}
+	bump() {
+		this.flushTrivia();
+		const token = this.#tokenizer.peek();
+		if (token.kind === "Eof") return token;
+		this.#builder.token(token.kind, token.text);
+		this.#advance();
+		return token;
+	}
+	recoverToSyncPoint() {
+		for (;;) {
+			const token = this.#tokenizer.peek();
+			if (token.kind === "Eof" || token.kind === "Newline" || token.kind === "RBrace") return;
+			this.#builder.token(token.kind, token.text);
+			this.#advance();
+		}
+	}
+	flushTrivia() {
+		for (;;) {
+			const token = this.#tokenizer.peek();
+			if (!TRIVIA_KINDS.has(token.kind)) return;
+			this.#builder.token(token.kind, token.text);
+			this.#advance();
+		}
+	}
+	diagnostic(code, message, mark) {
+		const start = mark.offset;
+		const end = start + mark.length;
+		this.#diagnostics.push({
+			code,
+			message,
+			range: {
+				start: this.#sourceFile.positionAt(start),
+				end: this.#sourceFile.positionAt(end)
+			}
+		});
+	}
+	#advance() {
+		this.#offset += this.#tokenizer.next().text.length;
+	}
+};
+function parseIdentifier(cursor) {
+	cursor.startNode("Identifier");
+	cursor.bump();
+	cursor.finishNode();
+}
+/**
+* Returns `undefined` when the next significant token does not start a
+* recognised expression, leaving recovery to the caller.
+*/
+function parseExpression(cursor) {
+	return parseStringLiteralExpr(cursor) ?? parseNumberLiteralExpr(cursor) ?? parseArrayLiteral(cursor) ?? parseObjectLiteralExpr(cursor) ?? parseFunctionCall(cursor) ?? parseBooleanLiteralExpr(cursor) ?? parseIdentifierExpr(cursor);
+}
+function parseStringLiteralExpr(cursor) {
+	if (cursor.peekKind() !== "StringLiteral") return void 0;
+	const stringMark = cursor.mark();
+	const text = cursor.peekToken().text;
+	cursor.startNode("StringLiteralExpr");
+	cursor.bump();
+	if (!isTerminatedStringLiteral(text)) cursor.diagnostic("PSL_UNTERMINATED_STRING", "Unterminated string literal", stringMark);
+	return cursor.finishNode();
+}
+function parseNumberLiteralExpr(cursor) {
+	if (cursor.peekKind() !== "NumberLiteral") return void 0;
+	cursor.startNode("NumberLiteralExpr");
+	cursor.bump();
+	return cursor.finishNode();
+}
+/**
+* Parses a namespace-qualified name `[space ':']? Ident ('.' Ident)*`. The
+* caller guarantees a leading `Ident`.
+*
+* Parsing the whole chain up front lets a position decide
+* constructor-vs-reference by peeking exactly one token for `(`, with no scan of
+* the dotted chain's length.
+*/
+function parseQualifiedName(cursor) {
+	cursor.startNode("QualifiedName");
+	parseIdentifier(cursor);
+	parseQualifiedSegments(cursor, "Colon");
+	parseQualifiedSegments(cursor, "Dot");
+	cursor.finishNode();
+}
+/**
+* A well-formed name carries at most one colon space and one dot namespace, so
+* each separator past the first of its kind reports `PSL_INVALID_QUALIFIED_NAME`.
+* The separator is consumed regardless, keeping the lossless round-trip intact.
+*/
+function parseQualifiedSegments(cursor, separator) {
+	let seen = 0;
+	while (cursor.peekKind() === separator) {
+		seen++;
+		const separatorMark = cursor.mark();
+		cursor.bump();
+		if (seen > 1) cursor.diagnostic("PSL_INVALID_QUALIFIED_NAME", "Qualified name has too many segments", separatorMark);
+		if (cursor.peekKind() === "Ident") parseIdentifier(cursor);
+		else cursor.diagnostic("PSL_INVALID_QUALIFIED_NAME", "Qualified name is missing a name after the separator", cursor.mark());
+	}
+}
+function parseBooleanLiteralExpr(cursor) {
+	if (cursor.peekKind() !== "Ident") return void 0;
+	const text = cursor.peekToken().text;
+	if (text !== "true" && text !== "false") return void 0;
+	cursor.startNode("BooleanLiteralExpr");
+	cursor.bump();
+	return cursor.finishNode();
+}
+function parseIdentifierExpr(cursor) {
+	if (cursor.peekKind() !== "Ident") return void 0;
+	cursor.startNode("Identifier");
+	cursor.bump();
+	return cursor.finishNode();
+}
+function parseArrayLiteral(cursor) {
+	if (cursor.peekKind() !== "LBracket") return void 0;
+	cursor.startNode("ArrayLiteral");
+	cursor.bump();
+	while (cursor.peekKind() !== "RBracket" && cursor.peekKind() !== "Eof") {
+		if (!parseExpression(cursor)) break;
+		if (cursor.peekKind() === "Comma") cursor.bump();
+		else break;
+	}
+	if (cursor.peekKind() === "RBracket") cursor.bump();
+	return cursor.finishNode();
+}
+function parseObjectLiteralExpr(cursor) {
+	if (cursor.peekKind() !== "LBrace") return void 0;
+	const braceMark = cursor.mark();
+	cursor.startNode("ObjectLiteralExpr");
+	cursor.bump();
+	while (cursor.peekKind() !== "RBrace" && cursor.peekKind() !== "Eof") {
+		parseObjectField(cursor);
+		if (cursor.peekKind() === "Comma") cursor.bump();
+		else if (cursor.peekKind() === "Ident") cursor.diagnostic("PSL_INVALID_OBJECT_LITERAL", "Expected \",\" between object-literal fields", cursor.markAfterLastToken());
+		else break;
+	}
+	if (cursor.peekKind() === "RBrace") cursor.bump();
+	else cursor.diagnostic("PSL_INVALID_OBJECT_LITERAL", "Unterminated object literal", braceMark);
+	return cursor.finishNode();
+}
+function parseObjectField(cursor) {
+	cursor.startNode("ObjectField");
+	const keyMark = cursor.mark();
+	const keyText = cursor.peekToken().text;
+	if (cursor.peekKind() === "Ident") parseIdentifier(cursor);
+	else if (cursor.peekKind() === "StringLiteral") parseStringLiteralExpr(cursor);
+	if (cursor.peekKind() === "Colon") {
+		cursor.bump();
+		if (!parseExpression(cursor)) cursor.diagnostic("PSL_INVALID_OBJECT_LITERAL", "Expected a value after \":\"", cursor.mark());
+	} else {
+		cursor.diagnostic("PSL_INVALID_OBJECT_LITERAL", `Expected ":" after "${keyText}"`, keyMark);
+		if (!(cursor.peekKind() === "Ident" && cursor.peekKind(1) === "Colon")) parseExpression(cursor);
+	}
+	return cursor.finishNode();
+}
+/**
+* Whether the next tokens open a call: a bare `Ident(` or a namespace-qualified
+* `Ident.Ident(`. The lookahead is deliberately bounded so a bare dotted
+* reference like `a.b` is not mistaken for a call, rather than scanning an
+* unbounded dotted chain ahead to find the paren.
+*/
+function isCallAhead(cursor) {
+	if (cursor.peekKind() !== "Ident") return false;
+	if (cursor.peekKind(1) === "LParen") return true;
+	return cursor.peekKind(1) === "Dot" && cursor.peekKind(2) === "Ident" && cursor.peekKind(3) === "LParen";
+}
+/**
+* Parses a function/constructor call — bare `autoincrement()` or qualified
+* `temporal.updatedAt()`. Returns `undefined` unless {@link isCallAhead}
+* confirms a trailing `(`, so the `parseExpression` chain falls through to the
+* boolean and bare-identifier forms.
+*/
+function parseFunctionCall(cursor) {
+	if (!isCallAhead(cursor)) return void 0;
+	cursor.startNode("FunctionCall");
+	parseQualifiedName(cursor);
+	if (cursor.peekKind() === "LParen") parseParenArgs(cursor);
+	return cursor.finishNode();
+}
+/** Parses a parenthesised, comma-separated `AttributeArg` list into the currently open node. */
+function parseParenArgs(cursor) {
+	cursor.bump();
+	while (cursor.peekKind() !== "RParen" && cursor.peekKind() !== "Eof") {
+		parseAttributeArg(cursor);
+		if (cursor.peekKind() === "Comma") cursor.bump();
+		else break;
+	}
+	if (cursor.peekKind() === "RParen") cursor.bump();
+}
+function parseAttributeArg(cursor) {
+	cursor.startNode("AttributeArg");
+	if (cursor.peekKind() === "Ident" && cursor.peekKind(1) === "Colon") {
+		parseIdentifier(cursor);
+		cursor.bump();
+	}
+	parseArgValue(cursor);
+	return cursor.finishNode();
+}
+function parseArgValue(cursor) {
+	parseExpression(cursor);
+}
+function parseAttributeArgList(cursor) {
+	cursor.startNode("AttributeArgList");
+	parseParenArgs(cursor);
+	return cursor.finishNode();
+}
+function parseAttribute(cursor) {
+	const isBlockAttribute = cursor.peekKind() === "DoubleAt";
+	const attributeMark = cursor.mark();
+	cursor.startNode(isBlockAttribute ? "ModelAttribute" : "FieldAttribute");
+	cursor.bump();
+	if (cursor.peekKind() === "Ident") parseQualifiedName(cursor);
+	else cursor.diagnostic("PSL_INVALID_ATTRIBUTE_SYNTAX", "Attribute name expected", attributeMark);
+	if (cursor.peekKind() === "LParen") parseAttributeArgList(cursor);
+	return cursor.finishNode();
+}
+/** A type annotation: `QualifiedName (argList)? ([])? (?)?`, e.g. `pgvector.Vector(1536)[]?`. */
+function parseTypeAnnotation(cursor) {
+	cursor.startNode("TypeAnnotation");
+	if (cursor.peekKind() === "Ident") {
+		parseQualifiedName(cursor);
+		if (cursor.peekKind() === "LParen") parseAttributeArgList(cursor);
+	}
+	if (cursor.peekKind() === "LBracket") {
+		cursor.bump();
+		if (cursor.peekKind() === "RBracket") cursor.bump();
+	}
+	if (cursor.peekKind() === "Question") cursor.bump();
+	return cursor.finishNode();
+}
+/**
+* Parses a full PSL document. Never throws — malformed input yields diagnostics
+* and a recovered tree, not an exception.
+*/
+function parse(source) {
+	const cursor = new Cursor(source);
+	const root = createSyntaxTree(parseDocument(cursor));
+	return {
+		document: DocumentAst.cast(root) ?? new DocumentAst(root),
+		diagnostics: cursor.diagnostics,
+		sourceFile: cursor.sourceFile
+	};
+}
+function parseDocument(cursor) {
+	cursor.startNode("Document");
+	while (cursor.peekKind() !== "Eof") parseDeclaration(cursor, false);
+	cursor.flushTrivia();
+	return cursor.finishNode();
+}
+const RESERVED_BLOCK_KEYWORDS = new Set([
+	"model",
+	"namespace",
+	"type",
+	"types"
+]);
+function keywordIs(cursor, keyword) {
+	return cursor.peekKind() === "Ident" && cursor.peekToken().text === keyword;
+}
+/**
+* Each alternative is a no-op on non-match, consuming nothing, so the
+* forward-only cursor is never left half-consumed by a rejected alternative.
+* Recovery runs via the `if (!node)` tail rather than as a `??` arm, because it
+* appends raw tokens to the open parent instead of returning a child node.
+*/
+function parseDeclaration(cursor, insideNamespace) {
+	const name = cursor.peekKind(1) === "Ident" ? cursor.peekToken(1).text : "";
+	if (insideNamespace && keywordIs(cursor, "namespace")) cursor.diagnostic("PSL_INVALID_NAMESPACE_BLOCK", `Recursive "namespace ${name}" block is not allowed; namespace blocks may not nest`, cursor.mark());
+	else if (insideNamespace && keywordIs(cursor, "types")) cursor.diagnostic("PSL_INVALID_NAMESPACE_BLOCK", "`types` blocks must be declared at the document top level, not inside a namespace block", cursor.mark());
+	else if (keywordIs(cursor, "namespace") && name === UNSPECIFIED_PSL_NAMESPACE_ID) cursor.diagnostic("PSL_INVALID_NAMESPACE_BLOCK", `Namespace name "${UNSPECIFIED_PSL_NAMESPACE_ID}" is reserved for the parser-synthesised bucket for top-level declarations`, cursor.mark(1));
+	if (!(parseModel(cursor) ?? parseNamespace(cursor) ?? parseCompositeType(cursor) ?? parseTypesBlock(cursor) ?? parseGenericBlock(cursor))) parseUnsupportedTopLevel(cursor);
+}
+/**
+* Reports only the first missing piece — a missing name suppresses the
+* missing-brace diagnostic. `nameRequired` is false only for the `types` block.
+*/
+function parseBlock(cursor, kind, nameRequired, parseMember) {
+	const keyword = cursor.peekToken().text;
+	const keywordMark = cursor.mark();
+	cursor.startNode(kind);
+	cursor.bump();
+	const hasName = nameRequired && cursor.peekKind() === "Ident";
+	if (hasName) parseIdentifier(cursor);
+	if (nameRequired && !hasName) cursor.diagnostic("PSL_INVALID_DECLARATION", `Expected a name after "${keyword}"`, keywordMark);
+	else if (cursor.peekKind() !== "LBrace") cursor.diagnostic("PSL_INVALID_DECLARATION", `Expected "{" to open the "${keyword}" block`, cursor.markAfterLastToken());
+	if (cursor.peekKind() === "LBrace") parseBlockBody(cursor, parseMember);
+	else cursor.recoverToSyncPoint();
+	return cursor.finishNode();
+}
+function parseModel(cursor) {
+	if (!keywordIs(cursor, "model")) return void 0;
+	return parseBlock(cursor, "ModelDeclaration", true, parseModelMember);
+}
+/**
+* Excluding the reserved keywords keeps a malformed reserved block (e.g. `model
+* {` with no name) routed to its dedicated parser. The generic keyword set is
+* open, so a bare identifier with no brace (e.g. `oops`) is read as an unfinished
+* custom declaration rather than unsupported content.
+*/
+function parseGenericBlock(cursor) {
+	if (cursor.peekKind() !== "Ident") return void 0;
+	const keyword = cursor.peekToken().text;
+	if (RESERVED_BLOCK_KEYWORDS.has(keyword)) return void 0;
+	const hasName = cursor.peekKind(1) === "Ident" && cursor.peekKind(2) === "LBrace";
+	cursor.startNode("GenericBlockDeclaration");
+	cursor.bump();
+	if (hasName) parseIdentifier(cursor);
+	if (cursor.peekKind() === "LBrace") parseBlockBody(cursor, parseKeyValueMember);
+	else {
+		cursor.diagnostic("PSL_INVALID_DECLARATION", `Expected "{" to open the "${keyword}" block`, cursor.markAfterLastToken());
+		cursor.recoverToSyncPoint();
+	}
+	return cursor.finishNode();
+}
+function parseNamespace(cursor) {
+	if (!keywordIs(cursor, "namespace")) return void 0;
+	return parseBlock(cursor, "Namespace", true, (inner) => parseDeclaration(inner, true));
+}
+function parseCompositeType(cursor) {
+	if (!keywordIs(cursor, "type")) return void 0;
+	return parseBlock(cursor, "CompositeTypeDeclaration", true, parseModelMember);
+}
+/** `types` (plural) is the no-name types block; the singular `type` is the composite type above. */
+function parseTypesBlock(cursor) {
+	if (!keywordIs(cursor, "types")) return void 0;
+	return parseBlock(cursor, "TypesBlock", false, parseNamedTypeMember);
+}
+/** Every `parseMember` consumes at least one significant token, so the loop always terminates. */
+function parseBlockBody(cursor, parseMember) {
+	const braceMark = cursor.mark();
+	cursor.bump();
+	for (;;) {
+		const kind = cursor.peekKind();
+		if (kind === "RBrace" || kind === "Eof") break;
+		parseMember(cursor);
+	}
+	if (cursor.peekKind() === "RBrace") cursor.bump();
+	else cursor.diagnostic("PSL_UNTERMINATED_BLOCK", "Unterminated block declaration", braceMark);
+}
+function parseUnsupportedTopLevel(cursor) {
+	const offending = cursor.peekToken().text;
+	const message = cursor.peekKind(1) === "LBrace" ? `Unsupported top-level block "${offending}"` : `Unsupported top-level declaration "${offending}"`;
+	cursor.diagnostic("PSL_UNSUPPORTED_TOP_LEVEL_BLOCK", message, cursor.mark());
+	cursor.bump();
+	cursor.recoverToSyncPoint();
+}
+/**
+* Matches a leading `@@` block attribute, a no-op otherwise. Single-`@`
+* attributes belong to fields and are parsed inside `parseField`.
+*/
+function parseBlockAttribute(cursor) {
+	if (cursor.peekKind() !== "DoubleAt") return void 0;
+	return parseAttribute(cursor);
+}
+function parseModelMember(cursor) {
+	if (!(parseBlockAttribute(cursor) ?? parseField(cursor))) invalidMember(cursor, "PSL_INVALID_MODEL_MEMBER", `Invalid model member declaration "${cursor.peekToken().text}"`);
+}
+function parseNamedTypeMember(cursor) {
+	if (!parseNamedType(cursor)) invalidMember(cursor, "PSL_INVALID_TYPES_MEMBER", `Invalid types declaration "${cursor.peekToken().text}"`);
+}
+/**
+* A generic-block member is either a `@@`-block attribute or a `key = value`
+* entry. The block-attribute alternative is purely syntactic — it does not judge
+* whether the attribute is valid for the block's kind.
+*/
+function parseKeyValueMember(cursor) {
+	if (!(parseBlockAttribute(cursor) ?? parseKeyValue(cursor))) invalidMember(cursor, "PSL_INVALID_EXTENSION_BLOCK_MEMBER", "Invalid block entry");
+}
+function invalidMember(cursor, code, message) {
+	cursor.diagnostic(code, message, cursor.mark());
+	cursor.bump();
+	cursor.recoverToSyncPoint();
+}
+function parseField(cursor) {
+	if (cursor.peekKind() !== "Ident") return void 0;
+	cursor.startNode("FieldDeclaration");
+	parseIdentifier(cursor);
+	parseTypeAnnotation(cursor);
+	while (cursor.peekKind() === "At") parseAttribute(cursor);
+	return cursor.finishNode();
+}
+function parseNamedType(cursor) {
+	if (cursor.peekKind() !== "Ident") return void 0;
+	cursor.startNode("NamedTypeDeclaration");
+	const nameMark = cursor.mark();
+	const nameText = cursor.peekToken().text;
+	parseIdentifier(cursor);
+	if (cursor.peekKind() === "Equals") cursor.bump();
+	else cursor.diagnostic("PSL_INVALID_TYPES_MEMBER", `Expected "=" after "${nameText}"`, nameMark);
+	parseTypeAnnotation(cursor);
+	while (cursor.peekKind() === "At") parseAttribute(cursor);
+	return cursor.finishNode();
+}
+/**
+* A generic-block entry is either `key = value` or a bare `key` (committing a
+* `KeyValuePair` carrying only the key). A `key =` with no following expression
+* is flagged.
+*/
+function parseKeyValue(cursor) {
+	if (cursor.peekKind() !== "Ident") return void 0;
+	cursor.startNode("KeyValuePair");
+	parseIdentifier(cursor);
+	if (cursor.peekKind() === "Equals") {
+		cursor.bump();
+		if (!parseExpression(cursor)) cursor.diagnostic("PSL_INVALID_EXTENSION_BLOCK_MEMBER", "Expected a value after \"=\"", cursor.mark());
+	}
+	return cursor.finishNode();
+}
+//#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, TypeAnnotationAst, TypesBlockAst, castExpression, createSyntaxTree, filterChildren, findChildToken, findFirstChild, greenNode, greenToken, parse, printSyntax };
 
 //# sourceMappingURL=syntax.mjs.map