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

package/dist/parse-3-vr14ej.mjs

@@ -0,0 +1,626 @@
+import { N as createSyntaxTree, n as DocumentAst } from "./declarations-DR6To8_k.mjs";
+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 CARRIAGE_RETURN = 13;
+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;
+	}
+	lineStartOffset(line) {
+		if (line <= 0) return 0;
+		return this.#lineStarts[line] ?? this.#text.length;
+	}
+	lineEndOffset(line) {
+		if (line < 0) return 0;
+		const nextLineStart = this.#lineStarts[line + 1];
+		if (nextLineStart === void 0) return this.#text.length;
+		const lineFeedOffset = nextLineStart - 1;
+		const carriageReturnOffset = lineFeedOffset - 1;
+		return this.#text.charCodeAt(carriageReturnOffset) === CARRIAGE_RETURN ? carriageReturnOffset : lineFeedOffset;
+	}
+	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/green.ts
+function greenToken(kind, text) {
+	return {
+		type: "token",
+		kind,
+		text
+	};
+}
+function greenNode(kind, children) {
+	let textLength = 0;
+	for (const child of children) textLength += child.type === "token" ? child.text.length : child.textLength;
+	return {
+		type: "node",
+		kind,
+		children,
+		textLength
+	};
+}
+//#endregion
+//#region src/syntax/green-builder.ts
+var GreenNodeBuilder = class {
+	#stack = [];
+	startNode(kind) {
+		this.#stack.push({
+			kind,
+			children: []
+		});
+	}
+	token(kind, text) {
+		const current = this.#stack.at(-1);
+		if (!current) throw new Error("GreenNodeBuilder: token() called with no open node");
+		current.children.push(greenToken(kind, text));
+	}
+	finishNode() {
+		const completed = this.#stack.pop();
+		if (!completed) throw new Error("GreenNodeBuilder: finishNode() called with no open node");
+		const node = greenNode(completed.kind, completed.children);
+		const parent = this.#stack.at(-1);
+		if (parent) parent.children.push(node);
+		return node;
+	}
+};
+//#endregion
+//#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) {
+	const kind = cursor.peekKind();
+	if (kind !== "Ident" && kind !== "StringLiteral" && kind !== "NumberLiteral" && kind !== "LBracket" && kind !== "LBrace") return;
+	cursor.startNode("AttributeArg");
+	if (cursor.peekKind() === "Ident" && cursor.peekKind(1) === "Colon") {
+		parseIdentifier(cursor);
+		cursor.bump();
+	}
+	parseArgValue(cursor);
+	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)[]?`. When the field has no type, no node is emitted —
+* a missing type is the absence of a `TypeAnnotation`, not a zero-width one.
+*/
+function parseTypeAnnotation(cursor) {
+	const kind = cursor.peekKind();
+	if (kind !== "Ident" && kind !== "LBracket" && kind !== "Question") return;
+	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();
+	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");
+	const nameMark = cursor.mark();
+	const nameText = cursor.peekToken().text;
+	parseIdentifier(cursor);
+	if (cursor.peekKind() !== "Ident") cursor.diagnostic("PSL_INVALID_MODEL_MEMBER", `Expected a type after field "${nameText}"`, nameMark);
+	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 { SourceFile as a, greenToken as i, GreenNodeBuilder as n, greenNode as r, parse as t };
+
+//# sourceMappingURL=parse-3-vr14ej.mjs.map