@likec4/core 1.46.4 → 1.48.0

package/dist/_chunks/_types2.d.mts

@@ -0,0 +1,38 @@
+import { ht as _type, mt as _stage } from "./_aux.mjs";
+import { h as ProjectId } from "./scalar.mjs";
+import { i as BBox } from "./index.mjs";
+import { I as DiagramEdge, J as ComputedEdge, L as DiagramNode, X as ComputedNode, on as ViewAutoLayout, rn as BaseViewProperties } from "./index2.mjs";
+
+//#region src/compute-view/projects-view/_types.d.ts
+interface ComputedProjectNode extends ComputedNode {
+  readonly projectId: ProjectId;
+}
+interface ComputedProjectEdge extends ComputedEdge {
+  readonly projectId: ProjectId;
+}
+interface LayoutedProjectNode extends DiagramNode {
+  readonly projectId: ProjectId;
+}
+interface LayoutedProjectEdge extends DiagramEdge {
+  readonly projectId: ProjectId;
+}
+/**
+ * An overview of projects and their relationships, presented as a graph with nodes and edges.
+ * Even though it has same structure as other likec4 views, it is not mixed with them, as it represents a different kind.
+ */
+interface ComputedProjectsView extends BaseViewProperties<any> {
+  readonly [_type]: 'projects';
+  readonly [_stage]: 'computed';
+  readonly nodes: ReadonlyArray<ComputedProjectNode>;
+  readonly edges: ReadonlyArray<ComputedProjectEdge>;
+  readonly autoLayout: ViewAutoLayout;
+}
+interface LayoutedProjectsView extends BaseViewProperties<any> {
+  readonly [_type]: 'projects';
+  readonly [_stage]: 'layouted';
+  readonly nodes: ReadonlyArray<LayoutedProjectNode>;
+  readonly edges: ReadonlyArray<LayoutedProjectEdge>;
+  readonly bounds: BBox;
+}
+//#endregion
+export { LayoutedProjectNode as a, LayoutedProjectEdge as i, ComputedProjectNode as n, LayoutedProjectsView as o, ComputedProjectsView as r, ComputedProjectEdge as t };

package/dist/_chunks/assignTagColors.mjs

@@ -0,0 +1,24 @@
+import { D as e, Q as t$1, Y as t, et as t$4, l as t$2, m as e$1, p as t$5, w as t$3 } from "./libs/remeda.mjs";
+import { V as DefaultTagColors } from "./LikeC4Styles.mjs";
+import { I as compareNatural } from "./utils.mjs";
+import { n as nonNullable } from "./invariant.mjs";
+
+//#region src/styles/assignTagColors.ts
+function assignTagColors(tags) {
+	const tagsWithColors = [];
+	const tagsWithoutColors = [];
+	for (const [tag, spec] of t(tags)) if (e(spec.color)) tagsWithColors.push({
+		tag,
+		spec: { color: spec.color }
+	});
+	else tagsWithoutColors.push(tag);
+	return t$1(tagsWithoutColors, t$2(compareNatural), t$3((tag, idx) => {
+		return {
+			tag,
+			spec: { color: nonNullable(DefaultTagColors[idx % DefaultTagColors.length]) }
+		};
+	}), t$4(tagsWithColors), t$2((a, b) => compareNatural(a.tag, b.tag)), t$5(e$1("tag"), e$1("spec")));
+}
+
+//#endregion
+export { assignTagColors as t };

package/dist/_chunks/calcDriftsFromSnapshot.mjs

