likec4 1.48.0 → 1.50.0

package/dist/_chunks/define-config.mjs

@@ -1,409 +0,0 @@
-import { s as __toESM } from "./rolldown-runtime.mjs";
-import { F as t } from "./libs/remeda.mjs";
-import { t as require_lib } from "./libs/json5.mjs";
-import { A as v4_default } from "./libs/@modelcontextprotocol/sdk.mjs";
-import { BorderStyles, ElementShapes, IconPositions, RelationshipArrowTypes, Sizes, ThemeColors, computeColorValues } from "@likec4/core/styles";
-import { exact } from "@likec4/core/types";
-
-//#region ../config/src/schema.image-alias.ts
-const IMAGE_ALIAS_KEY_REGEX = /^@[A-Za-z0-9_-]*$/;
-const IMAGE_ALIAS_VALUE_REGEX = /^(?!\/|[A-Za-z]:[\\\/])(?!.*:\/\/).*$/;
-const ImageAliasValue = v4_default.string().min(1, "Image alias value cannot be empty").regex(IMAGE_ALIAS_VALUE_REGEX, "Image alias value must be a relative path (no leading slash or protocol)");
-const ImageAliasesSchema = v4_default.record(v4_default.string(), ImageAliasValue).meta({ description: "Map of image alias prefixes to relative paths (keys must match /^@\\w+$/; values must be relative paths without protocol or leading slash)." });
-function validateImageAliases(imageAliases) {
-	const invalidKeys = [];
-	const invalidValues = [];
-	if (imageAliases) for (const [key, value] of Object.entries(imageAliases)) {
-		if (!IMAGE_ALIAS_KEY_REGEX.test(key)) invalidKeys.push(key);
-		if (!IMAGE_ALIAS_VALUE_REGEX.test(value)) invalidValues.push(`${key} -> ${value}`);
-	}
-	if (invalidKeys.length || invalidValues.length) {
-		const parts = [];
-		if (invalidKeys.length) parts.push(`Invalid image alias key(s): ${invalidKeys.map((k) => JSON.stringify(k)).join(", ")} (must match ${IMAGE_ALIAS_KEY_REGEX})`);
-		if (invalidValues.length) parts.push(`Invalid image alias value(s): ${invalidValues.map((kv) => JSON.stringify(kv)).join(", ")} (must match ${IMAGE_ALIAS_VALUE_REGEX})`);
-		throw new Error(parts.join(" | "));
-	}
-}
-
-//#endregion
-//#region ../config/src/schema.include.ts
-const RELATIVE_PATH_REGEX = /^(?!\/|[A-Za-z]:[\\\/])(?!.*:\/\/).*$/;
-const IncludePathValue = v4_default.string().min(1, "Include path cannot be empty").regex(RELATIVE_PATH_REGEX, "Include path must be a relative path (no leading slash, drive letter, or protocol)");
-const IncludeConfigSchema = v4_default.strictObject({
-	paths: v4_default.array(IncludePathValue).min(1, "Include paths cannot be empty").meta({ description: [
-		"Additional relative directory paths to include LikeC4 source files from, searched recursively.",
-		"Paths are relative to the project folder (the folder containing this config file).",
-		"Example: [\"../shared\", \"../common/specs\"]"
-	].join("\n") }),
-	maxDepth: v4_default.number().int().min(1).max(20).default(3).meta({ description: [
-		"Maximum directory depth to scan when searching for .c4 files in include paths.",
-		"Prevents excessive scanning of deeply nested directories.",
-		"Default: 3"
-	].join("\n") }),
-	fileThreshold: v4_default.number().int().min(1).default(30).meta({ description: [
-		"Maximum number of files to load from include paths before warning.",
-		"Helps identify performance issues from accidentally including large directories.",
-		"Default: 30"
-	].join("\n") })
-}).meta({
-	id: "include-config",
-	description: "Configuration for including additional LikeC4 source files"
-});
-const IncludeSchema = IncludeConfigSchema.optional().meta({ description: ["Configuration for including additional LikeC4 source files from other directories.", "Example: { \"paths\": [\"../shared\", \"../common/specs\"], \"maxDepth\": 5, \"fileThreshold\": 50 }"].join("\n") });
-function normalizeIncludeConfig(include) {
-	if (!include) return {
-		paths: [],
-		maxDepth: 3,
-		fileThreshold: 30
-	};
-	return include;
-}
-function validateIncludePaths(include) {
-	if (!include?.paths) return;
-	const invalidPaths = [];
-	for (const path of include.paths) if (!RELATIVE_PATH_REGEX.test(path)) invalidPaths.push(path);
-	if (invalidPaths.length > 0) throw new Error(`Invalid include path(s): ${invalidPaths.map((p) => JSON.stringify(p)).join(", ")} (must be relative paths without leading slash, drive letter, or protocol)`);
-}
-
-//#endregion
-//#region ../config/src/schema.theme.ts
-const opacity = v4_default.int().min(0, "Opacity must be between 0 and 100").max(100, "Opacity must be between 0 and 100").meta({
-	id: "Opacity",
-	description: "Opacity 0-100%"
-});
-const shape = v4_default.literal(ElementShapes).meta({ id: "ElementShape" });
-const border = v4_default.literal(BorderStyles).meta({ id: "BorderStyle" });
-const size = v4_default.literal(Sizes).meta({ id: "ElementSize" });
-const iconPosition = v4_default.literal(IconPositions).meta({ id: "IconPosition" });
-const arrow = v4_default.literal(RelationshipArrowTypes).meta({ id: "ArrowType" });
-const line = v4_default.literal([
-	"dashed",
-	"solid",
-	"dotted"
-]).meta({ id: "LineType" });
-const themeColor = v4_default.literal(ThemeColors).meta({ id: "ThemeColor" });
-const customColor = v4_default.string().min(1, "Custom color name cannot be empty").transform((value) => value).meta({ id: "CustomColorName" });
-const color = v4_default.union([themeColor, customColor]).transform((value) => value).meta({ id: "ColorName" });
-const colorSchema = v4_default.string().min(1, "Color value cannot be empty").transform((value) => value).meta({
-	id: "ColorLiteral",
-	description: "Color value in any valid CSS format: hex, rgb, rgba, hsl, hsla ..."
-});
-const ElementColorValuesSchema = v4_default.strictObject({
-	fill: colorSchema.meta({ description: "Background color" }),
-	stroke: colorSchema.meta({ description: "Stroke color (border, paths above background)" }),
-	hiContrast: colorSchema.meta({ description: "High contrast text color (title)" }),
-	loContrast: colorSchema.meta({ description: "Low contrast text color (description)" })
-}).meta({ id: "ElementColorValues" }).transform((value) => value);
-const RelationshipColorValuesSchema = v4_default.strictObject({
-	line: colorSchema.meta({ description: "Line color" }),
-	label: colorSchema.meta({ description: "Label text color" }),
-	labelBg: colorSchema.optional().default("rgba(0, 0, 0, 0.5)").meta({ description: "Label background color" })
-}).meta({ id: "RelationshipColorValues" }).transform((value) => value);
-const StrictThemeColorValuesSchema = v4_default.strictObject({
-	elements: v4_default.union([colorSchema, ElementColorValuesSchema]).meta({ description: "Element color value (or a breakdown of specific color values)" }).transform((value) => {
-		if (typeof value === "string") return computeColorValues(value).elements;
-		return value;
-	}),
-	relationships: v4_default.union([colorSchema, RelationshipColorValuesSchema]).meta({ description: "Relationship color value (or a breakdown of specific color values)" }).transform((value) => {
-		if (typeof value === "string") return computeColorValues(value).relationships;
-		return value;
-	})
-}).meta({ id: "StrictThemeColorValues" });
-const ThemeColorValuesSchema = v4_default.union([colorSchema, StrictThemeColorValuesSchema]).meta({
-	id: "ThemeColorValues",
-	description: "Exact value (hex, rgb, rgba, hsl, hsla ...) or break down of specific color values"
-}).transform((value) => {
-	if (typeof value === "string") return computeColorValues(value);
-	return value;
-});
-const ThemeColorsSchema = v4_default.record(color, ThemeColorValuesSchema).meta({
-	id: "ThemeColors",
-	description: "Override theme colors"
-}).transform((value) => value);
-const DimensionsSchema = v4_default.strictObject({
-	width: v4_default.number().min(50),
-	height: v4_default.number().min(50)
-}).meta({
-	id: "Dimensions",
-	description: "Dimensions"
-});
-const LikeC4Config_Styles_Theme_Sizes = v4_default.strictObject(t(Sizes, () => DimensionsSchema.optional())).meta({
-	id: "ThemeSizes",
-	description: "Override theme sizes"
-});
-const LikeC4Config_Styles_Theme = v4_default.strictObject({
-	colors: ThemeColorsSchema.optional(),
-	sizes: LikeC4Config_Styles_Theme_Sizes.optional()
-}).meta({
-	id: "ThemeCustomization",
-	description: "Theme customization"
-}).transform(({ colors, sizes }) => {
-	return exact({
-		colors: colors ? exact(colors) : void 0,
-		sizes: sizes ? exact(sizes) : void 0
-	});
-});
-const LikeC4Config_Styles_Defaults_Group = v4_default.strictObject({
-	color: color.optional().meta({ description: "Default color for groups\n(must be a valid color name from the theme)" }),
-	opacity: opacity.optional().meta({ description: "Default opacity for groups" }),
-	border: border.optional().meta({ description: "Default border for groups" })
-}).meta({
-	id: "GroupDefaultStyleValues",
-	description: "Override default values for group style properties\nThese values will be used if such property is not defined"
-});
-const LikeC4Config_Styles_Defaults_Relationship = v4_default.strictObject({
-	color: color.optional().meta({ description: "Default color for relationships\n(must be a valid color name from the theme)" }),
-	line: line.optional().meta({ description: "Default line style for relationships" }),
-	arrow: arrow.optional().meta({ description: "Default arrow style for relationships" })
-}).meta({
-	id: "RelationshipDefaultStyleValues",
-	description: "Override default values for relationship style properties\nThese values will be used if such property is not defined"
-});
-const LikeC4Config_Styles_Defaults = v4_default.strictObject({
-	color: color.optional().meta({ description: "Default color for elements\n(must be a valid color name from the theme)" }),
-	opacity: opacity.optional().meta({ description: "Default opacity (0-100%) for elements when displayed as a group (like a container)" }),
-	border: border.optional().meta({ description: "Default border style for elements when displayed as a group (like a container)" }),
-	size: size.optional().meta({ description: "Default size for elements" }),
-	shape: shape.optional().meta({ description: "Default shape for elements" }),
-	iconPosition: iconPosition.optional().meta({ description: "Default icon position for elements" }),
-	group: LikeC4Config_Styles_Defaults_Group.optional().meta({ description: "Default style values for groups" }),
-	relationship: LikeC4Config_Styles_Defaults_Relationship.optional().meta({ description: "Default style values for relationships" })
-}).meta({
-	id: "DefaultStyleValues",
-	description: "Override default values for style properties\nThese values will be used if such property is not defined"
-});
-const LikeC4Config_Styles_CustomStylesheets = v4_default.union([v4_default.string().min(1, "Custom CSS file path cannot be empty"), v4_default.array(v4_default.string().min(1, "Custom CSS file path cannot be empty"))]).meta({
-	id: "CustomStylesheets",
-	description: "Custom CSS (or list of CSS files) to be included in the generated diagrams"
-});
-const LikeC4StylesConfigSchema = v4_default.strictObject({
-	theme: LikeC4Config_Styles_Theme.optional(),
-	defaults: LikeC4Config_Styles_Defaults.optional(),
-	customCss: LikeC4Config_Styles_CustomStylesheets.optional()
-}).meta({
-	id: "StylesConfiguration",
-	description: "Project styles customization"
-}).transform(({ theme, defaults, customCss }) => exact({
-	defaults: normalizeDefaults(defaults),
-	customCss: normalizeStylesheets(customCss),
-	theme
-}));
-function normalizeDefaults(defaults) {
-	if (!defaults) return;
-	const { relationship, group, ...rest } = defaults;
-	return exact({
-		...rest,
-		relationship: relationship && exact(relationship),
-		group: group && exact(group)
-	});
-}
-function normalizeStylesheets(stylesheets) {
-	if (!stylesheets) return;
-	const paths = (Array.isArray(stylesheets) ? stylesheets : [stylesheets]).filter(Boolean);
-	if (paths.length === 0) return;
-	return {
-		paths,
-		content: ""
-	};
-}
-
-//#endregion
-//#region ../config/src/schema.ts
-var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
-const ManualLayoutsConfigSchema = v4_default.strictObject({ outDir: v4_default.string().default(".likec4").meta({ description: [
-	"Path to the directory where manual layouts will be stored,",
-	"relative to the folder containing the project config. ",
-	"",
-	"Defaults to '.likec4'."
-].join("\n") }) }).meta({
-	id: "manual-layouts-config",
-	description: "Configuration for manual layouts"
-});
-const LikeC4ProjectJsonConfigSchema = v4_default.object({
-	name: v4_default.string().nonempty("Project name cannot be empty").refine((value) => value !== "default", {
-		abort: true,
-		error: "Project name cannot be \"default\""
-	}).refine((value) => !value.includes(".") && !value.includes("@") && !value.includes("#"), {
-		abort: true,
-		error: "Project name cannot contain \".\", \"@\" or \"#\", try to use A-z, 0-9, _ and -"
-	}).meta({ description: "Project name, must be unique in the workspace" }),
-	title: v4_default.string().nonempty("Project title cannot be empty if specified").optional().meta({ description: "A human readable title for the project" }),
-	contactPerson: v4_default.string().nonempty("Contact person cannot be empty if specified").optional().meta({ description: "A person who has been involved in creating or maintaining this project" }),
-	imageAliases: ImageAliasesSchema.optional(),
-	include: IncludeSchema,
-	styles: LikeC4StylesConfigSchema.optional(),
-	exclude: v4_default.array(v4_default.string()).optional().meta({ description: "List of file patterns to exclude from the project, default is [\"**/node_modules/**\"]" }),
-	manualLayouts: ManualLayoutsConfigSchema.optional()
-}).meta({ description: "LikeC4 project configuration" });
-const FunctionType = v4_default.instanceof(Function);
-const GeneratorsSchema = v4_default.record(v4_default.string(), FunctionType);
-const LikeC4ProjectConfigSchema = LikeC4ProjectJsonConfigSchema.extend({ generators: GeneratorsSchema.optional() });
-/**
-* Validates JSON string or JSON object into a LikeC4ProjectConfig object.
-*/
-function validateProjectConfig(config) {
-	const parsed = LikeC4ProjectConfigSchema.safeParse(typeof config === "string" ? import_lib.default.parse(config) : config);
-	if (!parsed.success) throw new Error("Config validation failed:\n" + v4_default.prettifyError(parsed.error));
-	if (parsed.data.imageAliases) validateImageAliases(parsed.data.imageAliases);
-	if (parsed.data.include) validateIncludePaths(parsed.data.include);
-	return parsed.data;
-}
-
-//#endregion
-//#region ../config/src/filenames.ts
-const configJsonFilenames = [
-	".likec4rc",
-	".likec4.config.json",
-	"likec4.config.json"
-];
-const configNonJsonFilenames = [
-	"likec4.config.js",
-	"likec4.config.cjs",
-	"likec4.config.mjs",
-	"likec4.config.ts",
-	"likec4.config.cts",
-	"likec4.config.mts"
-];
-const ConfigFilenames = [...configJsonFilenames, ...configNonJsonFilenames];
-/**
-* Checks if the given filename is a LikeC4 JSON config file (JSON, RC).
-*/
-function isLikeC4JsonConfig(filename) {
-	for (const ext of configJsonFilenames) if (filename.endsWith(ext)) return true;
-	return false;
-}
-/**
-* Checks if the given filename is a LikeC4 non-JSON config file (JS, MJS, TS, MTS)
-*/
-function isLikeC4NonJsonConfig(filename) {
-	for (const ext of configNonJsonFilenames) if (filename.endsWith(ext)) return true;
-	return false;
-}
-/**
-* Checks if the given filename is a LikeC4 config file (JSON or non-JSON)
-*/
-function isLikeC4Config(filename) {
-	return isLikeC4JsonConfig(filename) || isLikeC4NonJsonConfig(filename);
-}
-
-//#endregion
-//#region ../config/src/define-config.ts
-/**
-* Defines LikeC4 Project, allows custom generators that can be executed using CLI:
-*
-* `$ likec4 gen <generator-name>`
-*
-* or VSCode command `LikeC4: Run code generator`
-*
-* @example
-* ```ts
-* export default defineConfig({
-*   name: 'my-project',
-*   title: 'My Project',
-*
-*   exclude: ['picomatch pattern'],
-*   generators: {
-*     '<generator-name>': async ({ likec4model, ctx }) => {
-*       await ctx.write('my-generator.txt', likec4model.project.id)
-*     }
-*   }
-* })
-* ```
-*/
-function defineConfig(config) {
-	return LikeC4ProjectConfigSchema.parse(config);
-}
-/**
-* Define reusable custom generators
-*
-* @example
-* ```ts
-* // generators.ts
-* export default defineGenerators({
-*   'my-generator': async ({ likec4model, ctx }) => {
-*     await ctx.write('my-generator.txt', likec4model.project.id)
-*   }
-* })
-*
-* // likec4.config.ts
-* import generators from './generators'
-*
-* export default defineConfig({
-*   name: 'my-project',
-*   generators,
-* })
-* ```
-*/
-function defineGenerators(generators) {
-	return GeneratorsSchema.parse(generators);
-}
-/**
-* Define reusable custom theme color
-* @example
-* ```ts
-* export default defineThemeColor({
-*   element: {
-*     fill: 'red'
-*   }
-* })
-* ```
-*/
-function defineThemeColor(colors) {
-	return ThemeColorValuesSchema.parse(colors);
-}
-/**
-* Define reusable custom theme
-* @example
-* ```ts
-* import { defineThemeColor, defineTheme } from 'likec4/config'
-*
-* export default defineTheme({
-*   colors: {
-*     primary: '#FF0000',
-*     // Or use defineThemeColor
-*     red: defineThemeColor({
-*       elements: {
-*         fill: 'red'
-*       }
-*     })
-*   }
-* })
-* ```
-*/
-function defineTheme(theme) {
-	return LikeC4Config_Styles_Theme.parse(theme);
-}
-/**
-* Define reusable custom style
-* @example
-* ```ts
-* import { defineStyle, defineThemeColor } from 'likec4/config'
-*
-* export default defineStyle({
-*   theme: {
-*     colors: {
-*       red: defineThemeColor({
-*         elements: {
-*           fill: 'red'
-*         }
-*       })
-*     }
-*   },
-*   defaults: {
-*     color: 'red',
-*     opacity: 50,
-*     border: 'solid',
-*     size: 'sm',
-*     relationship: {
-*       color: 'grey',
-*       line: 'solid',
-*     }
-*   }
-* })
-*/
-function defineStyle(styles) {
-	return LikeC4StylesConfigSchema.parse(styles);
-}
-
-//#endregion
-export { defineThemeColor as a, isLikeC4NonJsonConfig as c, defineTheme as i, validateProjectConfig as l, defineGenerators as n, isLikeC4Config as o, defineStyle as r, isLikeC4JsonConfig as s, defineConfig as t, normalizeIncludeConfig as u };

