@prisma-next/psl-parser 0.13.0-dev.4 → 0.13.0-dev.40

package/dist/syntax.mjs

@@ -1,3 +1,66 @@
+import { n as isTerminatedStringLiteral, t as Tokenizer } from "./tokenizer-DdaOstnz.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;
@@ -182,6 +245,75 @@ 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 "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 +325,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 +366,64 @@ 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);
+		}
+	}
+	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;
@@ -413,7 +592,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) ?? EnumDeclarationAst.cast(node) ?? CompositeTypeDeclarationAst.cast(node) ?? GenericBlockDeclarationAst.cast(node);
 }
 var DocumentAst = class DocumentAst {
 	syntax;
@@ -553,7 +732,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;
@@ -574,7 +753,7 @@ var BlockDeclarationAst = class BlockDeclarationAst {
 		yield* filterChildren(this.syntax, KeyValuePairAst.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 {
@@ -703,6 +882,511 @@ 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 leaf and (later) declaration grammars
+* drive. It owns the token cursor, the green-tree builder with its
+* trivia-attachment discipline, the diagnostic sink, and the recovery
+* primitive. 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(1)` = the one after), captured eagerly so it stays valid after the cursor advances.
+	*/
+	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 (before any trailing
+	* trivia) — anchors an "expected here" diagnostic at the spot, 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();
+}
+/**
+* Parses a single expression in argument or element position. Returns the
+* produced node, or `undefined` when the next significant token does not start a
+* recognised expression (the caller decides how to recover).
+*/
+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();
+}
+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") {
+		cursor.diagnostic("PSL_INVALID_OBJECT_LITERAL", "Object literal keys must be identifiers", keyMark);
+		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();
+}
+function parseFunctionCall(cursor) {
+	if (cursor.peekKind() !== "Ident" || cursor.peekKind(1) !== "LParen") return void 0;
+	cursor.startNode("FunctionCall");
+	parseIdentifier(cursor);
+	parseParenArgs(cursor);
+	return cursor.finishNode();
+}
+/**
+* Parses a parenthesised, comma-separated `AttributeArg` list into the
+* currently open node (a `FunctionCall` or an `AttributeArgList`), consuming the
+* surrounding parentheses.
+*/
+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") {
+		parseIdentifier(cursor);
+		if (cursor.peekKind() === "Dot") {
+			cursor.bump();
+			if (cursor.peekKind() === "Ident") parseIdentifier(cursor);
+			else cursor.diagnostic("PSL_INVALID_ATTRIBUTE_SYNTAX", "Attribute name expected after \".\"", cursor.mark());
+		}
+	} else cursor.diagnostic("PSL_INVALID_ATTRIBUTE_SYNTAX", "Attribute name expected", attributeMark);
+	if (cursor.peekKind() === "LParen") parseAttributeArgList(cursor);
+	return cursor.finishNode();
+}
+function parseTypeAnnotation(cursor) {
+	cursor.startNode("TypeAnnotation");
+	if (cursor.peekKind() === "Ident" && cursor.peekKind(1) === "LParen") parseFunctionCall(cursor);
+	else if (cursor.peekKind() === "Ident") {
+		parseIdentifier(cursor);
+		parseQualifierSegments(cursor, "Colon");
+		parseQualifierSegments(cursor, "Dot");
+	}
+	if (cursor.peekKind() === "LBracket") {
+		cursor.bump();
+		if (cursor.peekKind() === "RBracket") cursor.bump();
+	}
+	if (cursor.peekKind() === "Question") cursor.bump();
+	return cursor.finishNode();
+}
+/**
+* Consumes a run of `<separator> Ident` qualifier segments. A well-formed type
+* carries at most one colon-introduced space and one dot-introduced namespace;
+* any second separator of the same kind is over-qualification and emits
+* `PSL_INVALID_QUALIFIED_TYPE` pointed at the offending separator, while still
+* consuming the segment so the subtree (and the round-trip) stays intact.
+*/
+function parseQualifierSegments(cursor, separator) {
+	let seen = 0;
+	while (cursor.peekKind() === separator) {
+		seen++;
+		const separatorMark = cursor.mark();
+		cursor.bump();
+		if (seen > 1) cursor.diagnostic("PSL_INVALID_QUALIFIED_TYPE", "Qualified type reference has too many segments", separatorMark);
+		if (cursor.peekKind() === "Ident") parseIdentifier(cursor);
+	}
+}
+/**
+* Drives the recursive descent over a full PSL document. Tokenizes via the
+* substrate cursor, builds a complete green/red tree wrapped as a
+* {@link DocumentAst}, collects every syntactic {@link ParseDiagnostic}, and
+* 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",
+	"enum",
+	"namespace",
+	"type",
+	"types"
+]);
+function keywordIs(cursor, keyword) {
+	return cursor.peekKind() === "Ident" && cursor.peekToken().text === keyword;
+}
+/**
+* Recognises one top-level (or namespace-body) declaration as an ordered list of
+* alternatives composed with `??`. Each alternative owns its discriminating
+* `peekKind`/`peekToken` lookahead and is a no-op on non-match: it returns
+* `undefined` having consumed and mutated nothing, so the forward-only cursor is
+* never left half-consumed by a rejected alternative. The first alternative to
+* commit wins; when none match, the input is recovered as an unsupported
+* declaration. 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) ?? parseEnum(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, which never has a name.
+*/
+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);
+}
+function parseEnum(cursor) {
+	if (!keywordIs(cursor, "enum")) return void 0;
+	return parseBlock(cursor, "EnumDeclaration", true, parseEnumMember);
+}
+/**
+* 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
+* (extension-contributed), so a bare identifier with no brace (e.g. `oops`) is read as an
+* unfinished custom declaration — a committed `GenericBlockDeclaration` + missing-brace diagnostic
+* — not unsupported content. A non-identifier lead can't be a declaration name, so it falls
+* through to `parseUnsupportedTopLevel`.
+*/
+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);
+}
+/**
+* Parses a `{ … }` block body: consumes the braces, dispatches each member to
+* `parseMember` until the closing brace or EOF, and flags an unclosed block.
+* 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();
+}
+/**
+* Block-attribute alternative shared by model and enum members: matches a
+* leading `@@` (yielding a `ModelAttribute`) and is a no-op on anything else. The
+* `@@`-vs-`@` distinction is preserved exactly — single-`@` attributes belong to
+* fields and enum values and are parsed inside `parseField`/`parseEnumValue`.
+*/
+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 parseEnumMember(cursor) {
+	if (!(parseBlockAttribute(cursor) ?? parseEnumValue(cursor))) invalidMember(cursor, "PSL_INVALID_ENUM_MEMBER", `Invalid enum value declaration "${cursor.peekToken().text}"`);
+}
+function parseNamedTypeMember(cursor) {
+	if (!parseNamedType(cursor)) invalidMember(cursor, "PSL_INVALID_TYPES_MEMBER", `Invalid types declaration "${cursor.peekToken().text}"`);
+}
+function parseKeyValueMember(cursor) {
+	if (!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 parseEnumValue(cursor) {
+	if (cursor.peekKind() !== "Ident") return void 0;
+	cursor.startNode("EnumValueDeclaration");
+	parseIdentifier(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();
+}
+function parseKeyValue(cursor) {
+	if (cursor.peekKind() !== "Ident") return void 0;
+	cursor.startNode("KeyValuePair");
+	const keyMark = cursor.mark();
+	const keyText = cursor.peekToken().text;
+	parseIdentifier(cursor);
+	if (cursor.peekKind() === "Equals") cursor.bump();
+	else cursor.diagnostic("PSL_INVALID_EXTENSION_BLOCK_MEMBER", `Expected "=" after "${keyText}"`, keyMark);
+	parseExpression(cursor);
+	return cursor.finishNode();
+}
+//#endregion
+export { ArrayLiteralAst, AttributeArgAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, DocumentAst, EnumDeclarationAst, EnumValueDeclarationAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, GreenNodeBuilder, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamedTypeDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectFieldAst, ObjectLiteralExprAst, SourceFile, StringLiteralExprAst, SyntaxNode, TypeAnnotationAst, TypesBlockAst, castExpression, createSyntaxTree, filterChildren, findChildToken, findFirstChild, greenNode, greenToken, parse };
 
 //# sourceMappingURL=syntax.mjs.map