@@ -0,0 +1,379 @@
+import { A as e$2, B as t$8, D as e$3, G as t$6, J as n, Q as t, S as t$2, V as t$1, Y as t$5, Z as t$9, _ as t$10, c as t$7, h as t$3, i as n$1, j as e$1, m as e, w as t$4 } from "./libs/remeda.mjs";
+import { M as _layout, g as isElementView, h as isDynamicView } from "./LikeC4Styles.mjs";
+import { l as symmetricDifference } from "./utils.mjs";
+import { t as invariant } from "./invariant.mjs";
+import { f as ifilter, s as ihead } from "./iterable.mjs";
+import { castDraft, produce } from "immer";
+
+//#region src/compute-view/utils/buildElementNotations.ts
+/**
+* Build element notations from computed nodes:
+* 1. Group by notation
+* 2. Group by shape
+* 3. Group by color
+* 4. For each group get unique kinds
+* 5. Unwind the groups
+*/
+function buildElementNotations(nodes) {
+	return t(nodes, n((n) => !!n.notation), t$1(e("notation")), t$2(t$3(t$1(e("shape")), t$2(t$3(t$1(e("color")), t$2(t$3(t$4(e("kind")), n$1())), t$5(), t$4(([color, kinds]) => ({
+		kinds,
+		color
+	})))), t$5(), t$6(([shape, colors]) => colors.map(({ color, kinds }) => ({
+		shape,
+		color,
+		kinds
+	}))))), t$5(), t$6(([title, shapes]) => shapes.map(({ shape, color, kinds }) => ({
+		title,
+		shape,
+		color,
+		kinds
+	}))), t$7(e("shape"), e("title"), [(n) => n.kinds.length, "desc"]));
+}
+
+//#endregion
+//#region src/manual-layout/applyManualLayout.ts
+const changed = (a, b) => {
+	if (a === b || e$1(a) && e$1(b)) return false;
+	return !t$8(a, b);
+};
+/**
+* Maximum allowed drift per coordinate (top, left, bottom, right)
+*/
+const MAX_ALLOWED_DRIFT = 5;
+/**
+* 'Safely' applies non-drifting properties from `next` to `draft`.
+* Used to auto-apply certain properties that are not considered drifting.
+*/
+function autoApplyMetaAndStyles(draft, next) {
+	draft.color = next.color;
+	draft.kind = next.kind;
+	draft.navigateTo = next.navigateTo ?? null;
+	draft.links = next.links ? [...next.links] : null;
+	draft.tags = [...next.tags];
+	if (e$1(next.style.border)) delete draft.style.border;
+	else draft.style.border = next.style.border;
+	if (e$2(next.style.opacity)) draft.style.opacity = next.style.opacity;
+	else delete draft.style.opacity;
+	if (e$1(next.style.multiple)) delete draft.style.multiple;
+	else draft.style.multiple = next.style.multiple;
+}
+/**
+* Auto-applies icon changes according to the rules:
+* - If icon was set before and changed, auto-apply
+* - If icon was set before and now removed, auto-apply
+* - If icon was added, only auto-apply if size not changed
+* @returns true if icon was auto-applied, false otherwise
+*/
+function autoApplyIcon(draft, next, sizeNotChanged) {
+	if (changed(next.icon ?? "none", draft.icon ?? "none")) {
+		const iconWasSet = e$3(draft.icon) && draft.icon !== "none";
+		switch (true) {
+			case iconWasSet && e$3(next.icon) && next.icon !== "none":
+				draft.icon = next.icon;
+				return true;
+			case iconWasSet && (e$1(next.icon) || next.icon === "none"):
+				draft.icon = "none";
+				return true;
+			case !iconWasSet && e$3(next.icon) && next.icon !== "none": if (sizeNotChanged) {
+				draft.icon = next.icon;
+				return true;
+			} else return false;
+		}
+	}
+	return true;
+}
+/**
+* Auto-applies icon style changes according to the rules:
+* - iconColor is always auto-applied
+* - iconSize/iconPosition are auto-applied only if size not changed
+* @returns true if icon style changes were auto-applied, false otherwise
+*/
+function autoApplyIconStyles(draft, next, sizeNotChanged) {
+	let applied = true;
+	if (changed(draft.style.iconColor, next.style.iconColor)) if (e$1(next.style.iconColor)) delete draft.style.iconColor;
+	else draft.style.iconColor = next.style.iconColor;
+	if (changed(draft.style.iconSize, next.style.iconSize)) if (sizeNotChanged) if (e$1(next.style.iconSize)) delete draft.style.iconSize;
+	else draft.style.iconSize = next.style.iconSize;
+	else applied = false;
+	if (changed(draft.style.iconPosition, next.style.iconPosition)) if (sizeNotChanged) if (e$1(next.style.iconPosition)) delete draft.style.iconPosition;
+	else draft.style.iconPosition = next.style.iconPosition;
+	else applied = false;
+	return applied;
+}
+function patchMarkdownOrString(draft, next) {
+	if (!draft) return next;
+	if ("md" in next) {
+		draft.md = next.md;
+		delete draft.txt;
+		return draft;
+	}
+	if ("txt" in next) {
+		draft.txt = next.txt;
+		delete draft.md;
+	}
+	return draft;
+}
+/**
+* Auto-applies title, description, technology to leaf node
+* @returns true if all labels were auto-applied, false otherwise
+*/
+function autoApplyLabelsToLeaf(draft, next, sizeNotChanged) {
+	let applied = true;
+	if (changed(draft.title, next.title)) if (sizeNotChanged) draft.title = next.title;
+	else applied = false;
+	if (changed(draft.description, next.description)) if (e$1(next.description)) delete draft.description;
+	else if (sizeNotChanged) draft.description = patchMarkdownOrString(draft.description, next.description);
+	else applied = false;
+	if (changed(draft.technology, next.technology)) if (e$1(next.technology)) delete draft.technology;
+	else if (sizeNotChanged) draft.technology = next.technology;
+	else applied = false;
+	return applied;
+}
+/**
+* Auto-applies title, description, technology to compound node
+* Currently always updates properties
+*/
+function autoApplyLabelsToCompound(draft, next, _sizeNotChanged) {
+	draft.title = next.title;
+	if (e$1(next.description)) delete draft.description;
+	else draft.description = patchMarkdownOrString(draft.description, next.description);
+	if (e$1(next.technology)) delete draft.technology;
+	else draft.technology = next.technology;
+	return true;
+}
+/**
+* Proof-of-concept
+* Use layout from the snapshot, and 'safe'-apply style properties from the `autoLayouted` view
+*
+* @param autoLayouted Auto-layouted view
+* @param snapshot The view snapshot with manual-layout
+* @returns The snapshot with the next view applied
+*/
+function applyManualLayout(autoLayouted, snapshot) {
+	invariant(autoLayouted.id === snapshot.id, "applyManualLayout: view ids do not match");
+	invariant(autoLayouted._stage === "layouted", "applyManualLayout: expected layouted view");
+	invariant(snapshot._stage === "layouted", "applyManualLayout: expected layouted snapshot");
+	invariant(autoLayouted._layout !== "manual", "applyManualLayout: expected auto-layouted view");
+	const viewDrifts = /* @__PURE__ */ new Set();
+	if (autoLayouted._type !== snapshot._type) viewDrifts.add("type-changed");
+	const nodes = applyNodesManualLayout(snapshot.nodes, autoLayouted.nodes, viewDrifts);
+	const edges = applyEdgesManualLayout(snapshot.edges, autoLayouted.edges, viewDrifts);
+	const nodeNotations = buildElementNotations(nodes);
+	return produce(snapshot, (draft) => {
+		draft.title = autoLayouted.title ?? snapshot.title;
+		draft.description = autoLayouted.description ?? snapshot.description;
+		draft.tags = autoLayouted.tags ? [...autoLayouted.tags] : null;
+		draft.links = autoLayouted.links ? [...autoLayouted.links] : null;
+		draft.sourcePath = autoLayouted.sourcePath;
+		draft[_layout] = "manual";
+		if (nodeNotations && nodeNotations.length > 0) draft.notation = { nodes: nodeNotations };
+		else delete draft.notation;
+		draft.nodes = castDraft(nodes);
+		draft.edges = castDraft(edges);
+		if (isDynamicView(autoLayouted) && draft._type === "dynamic") draft.variant = autoLayouted.variant;
+		if (isElementView(autoLayouted) && draft._type === "element") {
+			if (autoLayouted.viewOf) draft.viewOf = autoLayouted.viewOf;
+			else delete draft.viewOf;
+			if (autoLayouted.extends) draft.extends = autoLayouted.extends;
+			else delete draft.extends;
+		}
+		const drifts = [...viewDrifts];
+		if (t$9(drifts, 1)) draft.drifts = drifts;
+		else {
+			draft.hash = autoLayouted.hash;
+			delete draft.drifts;
+		}
+	});
+}
+function applyNodesManualLayout(snapshotNodes, latestNodes, viewDrifts) {
+	const nextNodes = new Map(latestNodes.map((n) => [n.id, n]));
+	const nodes = snapshotNodes.map((node) => {
+		const next = nextNodes.get(node.id);
+		if (!next) {
+			viewDrifts.add("nodes-removed");
+			return {
+				...node,
+				drifts: ["removed"]
+			};
+		}
+		nextNodes.delete(next.id);
+		return produce(node, (draft) => {
+			autoApplyMetaAndStyles(draft, next);
+			const nodeDrifts = /* @__PURE__ */ new Set();
+			const wasCompound = node.children.length > 0;
+			const willBeCompound = next.children.length > 0;
+			if (changed(draft.modelRef, next.modelRef) || changed(draft.deploymentRef, next.deploymentRef)) nodeDrifts.add("modelRef-changed");
+			if (willBeCompound && !wasCompound) nodeDrifts.add("became-compound");
+			if (!willBeCompound && wasCompound) nodeDrifts.add("became-leaf");
+			if (changed(draft.parent, next.parent)) nodeDrifts.add("parent-changed");
+			const sizeNotChanged = draft.width + MAX_ALLOWED_DRIFT >= next.width && draft.height + MAX_ALLOWED_DRIFT >= next.height;
+			if (changed(draft.shape, next.shape)) if (sizeNotChanged) draft.shape = next.shape;
+			else nodeDrifts.add("shape-changed");
+			if (!autoApplyIconStyles(draft, next, sizeNotChanged)) nodeDrifts.add("label-changed");
+			if (!autoApplyIcon(draft, next, sizeNotChanged && willBeCompound === wasCompound)) nodeDrifts.add("label-changed");
+			if (!(wasCompound ? autoApplyLabelsToCompound : autoApplyLabelsToLeaf)(draft, next, sizeNotChanged)) nodeDrifts.add("label-changed");
+			if (changed(node.notation, next.notation)) draft.notation = next.notation ?? null;
+			if (wasCompound && willBeCompound && symmetricDifference(new Set(node.children), new Set(next.children)).size > 0) nodeDrifts.add("children-changed");
+			const _drifts = [...nodeDrifts];
+			if (t$9(_drifts, 1)) {
+				viewDrifts.add("nodes-drift");
+				draft.drifts = _drifts;
+			} else delete draft.drifts;
+		});
+	});
+	if (nextNodes.size > 0) viewDrifts.add("nodes-added");
+	return nodes;
+}
+function applyEdgesManualLayout(snapshotEdges, latestEdges, viewDrifts) {
+	const nextEdges = new Map(latestEdges.map((e) => [e.id, e]));
+	const edges = snapshotEdges.map((edge) => {
+		let next = nextEdges.get(edge.id) ?? t(nextEdges.values(), ifilter((e) => e.source === edge.source && e.target === edge.target), ihead());
+		if (next) nextEdges.delete(next.id);
+		return produce(edge, (draft) => {
+			if (!next) {
+				draft.drifts = ["removed"];
+				viewDrifts.add("edges-removed");
+				return;
+			}
+			const edgeDrifts = /* @__PURE__ */ new Set();
+			const isSameId = edge.id === next.id;
+			switch (true) {
+				case isSameId && edge.source == next.source && edge.target == next.target:
+					if (changed(draft.dir ?? "forward", next.dir ?? "forward")) edgeDrifts.add("direction-changed");
+					break;
+				case isSameId && edge.source == next.target && edge.target == next.source:
+					if (edge.source !== edge.target) edgeDrifts.add("direction-changed");
+					break;
+				case isSameId:
+					if (edge.source != next.source) edgeDrifts.add("source-changed");
+					if (edge.target != next.target) edgeDrifts.add("target-changed");
+					break;
+				default:
+					invariant(edge.id != next.id, "Unexpected case in edge drift detection, ids should not match");
+					invariant(edge.source == next.source, "Unexpected case in edge drift detection, sources should match");
+					invariant(edge.target == next.target, "Unexpected case in edge drift detection, targets should match");
+					if (changed(draft.dir ?? "forward", next.dir ?? "forward")) edgeDrifts.add("direction-changed");
+					break;
+			}
+			draft.color = next.color;
+			draft.line = next.line;
+			draft.navigateTo = next.navigateTo ?? null;
+			draft.tags = next.tags ? [...next.tags] : null;
+			if (changed(edge.notes, next.notes)) {
+				if (e$1(edge.notes) !== e$1(next.notes)) edgeDrifts.add("notes-changed");
+				draft.notes = next.notes ?? edge.notes;
+			}
+			if (next.astPath) draft.astPath = next.astPath;
+			else delete draft.astPath;
+			if (changed(t$10(edge, [
+				"label",
+				"description",
+				"technology",
+				"labelBBox"
+			]), t$10(next, [
+				"label",
+				"description",
+				"technology",
+				"labelBBox"
+			]))) switch (true) {
+				case next.labelBBox && !edge.labelBBox:
+					edgeDrifts.add("label-added");
+					break;
+				case edge.labelBBox && !next.labelBBox:
+					edgeDrifts.add("label-removed");
+					break;
+				case !!edge.labelBBox && !!next.labelBBox:
+					if (next.labelBBox.width * next.labelBBox.height > (edge.labelBBox.width + MAX_ALLOWED_DRIFT) * (edge.labelBBox.height + MAX_ALLOWED_DRIFT)) {
+						draft.labelBBox.width = Math.round(next.labelBBox.width);
+						draft.labelBBox.height = Math.round(next.labelBBox.height);
+					}
+					if (changed(edge.label, next.label)) {
+						if (e$1(next.label) !== e$1(edge.label)) edgeDrifts.add("label-changed");
+						draft.label = next.label ?? edge.label;
+					}
+					if (changed(edge.description, next.description)) {
+						if (e$1(next.description) !== e$1(edge.description)) edgeDrifts.add("label-changed");
+						if (next.description) draft.description = patchMarkdownOrString(edge.description, next.description);
+					}
+					if (changed(edge.technology, next.technology)) {
+						if (e$1(next.technology) !== e$1(edge.technology)) edgeDrifts.add("label-changed");
+						draft.technology = next.technology ?? edge.technology ?? null;
+					}
+					break;
+				default:
+					invariant(!edge.labelBBox, "Unexpected case in edge labelBBox drift detection");
+					invariant(!next.labelBBox, "Unexpected case in next labelBBox drift detection");
+					break;
+			}
+			const _drifts = [...edgeDrifts];
+			if (t$9(_drifts, 1)) {
+				viewDrifts.add("edges-drift");
+				draft.drifts = _drifts;
+			} else delete draft.drifts;
+		});
+	});
+	if (nextEdges.size > 0) viewDrifts.add("edges-added");
+	return edges;
+}
+
+//#endregion
+//#region src/manual-layout/calcDriftsFromSnapshot.ts
+/**
+* Calculates drifts comparing latest autoLayouted with manual snapshot.
+*
+* @returns The autoLayouted view with calculated drifts if any.
+*/
+function calcDriftsFromSnapshot(autoLayouted, snapshot) {
+	const { drifts, ...manual } = applyManualLayout(autoLayouted, snapshot);
+	if (!drifts || drifts.length === 0) return produce(autoLayouted, (draft) => {
+		delete draft.drifts;
+		draft[_layout] = "auto";
+	});
+	const viewDrifts = /* @__PURE__ */ new Set();
+	if (drifts.includes("type-changed")) viewDrifts.add("type-changed");
+	const manualNodes = new Map(manual.nodes.map((n) => [n.id, n]));
+	const manualEdges = new Map(manual.edges.map((e) => [e.id, e]));
+	const nodes = autoLayouted.nodes.map((node) => {
+		const snapshotNode = manualNodes.get(node.id);
+		if (snapshotNode) manualNodes.delete(snapshotNode.id);
+		return produce(node, (draft) => {
+			if (!snapshotNode) {
+				viewDrifts.add("nodes-added");
+				draft.drifts = ["added"];
+				return;
+			}
+			if (snapshotNode.drifts) {
+				viewDrifts.add("nodes-drift");
+				draft.drifts = [...snapshotNode.drifts];
+			} else delete draft.drifts;
+		});
+	});
+	if (manualNodes.size > 0) viewDrifts.add("nodes-removed");
+	const edges = autoLayouted.edges.map((edge) => {
+		const snapshotEdge = manualEdges.get(edge.id) ?? t(manualEdges.values(), ifilter((e) => e.source === edge.source && e.target === edge.target), ihead());
+		if (snapshotEdge) manualEdges.delete(snapshotEdge.id);
+		return produce(edge, (draft) => {
+			if (!snapshotEdge) {
+				viewDrifts.add("edges-added");
+				draft.drifts = ["added"];
+				return;
+			}
+			if (snapshotEdge.drifts) {
+				viewDrifts.add("edges-drift");
+				draft.drifts = [...snapshotEdge.drifts];
+			} else delete draft.drifts;
+		});
+	});
+	if (manualEdges.size > 0) viewDrifts.add("edges-removed");
+	const _viewDrifts = [...viewDrifts];
+	return produce(autoLayouted, (draft) => {
+		if (t$9(_viewDrifts, 1)) draft.drifts = _viewDrifts;
+		else delete draft.drifts;
+		draft.nodes = castDraft(nodes);
+		draft.edges = castDraft(edges);
+		draft[_layout] = "auto";
+	});
+}
+
+//#endregion
+export { applyManualLayout as n, buildElementNotations as r, calcDriftsFromSnapshot as t };

