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

package/dist/syntax.mjs

@@ -1,1421 +1,2 @@
-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;
-	offset;
-	parent;
-	constructor(green, offset, parent) {
-		this.green = green;
-		this.offset = offset;
-		this.parent = parent;
-	}
-	get kind() {
-		return this.green.kind;
-	}
-	get textLength() {
-		return this.green.textLength;
-	}
-	get firstChild() {
-		return childAt(this, 0);
-	}
-	get lastChild() {
-		const len = this.green.children.length;
-		if (len === 0) return void 0;
-		return childAt(this, len - 1);
-	}
-	get nextSibling() {
-		if (!this.parent) return void 0;
-		const siblings = this.parent.green.children;
-		let offset = this.parent.offset;
-		let found = false;
-		for (const child of siblings) {
-			if (found) return wrapElement(child, offset, this.parent);
-			const childLen = elementTextLength(child);
-			if (child.type === "node" && offset === this.offset && child === this.green) found = true;
-			offset += childLen;
-		}
-	}
-	get prevSibling() {
-		if (!this.parent) return void 0;
-		const siblings = this.parent.green.children;
-		let offset = this.parent.offset;
-		let prev;
-		for (const child of siblings) {
-			if (child.type === "node" && offset === this.offset && child === this.green) {
-				if (!prev) return void 0;
-				return wrapElement(prev.green, prev.offset, this.parent);
-			}
-			prev = {
-				green: child,
-				offset
-			};
-			offset += elementTextLength(child);
-		}
-	}
-	*children() {
-		let offset = this.offset;
-		for (const child of this.green.children) {
-			yield wrapElement(child, offset, this);
-			offset += elementTextLength(child);
-		}
-	}
-	*childNodes() {
-		for (const child of this.children()) if (child instanceof SyntaxNode) yield child;
-	}
-	*ancestors() {
-		let current = this.parent;
-		while (current) {
-			yield current;
-			current = current.parent;
-		}
-	}
-	*descendants() {
-		const stack = [this];
-		for (let el = stack.pop(); el !== void 0; el = stack.pop()) {
-			yield el;
-			if (el instanceof SyntaxNode) {
-				const children = Array.from(el.children());
-				for (let i = children.length - 1; i >= 0; i--) {
-					const child = children[i];
-					if (child !== void 0) stack.push(child);
-				}
-			}
-		}
-	}
-	*tokens() {
-		for (const el of this.descendants()) if (!(el instanceof SyntaxNode)) yield el;
-	}
-};
-function elementTextLength(el) {
-	return el.type === "token" ? el.text.length : el.textLength;
-}
-function wrapElement(green, offset, parent) {
-	if (green.type === "token") return {
-		kind: green.kind,
-		text: green.text,
-		offset
-	};
-	return new SyntaxNode(green, offset, parent);
-}
-function childAt(node, index) {
-	const children = node.green.children;
-	const target = children[index];
-	if (target === void 0) return void 0;
-	let offset = node.offset;
-	for (let i = 0; i < index; i++) {
-		const child = children[i];
-		if (child !== void 0) offset += elementTextLength(child);
-	}
-	return wrapElement(target, offset, node);
-}
-function createSyntaxTree(green) {
-	return new SyntaxNode(green, 0, void 0);
-}
-//#endregion
-//#region src/syntax/ast-helpers.ts
-function findChildToken(node, kind) {
-	for (const child of node.children()) if (!(child instanceof SyntaxNode) && child.kind === kind) return child;
-}
-function findFirstChild(node, cast) {
-	for (const child of node.childNodes()) {
-		const result = cast(child);
-		if (result !== void 0) return result;
-	}
-}
-function* filterChildren(node, cast) {
-	for (const child of node.childNodes()) {
-		const result = cast(child);
-		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 {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	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, 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");
-	}
-	rparen() {
-		return findChildToken(this.syntax, "RParen");
-	}
-	*args() {
-		yield* filterChildren(this.syntax, AttributeArgAst.cast);
-	}
-	static cast(node) {
-		return node.kind === "FunctionCall" ? new FunctionCallAst(node) : void 0;
-	}
-};
-var ArrayLiteralAst = class ArrayLiteralAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	lbracket() {
-		return findChildToken(this.syntax, "LBracket");
-	}
-	rbracket() {
-		return findChildToken(this.syntax, "RBracket");
-	}
-	*elements() {
-		yield* filterChildren(this.syntax, castExpression);
-	}
-	static cast(node) {
-		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) {
-		this.syntax = syntax;
-	}
-	token() {
-		return findChildToken(this.syntax, "StringLiteral");
-	}
-	value() {
-		const tok = this.token();
-		if (!tok) return void 0;
-		return decodeStringLiteral(tok.text.slice(1, -1));
-	}
-	static cast(node) {
-		return node.kind === "StringLiteralExpr" ? new StringLiteralExprAst(node) : void 0;
-	}
-};
-var NumberLiteralExprAst = class NumberLiteralExprAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	token() {
-		return findChildToken(this.syntax, "NumberLiteral");
-	}
-	value() {
-		const tok = this.token();
-		if (!tok) return void 0;
-		return Number(tok.text);
-	}
-	static cast(node) {
-		return node.kind === "NumberLiteralExpr" ? new NumberLiteralExprAst(node) : void 0;
-	}
-};
-var BooleanLiteralExprAst = class BooleanLiteralExprAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	token() {
-		return findChildToken(this.syntax, "Ident");
-	}
-	value() {
-		const tok = this.token();
-		if (!tok) return void 0;
-		if (tok.text === "true") return true;
-		if (tok.text === "false") return false;
-	}
-	static cast(node) {
-		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) ?? ObjectLiteralExprAst.cast(node) ?? IdentifierAst.cast(node);
-}
-var AttributeArgAst = class AttributeArgAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	name() {
-		if (!this.colon()) return void 0;
-		return findFirstChild(this.syntax, IdentifierAst.cast);
-	}
-	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 === "AttributeArg" ? new AttributeArgAst(node) : void 0;
-	}
-};
-//#endregion
-//#region src/syntax/ast/attributes.ts
-var AttributeArgListAst = class AttributeArgListAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	lparen() {
-		return findChildToken(this.syntax, "LParen");
-	}
-	rparen() {
-		return findChildToken(this.syntax, "RParen");
-	}
-	*args() {
-		yield* filterChildren(this.syntax, AttributeArgAst.cast);
-	}
-	static cast(node) {
-		return node.kind === "AttributeArgList" ? new AttributeArgListAst(node) : void 0;
-	}
-};
-var FieldAttributeAst = class FieldAttributeAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	at() {
-		return findChildToken(this.syntax, "At");
-	}
-	name() {
-		return findFirstChild(this.syntax, QualifiedNameAst.cast);
-	}
-	argList() {
-		return findFirstChild(this.syntax, AttributeArgListAst.cast);
-	}
-	static cast(node) {
-		return node.kind === "FieldAttribute" ? new FieldAttributeAst(node) : void 0;
-	}
-};
-var ModelAttributeAst = class ModelAttributeAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	doubleAt() {
-		return findChildToken(this.syntax, "DoubleAt");
-	}
-	name() {
-		return findFirstChild(this.syntax, QualifiedNameAst.cast);
-	}
-	argList() {
-		return findFirstChild(this.syntax, AttributeArgListAst.cast);
-	}
-	static cast(node) {
-		return node.kind === "ModelAttribute" ? new ModelAttributeAst(node) : void 0;
-	}
-};
-//#endregion
-//#region src/syntax/ast/type-annotation.ts
-var TypeAnnotationAst = class TypeAnnotationAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	/** The annotation's reference, doubling as the constructor callee when an {@link argList} follows. */
-	name() {
-		return findFirstChild(this.syntax, QualifiedNameAst.cast);
-	}
-	/** Present when the annotation is a constructor (`Vector(1536)`) rather than a plain reference. */
-	argList() {
-		return findFirstChild(this.syntax, AttributeArgListAst.cast);
-	}
-	isConstructor() {
-		return this.argList() !== void 0;
-	}
-	lbracket() {
-		return findChildToken(this.syntax, "LBracket");
-	}
-	rbracket() {
-		return findChildToken(this.syntax, "RBracket");
-	}
-	questionMark() {
-		return findChildToken(this.syntax, "Question");
-	}
-	isList() {
-		return this.lbracket() !== void 0;
-	}
-	isOptional() {
-		return this.questionMark() !== void 0;
-	}
-	static cast(node) {
-		return node.kind === "TypeAnnotation" ? new TypeAnnotationAst(node) : void 0;
-	}
-};
-//#endregion
-//#region src/syntax/ast/declarations.ts
-function castNamespaceMember(node) {
-	return ModelDeclarationAst.cast(node) ?? CompositeTypeDeclarationAst.cast(node) ?? GenericBlockDeclarationAst.cast(node);
-}
-var DocumentAst = class DocumentAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	*declarations() {
-		yield* filterChildren(this.syntax, (node) => castNamespaceMember(node) ?? TypesBlockAst.cast(node) ?? NamespaceDeclarationAst.cast(node));
-	}
-	static cast(node) {
-		return node.kind === "Document" ? new DocumentAst(node) : void 0;
-	}
-};
-var ModelDeclarationAst = class ModelDeclarationAst {
-	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");
-	}
-	*fields() {
-		yield* filterChildren(this.syntax, FieldDeclarationAst.cast);
-	}
-	*attributes() {
-		yield* filterChildren(this.syntax, ModelAttributeAst.cast);
-	}
-	static cast(node) {
-		return node.kind === "ModelDeclaration" ? new ModelDeclarationAst(node) : void 0;
-	}
-};
-var CompositeTypeDeclarationAst = class CompositeTypeDeclarationAst {
-	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");
-	}
-	*fields() {
-		yield* filterChildren(this.syntax, FieldDeclarationAst.cast);
-	}
-	*attributes() {
-		yield* filterChildren(this.syntax, ModelAttributeAst.cast);
-	}
-	static cast(node) {
-		return node.kind === "CompositeTypeDeclaration" ? new CompositeTypeDeclarationAst(node) : void 0;
-	}
-};
-var NamespaceDeclarationAst = class NamespaceDeclarationAst {
-	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");
-	}
-	*declarations() {
-		yield* filterChildren(this.syntax, castNamespaceMember);
-	}
-	static cast(node) {
-		return node.kind === "Namespace" ? new NamespaceDeclarationAst(node) : void 0;
-	}
-};
-var TypesBlockAst = class TypesBlockAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	keyword() {
-		return findChildToken(this.syntax, "Ident");
-	}
-	lbrace() {
-		return findChildToken(this.syntax, "LBrace");
-	}
-	rbrace() {
-		return findChildToken(this.syntax, "RBrace");
-	}
-	*declarations() {
-		yield* filterChildren(this.syntax, NamedTypeDeclarationAst.cast);
-	}
-	static cast(node) {
-		return node.kind === "TypesBlock" ? new TypesBlockAst(node) : void 0;
-	}
-};
-var GenericBlockDeclarationAst = class GenericBlockDeclarationAst {
-	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");
-	}
-	*entries() {
-		yield* filterChildren(this.syntax, KeyValuePairAst.cast);
-	}
-	*attributes() {
-		yield* filterChildren(this.syntax, ModelAttributeAst.cast);
-	}
-	static cast(node) {
-		return node.kind === "GenericBlockDeclaration" ? new GenericBlockDeclarationAst(node) : void 0;
-	}
-};
-var KeyValuePairAst = class KeyValuePairAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	key() {
-		return findFirstChild(this.syntax, IdentifierAst.cast);
-	}
-	equals() {
-		return findChildToken(this.syntax, "Equals");
-	}
-	value() {
-		let pastEquals = false;
-		for (const child of this.syntax.children()) {
-			if (!(child instanceof SyntaxNode)) {
-				if (child.kind === "Equals") pastEquals = true;
-				continue;
-			}
-			if (pastEquals) {
-				const expr = castExpression(child);
-				if (expr) return expr;
-			}
-		}
-	}
-	static cast(node) {
-		return node.kind === "KeyValuePair" ? new KeyValuePairAst(node) : void 0;
-	}
-};
-var FieldDeclarationAst = class FieldDeclarationAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	name() {
-		return findFirstChild(this.syntax, IdentifierAst.cast);
-	}
-	typeAnnotation() {
-		return findFirstChild(this.syntax, TypeAnnotationAst.cast);
-	}
-	*attributes() {
-		yield* filterChildren(this.syntax, FieldAttributeAst.cast);
-	}
-	static cast(node) {
-		return node.kind === "FieldDeclaration" ? new FieldDeclarationAst(node) : void 0;
-	}
-};
-var NamedTypeDeclarationAst = class NamedTypeDeclarationAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	name() {
-		return findFirstChild(this.syntax, IdentifierAst.cast);
-	}
-	equals() {
-		return findChildToken(this.syntax, "Equals");
-	}
-	typeAnnotation() {
-		return findFirstChild(this.syntax, TypeAnnotationAst.cast);
-	}
-	*attributes() {
-		yield* filterChildren(this.syntax, FieldAttributeAst.cast);
-	}
-	static cast(node) {
-		return node.kind === "NamedTypeDeclaration" ? new NamedTypeDeclarationAst(node) : void 0;
-	}
-};
-//#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) {
-	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");
-	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
+import { A as findChildToken, C as ObjectFieldAst, D as QualifiedNameAst, E as castExpression, F as SourceFile, M as printSyntax, N as SyntaxNode, O as IdentifierAst, P as createSyntaxTree, S as NumberLiteralExprAst, T as StringLiteralExprAst, _ as ModelAttributeAst, a as CompositeTypeDeclarationAst, b as BooleanLiteralExprAst, c as GenericBlockDeclarationAst, d as NamedTypeDeclarationAst, f as NamespaceDeclarationAst, g as FieldAttributeAst, h as AttributeArgListAst, i as greenToken, j as findFirstChild, k as filterChildren, l as KeyValuePairAst, m as TypeAnnotationAst, n as GreenNodeBuilder, o as DocumentAst, p as TypesBlockAst, r as greenNode, s as FieldDeclarationAst, t as parse, u as ModelDeclarationAst, v as ArrayLiteralAst, w as ObjectLiteralExprAst, x as FunctionCallAst, y as AttributeArgAst } from "./parse-B_3gIEFd.mjs";
 export { ArrayLiteralAst, AttributeArgAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, DocumentAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, GreenNodeBuilder, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamedTypeDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectFieldAst, ObjectLiteralExprAst, QualifiedNameAst, SourceFile, StringLiteralExprAst, SyntaxNode, TypeAnnotationAst, TypesBlockAst, castExpression, createSyntaxTree, filterChildren, findChildToken, findFirstChild, greenNode, greenToken, parse, printSyntax };
-
-//# sourceMappingURL=syntax.mjs.map