@prisma/orm-framework 0.16.0

package/dist/psl-parser.mjs

@@ -0,0 +1,804 @@
+import { t as blindCast } from "./casts-DpaahrlC-Bd5n2coI.mjs";
+import { n as ok, t as notOk } from "./result-CBZ8X9mU.mjs";
+import { h as isAuthoringPslBlockDescriptor } from "./framework-authoring-CDEvlouU-mlMWSksD.mjs";
+import { a as makePslNamespace, c as validateExtensionBlock, i as flatPslModels, n as UNSPECIFIED_PSL_NAMESPACE_ID, o as makePslNamespaceEntries, s as namespacePslExtensionBlocks } from "./psl-ast-DUCvVXbB.mjs";
+import { E as TypesBlockAst, N as printSyntax, _ as NumberLiteralExprAst, a as CompositeTypeDeclarationAst, d as IdentifierAst, g as NamespaceDeclarationAst, i as BooleanLiteralExprAst, l as FunctionCallAst, m as ModelDeclarationAst, t as ArrayLiteralAst, u as GenericBlockDeclarationAst, x as StringLiteralExprAst, y as ObjectLiteralExprAst } from "./declarations-DR6To8_k-BFwkCGeP.mjs";
+//#region ../../../1-framework/2-authoring/psl-parser/dist/index.mjs
+function getPositionalArgument(attribute, index = 0) {
+	return attribute.args.filter((arg) => arg.kind === "positional")[index]?.value;
+}
+function parseQuotedStringLiteral(value) {
+	const match = value.trim().match(/^(['"])(.*)\1$/);
+	if (!match) return void 0;
+	return match[2] ?? "";
+}
+function readResolvedAttribute(attribute, sourceFile) {
+	return {
+		name: attributeName(attribute.name()),
+		args: readResolvedArgList(attribute.argList(), sourceFile),
+		span: nodePslSpan(attribute.syntax, sourceFile)
+	};
+}
+function readResolvedAttributes(attributes, sourceFile) {
+	return Array.from(attributes, (attribute) => readResolvedAttribute(attribute, sourceFile));
+}
+function readResolvedConstructorCall(annotation, sourceFile) {
+	const argList = annotation?.argList();
+	if (annotation === void 0 || argList === void 0) return void 0;
+	return {
+		path: annotation.name()?.path() ?? [],
+		args: readResolvedArgList(argList, sourceFile),
+		span: nodePslSpan(annotation.syntax, sourceFile)
+	};
+}
+function readResolvedArgList(argList, sourceFile) {
+	if (argList === void 0) return [];
+	const args = [];
+	for (const arg of argList.args()) {
+		const name = arg.name()?.name();
+		const expression = arg.value();
+		args.push({
+			kind: name !== void 0 ? "named" : "positional",
+			...name !== void 0 ? { name } : {},
+			value: renderExpression(expression),
+			...expression !== void 0 ? { expression } : {},
+			span: nodePslSpan(arg.syntax, sourceFile)
+		});
+	}
+	return args;
+}
+function attributeName(name) {
+	return name?.path().join(".") ?? "";
+}
+function renderExpression(expression) {
+	if (expression === void 0) return "";
+	return printSyntax(expression.syntax).trim();
+}
+function nodePslSpan(node, sourceFile) {
+	const start = node.offset;
+	const end = start + node.green.textLength;
+	return {
+		start: offsetToPslPosition(start, sourceFile),
+		end: offsetToPslPosition(end, sourceFile)
+	};
+}
+/** Unsupported-top-level-block diagnostics are anchored to the keyword token. */
+function keywordPslSpan(node, keyword, sourceFile) {
+	const start = node.offset;
+	const end = start + keyword.length;
+	return {
+		start: offsetToPslPosition(start, sourceFile),
+		end: offsetToPslPosition(end, sourceFile)
+	};
+}
+function rangeToPslSpan(range, sourceFile) {
+	return {
+		start: offsetToPslPosition(sourceFile.offsetAt(range.start), sourceFile),
+		end: offsetToPslPosition(sourceFile.offsetAt(range.end), sourceFile)
+	};
+}
+function offsetToPslPosition(offset, sourceFile) {
+	const position = sourceFile.positionAt(offset);
+	return {
+		offset,
+		line: position.line + 1,
+		column: position.character + 1
+	};
+}
+const ATTRIBUTE_DIAGNOSTIC_CODE = "PSL_INVALID_ATTRIBUTE_SYNTAX";
+function leafDiagnostic(ctx, node, message, code = ATTRIBUTE_DIAGNOSTIC_CODE) {
+	return {
+		code,
+		message,
+		sourceId: ctx.sourceId,
+		span: nodePslSpan(node.syntax, ctx.sourceFile)
+	};
+}
+function bool() {
+	return {
+		kind: "bool",
+		label: "boolean",
+		parse: (arg, ctx) => {
+			if (arg instanceof BooleanLiteralExprAst) {
+				const value = arg.value();
+				if (value !== void 0) return ok(value);
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected a boolean literal")]);
+		}
+	};
+}
+function entityRef() {
+	return {
+		kind: "entityRef",
+		label: "model name",
+		parse: (arg, ctx) => {
+			if (!(arg instanceof IdentifierAst)) return notOk([leafDiagnostic(ctx, arg, "Expected a model name")]);
+			const name = arg.name();
+			if (name === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a model name")]);
+			return ok(name);
+		}
+	};
+}
+function fieldRef(scope) {
+	return {
+		kind: "fieldRef",
+		label: "field name",
+		scope,
+		parse: (arg, ctx) => {
+			if (!(arg instanceof IdentifierAst)) return notOk([leafDiagnostic(ctx, arg, "Expected a field name")]);
+			const name = arg.name();
+			if (name === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a field name")]);
+			const model = scope === "self" ? ctx.selfModel : ctx.resolveReferencedModel();
+			if (model !== void 0 && !Object.hasOwn(model.fields, name)) return notOk([leafDiagnostic(ctx, arg, `Field "${name}" does not exist on model "${model.name}"`)]);
+			return ok(name);
+		}
+	};
+}
+function interpretArgs(args, spec, ctx, span) {
+	const diagnostics = [];
+	const output = {};
+	const seen = /* @__PURE__ */ new Set();
+	let positionalSlot = 0;
+	let reportedExcess = false;
+	for (const arg of args) {
+		const name = arg.name()?.name();
+		let key;
+		let param;
+		if (name === void 0) {
+			const posParam = spec.positional[positionalSlot];
+			if (posParam === void 0) {
+				if (!reportedExcess) {
+					diagnostics.push(diagnostic(`Attribute "${spec.name}" received too many positional arguments`, ctx, span));
+					reportedExcess = true;
+				}
+				continue;
+			}
+			positionalSlot += 1;
+			key = posParam.key;
+			param = posParam.type;
+		} else {
+			const namedParam = Object.hasOwn(spec.named, name) ? spec.named[name] : void 0;
+			if (namedParam === void 0) {
+				diagnostics.push(diagnostic(`Attribute "${spec.name}" received unknown argument "${name}"`, ctx, nodePslSpan(arg.syntax, ctx.sourceFile)));
+				continue;
+			}
+			key = name;
+			param = namedParam;
+		}
+		if (seen.has(key)) {
+			diagnostics.push(diagnostic(`Attribute "${spec.name}" received duplicate argument "${key}"`, ctx, nodePslSpan(arg.syntax, ctx.sourceFile)));
+			continue;
+		}
+		seen.add(key);
+		const result = parseArgValue(arg, param, ctx, diagnostics);
+		if (result.ok) output[key] = result.value;
+	}
+	const finalized = /* @__PURE__ */ new Set();
+	const finalizeAbsentKey = (key, positionalParam, namedParam) => {
+		if (finalized.has(key) || seen.has(key)) return;
+		finalized.add(key);
+		const effective = namedParam ?? positionalParam;
+		if (effective === void 0) return;
+		if (isOptionalArgType(effective)) {
+			if (effective.hasDefault) output[key] = effective.defaultValue;
+			return;
+		}
+		diagnostics.push(diagnostic(`Attribute "${spec.name}" is missing required argument "${key}"`, ctx, span));
+	};
+	for (const param of spec.positional) {
+		const namedParam = Object.hasOwn(spec.named, param.key) ? spec.named[param.key] : void 0;
+		finalizeAbsentKey(param.key, param.type, namedParam);
+	}
+	for (const key of Object.keys(spec.named)) finalizeAbsentKey(key, void 0, spec.named[key]);
+	if (diagnostics.length > 0) return notOk(diagnostics);
+	return ok(output);
+}
+function interpretAttribute(attrNode, spec, ctx) {
+	const attributeSpan = nodePslSpan(attrNode.syntax, ctx.sourceFile);
+	const bound = interpretArgs(attrNode.argList()?.args() ?? [], spec, ctx, attributeSpan);
+	if (!bound.ok) return notOk(bound.failure);
+	const value = blindCast(bound.value);
+	if (spec.refine !== void 0) {
+		const refineDiagnostics = spec.refine(value, ctx, attrNode);
+		if (refineDiagnostics.length > 0) return notOk(refineDiagnostics);
+	}
+	return ok(value);
+}
+function parseArgValue(arg, argType, ctx, diagnostics) {
+	const value = arg.value();
+	if (value === void 0) {
+		const missing = diagnostic("Attribute argument is missing a value", ctx, nodePslSpan(arg.syntax, ctx.sourceFile));
+		diagnostics.push(missing);
+		return notOk([missing]);
+	}
+	const result = argType.parse(value, ctx);
+	if (!result.ok) for (const failure of result.failure) diagnostics.push(failure);
+	return result;
+}
+function isOptionalArgType(param) {
+	return "optional" in param && param.optional === true;
+}
+function diagnostic(message, ctx, span) {
+	return {
+		code: ATTRIBUTE_DIAGNOSTIC_CODE,
+		message,
+		sourceId: ctx.sourceId,
+		span
+	};
+}
+function funcCall(name, sig) {
+	return {
+		kind: "funcCall",
+		label: "function call",
+		parse: (arg, ctx) => {
+			const guard = matchCallee(arg, name, ctx);
+			if (!guard.ok) return guard;
+			const span = nodePslSpan(guard.value.syntax, ctx.sourceFile);
+			const bound = interpretArgs(guard.value.args(), {
+				name,
+				positional: sig.positional ?? [],
+				named: sig.named ?? {}
+			}, ctx, span);
+			if (!bound.ok) return notOk(bound.failure);
+			return ok({
+				fn: name,
+				span,
+				args: bound.value
+			});
+		}
+	};
+}
+function matchCallee(arg, name, ctx) {
+	if (!(arg instanceof FunctionCallAst)) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
+	const qname = arg.name();
+	if (qname === void 0 || qname.dot() !== void 0 || qname.colon() !== void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
+	const calleeName = qname.identifier()?.token()?.text;
+	if (calleeName === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
+	if (calleeName !== name) return notOk([leafDiagnostic(ctx, arg, `Expected ${name}()`)]);
+	return ok(arg);
+}
+function identifier(name) {
+	return {
+		kind: "identifier",
+		label: name,
+		parse: (arg, ctx) => {
+			if (arg instanceof IdentifierAst && arg.name() === name) return ok(name);
+			return notOk([leafDiagnostic(ctx, arg, `Expected ${name}`)]);
+		}
+	};
+}
+function int(opts) {
+	const min = opts?.min;
+	const max = opts?.max;
+	return {
+		kind: "int",
+		label: "integer",
+		parse: (arg, ctx) => {
+			if (arg instanceof NumberLiteralExprAst) {
+				const value = arg.value();
+				if (value !== void 0 && Number.isInteger(value)) {
+					if ((min === void 0 || value >= min) && (max === void 0 || value <= max)) return ok(value);
+					return notOk([leafDiagnostic(ctx, arg, rangeMessage(min, max))]);
+				}
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected an integer literal")]);
+		}
+	};
+}
+function rangeMessage(min, max) {
+	if (min !== void 0 && max !== void 0) return `Expected an integer between ${min} and ${max}`;
+	if (min !== void 0) return `Expected an integer greater than or equal to ${min}`;
+	return `Expected an integer less than or equal to ${max}`;
+}
+function list(of, opts) {
+	return {
+		kind: "list",
+		label: `${of.label}[]`,
+		parse: (arg, ctx) => {
+			if (!(arg instanceof ArrayLiteralAst)) return notOk([leafDiagnostic(ctx, arg, `Expected a list of ${of.label}`)]);
+			const diagnostics = [];
+			const parsed = [];
+			let count = 0;
+			for (const element of arg.elements()) {
+				count += 1;
+				const result = of.parse(element, ctx);
+				if (result.ok) parsed.push({
+					node: element,
+					value: result.value
+				});
+				else diagnostics.push(...result.failure);
+			}
+			if (opts?.nonEmpty === true && count === 0) diagnostics.push(leafDiagnostic(ctx, arg, "Expected a non-empty list"));
+			if (opts?.unique === true) {
+				const seen = /* @__PURE__ */ new Set();
+				for (const { node, value } of parsed) if (seen.has(value)) diagnostics.push(leafDiagnostic(ctx, node, "Duplicate list entry"));
+				else seen.add(value);
+			}
+			if (diagnostics.length > 0) return notOk(diagnostics);
+			return ok(parsed.map((entry) => entry.value));
+		}
+	};
+}
+function num(value) {
+	return {
+		kind: "num",
+		label: value === void 0 ? "number" : String(value),
+		parse: (arg, ctx) => {
+			if (arg instanceof NumberLiteralExprAst) {
+				const parsed = arg.value();
+				if (parsed !== void 0 && (value === void 0 || parsed === value)) return ok(parsed);
+			}
+			return notOk([leafDiagnostic(ctx, arg, value === void 0 ? "Expected a number literal" : `Expected ${value}`)]);
+		}
+	};
+}
+function oneOf(...alts) {
+	const label = alts.map((alt) => alt.label).join(" | ");
+	return {
+		kind: "oneOf",
+		label,
+		parse: (arg, ctx) => {
+			for (const alt of alts) {
+				const result = alt.parse(arg, ctx);
+				if (result.ok) return ok(blindCast(result.value));
+			}
+			return notOk([leafDiagnostic(ctx, arg, `Expected one of: ${label}`)]);
+		}
+	};
+}
+function record(of) {
+	return {
+		kind: "record",
+		label: `{ [key]: ${of.label} }`,
+		parse: (arg, ctx) => {
+			if (!(arg instanceof ObjectLiteralExprAst)) return notOk([leafDiagnostic(ctx, arg, "Expected an object literal")]);
+			const diagnostics = [];
+			const result = {};
+			for (const field of arg.fields()) {
+				const key = field.keyName();
+				if (key === void 0) {
+					diagnostics.push(leafDiagnostic(ctx, field, "Expected a key"));
+					continue;
+				}
+				const value = field.value();
+				if (value === void 0) {
+					diagnostics.push(leafDiagnostic(ctx, field, `Expected a value for key "${key}"`));
+					continue;
+				}
+				const parsed = of.parse(value, ctx);
+				if (!parsed.ok) {
+					diagnostics.push(...parsed.failure);
+					continue;
+				}
+				if (Object.hasOwn(result, key)) {
+					diagnostics.push(leafDiagnostic(ctx, field, `Duplicate key "${key}"`));
+					continue;
+				}
+				result[key] = parsed.value;
+			}
+			if (diagnostics.length > 0) return notOk(diagnostics);
+			return ok(result);
+		}
+	};
+}
+function str() {
+	return {
+		kind: "str",
+		label: "string",
+		parse: (arg, ctx) => {
+			if (arg instanceof StringLiteralExprAst) {
+				const value = arg.value();
+				if (value !== void 0) return ok(value);
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected a string literal")]);
+		}
+	};
+}
+function fieldAttribute(name, config) {
+	return {
+		level: "field",
+		name,
+		positional: config.positional ?? [],
+		named: config.named ?? {},
+		...config.refine !== void 0 ? { refine: config.refine } : {}
+	};
+}
+function modelAttribute(name, config) {
+	return {
+		level: "model",
+		name,
+		positional: config.positional ?? [],
+		named: config.named ?? {},
+		...config.refine !== void 0 ? { refine: config.refine } : {}
+	};
+}
+function optional(type, ...rest) {
+	if (rest.length === 0) return {
+		...type,
+		optional: true,
+		hasDefault: false
+	};
+	return {
+		...type,
+		optional: true,
+		hasDefault: true,
+		defaultValue: rest[0]
+	};
+}
+function findBlockDescriptor(descriptors, keyword) {
+	if (descriptors === void 0) return void 0;
+	for (const value of Object.values(descriptors)) {
+		if (value === void 0) continue;
+		if (isAuthoringPslBlockDescriptor(value)) {
+			if (value.keyword === keyword) return value;
+			continue;
+		}
+		const nested = findBlockDescriptor(value, keyword);
+		if (nested !== void 0) return nested;
+	}
+}
+function validateExtensionBlockFromSymbol(input) {
+	const refCtx = buildRefResolutionContext(input.symbolTable, input.block);
+	return validateExtensionBlock(input.block.block, input.descriptor, input.sourceId, input.codecLookup, refCtx);
+}
+const ZERO_SPAN = {
+	start: {
+		offset: 0,
+		line: 1,
+		column: 1
+	},
+	end: {
+		offset: 0,
+		line: 1,
+		column: 1
+	}
+};
+function buildRefResolutionContext(symbolTable, block) {
+	const unspecifiedNamespace = makeNamespace(UNSPECIFIED_PSL_NAMESPACE_ID, Object.values(symbolTable.topLevel.models));
+	const allNamespaces = [unspecifiedNamespace, ...Object.values(symbolTable.topLevel.namespaces).map((namespace) => makeNamespace(namespace.name, Object.values(namespace.models)))];
+	const ownerNamespaceName = findOwnerNamespaceName(symbolTable, block);
+	return {
+		ownerNamespace: allNamespaces.find((namespace) => namespace.name === ownerNamespaceName) ?? unspecifiedNamespace,
+		allNamespaces
+	};
+}
+function makeNamespace(name, models) {
+	return makePslNamespace({
+		kind: "namespace",
+		name,
+		entries: makePslNamespaceEntries(models.map((model) => ({
+			kind: "model",
+			name: model.name,
+			fields: [],
+			attributes: [],
+			span: ZERO_SPAN
+		})), [], []),
+		span: ZERO_SPAN
+	});
+}
+function findOwnerNamespaceName(symbolTable, block) {
+	for (const namespace of Object.values(symbolTable.topLevel.namespaces)) if (Object.values(namespace.blocks).some((candidate) => candidate === block)) return namespace.name;
+	return UNSPECIFIED_PSL_NAMESPACE_ID;
+}
+/**
+* Descriptor-free and unknown parameters become `value` stubs so validation can
+* report them via key-set comparison. Duplicate member names are first-wins.
+*/
+function reconstructExtensionBlock(node, descriptor, sourceFile, diagnostics) {
+	const keyword = node.keyword()?.text ?? "";
+	const blockName = node.name()?.name() ?? "";
+	const blockAttributes = [];
+	for (const attribute of node.attributes()) {
+		const name = attribute.name()?.path().join(".") ?? "";
+		const args = Array.from(attribute.argList()?.args() ?? [], (arg) => {
+			const value = arg.value();
+			return {
+				kind: "positional",
+				value: value === void 0 ? "" : printSyntax(value.syntax).trim(),
+				span: nodePslSpan(arg.syntax, sourceFile)
+			};
+		});
+		blockAttributes.push({
+			name,
+			args,
+			span: nodePslSpan(attribute.syntax, sourceFile)
+		});
+	}
+	const parameters = {};
+	for (const entry of node.entries()) {
+		const key = entry.key()?.name();
+		if (key === void 0) continue;
+		const span = nodePslSpan(entry.syntax, sourceFile);
+		if (Object.hasOwn(parameters, key)) {
+			diagnostics.push({
+				code: "PSL_EXTENSION_DUPLICATE_PARAMETER",
+				message: `Duplicate parameter "${key}" in "${keyword}" block "${blockName}"; first occurrence wins`,
+				range: {
+					start: sourceFile.positionAt(entry.syntax.offset),
+					end: sourceFile.positionAt(entry.syntax.offset + entry.syntax.green.textLength)
+				}
+			});
+			continue;
+		}
+		parameters[key] = reconstructParamValue(entry, descriptor?.parameters[key], span, sourceFile, diagnostics);
+	}
+	return {
+		kind: descriptor?.discriminator ?? keyword,
+		keyword,
+		name: blockName,
+		parameters,
+		blockAttributes,
+		span: nodePslSpan(node.syntax, sourceFile)
+	};
+}
+function reconstructParamValue(entry, param, span, sourceFile, diagnostics) {
+	const value = entry.value();
+	if (value === void 0) return {
+		kind: "bare",
+		span
+	};
+	return reconstructFromExpression(value, param, span, sourceFile, diagnostics);
+}
+function reconstructFromExpression(value, param, span, sourceFile, diagnostics) {
+	const raw = printSyntax(value.syntax).trim();
+	if (param?.kind === "list") {
+		const array = ArrayLiteralAst.cast(value.syntax);
+		if (!array) {
+			diagnostics?.push({
+				code: "PSL_EXTENSION_INVALID_VALUE",
+				message: `List parameter expects an array literal, got ${raw}`,
+				range: {
+					start: sourceFile.positionAt(value.syntax.offset),
+					end: sourceFile.positionAt(value.syntax.offset + value.syntax.green.textLength)
+				}
+			});
+			return {
+				kind: "value",
+				raw,
+				span
+			};
+		}
+		const items = [];
+		for (const element of array.elements()) items.push(reconstructFromExpression(element, param.of, nodePslSpan(element.syntax, sourceFile), sourceFile, diagnostics));
+		return {
+			kind: "list",
+			items,
+			span
+		};
+	}
+	switch (param?.kind) {
+		case "ref": return {
+			kind: "ref",
+			identifier: raw,
+			span
+		};
+		case "option": return {
+			kind: "option",
+			token: raw,
+			span
+		};
+		default: return {
+			kind: "value",
+			raw,
+			span
+		};
+	}
+}
+/**
+* Owns duplicate-declaration detection for all PSL scopes; downstream consumers
+* should consume first-wins symbols rather than re-emitting duplicate diagnostics.
+*/
+function buildSymbolTable(options) {
+	const { document, sourceFile, pslBlockDescriptors } = options;
+	const diagnostics = [];
+	const namespaces = {};
+	const namedTypes = {};
+	const blocks = {};
+	const models = {};
+	const compositeTypes = {};
+	const topLevelNames = /* @__PURE__ */ new Set();
+	const claim = (taken, name) => {
+		const text = name?.name();
+		if (text === void 0) return void 0;
+		if (taken.has(text)) {
+			const range = nameRange(name, sourceFile);
+			if (range) diagnostics.push({
+				code: "PSL_DUPLICATE_DECLARATION",
+				message: `Duplicate declaration of "${text}"`,
+				range
+			});
+			return;
+		}
+		taken.add(text);
+		return text;
+	};
+	for (const declaration of document.declarations()) if (declaration instanceof ModelDeclarationAst) {
+		const name = claim(topLevelNames, declaration.name());
+		if (name !== void 0) models[name] = buildModel(name, declaration, sourceFile, diagnostics);
+	} else if (declaration instanceof CompositeTypeDeclarationAst) {
+		const name = claim(topLevelNames, declaration.name());
+		if (name !== void 0) compositeTypes[name] = buildCompositeType(name, declaration, sourceFile, diagnostics);
+	} else if (declaration instanceof GenericBlockDeclarationAst) {
+		const name = claim(topLevelNames, declaration.name());
+		if (name !== void 0) blocks[name] = buildBlock(name, declaration, sourceFile, pslBlockDescriptors, diagnostics);
+	} else if (declaration instanceof NamespaceDeclarationAst) {
+		const name = claim(topLevelNames, declaration.name());
+		if (name !== void 0) namespaces[name] = buildNamespace(name, declaration, diagnostics, sourceFile, pslBlockDescriptors);
+	} else if (declaration instanceof TypesBlockAst) for (const binding of declaration.declarations()) {
+		const name = claim(topLevelNames, binding.name());
+		if (name === void 0) continue;
+		const resolved = resolveNamedTypeBinding(binding, sourceFile);
+		namedTypes[name] = {
+			kind: "namedType",
+			name,
+			node: binding,
+			span: nodePslSpan(binding.syntax, sourceFile),
+			...resolved
+		};
+	}
+	return {
+		table: { topLevel: {
+			namespaces,
+			namedTypes,
+			blocks,
+			models,
+			compositeTypes
+		} },
+		diagnostics
+	};
+}
+function buildModel(name, node, sourceFile, diagnostics) {
+	return {
+		kind: "model",
+		name,
+		node,
+		span: nodePslSpan(node.syntax, sourceFile),
+		fields: buildFields(name, node.fields(), sourceFile, diagnostics),
+		attributes: readResolvedAttributes(node.attributes(), sourceFile)
+	};
+}
+function buildCompositeType(name, node, sourceFile, diagnostics) {
+	return {
+		kind: "compositeType",
+		name,
+		node,
+		span: nodePslSpan(node.syntax, sourceFile),
+		fields: buildFields(name, node.fields(), sourceFile, diagnostics),
+		attributes: readResolvedAttributes(node.attributes(), sourceFile)
+	};
+}
+function buildBlock(name, node, sourceFile, pslBlockDescriptors, diagnostics) {
+	const keyword = node.keyword()?.text ?? "";
+	const descriptor = findBlockDescriptor(pslBlockDescriptors, keyword);
+	return {
+		kind: "block",
+		name,
+		keyword,
+		node,
+		span: nodePslSpan(node.syntax, sourceFile),
+		block: reconstructExtensionBlock(node, descriptor, sourceFile, diagnostics)
+	};
+}
+function buildNamespace(name, node, diagnostics, sourceFile, pslBlockDescriptors) {
+	const models = {};
+	const compositeTypes = {};
+	const blocks = {};
+	const taken = /* @__PURE__ */ new Set();
+	for (const member of node.declarations()) {
+		const memberName = member.name()?.name();
+		if (memberName === void 0) continue;
+		if (taken.has(memberName)) {
+			const range = nameRange(member.name(), sourceFile);
+			if (range) diagnostics.push({
+				code: "PSL_DUPLICATE_DECLARATION",
+				message: `Duplicate declaration of "${memberName}"`,
+				range
+			});
+			continue;
+		}
+		taken.add(memberName);
+		if (member instanceof ModelDeclarationAst) models[memberName] = buildModel(memberName, member, sourceFile, diagnostics);
+		else if (member instanceof CompositeTypeDeclarationAst) compositeTypes[memberName] = buildCompositeType(memberName, member, sourceFile, diagnostics);
+		else if (member instanceof GenericBlockDeclarationAst) blocks[memberName] = buildBlock(memberName, member, sourceFile, pslBlockDescriptors, diagnostics);
+	}
+	return {
+		kind: "namespace",
+		name,
+		node,
+		span: nodePslSpan(node.syntax, sourceFile),
+		models,
+		compositeTypes,
+		blocks
+	};
+}
+function buildFields(ownerName, fields, sourceFile, diagnostics) {
+	const result = {};
+	for (const field of fields) {
+		const nameNode = field.name();
+		const name = nameNode?.name();
+		if (name === void 0) continue;
+		if (Object.hasOwn(result, name)) {
+			const range = nameRange(nameNode, sourceFile);
+			if (range) diagnostics.push({
+				code: "PSL_DUPLICATE_DECLARATION",
+				message: `Duplicate declaration of "${name}"`,
+				range
+			});
+			continue;
+		}
+		result[name] = buildField(ownerName, name, field, sourceFile, diagnostics);
+	}
+	return result;
+}
+function buildField(ownerName, name, node, sourceFile, diagnostics) {
+	const attributes = readResolvedAttributes(node.attributes(), sourceFile);
+	const span = nodePslSpan(node.syntax, sourceFile);
+	const annotation = node.typeAnnotation();
+	const typeName = annotation?.name();
+	if (typeName?.isOverQualified()) {
+		const path = typeName.path();
+		diagnostics.push({
+			code: "PSL_INVALID_QUALIFIED_TYPE",
+			message: `Field "${ownerName}.${name}" has an invalid qualified type "${path.join(".")}"; use at most one namespace qualifier (e.g. "ns.TypeName")`,
+			range: nodeRange(typeName.syntax, sourceFile)
+		});
+		return {
+			kind: "field",
+			name,
+			node,
+			span,
+			typeName: path[path.length - 1] ?? "",
+			optional: false,
+			list: false,
+			malformedType: true,
+			attributes
+		};
+	}
+	const typeConstructor = annotation?.isConstructor() ? readResolvedConstructorCall(annotation, sourceFile) : void 0;
+	const typeNamespaceId = typeName?.namespace()?.name();
+	const typeContractSpaceId = typeName?.space()?.name();
+	return {
+		kind: "field",
+		name,
+		node,
+		span,
+		typeName: typeName?.identifier()?.name() ?? "",
+		...typeNamespaceId !== void 0 ? { typeNamespaceId } : {},
+		...typeContractSpaceId !== void 0 ? { typeContractSpaceId } : {},
+		optional: annotation?.isOptional() ?? false,
+		list: annotation?.isList() ?? false,
+		...typeConstructor !== void 0 ? { typeConstructor } : {},
+		attributes
+	};
+}
+function resolveNamedTypeBinding(node, sourceFile) {
+	const annotation = node.typeAnnotation();
+	const isConstructor = annotation?.isConstructor() ?? false;
+	const baseType = annotation?.name()?.identifier()?.name();
+	const typeConstructor = readResolvedConstructorCall(annotation, sourceFile);
+	return {
+		isConstructor,
+		...!isConstructor && baseType !== void 0 ? { baseType } : {},
+		...typeConstructor !== void 0 ? { typeConstructor } : {},
+		attributes: readResolvedAttributes(node.attributes(), sourceFile)
+	};
+}
+function nameRange(name, sourceFile) {
+	if (name === void 0) return void 0;
+	for (const token of name.syntax.tokens()) if (token.kind === "Ident") return {
+		start: sourceFile.positionAt(token.offset),
+		end: sourceFile.positionAt(token.offset + token.text.length)
+	};
+}
+function nodeRange(node, sourceFile) {
+	const start = node.offset;
+	const end = start + node.green.textLength;
+	return {
+		start: sourceFile.positionAt(start),
+		end: sourceFile.positionAt(end)
+	};
+}
+//#endregion
+export { bool, buildSymbolTable, entityRef, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, funcCall, getPositionalArgument, identifier, int, interpretArgs, interpretAttribute, keywordPslSpan, leafDiagnostic, list, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, num, oneOf, optional, parseQuotedStringLiteral, rangeToPslSpan, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, record, str, validateExtensionBlockFromSymbol };
+
+//# sourceMappingURL=psl-parser.mjs.map