package/dist/_chunks/const.d.mts

@@ -0,0 +1,43 @@
+import { n as Any } from "./_aux.mjs";
+import { s as Fqn } from "./scalar.mjs";
+import { C as ElementModel, i as DeploymentElementModel } from "./LikeC4Model.mjs";
+
+//#region src/model/connection/Connection.d.ts
+interface Connection<Elem = ElementModel<Any> | DeploymentElementModel<Any>, Id = string> {
+  readonly id: Id;
+  readonly source: Elem;
+  readonly target: Elem;
+  /**
+   * Common ancestor of the source and target elements.
+   * Represents the boundary of the connection.
+   */
+  readonly boundary: Elem | null;
+  /**
+   * Human readable expression of the connection
+   * Mostly used for testing and debugging
+   */
+  readonly expression: string;
+  mergeWith(this: Connection<Elem, Id>, other: typeof this): typeof this;
+  nonEmpty(): boolean;
+  difference(this: Connection<Elem, Id>, other: typeof this): typeof this;
+  intersect(this: Connection<Elem, Id>, other: typeof this): typeof this;
+  equals(other: Connection): boolean;
+}
+declare namespace Connection {
+  type ConnectionPredicate = <C extends Connection<{
+    id: string;
+  }, any>>(connection: C) => boolean;
+  type ElementId = Fqn | string;
+  export const isInside: (fqn: ElementId) => ConnectionPredicate;
+  export const isDirectedBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
+  export const isAnyBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
+  export const isIncoming: (target: ElementId) => ConnectionPredicate;
+  export const isOutgoing: (source: ElementId) => ConnectionPredicate;
+  export const isAnyInOut: (source: ElementId) => ConnectionPredicate;
+  export {};
+}
+//#endregion
+//#region src/utils/const.d.ts
+declare const customInspectSymbol: unique symbol;
+//#endregion
+export { Connection as n, customInspectSymbol as t };

