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

package/dist/declarations-CPDuQm7x.mjs

@@ -0,0 +1,1055 @@
+//#region src/syntax/red.ts
+/**
+* A token in the red tree. Unlike the green-layer {@link Token} (kind + text
+* only), a red token also carries its absolute `offset` within the source and a
+* link back to its `parent` {@link SyntaxNode}, so a cursor anchored on a token
+* can walk outward (parent, previous/next token, siblings) without re-scanning
+* from the document root.
+*/
+var SyntaxToken = class {
+	green;
+	kind;
+	text;
+	offset;
+	parent;
+	/** Position within the parent's children, enabling O(1) sibling navigation without rescanning the green layer. */
+	index;
+	constructor(green, offset, parent, index) {
+		this.green = green;
+		this.kind = green.kind;
+		this.text = green.text;
+		this.offset = offset;
+		this.parent = parent;
+		this.index = index;
+	}
+	get textLength() {
+		return this.text.length;
+	}
+	get endOffset() {
+		return this.offset + this.textLength;
+	}
+	/** Whether `offset` falls within this token, inclusive of both ends. */
+	isInside(offset) {
+		return offset >= this.offset && offset <= this.endOffset;
+	}
+	isOutside(offset) {
+		return !this.isInside(offset);
+	}
+	/** The sibling element immediately after this token within its parent. */
+	get nextSiblingOrToken() {
+		return childAt(this.parent, this.index + 1);
+	}
+	/** The sibling element immediately before this token within its parent. */
+	get prevSiblingOrToken() {
+		return childAt(this.parent, this.index - 1);
+	}
+	/** The next token in document order, crossing node boundaries. */
+	get nextToken() {
+		for (let el = climbingNext(this); el !== void 0; el = climbingNext(el)) {
+			const token = firstToken(el);
+			if (token !== void 0) return token;
+		}
+	}
+	/** The previous token in document order, crossing node boundaries. */
+	get prevToken() {
+		for (let el = climbingPrev(this); el !== void 0; el = climbingPrev(el)) {
+			const token = lastToken(el);
+			if (token !== void 0) return token;
+		}
+	}
+};
+var TokenAtOffset = class TokenAtOffset {
+	#state;
+	constructor(state) {
+		this.#state = state;
+	}
+	static none() {
+		return new TokenAtOffset({ kind: "none" });
+	}
+	static single(token) {
+		return new TokenAtOffset({
+			kind: "single",
+			token
+		});
+	}
+	static between(left, right) {
+		return new TokenAtOffset({
+			kind: "between",
+			left,
+			right
+		});
+	}
+	get isEmpty() {
+		return this.#state.kind === "none";
+	}
+	get isBetween() {
+		return this.#state.kind === "between";
+	}
+	leftBiased() {
+		switch (this.#state.kind) {
+			case "none": return;
+			case "single": return this.#state.token;
+			case "between": return this.#state.left;
+		}
+	}
+	rightBiased() {
+		switch (this.#state.kind) {
+			case "none": return;
+			case "single": return this.#state.token;
+			case "between": return this.#state.right;
+		}
+	}
+};
+var SyntaxNode = class SyntaxNode {
+	green;
+	offset;
+	parent;
+	/** Position within the parent's children, enabling O(1) sibling navigation without rescanning the green layer. */
+	index;
+	constructor(green, offset, parent, index) {
+		this.green = green;
+		this.offset = offset;
+		this.parent = parent;
+		this.index = index;
+	}
+	get kind() {
+		return this.green.kind;
+	}
+	get textLength() {
+		return this.green.textLength;
+	}
+	get endOffset() {
+		return this.offset + this.textLength;
+	}
+	/** Whether `offset` falls within this node, inclusive of both ends. */
+	isInside(offset) {
+		return offset >= this.offset && offset <= this.endOffset;
+	}
+	isOutside(offset) {
+		return !this.isInside(offset);
+	}
+	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() {
+		return this.parent === void 0 ? void 0 : childAt(this.parent, this.index + 1);
+	}
+	get prevSibling() {
+		return this.parent === void 0 ? void 0 : childAt(this.parent, this.index - 1);
+	}
+	/** The sibling element immediately after this node within its parent. */
+	get nextSiblingOrToken() {
+		return this.nextSibling;
+	}
+	/** The sibling element immediately before this node within its parent. */
+	get prevSiblingOrToken() {
+		return this.prevSibling;
+	}
+	/** The first token in this subtree (depth-first), or `undefined` if empty. */
+	get firstToken() {
+		return firstToken(this);
+	}
+	/** The last token in this subtree (depth-first), or `undefined` if empty. */
+	get lastToken() {
+		return lastToken(this);
+	}
+	*children() {
+		let offset = this.offset;
+		let index = 0;
+		for (const child of this.green.children) {
+			yield wrapElement(child, offset, this, index);
+			offset += elementTextLength(child);
+			index++;
+		}
+	}
+	*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;
+		}
+	}
+	/** The nearest match, testing this node itself before walking its ancestors. */
+	findAncestor(cast) {
+		const self = cast(this);
+		if (self !== void 0) return self;
+		for (const ancestor of this.ancestors()) {
+			const result = cast(ancestor);
+			if (result !== void 0) return result;
+		}
+	}
+	*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 SyntaxToken) yield el;
+	}
+	/**
+	* The token(s) at `offset`. The between-two-tokens case (offset exactly on a
+	* token seam) is represented explicitly so callers can left/right bias.
+	*/
+	tokenAtOffset(offset) {
+		return tokenAtOffsetOf(this, offset);
+	}
+	/**
+	* The smallest element fully containing the range `[start, end]`. At a seam
+	* (and for empty ranges) the left-hand element is preferred, matching
+	* {@link containsOffset}'s inclusive span.
+	*/
+	coveringElement(start, end) {
+		let result = this;
+		for (;;) {
+			if (result instanceof SyntaxToken) return result;
+			let next;
+			for (const child of result.children()) if (containsRange(child, start, end)) {
+				next = child;
+				break;
+			}
+			if (next === void 0) return result;
+			result = next;
+		}
+	}
+};
+function elementTextLength(el) {
+	return el.type === "token" ? el.text.length : el.textLength;
+}
+function elementLength(el) {
+	return el instanceof SyntaxToken ? el.text.length : el.textLength;
+}
+/**
+* Whether `el` contains `offset`. The span is inclusive on both ends so a seam
+* offset touches both neighbours.
+*/
+function containsOffset(el, offset) {
+	const start = el.offset;
+	const len = elementLength(el);
+	return offset >= start && offset <= start + len;
+}
+function containsRange(el, start, end) {
+	const elStart = el.offset;
+	const len = elementLength(el);
+	return elStart <= start && end <= elStart + len;
+}
+function tokenAtOffsetOf(el, offset) {
+	if (el instanceof SyntaxToken) return TokenAtOffset.single(el);
+	let left;
+	let right;
+	for (const child of el.children()) {
+		if (!containsOffset(child, offset)) continue;
+		if (left === void 0) left = child;
+		else {
+			right = child;
+			break;
+		}
+	}
+	if (left === void 0) return TokenAtOffset.none();
+	if (right === void 0) return tokenAtOffsetOf(left, offset);
+	const leftToken = tokenAtOffsetOf(left, offset).rightBiased();
+	const rightToken = tokenAtOffsetOf(right, offset).leftBiased();
+	if (leftToken !== void 0 && rightToken !== void 0) return TokenAtOffset.between(leftToken, rightToken);
+	if (leftToken !== void 0) return TokenAtOffset.single(leftToken);
+	if (rightToken !== void 0) return TokenAtOffset.single(rightToken);
+	return TokenAtOffset.none();
+}
+function firstToken(el) {
+	if (el instanceof SyntaxToken) return el;
+	for (const child of el.children()) {
+		const token = firstToken(child);
+		if (token !== void 0) return token;
+	}
+}
+function lastToken(el) {
+	if (el instanceof SyntaxToken) return el;
+	const children = Array.from(el.children());
+	for (let i = children.length - 1; i >= 0; i--) {
+		const child = children[i];
+		if (child !== void 0) {
+			const token = lastToken(child);
+			if (token !== void 0) return token;
+		}
+	}
+}
+function climbingNext(el) {
+	let current = el;
+	for (;;) {
+		const parent = current.parent;
+		if (parent === void 0) return void 0;
+		const sibling = childAt(parent, current.index + 1);
+		if (sibling !== void 0) return sibling;
+		current = parent;
+	}
+}
+function climbingPrev(el) {
+	let current = el;
+	for (;;) {
+		const parent = current.parent;
+		if (parent === void 0) return void 0;
+		const sibling = childAt(parent, current.index - 1);
+		if (sibling !== void 0) return sibling;
+		current = parent;
+	}
+}
+function wrapElement(green, offset, parent, index) {
+	if (green.type === "token") return new SyntaxToken(green, offset, parent, index);
+	return new SyntaxNode(green, offset, parent, index);
+}
+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, index);
+}
+function createSyntaxTree(green) {
+	return new SyntaxNode(green, 0, void 0, 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;
+	}
+}
+function any(...casts) {
+	return (node) => {
+		for (const cast of casts) {
+			const result = cast(node);
+			if (result !== void 0) return 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;
+	}
+	#segmentBefore(boundary) {
+		let found;
+		for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
+			if (segment.syntax.offset >= boundary) break;
+			found = segment;
+		}
+		return found;
+	}
+	#segmentAfter(boundary) {
+		for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) if (segment.syntax.offset > boundary) return segment;
+	}
+	#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() {
+		const colon = this.colon();
+		if (!colon) return void 0;
+		return this.#segmentBefore(colon.offset);
+	}
+	namespace() {
+		const dot = this.dot();
+		if (!dot) return void 0;
+		return this.#segmentBefore(dot.offset);
+	}
+	identifier() {
+		const dot = this.dot();
+		if (dot) return this.#segmentAfter(dot.offset);
+		const colon = this.colon();
+		if (colon) return this.#segmentAfter(colon.offset);
+		return findFirstChild(this.syntax, IdentifierAst.cast);
+	}
+	/**
+	* 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);
+	}
+	*members() {
+		yield* filterChildren(this.syntax, (node) => FieldDeclarationAst.cast(node) ?? ModelAttributeAst.cast(node));
+	}
+	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);
+	}
+	*members() {
+		yield* filterChildren(this.syntax, (node) => FieldDeclarationAst.cast(node) ?? ModelAttributeAst.cast(node));
+	}
+	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);
+	}
+	*members() {
+		yield* filterChildren(this.syntax, (node) => KeyValuePairAst.cast(node) ?? ModelAttributeAst.cast(node));
+	}
+	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
+export { SyntaxNode as A, QualifiedNameAst as C, findChildToken as D, filterChildren as E, TokenAtOffset as M, createSyntaxTree as N, findFirstChild as O, castExpression as S, any as T, FunctionCallAst as _, KeyValuePairAst as a, ObjectLiteralExprAst as b, NamespaceDeclarationAst as c, AttributeArgListAst as d, FieldAttributeAst as f, BooleanLiteralExprAst as g, AttributeArgAst as h, GenericBlockDeclarationAst as i, SyntaxToken as j, printSyntax as k, TypesBlockAst as l, ArrayLiteralAst as m, DocumentAst as n, ModelDeclarationAst as o, ModelAttributeAst as p, FieldDeclarationAst as r, NamedTypeDeclarationAst as s, CompositeTypeDeclarationAst as t, TypeAnnotationAst as u, NumberLiteralExprAst as v, IdentifierAst as w, StringLiteralExprAst as x, ObjectFieldAst as y };
+
+//# sourceMappingURL=declarations-CPDuQm7x.mjs.map