package/dist/_chunks/index3.d.mts

@@ -1,60 +0,0 @@
-import { i as __reExport, r as __exportAll } from "./rolldown-runtime.mjs";
-import * as types from "@likec4/core/types";
-import { BBox, LayoutedDynamicView, NodeId, ViewId } from "@likec4/core/types";
-import { Connection, ConnectionModel, DeployedInstanceModel, DeploymentConnectionModel, DeploymentElementModel as DeploymentElementModel$1, DeploymentNodeModel, DeploymentRelationEndpoint, DeploymentRelationModel as DeploymentRelationModel$1, EdgeModel, ElementModel as ElementModel$1, LikeC4DeploymentModel, LikeC4Model, LikeC4Model as LikeC4Model$1, LikeC4ViewModel as LikeC4ViewModel$1, NodeModel, RelationshipModel as RelationshipModel$1, deploymentConnection, differenceConnections, findAscendingConnections, findDeepestNestedConnection, findDescendantConnections, hasSameSource, hasSameSourceTarget, hasSameTarget, isAnyInOut, isDeployedInstanceModel, isDeploymentElementModel as isDeploymentElementModel$1, isDeploymentNodeModel, isDeploymentRelationModel as isDeploymentRelationModel$1, isEdgeModel, isElementModel as isElementModel$1, isIncoming, isLikeC4ViewModel as isLikeC4ViewModel$1, isNestedConnection, isNestedElementOfDeployedInstanceModel, isNodeModel, isOutgoing, isRelationModel as isRelationModel$1, mergeConnections, modelConnection as modelConnection$1, sortConnectionsByBoundaryHierarchy, sortDeepestFirst } from "@likec4/core/model";
-import { ComputedProjectEdge, ComputedProjectNode, ComputedProjectsView as ComputedProjectsView$1, LayoutedProjectEdge, LayoutedProjectNode, LayoutedProjectsView as LayoutedProjectsView$1 } from "@likec4/core/compute-view";
-
-//#region ../layouts/dist/sequence/index.d.mts
-//#region src/sequence/_types.d.ts
-interface SequenceActorStepPort {
-  id: string;
-  cx: number;
-  cy: number;
-  height: number;
-  type: 'target' | 'source';
-  position: 'left' | 'right' | 'top' | 'bottom';
-}
-interface SequenceActor {
-  id: NodeId;
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-  ports: Array<SequenceActorStepPort>;
-}
-interface SequenceCompound {
-  id: NodeId;
-  origin: NodeId;
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-  depth: number;
-}
-interface SequenceParallelArea {
-  parallelPrefix: string;
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-}
-interface SequenceViewLayout {
-  id: ViewId;
-  actors: Array<SequenceActor>;
-  compounds: Array<SequenceCompound>;
-  parallelAreas: Array<SequenceParallelArea>;
-  bounds: BBox;
-} //#endregion
-//#region src/sequence/sequence-view.d.ts
-declare function calcSequenceLayout(view: LayoutedDynamicView): LayoutedDynamicView.Sequence.Layout; //#endregion
-declare namespace index_d_exports {
-  export { ComputedProjectEdge, ComputedProjectNode, ComputedProjectsView$1 as ComputedProjectsView, Connection, ConnectionModel, DeployedInstanceModel, DeploymentConnectionModel, DeploymentElementModel$1 as DeploymentElementModel, DeploymentNodeModel, DeploymentRelationEndpoint, DeploymentRelationModel$1 as DeploymentRelationModel, EdgeModel, ElementModel$1 as ElementModel, LayoutedProjectEdge, LayoutedProjectNode, LayoutedProjectsView$1 as LayoutedProjectsView, LikeC4DeploymentModel, LikeC4Model$1 as LikeC4Model, LikeC4ViewModel$1 as LikeC4ViewModel, NodeModel, RelationshipModel$1 as RelationshipModel, SequenceViewLayout, UnknownLayouted, calcSequenceLayout, createLikeC4Model, deploymentConnection, differenceConnections, findAscendingConnections, findDeepestNestedConnection, findDescendantConnections, hasSameSource, hasSameSourceTarget, hasSameTarget, isAnyInOut, isDeployedInstanceModel, isDeploymentElementModel$1 as isDeploymentElementModel, isDeploymentNodeModel, isDeploymentRelationModel$1 as isDeploymentRelationModel, isEdgeModel, isElementModel$1 as isElementModel, isIncoming, isLikeC4ViewModel$1 as isLikeC4ViewModel, isNestedConnection, isNestedElementOfDeployedInstanceModel, isNodeModel, isOutgoing, isRelationModel$1 as isRelationModel, mergeConnections, modelConnection$1 as modelConnection, sortConnectionsByBoundaryHierarchy, sortDeepestFirst };
-}
-import * as import__likec4_core_types from "@likec4/core/types";
-type UnknownLayouted = types.UnknownLayouted;
-/**
- * Used by vite plugin to generate `virtual:likec4/model`
- */
-declare function createLikeC4Model(model: any): LikeC4Model<UnknownLayouted>;
-//#endregion
-export { hasSameSourceTarget as A, isIncoming as B, createLikeC4Model as C, findDeepestNestedConnection as D, findAscendingConnections as E, isDeploymentElementModel$1 as F, isOutgoing as G, isNestedConnection as H, isDeploymentNodeModel as I, modelConnection$1 as J, isRelationModel$1 as K, isDeploymentRelationModel$1 as L, index_d_exports as M, isAnyInOut as N, findDescendantConnections as O, isDeployedInstanceModel as P, calcSequenceLayout as Q, isEdgeModel as R, UnknownLayouted as S, differenceConnections as T, isNestedElementOfDeployedInstanceModel as U, isLikeC4ViewModel$1 as V, isNodeModel as W, sortDeepestFirst as X, sortConnectionsByBoundaryHierarchy as Y, SequenceViewLayout as Z, LikeC4DeploymentModel as _, ConnectionModel as a, NodeModel as b, DeploymentElementModel$1 as c, DeploymentRelationModel$1 as d, EdgeModel as f, LayoutedProjectsView$1 as g, LayoutedProjectNode as h, Connection as i, hasSameTarget as j, hasSameSource as k, DeploymentNodeModel as l, LayoutedProjectEdge as m, ComputedProjectNode as n, DeployedInstanceModel as o, ElementModel$1 as p, mergeConnections as q, ComputedProjectsView$1 as r, DeploymentConnectionModel as s, ComputedProjectEdge as t, DeploymentRelationEndpoint as u, LikeC4Model$1 as v, deploymentConnection as w, RelationshipModel$1 as x, LikeC4ViewModel$1 as y, isElementModel$1 as z };