package/dist/_chunks/const.mjs

@@ -0,0 +1,33 @@
+import { C as isAncestor } from "./utils.mjs";
+
+//#region src/model/connection/Connection.ts
+let Connection;
+(function(_Connection) {
+	_Connection.isInside = (fqn) => {
+		return (connection) => isAncestor(fqn, connection.source.id) && isAncestor(fqn, connection.target.id);
+	};
+	const isDirectedBetween = _Connection.isDirectedBetween = (source, target) => {
+		return (connection) => (connection.source.id === source || isAncestor(source, connection.source.id)) && (connection.target.id === target || isAncestor(target, connection.target.id));
+	};
+	_Connection.isAnyBetween = (source, target) => {
+		const forward = isDirectedBetween(source, target), backward = isDirectedBetween(target, source);
+		return (connection) => forward(connection) || backward(connection);
+	};
+	const isIncoming = _Connection.isIncoming = (target) => {
+		return (connection) => (connection.target.id === target || isAncestor(target, connection.target.id)) && !isAncestor(target, connection.source.id);
+	};
+	const isOutgoing = _Connection.isOutgoing = (source) => {
+		return (connection) => (connection.source.id === source || isAncestor(source, connection.source.id)) && !isAncestor(source, connection.target.id);
+	};
+	_Connection.isAnyInOut = (source) => {
+		const isIn = isIncoming(source), isOut = isOutgoing(source);
+		return (connection) => isIn(connection) || isOut(connection);
+	};
+})(Connection || (Connection = {}));
+
+//#endregion
+//#region src/utils/const.ts
+const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+
+//#endregion
+export { Connection as n, customInspectSymbol as t };