@likec4/generators 1.52.0 → 1.53.0

package/dist/likec4/index.mjs

@@ -0,0 +1,1799 @@
+import { t as __exportAll } from "../_chunks/chunk.mjs";
+import { CompositeGeneratorNode, NL, NewLineNode, joinToNode, toString } from "langium/generate";
+import { entries, filter, hasAtLeast, identity, indexBy, isArray, isDeepEqual, isEmptyish, isFunction, isNonNullish, isNot, isNullish, isNumber, isObjectType, isString, map, mapToObj, mapValues, only, pickBy, pipe, piped, prop, randomString, values } from "remeda";
+import { hasProp, invariant, nonexhaustive } from "@likec4/core";
+import { exact } from "@likec4/core/types";
+import { invariant as invariant$1, nameFromFqn, parentFqn, sortParentsFirst } from "@likec4/core/utils";
+import { dedent } from "strip-indent";
+import * as z$1 from "zod/v4";
+import { BorderStyles, ElementShapes, IconPositions, RelationshipArrowTypes, Sizes, ThemeColors } from "@likec4/core/styles";
+import { produce } from "immer";
+import { LikeC4StylesConfigSchema } from "@likec4/config";
+var base_exports = /* @__PURE__ */ __exportAll({
+	body: () => body,
+	eachOnFresh: () => eachOnFresh,
+	eq: () => eq,
+	executeOnCtx: () => executeOnCtx,
+	executeOnFresh: () => executeOnFresh,
+	foreach: () => foreach,
+	foreachNewLine: () => foreachNewLine,
+	fresh: () => fresh,
+	guard: () => guard,
+	indent: () => indent,
+	inlineText: () => inlineText,
+	join: () => join,
+	lazy: () => lazy,
+	lines: () => lines,
+	markdown: () => markdown,
+	markdownOrString: () => markdownOrString$1,
+	materialize: () => materialize,
+	merge: () => merge,
+	newline: () => newline,
+	noop: () => noop,
+	operation: () => operation,
+	print: () => print$1,
+	printProperty: () => printProperty,
+	property: () => property,
+	select: () => select,
+	separateComma: () => separateComma,
+	separateNewLine: () => separateNewLine,
+	separateWith: () => separateWith,
+	space: () => space,
+	spaceBetween: () => spaceBetween,
+	text: () => text,
+	when: () => when,
+	withctx: () => withctx,
+	zodOp: () => zodOp
+});
+function hasContent(out) {
+	if (typeof out === "string") return out.trimStart().length !== 0;
+	if (out instanceof CompositeGeneratorNode) return out.contents.some((e) => hasContent(e));
+	return false;
+}
+function hasContentOrNewLine(out) {
+	if (typeof out === "string") return out.trimStart().length !== 0;
+	if (out instanceof NewLineNode) return !out.ifNotEmpty;
+	if (out instanceof CompositeGeneratorNode) return out.contents.some((e) => hasContentOrNewLine(e));
+	return false;
+}
+function fresh(ctx) {
+	return {
+		ctx: ctx ?? void 0,
+		out: new CompositeGeneratorNode()
+	};
+}
+/**
+* Materialize context or operation into a string
+*/
+function materialize(ctx, defaultIndentation = 2) {
+	return toString(isFunction(ctx) ? executeOnFresh(void 0, [ctx]).out : ctx.out, defaultIndentation).replaceAll(/\r\n/g, "\n");
+}
+function executeOnCtx(ctx, op, ...ops) {
+	if (isArray(op)) {
+		invariant(ops.length === 0, "When first argument is an array, no additional operations are allowed");
+		ops = op;
+	} else ops = [op, ...ops];
+	for (const o of ops) ctx = o(ctx);
+	return ctx;
+}
+function executeOnFresh(ctx, op, ...ops) {
+	if (isArray(op)) return executeOnCtx(fresh(ctx), op);
+	return executeOnCtx(fresh(ctx), [op, ...ops]);
+}
+/**
+* Execute each operation on a fresh context (new empty output node)
+* This is map operation
+*/
+function eachOnFresh(ctx, ops) {
+	return ops.map((op) => op(fresh(ctx)));
+}
+function operation(opOrName, fn) {
+	const operationFn = typeof opOrName === "function" ? opOrName : fn;
+	const wrapped = (input) => {
+		const result = operationFn(input);
+		if (result instanceof CompositeGeneratorNode) return {
+			...input,
+			out: result
+		};
+		return input;
+	};
+	if (typeof opOrName === "string" && operationFn.name == "") Object.defineProperties(wrapped, { name: { value: `wrapped(${opOrName})` } });
+	return wrapped;
+}
+function isPrintable(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function print$1(value) {
+	return operation(function printOp({ ctx, out }) {
+		let v = typeof value === "function" ? value(ctx) : value ?? ctx;
+		if (isNullish(v) || v === "") return;
+		invariant(isPrintable(v), "Value must be a string, number or boolean - got " + typeof v);
+		out.append(String(v));
+	});
+}
+const eq = () => print$1("=");
+const space = () => print$1(" ");
+function noop() {
+	return identity();
+}
+/**
+* To be used for recursive operations
+*/
+function lazy(op) {
+	return (input) => {
+		op()(input);
+		return input;
+	};
+}
+function newline(when) {
+	return operation(({ out }) => {
+		if (when === "ifNotEmpty") out.appendNewLineIfNotEmpty();
+		else out.appendNewLine();
+	});
+}
+/**
+* Merge multiple operations into a single output node
+*/
+function merge(...ops) {
+	return operation(function merge({ ctx, out }) {
+		const nested = executeOnFresh(ctx, ops);
+		out.appendIf(hasContent(nested.out), nested.out);
+	});
+}
+function indent(...args) {
+	if (args.length === 1 && typeof args[0] === "string") {
+		const text = dedent(args[0]);
+		if (text.trimStart().length === 0) return noop();
+		return operation(function indent1({ out }) {
+			out.appendNewLineIfNotEmpty().indent({
+				indentEmptyLines: true,
+				indentedChildren: [joinToNode(text.split(/\r?\n/), { separator: NL })]
+			}).appendNewLineIfNotEmpty();
+		});
+	}
+	const ops = args;
+	return operation(function indent2({ ctx, out }) {
+		const nested = executeOnFresh(ctx, ops);
+		if (hasContent(nested.out)) out.appendNewLineIfNotEmpty().indent({
+			indentEmptyLines: true,
+			indentedChildren: nested.out.contents
+		}).appendNewLineIfNotEmpty();
+	});
+}
+function body(...args) {
+	const keyword = only(args);
+	if (isString(keyword)) return body(keyword + " {", "}");
+	if (args.length === 2 && isString(args[0]) && isString(args[1])) {
+		const [open, close] = args;
+		return (...ops) => operation(function body({ ctx, out }) {
+			const bodyOutput = indent(lines(...ops))(fresh(ctx)).out;
+			out.appendIf(hasContent(bodyOutput), joinToNode([
+				open,
+				bodyOutput,
+				close
+			]));
+		});
+	}
+	const ops = args;
+	return body("{", "}")(...ops);
+}
+const QUOTE = "'";
+const ESCAPED_QUOTE = "\\" + QUOTE;
+function inlineText(value) {
+	return operation(({ ctx, out }) => {
+		let v = value ?? ctx;
+		if (isNullish(v)) return;
+		invariant(isString(v), "Value must be a string - got " + typeof v);
+		const escapedValue = v.replace(/(\r?\n|\t)+/g, " ").replaceAll(QUOTE, ESCAPED_QUOTE).trim();
+		out.append(`${QUOTE}${escapedValue}${QUOTE}`);
+	});
+}
+function multilineText(value, quotes = QUOTE) {
+	return merge(print$1(quotes), indent(value.replaceAll(QUOTE, ESCAPED_QUOTE)), print$1(quotes));
+}
+function text(value) {
+	return operation(function text({ ctx, out }) {
+		let v = typeof value === "function" ? value(ctx) : value ?? ctx;
+		if (isNullish(v)) return;
+		invariant(isString(v), "Value must be a string - got " + typeof v);
+		if (v.includes("\n")) return multilineText(v)({
+			ctx: v,
+			out
+		});
+		return inlineText()({
+			ctx: v,
+			out
+		});
+	});
+}
+const TRIPLE_QUOTE = QUOTE.repeat(3);
+function markdown(value) {
+	return operation(function markdown(ctx) {
+		let v = value ?? ctx.ctx;
+		if (isNullish(v)) return;
+		invariant(isString(v), "Value must be a string - got " + typeof v);
+		return multilineText(v, TRIPLE_QUOTE)(ctx);
+	});
+}
+function markdownOrString$1(value) {
+	return operation(function markdownOrString(ctx) {
+		let v = value ?? ctx.ctx;
+		if (isNullish(v)) return;
+		if (typeof v === "string") return text(v)(ctx);
+		if ("md" in v) return markdown(v.md)(ctx);
+		if ("txt" in v) return multilineText(v.txt)(ctx);
+		throw new Error("Invalid MarkdownOrString value: " + v);
+	});
+}
+/**
+* helps to join operations
+*
+* @internal
+*
+* @see spaceBetween
+* @see lines
+* @see foreach
+*/
+function join(params) {
+	return operation(function joinOp({ ctx, out }) {
+		const { operations, ...joinOptions } = params;
+		const ops = Array.isArray(operations) ? operations : [operations];
+		invariant(hasAtLeast(ops, 1), "At least one operation is required");
+		let nested;
+		if (ops.length === 1) nested = ops[0](fresh(ctx)).out.contents;
+		else nested = pipe(eachOnFresh(ctx, ops), map((n) => n.out));
+		nested = filter(nested, hasContentOrNewLine);
+		return out.appendIf(nested.length > 0, joinToNode(nested, joinOptions));
+	});
+}
+/**
+* Joins all outputs with a space between
+* @see lines
+*/
+function spaceBetween(...ops) {
+	return join({
+		operations: ops,
+		suffix: (node, _index, isLast) => {
+			return !isLast && hasContent(node) ? " " : void 0;
+		}
+	});
+}
+function lines(...args) {
+	let linesBetween = only(args);
+	if (isNumber(linesBetween)) {
+		let suffix = fresh(void 0);
+		for (let i = 0; i < linesBetween; i++) suffix.out.appendNewLine();
+		return (...ops) => {
+			return join({
+				operations: ops,
+				suffix: (_node, _index, isLast) => {
+					return !isLast ? suffix.out : void 0;
+				}
+			});
+		};
+	}
+	return join({
+		operations: args,
+		appendNewLineIfNotEmpty: true,
+		skipNewLineAfterLastItem: true
+	});
+}
+function withctx(...args) {
+	const ctx = args[0];
+	if (args.length === 1) return (...ops) => operation(function withctx1({ out }) {
+		executeOnCtx({
+			ctx,
+			out
+		}, ops);
+	});
+	const ops = args.slice(1);
+	return operation(function withctx2({ out }) {
+		executeOnCtx({
+			ctx,
+			out
+		}, ops);
+	});
+}
+/**
+* Executes the given operation on the property of the context if it is non-nullish
+* If no operation is provided, prints the property name and property value
+* (use {@link printProperty} if you need print value only)
+*
+* @see printProperty
+*
+* @example
+* ```ts
+* withctx({name: 'John'})(
+*   property(
+*    'name',
+*     spaceBetween(
+*       print('Name:'),
+*       print()
+*     )
+*   )
+* )
+* // Output:
+* // Name: John
+* ```
+* @example
+* ```ts
+* withctx({name: 'John'})(
+*   property('name')
+* )
+* // Output:
+* // name John
+* ```
+*/
+function property(propertyName, op) {
+	return operation(function propertyOp({ ctx, out }) {
+		const value = isObjectType(ctx) && hasProp(ctx, propertyName) ? ctx[propertyName] : void 0;
+		if (value === null || value === void 0) return;
+		if (!op) {
+			invariant(isPrintable(value), `Property ${propertyName} is not printable "${value}"`);
+			out.append(propertyName, " ", String(value));
+			return;
+		}
+		op({
+			ctx: value,
+			out
+		});
+	});
+}
+/**
+* Prints context's property value
+*
+* @see property
+*
+* @example
+* ```ts
+* withctx({name: 'John'})(
+*   printProperty('name')
+* )
+* // Output:
+* // John
+* ```
+*/
+function printProperty(propertyName) {
+	return property(propertyName, print$1());
+}
+function foreach(...args) {
+	const [arg1, arg2] = args;
+	if (args.length === 2 && !isFunction(arg2)) {
+		const _op = arg1;
+		const joinOptions = arg2;
+		return operation(function foreachSingleOp({ ctx, out }) {
+			const items = [];
+			for (const value of ctx) {
+				const itemOut = _op(fresh(value)).out;
+				if (hasContent(itemOut)) items.push(itemOut);
+			}
+			out.appendIf(items.length > 0, joinToNode(items, joinOptions));
+		});
+	}
+	const ops = args;
+	return operation(({ ctx, out }) => {
+		for (const value of ctx) executeOnCtx({
+			ctx: value,
+			out
+		}, ops);
+	});
+}
+function separateWith(separator) {
+	return { separator };
+}
+function separateNewLine(lines = 1) {
+	if (lines > 1) {
+		let suffix = fresh(void 0);
+		for (let i = 0; i < lines; i++) suffix.out.appendNewLine();
+		return separateWith(suffix.out);
+	}
+	return separateWith(NL);
+}
+function separateComma(addNewLine) {
+	if (addNewLine) return {
+		separator: ",",
+		appendNewLineIfNotEmpty: true,
+		skipNewLineAfterLastItem: true
+	};
+	return { separator: ", " };
+}
+/**
+* Executes given operations on each item of the iterable context
+* And joins the results with a new line
+*/
+function foreachNewLine(...ops) {
+	return operation(function foreachNewLineOp({ ctx, out }) {
+		const items = [];
+		for (const value of ctx) {
+			const itemOut = executeOnFresh(value, ops).out;
+			if (hasContent(itemOut)) items.push(itemOut);
+		}
+		out.appendIf(items.length > 0, joinToNode(items, separateNewLine()));
+	});
+}
+function guard(condition, ...ops) {
+	return operation("guard", ({ ctx, out }) => {
+		if ("safeParse" in condition) {
+			const parsed = condition.safeParse(ctx);
+			if (parsed.success) executeOnCtx({
+				ctx: parsed.data,
+				out
+			}, ops);
+			else throw new Error(`Guard failed: ${z$1.prettifyError(parsed.error)}`);
+			return;
+		}
+		invariant(typeof condition === "function");
+		if (condition(ctx)) {
+			executeOnCtx({
+				ctx,
+				out
+			}, ops);
+			return;
+		}
+	});
+}
+/**
+* Executes operations on the context if the condition is true
+*/
+function when(condition, ...ops) {
+	return operation(function whenOp({ ctx, out }) {
+		if (condition(ctx)) executeOnCtx({
+			ctx,
+			out
+		}, ops);
+	});
+}
+function select(selector, ...ops) {
+	return operation(function selectOp({ ctx, out }) {
+		const value = selector(ctx);
+		if (isNonNullish(value)) executeOnCtx({
+			ctx: value,
+			out
+		}, ops);
+	});
+}
+/**
+* Creates an execution function that runs operations
+* with new context but using the same output
+*/
+function execToOut(out) {
+	return (ctx, ...ops) => executeOnCtx({
+		ctx,
+		out
+	}, ops);
+}
+/**
+* Creates print operation with context based on zod schema
+* @example
+* ```ts
+* const newOp = zodOp(schemas.directRelationExpr)(
+*   merge(
+*     property(
+*       'source',
+*       fqnExpr(),
+*     ),
+*     print(v => v.isBidirectional ? ' <-> ' : ' -> '),
+*     property(
+*       'target',
+*       fqnExpr(),
+*     ),
+*   ),
+* )
+* ```
+*
+* @example
+* ```ts
+* const whereOperator = zodOp(schemas.whereOperator)(({ ctx, exec }) => {
+*   if ('and' in ctx) {
+*     return exec(ctx, whereAnd())
+*   }
+*   if ('or' in ctx) {
+*     return exec(ctx, whereOr())
+*   }
+*   nonexhaustive(ctx)
+* })
+* ```
+*/
+function zodOp(schema) {
+	return (operation) => {
+		return () => {
+			return ({ ctx, out }) => {
+				const result = z$1.safeParse(schema, ctx);
+				if (result.success) {
+					const opres = operation({
+						ctx: result.data,
+						out,
+						exec: execToOut(out)
+					});
+					if (opres instanceof CompositeGeneratorNode) return {
+						ctx,
+						out: opres
+					};
+					if (typeof opres === "function") return {
+						ctx,
+						out,
+						...opres({
+							ctx,
+							out
+						})
+					};
+					return {
+						ctx,
+						out
+					};
+				}
+				throw result.error;
+			};
+		};
+	};
+}
+var common_exports = /* @__PURE__ */ __exportAll({
+	arrow: () => arrow,
+	border: () => border,
+	color: () => color,
+	customColor: () => customColor,
+	fqn: () => fqn,
+	icon: () => icon,
+	iconPosition: () => iconPosition,
+	id: () => id,
+	kind: () => kind,
+	line: () => line,
+	link: () => link,
+	links: () => links,
+	markdownOrString: () => markdownOrString,
+	metadata: () => metadata,
+	metadataValue: () => metadataValue$1,
+	opacity: () => opacity,
+	props: () => props,
+	shape: () => shape,
+	size: () => size,
+	style: () => style,
+	tag: () => tag,
+	tags: () => tags,
+	themeColor: () => themeColor,
+	viewId: () => viewId
+});
+const id = z$1.string().regex(/^[a-zA-Z0-9_.-]+$/, "id must consist of alphanumeric characters, underscores or hyphens");
+const viewId = id.transform((value) => value);
+const fqn = z$1.string().regex(/^[a-zA-Z0-9_.-]+$/, "FQN must consist of alphanumeric characters, dots, underscores or hyphens").transform((value) => value);
+const kind = z$1.string().regex(/^[a-zA-Z0-9_-]+$/, "Kind must consist of alphanumeric characters, underscores or hyphens").transform((value) => value);
+const opacity = z$1.int().min(0, "Opacity must be between 0 and 100").max(100, "Opacity must be between 0 and 100");
+const shape = z$1.literal(ElementShapes);
+const icon = z$1.string().nonempty("Icon cannot be empty").transform((value) => value);
+const border = z$1.literal(BorderStyles);
+const size = z$1.literal(Sizes);
+const iconPosition = z$1.literal(IconPositions);
+const arrow = z$1.literal(RelationshipArrowTypes);
+const line = z$1.literal([
+	"dashed",
+	"solid",
+	"dotted"
+]);
+const link = z$1.union([z$1.string(), z$1.object({
+	title: z$1.string().optional(),
+	url: z$1.string()
+})]).transform((value) => exact(typeof value === "string" ? { url: value } : value));
+const links = z$1.array(link).readonly();
+const themeColor = z$1.literal(ThemeColors);
+const customColor = z$1.custom().refine((v) => typeof v === "string", "Custom color name must be a string").transform((value) => value);
+const tag = z$1.string().nonempty("Tag cannot be empty").transform((tag) => tag.startsWith("#") ? tag.slice(1) : tag);
+const tags = z$1.array(tag).readonly();
+const markdownOrString = z$1.union([
+	z$1.string(),
+	z$1.strictObject({ md: z$1.string() }),
+	z$1.strictObject({ txt: z$1.string() })
+]).transform((v) => typeof v === "string" ? { txt: v } : v);
+const color = themeColor.or(customColor);
+const style = z$1.object({
+	shape,
+	icon,
+	iconColor: color,
+	iconSize: size,
+	iconPosition,
+	color,
+	border,
+	opacity,
+	size,
+	padding: size,
+	textSize: size,
+	multiple: z$1.boolean()
+}).partial();
+const metadataValue$1 = z$1.union([
+	z$1.string(),
+	z$1.boolean(),
+	z$1.number()
+]);
+const metadata = z$1.record(z$1.string(), metadataValue$1.or(z$1.array(metadataValue$1)));
+const props = z$1.object({
+	tags: tags.nullable(),
+	title: z$1.string(),
+	summary: markdownOrString.nullable(),
+	description: markdownOrString.nullable(),
+	notation: z$1.string().nullable(),
+	technology: z$1.string().nullable(),
+	links: links.nullable(),
+	metadata
+}).partial();
+var expression_exports = /* @__PURE__ */ __exportAll({
+	directRelationExpr: () => directRelationExpr$1,
+	elementKindExpr: () => elementKindExpr,
+	elementTagExpr: () => elementTagExpr,
+	expression: () => expression$1,
+	fqnExpr: () => fqnExpr$1,
+	fqnExprAny: () => fqnExprAny$1,
+	fqnExprCustom: () => fqnExprCustom$1,
+	fqnExprOrWhere: () => fqnExprOrWhere$1,
+	fqnRef: () => fqnRef$1,
+	incomingRelationExpr: () => incomingRelationExpr$1,
+	inoutRelationExpr: () => inoutRelationExpr,
+	outgoingRelationExpr: () => outgoingRelationExpr$1,
+	refDeployment: () => refDeployment,
+	refExpr: () => refExpr,
+	refModel: () => refModel,
+	relationExpr: () => relationExpr$1,
+	relationExprAny: () => relationExprAny$1,
+	relationExprCustom: () => relationExprCustom$1,
+	relationExprOrWhere: () => relationExprOrWhere$1,
+	selector: () => selector,
+	whereAnd: () => whereAnd$1,
+	whereExpr: () => whereExpr,
+	whereKind: () => whereKind,
+	whereMetadata: () => whereMetadata,
+	whereNot: () => whereNot$1,
+	whereOperator: () => whereOperator$1,
+	whereOr: () => whereOr$1,
+	whereParticipant: () => whereParticipant$1,
+	whereTag: () => whereTag,
+	wildcardExpr: () => wildcardExpr
+});
+const refModel = z$1.strictObject({
+	model: fqn,
+	project: z$1.string().optional()
+});
+const refDeployment = z$1.strictObject({
+	deployment: fqn,
+	element: fqn.nullish()
+});
+const fqnRef$1 = z$1.union([refModel, refDeployment]);
+const selector = z$1.literal([
+	"children",
+	"expanded",
+	"descendants"
+]);
+/**
+* Accepts a value directly (shorthand for equality), or an explicit {eq: value} / {neq: value}.
+* Replicates the EqualOperator from the core.
+*/
+function equalOp(schema) {
+	return z$1.union([
+		schema.transform((value) => ({ eq: value })),
+		z$1.object({ eq: schema }),
+		z$1.object({ neq: schema })
+	]);
+}
+const whereTag = z$1.object({ tag: equalOp(tag) });
+const whereKind = z$1.object({ kind: equalOp(kind) });
+const whereMetadata = z$1.object({ metadata: z$1.object({
+	key: z$1.string(),
+	value: equalOp(z$1.string()).optional()
+}) });
+const whereParticipant$1 = z$1.object({
+	participant: z$1.literal(["source", "target"]),
+	operator: z$1.union([
+		whereTag,
+		whereKind,
+		whereMetadata
+	])
+});
+const whereAnd$1 = z$1.object({ get and() {
+	return z$1.array(whereOperator$1);
+} });
+const whereNot$1 = z$1.object({ get not() {
+	return whereOperator$1;
+} });
+const whereOr$1 = z$1.object({ get or() {
+	return z$1.array(whereOperator$1);
+} });
+const whereOperator$1 = z$1.union([
+	whereTag,
+	whereKind,
+	whereMetadata,
+	whereParticipant$1,
+	whereAnd$1,
+	whereOr$1,
+	whereNot$1
+]);
+const wildcardExpr = z$1.object({ wildcard: z$1.literal(true) });
+const refExpr = z$1.object({
+	ref: fqnRef$1,
+	selector: selector.optional()
+});
+const elementKindExpr = z$1.object({
+	elementKind: kind,
+	isEqual: z$1.boolean()
+});
+const elementTagExpr = z$1.object({
+	elementTag: tag,
+	isEqual: z$1.boolean()
+});
+const fqnExpr$1 = z$1.union([
+	wildcardExpr,
+	refExpr,
+	elementKindExpr,
+	elementTagExpr
+]);
+const fqnExprWhere = z$1.strictObject({ where: z$1.strictObject({
+	expr: fqnExpr$1,
+	condition: whereOperator$1
+}) });
+const fqnExprOrWhere$1 = z$1.union([fqnExpr$1, fqnExprWhere]);
+/**
+* Common custom properties that apply to both elements and relations
+*/
+const commonCustomProperties = z$1.object({
+	title: z$1.string(),
+	description: markdownOrString,
+	technology: z$1.string(),
+	notation: z$1.string(),
+	notes: markdownOrString,
+	navigateTo: viewId,
+	color
+});
+const customElementProperties = z$1.object({
+	...commonCustomProperties.shape,
+	shape,
+	icon,
+	iconColor: color,
+	iconSize: size,
+	iconPosition,
+	border,
+	opacity,
+	multiple: z$1.boolean(),
+	size,
+	padding: size,
+	textSize: size
+}).partial();
+const customRelationProperties = z$1.object({
+	...commonCustomProperties.shape,
+	line,
+	head: arrow,
+	tail: arrow
+}).partial();
+const fqnExprCustom$1 = z$1.strictObject({ custom: customElementProperties.extend({ expr: fqnExprOrWhere$1 }) });
+const fqnExprAny$1 = z$1.union([fqnExprOrWhere$1, fqnExprCustom$1]);
+const directRelationExpr$1 = z$1.object({
+	source: fqnExpr$1,
+	target: fqnExpr$1,
+	isBidirectional: z$1.boolean().optional()
+});
+const incomingRelationExpr$1 = z$1.object({ incoming: fqnExpr$1 });
+const outgoingRelationExpr$1 = z$1.object({ outgoing: fqnExpr$1 });
+const inoutRelationExpr = z$1.object({ inout: fqnExpr$1 });
+const relationExpr$1 = z$1.union([
+	directRelationExpr$1,
+	incomingRelationExpr$1,
+	outgoingRelationExpr$1,
+	inoutRelationExpr
+]);
+const relationExprOrWhere$1 = z$1.union([relationExpr$1, z$1.strictObject({ where: z$1.strictObject({
+	expr: relationExpr$1,
+	condition: whereOperator$1
+}) })]);
+const relationExprCustom$1 = z$1.strictObject({ customRelation: customRelationProperties.extend({ expr: relationExprOrWhere$1 }) });
+const relationExprAny$1 = z$1.union([relationExprOrWhere$1, relationExprCustom$1]);
+const whereExpr = z$1.object({ where: z$1.object({
+	expr: z$1.union([fqnExpr$1, relationExpr$1]),
+	condition: whereOperator$1
+}) });
+/**
+* Full model expression, union of all fqn and relation expression variants.
+* Replicates ModelExpression from the core.
+*/
+const expression$1 = z$1.union([
+	fqnExpr$1,
+	fqnExprCustom$1,
+	relationExpr$1,
+	relationExprCustom$1,
+	whereExpr
+]);
+var deployment_exports$1 = /* @__PURE__ */ __exportAll({
+	element: () => element$3,
+	instance: () => instance$1,
+	node: () => node$1,
+	relationship: () => relationship$4,
+	schema: () => schema$2
+});
+const node$1 = props.extend({
+	id: fqn,
+	kind,
+	style: style.optional(),
+	shape: shape.optional(),
+	color: color.optional(),
+	icon: icon.optional()
+}).readonly().transform((value) => {
+	const { shape, color, icon, ...rest } = value;
+	if (shape || color || icon) return produce(rest, (draft) => {
+		draft.style = rest.style || {};
+		draft.style.shape = shape ?? rest.style?.shape;
+		draft.style.color = color ?? rest.style?.color;
+		draft.style.icon = icon ?? rest.style?.icon;
+	});
+	return rest;
+}).transform(pickBy(isNonNullish));
+const instance$1 = props.extend({
+	id: fqn,
+	element: fqn,
+	style: style.optional(),
+	shape: shape.optional(),
+	color: color.optional(),
+	icon: icon.optional()
+}).readonly().transform((value) => {
+	const { shape, color, icon, ...rest } = value;
+	if (shape || color || icon) return produce(rest, (draft) => {
+		draft.style = rest.style || {};
+		draft.style.shape = shape ?? rest.style?.shape;
+		draft.style.color = color ?? rest.style?.color;
+		draft.style.icon = icon ?? rest.style?.icon;
+	});
+	return rest;
+}).transform(pickBy(isNonNullish));
+const relationshipEndpoint$1 = refDeployment;
+const relationshipId$1 = id.transform((value) => value);
+const relationship$4 = props.extend({
+	id: relationshipId$1.optional(),
+	title: z$1.string().nullish(),
+	source: relationshipEndpoint$1,
+	target: relationshipEndpoint$1,
+	navigateTo: viewId.nullish(),
+	color: color.nullish(),
+	kind: kind.nullish(),
+	line: line.nullish(),
+	head: arrow.nullish(),
+	tail: arrow.nullish()
+}).readonly().transform(pickBy(isNonNullish));
+const element$3 = z$1.union([node$1, instance$1]);
+const elements$1 = z$1.record(fqn, element$3);
+const relationships$1 = z$1.record(relationshipId$1, relationship$4);
+const genRelationshipId$1 = (r) => r.id ?? randomString(8);
+const schema$2 = z$1.object({
+	elements: z$1.union([elements$1, z$1.array(element$3)]).transform((v) => isArray(v) ? indexBy(v, prop("id")) : v).optional(),
+	relations: z$1.union([relationships$1, z$1.array(relationship$4)]).transform((v) => isArray(v) ? indexBy(v, genRelationshipId$1) : v).optional()
+});
+var model_exports$1 = /* @__PURE__ */ __exportAll({
+	element: () => element$2,
+	relationship: () => relationship$3,
+	schema: () => schema$1
+});
+/**
+* Replicates the {@link Element} from the core,
+* less strict, as the generator should be able to handle missing fields and provide defaults.
+*/
+const element$2 = z$1.object({
+	...props.shape,
+	id: fqn,
+	kind,
+	style: style.optional(),
+	shape: shape.optional(),
+	color: color.optional(),
+	icon: icon.optional()
+}).transform((value) => {
+	let { shape, color, icon, ...rest } = value;
+	if (shape || color || icon) rest = produce(rest, (draft) => {
+		draft.style = rest.style || {};
+		draft.style.shape = shape ?? rest.style?.shape;
+		draft.style.color = color ?? rest.style?.color;
+		draft.style.icon = icon ?? rest.style?.icon;
+	});
+	return pickBy(rest, isNonNullish);
+}).readonly();
+const relationshipEndpoint = z$1.union([fqn, z$1.strictObject({ model: fqn })]).transform((v) => typeof v === "string" ? { model: v } : v);
+const relationshipId = id.transform((value) => value);
+const relationship$3 = z$1.object({
+	...props.shape,
+	id: relationshipId.optional(),
+	title: z$1.string().nullish(),
+	source: relationshipEndpoint,
+	target: relationshipEndpoint,
+	navigateTo: viewId.nullish(),
+	color: color.nullish(),
+	kind: kind.nullish(),
+	line: line.nullish(),
+	head: arrow.nullish(),
+	tail: arrow.nullish()
+}).transform(pickBy(isNonNullish)).readonly();
+const elements = z$1.record(fqn, element$2);
+const relationships = z$1.record(relationshipId, relationship$3);
+const genRelationshipId = (r) => r.id ?? randomString(8);
+const schema$1 = z$1.object({
+	elements: z$1.union([elements, z$1.array(element$2)]).transform((v) => isArray(v) ? indexBy(v, prop("id")) : v).optional(),
+	relations: z$1.union([relationships, z$1.array(relationship$3)]).transform((v) => isArray(v) ? indexBy(v, genRelationshipId) : v).optional()
+});
+var specification_exports$1 = /* @__PURE__ */ __exportAll({
+	element: () => element$1,
+	relationship: () => relationship$2,
+	schema: () => schema,
+	tagSpec: () => tagSpec
+});
+/**
+* Replicates the {@link ElementSpecification} from the core,
+* less strict, as the generator should be able to handle missing fields and provide defaults.
+*/
+const element$1 = z$1.object({
+	tags: tags.nullable(),
+	title: z$1.string().nullable(),
+	summary: markdownOrString.nullable(),
+	description: markdownOrString.nullable(),
+	technology: z$1.string().nullable(),
+	notation: z$1.string().nullable(),
+	links: links.nullable(),
+	style: style.nullable()
+}).partial().transform(pickBy(isNonNullish));
+/**
+* Replicates the {@link RelationshipSpecification} from the core,
+* less strict, as the generator should be able to handle missing fields and provide defaults.
+*/
+const relationship$2 = z$1.object({
+	technology: z$1.string().nullable(),
+	notation: z$1.string().nullable(),
+	color: color.nullable(),
+	line: line.nullable(),
+	head: arrow.nullable(),
+	tail: arrow.nullable()
+}).partial().transform(pickBy(isNonNullish));
+const tagSpec = z$1.object({ color: z$1.string().regex(/^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/).optional().catch(void 0) }).partial().transform(pickBy(isNonNullish));
+const schema = z$1.object({
+	elements: z$1.record(kind, element$1),
+	deployments: z$1.record(kind, element$1),
+	relationships: z$1.record(kind, relationship$2),
+	tags: z$1.union([z$1.record(tag, tagSpec), z$1.array(tag).transform((tags) => mapToObj(tags, (t) => [t, {}]))])
+}).partial();
+var views_exports$1 = /* @__PURE__ */ __exportAll({
+	anyView: () => anyView$1,
+	autoLayoutDirection: () => autoLayoutDirection,
+	deploymentView: () => deploymentView$1,
+	deploymentViewRule: () => deploymentViewRule$1,
+	dynamicStep: () => dynamicStep$1,
+	dynamicStepsParallel: () => dynamicStepsParallel$1,
+	dynamicStepsSeries: () => dynamicStepsSeries$1,
+	dynamicView: () => dynamicView$1,
+	dynamicViewIncludeRule: () => dynamicViewIncludeRule$1,
+	dynamicViewRule: () => dynamicViewRule$1,
+	dynamicViewStep: () => dynamicViewStep$1,
+	dynamicViewVariant: () => dynamicViewVariant,
+	elementView: () => elementView$1,
+	elementViewRule: () => elementViewRule$1,
+	viewRuleAutoLayout: () => viewRuleAutoLayout$1,
+	viewRuleExclude: () => viewRuleExclude,
+	viewRuleGlobalPredicate: () => viewRuleGlobalPredicate$1,
+	viewRuleGlobalStyle: () => viewRuleGlobalStyle$1,
+	viewRuleGroup: () => viewRuleGroup$1,
+	viewRuleInclude: () => viewRuleInclude,
+	viewRulePredicate: () => viewRulePredicate$1,
+	viewRuleRank: () => viewRuleRank$1,
+	viewRuleStyle: () => viewRuleStyle$1,
+	views: () => views$1
+});
+const autoLayoutDirection = z$1.literal([
+	"TB",
+	"BT",
+	"LR",
+	"RL"
+]);
+const viewRuleAutoLayout$1 = z$1.object({
+	direction: autoLayoutDirection,
+	nodeSep: z$1.number().optional(),
+	rankSep: z$1.number().optional()
+}).transform((v) => v);
+const viewRuleInclude = z$1.strictObject({ include: z$1.array(expression$1) });
+const viewRuleExclude = z$1.strictObject({ exclude: z$1.array(expression$1) });
+const viewRulePredicate$1 = z$1.union([viewRuleInclude, viewRuleExclude]).transform((v) => v);
+const viewRuleStyle$1 = z$1.object({
+	targets: z$1.array(fqnExpr$1),
+	notation: z$1.string().optional(),
+	style
+}).transform((v) => v);
+const viewRuleGlobalStyle$1 = z$1.object({ styleId: z$1.string() }).transform((v) => v);
+const viewRuleGlobalPredicate$1 = z$1.object({ predicateId: z$1.string() }).transform((v) => v);
+const rankValue = z$1.literal([
+	"max",
+	"min",
+	"same",
+	"sink",
+	"source"
+]);
+const viewRuleRank$1 = z$1.object({
+	targets: z$1.array(fqnExpr$1),
+	rank: rankValue
+}).transform((v) => v);
+const viewRuleGroup$1 = z$1.lazy(() => z$1.object({
+	groupRules: z$1.array(z$1.union([viewRulePredicate$1, viewRuleGroup$1])),
+	title: z$1.string().nullable(),
+	color: color.optional(),
+	border: border.optional(),
+	opacity: opacity.optional(),
+	multiple: z$1.boolean().optional(),
+	size: size.optional(),
+	padding: size.optional(),
+	textSize: size.optional()
+}));
+const elementViewRule$1 = z$1.union([
+	viewRulePredicate$1,
+	viewRuleAutoLayout$1,
+	viewRuleStyle$1,
+	viewRuleGlobalStyle$1,
+	viewRuleGlobalPredicate$1,
+	viewRuleRank$1,
+	viewRuleGroup$1
+]);
+const viewProps = z$1.object({
+	id: viewId,
+	_stage: z$1.literal("parsed").default("parsed"),
+	title: z$1.string().nullish(),
+	description: markdownOrString.nullish(),
+	tags: tags.nullish(),
+	links: links.nullish()
+});
+/**
+* Replicates ParsedElementView from the core,
+* less strict, as the generator should be able to handle missing fields and provide defaults.
+*/
+const elementView$1 = viewProps.extend({
+	_type: z$1.literal("element"),
+	viewOf: fqn.nullish(),
+	extends: viewId.nullish(),
+	rules: z$1.array(elementViewRule$1).optional().default([])
+});
+const deploymentViewRule$1 = z$1.union([
+	viewRulePredicate$1,
+	viewRuleAutoLayout$1,
+	viewRuleStyle$1,
+	viewRuleGlobalStyle$1,
+	viewRuleGlobalPredicate$1
+]);
+/**
+* Replicates ParsedElementView from the core,
+* less strict, as the generator should be able to handle missing fields and provide defaults.
+*/
+const deploymentView$1 = viewProps.extend({
+	_type: z$1.literal("deployment"),
+	rules: z$1.array(deploymentViewRule$1).optional().default([])
+});
+const dynamicStep$1 = z$1.object({
+	source: fqn,
+	target: fqn,
+	title: z$1.string().nullish().default(null),
+	kind: z$1.string().nullish(),
+	description: markdownOrString.nullish(),
+	technology: z$1.string().nullish(),
+	notation: z$1.string().nullish(),
+	notes: markdownOrString.nullish(),
+	color: color.optional(),
+	line: line.optional(),
+	head: arrow.optional(),
+	tail: arrow.optional(),
+	isBackward: z$1.boolean().optional(),
+	navigateTo: viewId.nullish()
+}).readonly().transform(pickBy(isNonNullish));
+const dynamicStepsSeries$1 = z$1.object({
+	seriesId: z$1.string().optional(),
+	__series: z$1.array(z$1.any()).readonly()
+}).readonly().transform(pickBy(isNonNullish));
+const dynamicStepsParallel$1 = z$1.object({
+	parallelId: z$1.string().optional(),
+	__parallel: z$1.array(z$1.any()).readonly()
+}).readonly().transform(pickBy(isNonNullish));
+const dynamicViewStep$1 = z$1.union([
+	dynamicStep$1,
+	dynamicStepsSeries$1,
+	dynamicStepsParallel$1
+]);
+const dynamicViewIncludeRule$1 = z$1.strictObject({ include: z$1.array(expression$1) });
+const dynamicViewRule$1 = z$1.union([
+	dynamicViewIncludeRule$1,
+	viewRuleGlobalPredicate$1,
+	viewRuleStyle$1,
+	viewRuleGlobalStyle$1,
+	viewRuleAutoLayout$1
+]);
+const dynamicViewVariant = z$1.literal(["diagram", "sequence"]);
+/**
+* Replicates ParsedDynamicView from the core,
+* less strict, as the generator should be able to handle missing fields and provide defaults.
+*/
+const dynamicView$1 = viewProps.extend({
+	_type: z$1.literal("dynamic"),
+	variant: dynamicViewVariant.optional(),
+	steps: z$1.array(dynamicViewStep$1).optional(),
+	rules: z$1.array(dynamicViewRule$1).optional()
+});
+const anyView$1 = z$1.union([
+	elementView$1,
+	deploymentView$1,
+	dynamicView$1
+]);
+const views$1 = z$1.record(viewId, anyView$1);
+const likec4data$1 = z$1.object({
+	...schema$1.shape,
+	views: views$1,
+	project: z$1.object({
+		id: z$1.string(),
+		styles: LikeC4StylesConfigSchema.nullish()
+	}),
+	deployment: schema$2,
+	deployments: schema$2,
+	specification: schema
+}).partial().readonly().transform(normalizeStyles);
+function normalizeStyles(data) {
+	const elementSpecs = data.specification?.elements;
+	if (!isEmptyish(elementSpecs) && !isEmptyish(data.elements)) data = {
+		...data,
+		elements: mapValues(data.elements, (element) => normalizeElementStyles(element, elementSpecs))
+	};
+	return data;
+}
+function normalizeElementStyles(element, specs) {
+	const spec = specs[element.kind];
+	if (!spec) return element;
+	const specStyle = spec.style ?? {};
+	return produce(element, (draft) => {
+		for (const key of [
+			"description",
+			"technology",
+			"title",
+			"tags",
+			"summary"
+		]) {
+			const specValue = spec[key];
+			const elementValue = element[key];
+			if (isDeepEqual(specValue, elementValue)) delete draft[key];
+		}
+		if (!element.style) return;
+		for (const [key, value] of entries(specStyle)) if (isDeepEqual(element.style?.[key], value)) delete draft.style[key];
+	});
+}
+const schemas = {
+	common: common_exports,
+	expr: expression_exports,
+	specification: specification_exports$1,
+	model: model_exports$1,
+	deployment: deployment_exports$1,
+	views: views_exports$1,
+	likec4data: likec4data$1
+};
+var properties_exports = /* @__PURE__ */ __exportAll({
+	colorProperty: () => colorProperty,
+	descriptionProperty: () => descriptionProperty,
+	iconProperty: () => iconProperty,
+	linkProperty: () => linkProperty,
+	linksProperty: () => linksProperty,
+	markdownProperty: () => markdownProperty,
+	metadataProperty: () => metadataProperty,
+	metadataValue: () => metadataValue,
+	notationProperty: () => notationProperty,
+	notesProperty: () => notesProperty,
+	opacityProperty: () => opacityProperty,
+	styleBlockProperty: () => styleBlockProperty,
+	styleProperties: () => styleProperties,
+	summaryProperty: () => summaryProperty,
+	tagsProperty: () => tagsProperty,
+	technologyProperty: () => technologyProperty,
+	textProperty: () => textProperty,
+	titleProperty: () => titleProperty
+});
+/**
+* Print a property from the context as a text.
+*/
+function textProperty(propertyName, keyword) {
+	return select((e) => e[propertyName], spaceBetween(print$1(keyword ?? propertyName), text()));
+}
+/**
+* Print a property from the context as a markdown string.
+*/
+function markdownProperty(propertyName, keyword) {
+	return select((e) => e[propertyName], spaceBetween(print$1(keyword ?? propertyName), markdownOrString$1()));
+}
+const titleProperty = () => property("title", spaceBetween(print$1("title"), text()));
+const summaryProperty = () => property("summary", spaceBetween(print$1("summary"), markdownOrString$1()));
+const descriptionProperty = () => property("description", spaceBetween(print$1("description"), markdownOrString$1()));
+const notesProperty = () => property("notes", spaceBetween(print$1("notes"), markdownOrString$1()));
+const technologyProperty = () => property("technology", spaceBetween(print$1("technology"), text()));
+const notationProperty = () => property("notation", spaceBetween(print$1("notation"), text()));
+function printMetadataValue() {
+	return operation(({ ctx, out }) => {
+		if (isString(ctx)) return text()({
+			ctx,
+			out
+		});
+		return print$1()({
+			ctx,
+			out
+		});
+	});
+}
+function metadataValue() {
+	return piped(guard(isNot(isArray), printMetadataValue()), guard(isArray, body("[", "]")(foreach(printMetadataValue(), {
+		appendNewLineIfNotEmpty: true,
+		suffix(element, index, isLast) {
+			return !isLast ? "," : void 0;
+		}
+	}))));
+}
+const metadataProperty = () => select((e) => e.metadata ? entries(e.metadata) : void 0, body("metadata")(foreach(spaceBetween(print$1((v) => v[0]), property("1", metadataValue())), separateNewLine())));
+const tagsProperty = () => property("tags", print$1((v) => v.map((t) => `#${t}`).join(", ")));
+function linkProperty() {
+	return spaceBetween(select((l) => typeof l === "string" ? { url: l } : exact({
+		url: l.url,
+		title: l.title
+	}), print$1("link"), print$1((v) => v.url), property("title", inlineText())));
+}
+const linksProperty = () => property("links", foreachNewLine(linkProperty()));
+function styleBlockProperty() {
+	return select((e) => e.style, body("style")(styleProperties()));
+}
+function colorProperty() {
+	return property("color", spaceBetween(print$1("color"), print$1()));
+}
+function opacityProperty() {
+	return property("opacity", spaceBetween(print$1("opacity"), print$1((v) => `${v}%`)));
+}
+function iconProperty() {
+	return property("icon", spaceBetween(print$1("icon"), print$1()));
+}
+const styleProperties = zodOp(style)(lines(property("shape"), colorProperty(), iconProperty(), property("iconColor"), property("iconSize"), property("iconPosition"), property("border"), opacityProperty(), property("size"), property("padding"), property("textSize"), property("multiple")));
+var expressions_exports = /* @__PURE__ */ __exportAll({
+	directRelationExpr: () => directRelationExpr,
+	expression: () => expression,
+	fqnExpr: () => fqnExpr,
+	fqnExprAny: () => fqnExprAny,
+	fqnExprCustom: () => fqnExprCustom,
+	fqnExprOrWhere: () => fqnExprOrWhere,
+	fqnRef: () => fqnRef,
+	inOutRelationExpr: () => inOutRelationExpr,
+	incomingRelationExpr: () => incomingRelationExpr,
+	outgoingRelationExpr: () => outgoingRelationExpr,
+	relationExpr: () => relationExpr,
+	relationExprAny: () => relationExprAny,
+	relationExprCustom: () => relationExprCustom,
+	relationExprOrWhere: () => relationExprOrWhere,
+	whereAnd: () => whereAnd,
+	whereKindEqual: () => whereKindEqual,
+	whereMetadataEqual: () => whereMetadataEqual,
+	whereNot: () => whereNot,
+	whereOperator: () => whereOperator,
+	whereOr: () => whereOr,
+	whereParticipant: () => whereParticipant,
+	whereTagEqual: () => whereTagEqual
+});
+function appendSelector(out, selector) {
+	if (selector) switch (selector) {
+		case "children":
+			out.append(".*");
+			break;
+		case "descendants":
+			out.append(".**");
+			break;
+		case "expanded":
+			out.append("._");
+			break;
+		default: nonexhaustive(selector);
+	}
+	return out;
+}
+const whereTagEqual = zodOp(whereTag)(function whereTagEqualOp({ ctx: { tag }, out }) {
+	if ("eq" in tag) return out.appendTemplate`tag is #${tag.eq}`;
+	if ("neq" in tag) return out.appendTemplate`tag is not #${tag.neq}`;
+	nonexhaustive(tag);
+});
+const whereKindEqual = zodOp(whereKind)(function whereKindEqualOp({ ctx: { kind }, out }) {
+	if ("eq" in kind) return out.appendTemplate`kind is ${kind.eq}`;
+	if ("neq" in kind) return out.appendTemplate`kind is not ${kind.neq}`;
+	nonexhaustive(kind);
+});
+function quoteMetadataValue(v) {
+	return v === "true" || v === "false" ? v : `"${v}"`;
+}
+const whereMetadataEqual = zodOp(whereMetadata)(function whereMetadataEqualOp({ ctx: { metadata }, out }) {
+	const { key, value } = metadata;
+	if (value === void 0) return out.appendTemplate`metadata.${key}`;
+	if ("eq" in value) return out.append(`metadata.${key} is ${quoteMetadataValue(value.eq)}`);
+	if ("neq" in value) return out.append(`metadata.${key} is not ${quoteMetadataValue(value.neq)}`);
+	nonexhaustive(value);
+});
+const whereNot = zodOp(whereNot$1)(property("not", spaceBetween(print$1("not ("), lazy(() => whereOperator()), print$1(")"))));
+const whereParticipant = zodOp(whereParticipant$1)(function whereParticipantOp({ ctx: { participant, operator }, out }) {
+	out.append(participant, ".");
+	if ("tag" in operator) {
+		whereTagEqual()({
+			ctx: operator,
+			out
+		});
+		return;
+	}
+	if ("kind" in operator) {
+		whereKindEqual()({
+			ctx: operator,
+			out
+		});
+		return;
+	}
+	if ("metadata" in operator) {
+		whereMetadataEqual()({
+			ctx: operator,
+			out
+		});
+		return;
+	}
+	nonexhaustive(operator);
+});
+const whereAnd = zodOp(whereAnd$1)(function whereAndOp({ ctx: { and }, out }) {
+	const operands = map(and, (operand) => {
+		let { out } = executeOnFresh(operand, whereOperator());
+		if ("or" in operand) out = fresh().out.append("(", ...out.contents, ")");
+		return out;
+	});
+	return out.append(joinToNode(operands, {
+		appendNewLineIfNotEmpty: true,
+		skipNewLineAfterLastItem: true,
+		prefix(_element, index) {
+			return index > 0 ? "and " : void 0;
+		}
+	}));
+});
+const whereOr = zodOp(whereOr$1)(({ ctx: { or }, out }) => {
+	const operands = map(or, (operand) => {
+		let { out } = executeOnFresh(operand, whereOperator());
+		if ("and" in operand) out = fresh().out.append("(", ...out.contents, ")");
+		return out;
+	});
+	return out.append(joinToNode(operands, {
+		appendNewLineIfNotEmpty: true,
+		skipNewLineAfterLastItem: true,
+		prefix(_element, index) {
+			return index > 0 ? "or " : void 0;
+		}
+	}));
+});
+const whereOperator = zodOp(whereOperator$1)(({ ctx, exec }) => {
+	if ("and" in ctx) return exec(ctx, whereAnd());
+	if ("or" in ctx) return exec(ctx, whereOr());
+	if ("not" in ctx) return exec(ctx, whereNot());
+	if ("tag" in ctx) return exec(ctx, whereTagEqual());
+	if ("kind" in ctx) return exec(ctx, whereKindEqual());
+	if ("metadata" in ctx) return exec(ctx, whereMetadataEqual());
+	if ("participant" in ctx) return exec(ctx, whereParticipant());
+	nonexhaustive(ctx);
+});
+const fqnRef = zodOp(fqnRef$1)(({ ctx, out }) => {
+	if ("model" in ctx) out.append(ctx.model);
+	else {
+		out.append(ctx.deployment);
+		if (ctx.element) out.append(".", ctx.element);
+	}
+	return out;
+});
+const fqnExpr = zodOp(fqnExpr$1)(({ ctx, out, exec }) => {
+	if ("wildcard" in ctx) return out.append("*");
+	if ("elementKind" in ctx) return out.append("element.kind").append(ctx.isEqual ? " = " : " != ").append(ctx.elementKind);
+	if ("elementTag" in ctx) return out.append("element.tag").append(ctx.isEqual ? " = " : " != ").append(`#${ctx.elementTag}`);
+	if ("ref" in ctx) {
+		exec(ctx.ref, fqnRef());
+		appendSelector(out, ctx.selector);
+		return out;
+	}
+	nonexhaustive(ctx);
+});
+const fqnExprCustom = zodOp(fqnExprCustom$1)(({ ctx: { custom }, exec }) => {
+	exec(custom.expr, fqnExprOrWhere());
+	const customOp = withctx(custom)(body("with")(titleProperty(), descriptionProperty(), notationProperty(), notesProperty(), property("navigateTo"), styleProperties()));
+	if ("where" in custom.expr) return exec({}, indent(customOp));
+	return exec({}, space(), customOp);
+});
+const fqnExprOrWhere = zodOp(fqnExprOrWhere$1)(({ ctx, exec }) => {
+	if ("where" in ctx) {
+		exec(ctx.where.expr, fqnExpr());
+		exec(ctx.where.condition, indent(print$1("where"), indent(whereOperator())));
+		return;
+	}
+	exec(ctx, fqnExpr());
+});
+const fqnExprAny = zodOp(fqnExprAny$1)(({ ctx, out }) => {
+	if ("custom" in ctx) return fqnExprCustom()({
+		ctx,
+		out
+	});
+	return fqnExprOrWhere()({
+		ctx,
+		out
+	});
+});
+const directRelationExpr = zodOp(directRelationExpr$1)(merge(property("source", fqnExpr()), print$1((v) => v.isBidirectional ? " <-> " : " -> "), property("target", fqnExpr())));
+const incomingRelationExpr = zodOp(incomingRelationExpr$1)(merge(print$1("-> "), property("incoming", fqnExpr())));
+const outgoingRelationExpr = zodOp(outgoingRelationExpr$1)(merge(property("outgoing", fqnExpr()), print$1(" ->")));
+const inOutRelationExpr = zodOp(inoutRelationExpr)(merge(print$1("-> "), property("inout", fqnExpr()), print$1(" ->")));
+const relationExpr = zodOp(relationExpr$1)(({ ctx, exec }) => {
+	if ("source" in ctx) return exec(ctx, directRelationExpr());
+	if ("incoming" in ctx) return exec(ctx, incomingRelationExpr());
+	if ("outgoing" in ctx) return exec(ctx, outgoingRelationExpr());
+	if ("inout" in ctx) return exec(ctx, inOutRelationExpr());
+	nonexhaustive(ctx);
+});
+const relationExprOrWhere = zodOp(relationExprOrWhere$1)(({ ctx, out }) => {
+	if ("where" in ctx) return merge(withctx(ctx.where.expr)(relationExpr()), indent(print$1("where"), indent(withctx(ctx.where.condition)(whereOperator()))))({
+		ctx,
+		out
+	});
+	return relationExpr()({
+		ctx,
+		out
+	});
+});
+const relationExprCustom = zodOp(relationExprCustom$1)(({ ctx: { customRelation }, exec }) => {
+	exec(customRelation.expr, relationExprOrWhere());
+	const customOp = withctx(customRelation)(body("with")(titleProperty(), descriptionProperty(), notationProperty(), markdownProperty("notes"), property("navigateTo"), styleProperties(), property("head"), property("tail"), property("line")));
+	if ("where" in customRelation.expr) exec({}, indent(customOp));
+	else exec({}, space(), customOp);
+});
+const relationExprAny = zodOp(relationExprAny$1)(({ ctx, exec }) => {
+	if ("customRelation" in ctx) return exec(ctx, relationExprCustom());
+	return exec(ctx, relationExprOrWhere());
+});
+const expression = zodOp(expression$1)(({ ctx, exec }) => {
+	if ("custom" in ctx) return exec(ctx, fqnExprCustom());
+	if ("customRelation" in ctx) return exec(ctx, relationExprCustom());
+	if ("wildcard" in ctx || "ref" in ctx || "elementKind" in ctx || "elementTag" in ctx) return exec(ctx, fqnExpr());
+	if ("source" in ctx || "incoming" in ctx || "outgoing" in ctx || "inout" in ctx) return exec(ctx, relationExpr());
+	if ("where" in ctx) {
+		const { expr, condition } = ctx.where;
+		if ("source" in expr || "incoming" in expr || "outgoing" in expr || "inout" in expr) return exec({ where: {
+			expr,
+			condition
+		} }, relationExprOrWhere());
+		return exec({ where: {
+			expr,
+			condition
+		} }, fqnExprOrWhere());
+	}
+	nonexhaustive(ctx);
+});
+var deployment_exports = /* @__PURE__ */ __exportAll({
+	deployment: () => deployment,
+	instance: () => instance,
+	node: () => node,
+	relationship: () => relationship$1
+});
+function buildTree$1(elements) {
+	const nodes = /* @__PURE__ */ new Map();
+	const roots = [];
+	const sorted = pipe(elements, sortParentsFirst);
+	for (const element of sorted) {
+		let node;
+		if ("element" in element) node = element;
+		else node = {
+			...element,
+			children: []
+		};
+		nodes.set(element.id, node);
+		const parentId = parentFqn(element.id);
+		const parent = parentId ? nodes.get(parentId) : void 0;
+		if (parent && "children" in parent) parent.children.push(node);
+		else roots.push(node);
+	}
+	return {
+		roots,
+		nodes,
+		exists: (fqn) => nodes.has(fqn)
+	};
+}
+function hasStyleProps$1(el) {
+	return !isEmptyish(el.style);
+}
+function hasElementProps$1(el) {
+	return !!(el.description || el.summary || el.technology || el.notation || el.tags && el.tags.length > 0 || el.links && el.links.length > 0 || !isEmptyish(el.metadata) || hasStyleProps$1(el));
+}
+const elementProperties$1 = zodOp(schemas.deployment.element)(lines(tagsProperty(), technologyProperty(), summaryProperty(), descriptionProperty(), linksProperty(), metadataProperty(), select((e) => hasStyleProps$1(e) ? e.style : void 0, body("style")(styleProperties()))));
+const instance = zodOp(schemas.deployment.instance)(spaceBetween(when((v) => nameFromFqn(v.id) !== nameFromFqn(v.element), print$1((v) => nameFromFqn(v.id)), print$1(" =")), print$1("instanceOf"), printProperty("element"), when((v) => !!v.title && v.title !== nameFromFqn(v.id), property("title", inlineText())), when((e) => hasElementProps$1(e), body(elementProperties$1()))));
+function node() {
+	return function nodeOp({ ctx, out }) {
+		const el = ctx;
+		if ("element" in el) {
+			instance()({
+				ctx: el,
+				out
+			});
+			return {
+				ctx,
+				out
+			};
+		}
+		invariant$1("children" in el, "Node must have children property");
+		const needsBody = el.children.length > 0 || hasElementProps$1(el);
+		const name = nameFromFqn(el.id);
+		const inline = [
+			print$1(name),
+			print$1("="),
+			print$1(el.kind)
+		];
+		if (el.title && el.title !== name) inline.push(inlineText(el.title));
+		if (needsBody) inline.push(body(lines(2)(withctx(el, elementProperties$1()), ...el.children.map((node) => withctx(node, nodeOp)))));
+		return spaceBetween(...inline)({
+			ctx,
+			out
+		});
+	};
+}
+function hasRelationStyle$1(rel) {
+	return !!(rel.color || rel.line || rel.head || rel.tail);
+}
+function hasRelationProps$1(rel) {
+	return !!(rel.description || rel.summary || rel.technology || rel.tags && rel.tags.length > 0 || rel.links && rel.links.length > 0 || !isEmptyish(rel.metadata) || hasRelationStyle$1(rel) || rel.navigateTo);
+}
+const relationship$1 = zodOp(schemas.deployment.relationship)(spaceBetween(property("source", fqnRef()), print$1((rel) => rel.kind ? `-[${rel.kind}]->` : "->"), property("target", fqnRef()), property("title", inlineText()), when(hasRelationProps$1, body(tagsProperty(), technologyProperty(), summaryProperty(), descriptionProperty(), property("navigateTo"), linksProperty(), metadataProperty(), when(hasRelationStyle$1, body("style")(colorProperty(), property("line"), property("head"), property("tail")))))));
+const deployment = zodOp(schemas.deployment.schema)(body("deployment")(lines(2)(select((d) => buildTree$1(d.elements ? values(d.elements) : []).roots, lines(2)(foreach(node()))), select((d) => d.relations ? values(d.relations) : void 0, lines(2)(foreach(relationship$1()))))));
+var model_exports = /* @__PURE__ */ __exportAll({
+	element: () => element,
+	model: () => model,
+	relationship: () => relationship
+});
+function buildTree(elements) {
+	const nodes = /* @__PURE__ */ new Map();
+	const roots = [];
+	const sorted = pipe(elements, sortParentsFirst);
+	for (const element of sorted) {
+		const node = {
+			...element,
+			children: []
+		};
+		nodes.set(element.id, node);
+		const parentId = parentFqn(element.id);
+		const parent = parentId ? nodes.get(parentId) : void 0;
+		if (parent) parent.children.push(node);
+		else roots.push(node);
+	}
+	return {
+		roots,
+		nodes,
+		exists: (fqn) => nodes.has(fqn)
+	};
+}
+function hasStyleProps(el) {
+	return !isEmptyish(el.style);
+}
+function hasElementProps(el) {
+	return !!(el.description || el.summary || el.technology || el.notation || el.tags && el.tags.length > 0 || el.links && el.links.length > 0 || !isEmptyish(el.metadata) || hasStyleProps(el));
+}
+const elementProperties = zodOp(schemas.model.element)(lines(tagsProperty(), technologyProperty(), summaryProperty(), descriptionProperty(), linksProperty(), metadataProperty(), select((e) => hasStyleProps(e) ? e.style : void 0, body("style")(styleProperties()))));
+function elementTree() {
+	return function elementTreeNodeOp({ ctx, out }) {
+		const el = ctx;
+		const needsBody = (ctx.children?.length ?? 0) > 0 || hasElementProps(el);
+		const name = nameFromFqn(el.id);
+		const inline = [
+			print$1(name),
+			print$1("="),
+			print$1(el.kind)
+		];
+		if (el.title && el.title !== name) inline.push(inlineText(el.title));
+		if (needsBody) inline.push(body(lines(2)(withctx(el, elementProperties()), ...(ctx.children ?? []).map((node) => withctx(node, elementTree())))));
+		return spaceBetween(...inline)({
+			ctx,
+			out
+		});
+	};
+}
+function hasRelationStyle(rel) {
+	return !!(rel.color || rel.line || rel.head || rel.tail);
+}
+function hasRelationProps(rel) {
+	return !!(rel.description || rel.summary || rel.technology || rel.tags && rel.tags.length > 0 || rel.links && rel.links.length > 0 || !isEmptyish(rel.metadata) || hasRelationStyle(rel) || rel.navigateTo);
+}
+const relationship = zodOp(schemas.model.relationship)(spaceBetween(property("source", fqnRef()), print$1((rel) => rel.kind ? `-[${rel.kind}]->` : "->"), property("target", fqnRef()), property("title", inlineText()), when(hasRelationProps, body(tagsProperty(), technologyProperty(), summaryProperty(), descriptionProperty(), property("navigateTo"), linksProperty(), metadataProperty(), when(hasRelationStyle, body("style")(colorProperty(), property("line"), property("head"), property("tail")))))));
+const element = zodOp(schemas.model.element)(elementTree());
+const model = zodOp(schemas.model.schema)(body("model")(lines(2)(select((d) => buildTree(d.elements ? values(d.elements) : []).roots, lines(2)(foreach(elementTree()))), select((d) => d.relations ? values(d.relations) : void 0, lines(2)(foreach(relationship()))))));
+var specification_exports = /* @__PURE__ */ __exportAll({
+	elementKind: () => elementKind,
+	relationshipKind: () => relationshipKind,
+	specification: () => specification,
+	tagSpecification: () => tagSpecification
+});
+const tagSpecification = zodOp(z$1.tuple([z$1.string(), tagSpec]))(spaceBetween(print$1("tag"), printProperty("0"), property("1", property("color", body(spaceBetween(print$1("color"), print$1()))))));
+const elementKind = (keyword) => zodOp(z$1.tuple([z$1.string(), element$1]))(spaceBetween(print$1(keyword), printProperty("0"), property("1", body(tagsProperty(), titleProperty(), summaryProperty(), descriptionProperty(), technologyProperty(), notationProperty(), linksProperty(), property("style", body("style")(styleProperties()))))));
+const relationshipKind = zodOp(z$1.tuple([z$1.string(), relationship$2]))(spaceBetween(print$1("relationship"), printProperty("0"), property("1", body(technologyProperty(), notationProperty(), colorProperty(), property("line"), property("head"), property("tail")))));
+const specification = zodOp(schema)(body("specification")(lines(2)(select((c) => c.elements && entries(c.elements), foreachNewLine(elementKind("element")())), select((c) => c.deployments && entries(c.deployments), foreachNewLine(elementKind("deploymentNode")())), select((c) => c.relationships && entries(c.relationships), foreachNewLine(relationshipKind())), select((c) => c.tags && entries(c.tags), foreachNewLine(tagSpecification())))));
+var views_exports = /* @__PURE__ */ __exportAll({
+	anyView: () => anyView,
+	deploymentView: () => deploymentView,
+	deploymentViewRule: () => deploymentViewRule,
+	dynamicStep: () => dynamicStep,
+	dynamicStepsParallel: () => dynamicStepsParallel,
+	dynamicStepsSeries: () => dynamicStepsSeries,
+	dynamicView: () => dynamicView,
+	dynamicViewIncludeRule: () => dynamicViewIncludeRule,
+	dynamicViewRule: () => dynamicViewRule,
+	dynamicViewStep: () => dynamicViewStep,
+	elementView: () => elementView,
+	elementViewRule: () => elementViewRule,
+	viewRuleAutoLayout: () => viewRuleAutoLayout,
+	viewRuleGlobalPredicate: () => viewRuleGlobalPredicate,
+	viewRuleGlobalStyle: () => viewRuleGlobalStyle,
+	viewRuleGroup: () => viewRuleGroup,
+	viewRulePredicate: () => viewRulePredicate,
+	viewRuleRank: () => viewRuleRank,
+	viewRuleStyle: () => viewRuleStyle,
+	views: () => views
+});
+const viewTitleProperty = () => property("title", spaceBetween(print$1("title"), inlineText()));
+const viewRulePredicate = zodOp(schemas.views.viewRulePredicate)(({ ctx, exec }) => {
+	let exprs;
+	let type;
+	if ("include" in ctx) {
+		exprs = ctx.include;
+		type = "include";
+	} else if ("exclude" in ctx) {
+		exprs = ctx.exclude;
+		type = "exclude";
+	}
+	invariant(exprs && type, "Invalid view rule predicate");
+	if (!hasAtLeast(exprs, 1)) return;
+	const isMultiple = hasAtLeast(exprs, 2);
+	const exprOp = withctx(exprs)(foreach(expression(), separateComma(isMultiple)));
+	exec(ctx, merge(print$1(type), ...isMultiple ? [indent(exprOp)] : [space(), exprOp]));
+});
+const viewRuleStyle = zodOp(schemas.views.viewRuleStyle)(spaceBetween(print$1("style"), property("targets", foreach(expression(), separateComma())), body("{", "}")(notationProperty(), property("style", styleProperties()))));
+const viewRuleGroup = zodOp(schemas.views.viewRuleGroup)(({ ctx, exec }) => {
+	throw new Error("not implemented");
+});
+const viewRuleGlobalStyle = zodOp(schemas.views.viewRuleGlobalStyle)(({ ctx, exec }) => {
+	throw new Error("not implemented");
+});
+const viewRuleGlobalPredicate = zodOp(schemas.views.viewRuleGlobalPredicate)(({ ctx, exec }) => {
+	throw new Error("not implemented");
+});
+const mapping = {
+	"TB": "TopBottom",
+	"BT": "BottomTop",
+	"LR": "LeftRight",
+	"RL": "RightLeft"
+};
+const viewRuleAutoLayout = zodOp(schemas.views.viewRuleAutoLayout)(spaceBetween(print$1("autoLayout"), property("direction", print$1((v) => mapping[v])), guard(hasProp("rankSep"), spaceBetween(printProperty("rankSep"), printProperty("nodeSep")))));
+const viewRuleRank = zodOp(schemas.views.viewRuleRank)(({ ctx, exec }) => {
+	throw new Error("not implemented");
+});
+const elementViewRule = zodOp(schemas.views.elementViewRule)(({ ctx, exec }) => {
+	if ("include" in ctx || "exclude" in ctx) return exec(ctx, viewRulePredicate());
+	if ("groupRules" in ctx) return exec(ctx, viewRuleGroup());
+	if ("rank" in ctx) return exec(ctx, viewRuleRank());
+	if ("direction" in ctx) return exec(ctx, viewRuleAutoLayout());
+	if ("styleId" in ctx) return exec(ctx, viewRuleGlobalStyle());
+	if ("predicateId" in ctx) return exec(ctx, viewRuleGlobalPredicate());
+	if ("targets" in ctx && "style" in ctx) return exec(ctx, viewRuleStyle());
+	nonexhaustive(ctx);
+});
+const elementView = zodOp(schemas.views.elementView.partial({ _type: true }))(spaceBetween(print$1("view"), print$1((v) => v.id), property("viewOf", spaceBetween(print$1("of"), print$1())), body(lines(2)(lines(tagsProperty(), viewTitleProperty(), descriptionProperty(), linksProperty()), property("rules", foreachNewLine(elementViewRule()))))));
+const deploymentViewRule = zodOp(schemas.views.deploymentViewRule)(({ ctx, exec }) => {
+	if ("include" in ctx || "exclude" in ctx) return exec(ctx, viewRulePredicate());
+	if ("direction" in ctx) return exec(ctx, viewRuleAutoLayout());
+	if ("styleId" in ctx) return exec(ctx, viewRuleGlobalStyle());
+	if ("predicateId" in ctx) return exec(ctx, viewRuleGlobalPredicate());
+	if ("targets" in ctx && "style" in ctx) return exec(ctx, viewRuleStyle());
+	nonexhaustive(ctx);
+});
+const deploymentView = zodOp(schemas.views.deploymentView.partial({ _type: true }))(spaceBetween(print$1("deployment view"), print$1((v) => v.id), body(lines(2)(lines(tagsProperty(), viewTitleProperty(), descriptionProperty(), linksProperty()), property("rules", foreachNewLine(deploymentViewRule()))))));
+const dynamicStep = zodOp(schemas.views.dynamicStep)(spaceBetween(print$1((v) => v.source), print$1((v) => v.isBackward ? "<-" : "->"), print$1((v) => v.target), body(lines(titleProperty(), technologyProperty(), descriptionProperty(), notesProperty(), property("navigateTo"), notationProperty(), colorProperty(), property("line"), property("head"), property("tail")))));
+const dynamicStepsSeries = zodOp(schemas.views.dynamicStepsSeries)(({ ctx, exec }) => {
+	throw new Error("Not implemented");
+});
+const dynamicStepsParallel = zodOp(schemas.views.dynamicStepsParallel)(({ ctx, exec }) => {
+	throw new Error("Not implemented");
+});
+const dynamicViewStep = zodOp(schemas.views.dynamicViewStep)(({ ctx, exec }) => {
+	if ("__series" in ctx) return exec(ctx, dynamicStepsSeries());
+	if ("__parallel" in ctx) return exec(ctx, dynamicStepsParallel());
+	return exec(ctx, dynamicStep());
+});
+const dynamicViewIncludeRule = zodOp(schemas.views.dynamicViewIncludeRule)(({ ctx, exec }) => {
+	if (!hasAtLeast(ctx.include, 1)) return;
+	const isMultiple = hasAtLeast(ctx.include, 2);
+	const exprOp = withctx(ctx.include)(foreach(expression(), separateComma(isMultiple)));
+	exec(ctx, merge(print$1("include"), ...isMultiple ? [indent(exprOp)] : [space(), exprOp]));
+});
+const dynamicViewRule = zodOp(schemas.views.dynamicViewRule)(({ ctx, exec }) => {
+	if ("include" in ctx) return exec(ctx, dynamicViewIncludeRule());
+	if ("predicateId" in ctx) return exec(ctx, viewRuleGlobalPredicate());
+	if ("targets" in ctx && "style" in ctx) return exec(ctx, viewRuleStyle());
+	if ("styleId" in ctx) return exec(ctx, viewRuleGlobalStyle());
+	if ("direction" in ctx) return exec(ctx, viewRuleAutoLayout());
+	nonexhaustive(ctx);
+});
+const dynamicView = zodOp(schemas.views.dynamicView.partial({ _type: true }))(spaceBetween(print$1("dynamic view"), print$1((v) => v.id), body(lines(2)(lines(tagsProperty(), viewTitleProperty(), descriptionProperty(), linksProperty(), property("variant")), property("steps", foreachNewLine(dynamicViewStep())), property("rules", foreachNewLine(dynamicViewRule()))))));
+const anyView = zodOp(schemas.views.anyView)(({ ctx, exec }) => {
+	if ("_type" in ctx) {
+		if (ctx._type == "element") return exec(ctx, elementView());
+		if (ctx._type === "deployment") return exec(ctx, deploymentView());
+		if (ctx._type === "dynamic") return exec(ctx, dynamicView());
+	}
+	nonexhaustive(ctx);
+});
+const views = zodOp(schemas.views.views)(body("views")(select((ctx) => values(ctx), foreach(anyView(), {
+	separator: new CompositeGeneratorNode().appendNewLine().appendNewLine(),
+	prefix: (_, index, isLast) => index === 0 && !isLast ? NL : void 0
+}))));
+z$1.object({});
+const likec4data = zodOp(schemas.likec4data)(lines(2)(property("specification", specification()), model(), property("deployment", deployment()), property("deployments", deployment()), property("views", views())));
+var operators_exports = /* @__PURE__ */ __exportAll({
+	base: () => base_exports,
+	deployment: () => deployment,
+	deploymentView: () => deploymentView,
+	deployments: () => deployment_exports,
+	dynamicView: () => dynamicView,
+	elementView: () => elementView,
+	expr: () => expressions_exports,
+	expression: () => expression,
+	likec4data: () => likec4data,
+	model: () => model,
+	models: () => model_exports,
+	props: () => properties_exports,
+	specification: () => specification,
+	specifications: () => specification_exports,
+	views: () => views_exports
+});
+function generateLikeC4(input, params) {
+	params = {
+		indentation: 2,
+		...params
+	};
+	return materialize(withctx(input, likec4data()), params.indentation);
+}
+/**
+* Prints the result of an operation with the data
+*
+* @see operators
+*
+* @example
+* ```ts
+* print(operators.expression, {
+*   ref: {
+*     model: 'some.el',
+*   },
+*   selector: 'descendants',
+* })
+* // "some.el.**"
+* ```
+*
+* @example
+* ```ts
+* print(operators.model, {
+*   elements: [
+*     {
+*       id: 'cloud',
+*       kind: 'system',
+*     },
+*     {
+*       id: 'cloud.mobile',
+*       kind: 'mobileapp',
+*       shape: 'mobile',
+*       color: 'amber',
+*     }
+*   ],
+* })
+* // model {
+* //   cloud = system {
+* //     mobile = mobileapp {
+* //       style {
+* //         shape mobile
+* //         color amber
+* //       }
+* //     }
+* //   }
+* // }
+* ```
+*/
+function print(operator, data, params) {
+	return materialize(withctx(data, operator()), params?.indentation);
+}
+/**
+* Same as {@link print} but uses tab indentation
+*/
+function printTabIndent(operator, data) {
+	return materialize(withctx(data, operator()), "	");
+}
+export { generateLikeC4 as generate, operators_exports as operators, print, printTabIndent };