@likec4/core 1.30.0 → 1.32.0

package/dist/shared/{core.CQXU9DF7.mjs → core.rmvsy0n3.mjs}

@@ -1,11 +1,9 @@
-import { i as invariant } from './core.C-YXI-43.mjs';
+import { t as t$1, i as invariant } from './core.Cy9smucx.mjs';
 
 var e={done:true,hasNext:false},s={done:false,hasNext:false},a=()=>e;
 
 function C(t,...o){let n=t,u=o.map(e=>"lazy"in e?y(e):void 0),p=0;for(;p<o.length;){if(u[p]===void 0||!B(n)){let i=o[p];n=i(n),p+=1;continue}let r=[];for(let i=p;i<o.length;i++){let l=u[i];if(l===void 0||(r.push(l),l.isSingle))break}let a=[];for(let i of n)if(f(i,a,r))break;let{isSingle:s}=r.at(-1);n=s?a[0]:a,p+=r.length;}return n}function f(t,o,n){if(n.length===0)return o.push(t),false;let u=t,p=s,e=false;for(let[r,a]of n.entries()){let{index:s,items:i}=a;if(i.push(u),p=a(u,s,i),a.index+=1,p.hasNext){if(p.hasMany??false){for(let l of p.next)if(f(l,o,n.slice(r+1)))return  true;return e}u=p.next;}if(!p.hasNext)break;p.done&&(e=true);}return p.hasNext&&o.push(u),e}function y(t){let{lazy:o,lazyArgs:n}=t,u=o(...n);return Object.assign(u,{isSingle:o.single??false,index:0,items:[]})}function B(t){return typeof t=="string"||typeof t=="object"&&t!==null&&Symbol.iterator in t}
 
-function t$1(r){return typeof r=="string"}
-
 function t(n){return typeof n=="function"}
 
 function getDefaultExportFromCjs (x) {
@@ -263,6 +261,27 @@ function compareNatural(a, b) {
   }
   return t$1(b) ? -1 : 0;
 }
+function compareNaturalHierarchically(separator = ".") {
+  return (a, b) => {
+    if (a === b) return 0;
+    if (!a) return -1;
+    if (!b) return 1;
+    const aParts = a.split(separator);
+    const bParts = b.split(separator);
+    if (aParts.length !== bParts.length) {
+      return aParts.length - bParts.length;
+    }
+    for (let i = 0; i < aParts.length; i++) {
+      const aPart = aParts[i];
+      const bPart = bParts[i];
+      const comparison = compare(aPart, bPart);
+      if (comparison !== 0) {
+        return comparison;
+      }
+    }
+    return 0;
+  };
+}
 
 function isString(value) {
   return value != null && typeof value === "string";
@@ -446,32 +465,4 @@ function ifilter(arg1, arg2) {
   return _filter(arg1);
 }
 
-function imap(arg1, arg2) {
-  const mapper = arg2 ?? arg1;
-  invariant(t(mapper));
-  function* _map(iter) {
-    for (const value of iter) {
-      yield mapper(value);
-    }
-    return;
-  }
-  if (!arg2) {
-    return _map;
-  }
-  return _map(arg1);
-}
-
-function toArray(iterable) {
-  if (iterable) {
-    return Array.from(iterable);
-  }
-  return (it) => Array.from(it);
-}
-function toSet(iterable) {
-  if (iterable) {
-    return new Set(iterable);
-  }
-  return (it) => new Set(it);
-}
-
-export { C, DefaultMap as D, isAncestor as a, toArray as b, ifilter as c, imap as d, isNonEmptyArray as e, t$1 as f, isSameHierarchy as g, t as h, isDescendantOf as i, getDefaultExportFromCjs as j, compareNatural as k, ancestorsFqn as l, commonAncestor as m, nameFromFqn as n, compareByFqnHierarchically as o, parentFqn as p, compareFqnHierarchically as q, hierarchyDistance as r, sortParentsFirst as s, toSet as t, hierarchyLevel as u, sortByFqnHierarchically as v, sortNaturalByFqn as w, isString as x, s as y, a as z };
+export { C, DefaultMap as D, isAncestor as a, ifilter as b, isNonEmptyArray as c, isSameHierarchy as d, a as e, s as f, getDefaultExportFromCjs as g, compareByFqnHierarchically as h, isDescendantOf as i, sortByFqnHierarchically as j, commonAncestor as k, ancestorsFqn as l, compareNatural as m, nameFromFqn as n, compareNaturalHierarchically as o, parentFqn as p, compareFqnHierarchically as q, hierarchyDistance as r, sortParentsFirst as s, t, hierarchyLevel as u, sortNaturalByFqn as v, isString as w };

package/dist/types/aux.d.mts

@@ -0,0 +1,3 @@
+import 'type-fest';
+import '../shared/core.BuO4ncfY.mjs';
+export { y as AllKinds, A as Any, A as AnyAux, C as AnySpec, b as Aux, q as DeploymentFqn, u as DeploymentId, D as DeploymentKind, h as EdgeId, g as ElementId, l as ElementKind, F as Fqn, p as LooseDeploymentId, a3 as LooseDeploymentKind, o as LooseElementId, a2 as LooseElementKind, a4 as LooseRelationKind, L as LooseTag, a1 as LooseTags, x as LooseViewId, j as Metadata, k as MetadataKey, N as Never, I as NodeId, a0 as OrString, G as PickByStage, P as ProjectId, m as RelationId, R as RelationKind, J as Spec, S as SpecAux, s as Stage, q as StrictDeploymentFqn, X as StrictDeploymentKind, Q as StrictElementKind, F as StrictFqn, K as StrictProjectId, Y as StrictRelationKind, O as StrictTag, n as StrictViewId, v as Tag, T as Tags, U as Unknown, c as UnknownComputed, d as UnknownLayouted, e as UnknownParsed, V as ViewId, $ as WithLinks, B as WithMetadata, z as WithOptionalLinks, W as WithOptionalTags, Z as WithTags, H as setStage, t as toComputed, r as toLayouted, w as toParsed } from '../shared/core.BaYE_r29.mjs';

package/dist/types/aux.mjs

@@ -0,0 +1 @@
+

package/dist/types/index.d.mts

@@ -1,48 +1,10 @@
-import { X as XYPoint, N as NonEmptyArray, P as Point, F as Fqn } from '../shared/core.SjLhMA7a.mjs';
-export { A as AsFqn, C as CustomColor, E as ExclusiveUnion, G as GlobalFqn, d as IconUrl, I as IteratorLike, K as KeysOf, b as NTuple, a as NonEmptyReadonlyArray, c as Predicate, e as ProjectId, T as Tag, i as isGlobalFqn, s as splitGlobalFqn } from '../shared/core.SjLhMA7a.mjs';
-import { bk as ViewId, aW as BBox, p as BorderStyle, t as ElementShape, ay as ThemeColor, bl as ViewManualLayout, aT as AutoLayoutDirection } from '../shared/core.DJvmfnEi.mjs';
-export { ag as AbstractRelation, a1 as AllNever, a2 as AndOperator, O as AnyParsedLikeC4ModelData, aU as BasicElementView, aV as BasicView, B as BorderStyles, ap as Color, aq as ColorLiteral, aX as ComputedDeploymentView, aY as ComputedDynamicView, aZ as ComputedEdge, a_ as ComputedElementView, C as ComputedLikeC4ModelData, az as ComputedNode, a as ComputedView, a$ as CustomColorDefinitions, ad as DefaultArrowType, j as DefaultElementShape, ae as DefaultLineStyle, k as DefaultPaddingSize, af as DefaultRelationshipColor, l as DefaultShapeSize, m as DefaultTextSize, n as DefaultThemeColor, c as DeployedInstance, D as DeploymentElement, d as DeploymentElementStyle, e as DeploymentNode, f as DeploymentNodeKind, g as DeploymentNodeKindSpecification, h as DeploymentRef, i as DeploymentRelation, b0 as DeploymentView, b1 as DeploymentViewRule, b2 as DeploymentViewRulePredicate, b3 as DeploymentViewRuleStyle, b4 as DiagramEdge, aA as DiagramNode, b5 as DiagramView, b6 as DynamicView, b7 as DynamicViewIncludeRule, b8 as DynamicViewParallelSteps, b9 as DynamicViewRule, ba as DynamicViewStep, bb as DynamicViewStepOrParallel, bc as EdgeId, q as Element, E as ElementKind, r as ElementKindSpecification, s as ElementKindSpecificationStyle, bw as ElementNotation, o as ElementShapes, u as ElementStyle, as as ElementThemeColorValues, ar as ElementThemeColors, bd as ElementView, a3 as EqualOperator, y as ExpressionV2, be as ExtendsElementView, a4 as Filterable, F as FqnExpr, z as FqnRef, Q as GenericLikeC4ModelData, G as GlobalDynamicPredicates, A as GlobalPredicateId, I as GlobalPredicates, J as GlobalStyleID, K as GlobalStyles, H as HexColorLiteral, a5 as KindEqual, S as LayoutedLikeC4ModelData, U as LikeC4ModelDump, b as LikeC4Theme, L as LikeC4View, v as Link, N as ModelGlobals, M as ModelLayer, ah as ModelRelation, bf as NodeId, a6 as NotOperator, a7 as OperatorPredicate, a8 as OrOperator, V as ParsedLikeC4ModelData, a9 as Participant, aa as ParticipantOperator, P as PredicateSelector, R as RelationExpr, ai as RelationId, aj as RelationshipArrowType, ak as RelationshipKind, al as RelationshipKindSpecification, am as RelationshipLineType, au as RelationshipThemeColorValues, at as RelationshipThemeColors, bg as ScopedElementView, av as ShapeSize, aw as SpacingSize, bh as StepEdgeId, bi as StepEdgeIdLiteral, ab as TagEqual, w as TagSpec, ax as TextSize, T as ThemeColorValues, ao as ThemeColors, x as TypedElement, bj as ViewAutoLayout, bm as ViewRule, bn as ViewRuleAutoLayout, bo as ViewRuleGlobalPredicateRef, bp as ViewRuleGlobalStyle, bq as ViewRuleGroup, br as ViewRulePredicate, bs as ViewRuleStyle, bt as ViewRuleStyleOrGlobalRef, bu as ViewWithHash, bv as ViewWithNotation, ac as WhereOperator, aB as extractStep, aC as getBBoxCenter, aD as getParallelStepsPrefix, W as isAndOperator, aE as isAutoLayoutDirection, aF as isDeploymentView, aG as isDynamicView, aH as isDynamicViewParallelSteps, aI as isElementView, aJ as isExtendsElementView, X as isKindEqual, Y as isNotOperator, Z as isOrOperator, _ as isParticipantOperator, aK as isScopedElementView, aL as isStepEdgeId, $ as isTagEqual, an as isThemeColor, aM as isViewRuleAutoLayout, aN as isViewRuleGlobalPredicateRef, aO as isViewRuleGlobalStyle, aP as isViewRuleGroup, aQ as isViewRulePredicate, aR as isViewRuleStyle, aS as stepEdgeId, a0 as whereOperatorAsPredicate } from '../shared/core.DJvmfnEi.mjs';
+import { d as NonEmptyArray, F as Fqn, D as DeploymentFqn } from '../shared/core.BuO4ncfY.mjs';
+export { A as AnyFqn, B as BuiltInIcon, C as Coalesce, b as DeploymentKind, E as EdgeId, a as ElementKind, f as ExclusiveUnion, m as GlobalFqn, G as GroupElementKind, i as Icon, j as IconUrl, I as IteratorLike, K as KeysOf, L as Link, g as NTuple, N as NodeId, e as NonEmptyReadonlyArray, h as Predicate, P as ProjectId, R as RelationId, l as RelationKind, c as RelationshipKind, p as StepEdgeId, S as StepEdgeIdLiteral, r as StepEdgeKind, T as Tag, V as ViewId, u as extractStep, n as isGlobalFqn, k as isGroupElementKind, t as isStepEdgeId, s as scalar, o as splitGlobalFqn, q as stepEdgeId } from '../shared/core.BuO4ncfY.mjs';
+export { A as Any, A as AnyAux, b as Aux, E as ExtractOnStage, M as ModelStage, S as SpecAux, U as Unknown, c as UnknownComputed, d as UnknownLayouted, e as UnknownParsed, _ as _stage, f as _type, a as aux, i as isOnStage } from '../shared/core.BaYE_r29.mjs';
+import { ap as BorderStyle, ar as ElementShape, ay as ThemeColor, b7 as ViewManualLayout, b2 as AutoLayoutDirection } from '../shared/core.Dpq3P3YJ.mjs';
+export { W as AbstractRelationship, ad as AndOperator, aY as AnyExcludePredicate, aX as AnyIncludePredicate, aK as AnyView, aZ as AnyViewRuleStyle, y as AuxFromDump, A as AuxFromLikeC4ModelData, B as BBox, ba as BaseParsedViewProperties, b9 as BaseViewProperties, ao as BorderStyles, az as Color, C as ColorLiteral, bh as ComputedDeploymentView, bi as ComputedDynamicView, bf as ComputedEdge, bg as ComputedElementView, l as ComputedLikeC4ModelData, be as ComputedNode, aI as ComputedView, at as CustomColor, au as CustomColorDefinitions, U as DefaultArrowType, H as DefaultElementShape, Q as DefaultLineStyle, J as DefaultPaddingSize, V as DefaultRelationshipColor, I as DefaultShapeSize, K as DefaultTextSize, z as DefaultThemeColor, p as DeployedInstance, q as DeploymentElement, r as DeploymentElementRef, D as DeploymentElementStyle, o as DeploymentNode, v as DeploymentRelation, u as DeploymentRelationship, bp as DeploymentViewExcludePredicate, bo as DeploymentViewIncludePredicate, bq as DeploymentViewPredicate, bs as DeploymentViewRule, br as DeploymentViewRuleStyle, bk as DiagramEdge, bj as DiagramNode, aG as DiagramView, by as DynamicViewIncludeRule, bv as DynamicViewParallelSteps, bz as DynamicViewRule, bu as DynamicViewStep, bx as DynamicViewStepOrParallel, O as Element, aq as ElementShapes, _ as ElementSpecification, N as ElementStyle, aB as ElementThemeColorValues, aC as ElementThemeColors, bD as ElementViewExcludePredicate, bC as ElementViewIncludePredicate, bE as ElementViewPredicate, bI as ElementViewRule, bF as ElementViewRuleGroup, bH as ElementViewRuleStyle, a3 as EqualOperator, E as Expression, ai as Filterable, F as FqnExpr, c as FqnRef, g as GlobalDynamicPredicates, G as GlobalPredicateId, f as GlobalPredicates, h as GlobalStyleID, i as GlobalStyles, as as HexColor, a6 as KindEqual, bm as LayoutedDeploymentView, bn as LayoutedDynamicView, bl as LayoutedElementView, m as LayoutedLikeC4ModelData, aG as LayoutedView, n as LikeC4ModelData, x as LikeC4ModelDump, L as LikeC4Theme, aF as LikeC4View, b as ModelExpression, M as ModelFqnExpr, j as ModelGlobals, Z as ModelRelation, a as ModelRelationExpr, bb as NodeNotation, ab as NotOperator, aj as OperatorPredicate, af as OrOperator, bt as ParsedDeploymentView, bA as ParsedDynamicView, bJ as ParsedElementView, k as ParsedLikeC4ModelData, aF as ParsedView, a8 as Participant, a9 as ParticipantOperator, d as Point, P as PredicateSelector, aJ as ProcessedView, e as RectBox, R as RelationExpr, Y as Relationship, aw as RelationshipArrowType, av as RelationshipLineType, a1 as RelationshipSpecification, aD as RelationshipThemeColorValues, aE as RelationshipThemeColors, an as ShapeSize, al as SpacingSize, w as SpecTypesFromDump, a2 as Specification, S as SpecificationDump, a4 as TagEqual, $ as TagSpecification, am as TextSize, T as ThemeColorValues, ax as ThemeColors, b6 as ViewAutoLayout, aL as ViewOnStage, aN as ViewRule, b4 as ViewRuleAutoLayout, b0 as ViewRuleGlobalPredicateRef, a_ as ViewRuleGlobalStyle, aO as ViewRulePredicate, b8 as ViewType, bd as ViewWithHash, bc as ViewWithNotation, aM as ViewWithType, ah as WhereOperator, X as XYPoint, bw as getParallelStepsPrefix, ae as isAndOperator, b3 as isAutoLayoutDirection, aR as isComputedView, t as isDeployedInstance, s as isDeploymentNode, aV as isDeploymentView, aH as isDiagramView, aW as isDynamicView, bB as isDynamicViewParallelSteps, aS as isElementView, aU as isExtendsElementView, a7 as isKindEqual, aH as isLayoutedView, ac as isNotOperator, ag as isOrOperator, aa as isParticipantOperator, aT as isScopedElementView, a0 as isTagColorSpecified, a5 as isTagEqual, aA as isThemeColor, b5 as isViewRuleAutoLayout, b1 as isViewRuleGlobalPredicateRef, a$ as isViewRuleGlobalStyle, bG as isViewRuleGroup, aP as isViewRulePredicate, aQ as isViewRuleStyle, ak as whereOperatorAsPredicate } from '../shared/core.Dpq3P3YJ.mjs';
 import 'type-fest';
 
-/**
- * OverviewGraph is a graph representation of all views in a model
- */
-declare namespace OverviewGraph {
-    type Node = {
-        id: string;
-        type: 'folder' | 'file';
-        path: string;
-        label: string;
-        parentId: string | null;
-        position: XYPoint;
-        width: number;
-        height: number;
-    } | {
-        id: string;
-        type: 'view';
-        viewId: ViewId;
-        label: string;
-        parentId: string | null;
-        position: XYPoint;
-        width: number;
-        height: number;
-    };
-    /**
-     * Edge represents a navigational link from one view to another
-     */
-    type Edge = {
-        id: string;
-        source: string;
-        target: string;
-        points: NonEmptyArray<Point>;
-    };
-}
-interface OverviewGraph {
-    nodes: OverviewGraph.Node[];
-    edges: OverviewGraph.Edge[];
-    bounds: BBox;
-}
-
 declare namespace ViewChange {
     interface ChangeElementStyle {
         op: 'change-element-style';
@@ -52,7 +14,7 @@ declare namespace ViewChange {
             shape?: ElementShape;
             color?: ThemeColor;
         };
-        targets: NonEmptyArray<Fqn>;
+        targets: NonEmptyArray<Fqn | DeploymentFqn>;
     }
     interface SaveManualLayout {
         op: 'save-manual-layout';
@@ -69,4 +31,4 @@ declare namespace ViewChange {
 }
 type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
 
-export { AutoLayoutDirection, BBox, BorderStyle, ElementShape, Fqn, NonEmptyArray, OverviewGraph, Point, ThemeColor, ViewChange, ViewId, ViewManualLayout, XYPoint };
+export { AutoLayoutDirection, BorderStyle, DeploymentFqn, ElementShape, Fqn, NonEmptyArray, ThemeColor, ViewChange, ViewManualLayout };

package/dist/types/index.mjs

@@ -1,5 +1,132 @@
-export { A as AsFqn, B as BorderStyles, C as ComputedNode, z as ComputedView, v as DefaultArrowType, D as DefaultElementShape, x as DefaultLineStyle, f as DefaultPaddingSize, y as DefaultRelationshipColor, g as DefaultShapeSize, h as DefaultTextSize, b as DefaultThemeColor, c as DeploymentElement, H as DiagramNode, E as ElementKind, j as ElementShapes, k as ExpressionV2, F as FqnExpr, l as FqnRef, G as GlobalFqn, M as ModelLayer, R as RelationExpr, I as extractStep, J as getBBoxCenter, K as getParallelStepsPrefix, m as isAndOperator, L as isAutoLayoutDirection, N as isDeploymentView, O as isDynamicView, P as isDynamicViewParallelSteps, a as isElementView, i as isExtendsElementView, e as isGlobalFqn, p as isKindEqual, q as isNotOperator, r as isOrOperator, t as isParticipantOperator, d as isScopedElementView, Q as isStepEdgeId, u as isTagEqual, S as isViewRuleAutoLayout, T as isViewRuleGlobalPredicateRef, U as isViewRuleGlobalStyle, V as isViewRuleGroup, W as isViewRulePredicate, X as isViewRuleStyle, s as splitGlobalFqn, Y as stepEdgeId, w as whereOperatorAsPredicate } from '../shared/core.DgfwjBtu.mjs';
+export { f as DefaultArrowType, D as DefaultElementShape, g as DefaultLineStyle, m as DefaultPaddingSize, h as DefaultRelationshipColor, l as DefaultShapeSize, p as DefaultTextSize, a as DefaultThemeColor, A as DeploymentFqn, H as EdgeId, z as Fqn, F as FqnRef, B as GlobalFqn, G as GroupElementKind, N as NodeId, R as RelationId, S as StepEdgeKind, V as ViewId, b as _stage, _ as _type, I as extractStep, v as isAndOperator, i as isDeployedInstance, k as isDeploymentNode, C as isGlobalFqn, e as isGroupElementKind, r as isKindEqual, u as isNotOperator, j as isOnStage, x as isOrOperator, t as isParticipantOperator, d as isStepEdgeId, q as isTagEqual, E as splitGlobalFqn, s as stepEdgeId, w as whereOperatorAsPredicate } from '../shared/core.CUYDgv2-.mjs';
+export { E as Expression, F as FqnExpr, k as ModelExpression, M as ModelFqnExpr, j as ModelRelationExpr, R as RelationExpr, s as getParallelStepsPrefix, r as isAutoLayoutDirection, n as isComputedView, m as isDeploymentView, p as isDiagramView, l as isDynamicView, h as isDynamicViewParallelSteps, a as isElementView, i as isExtendsElementView, p as isLayoutedView, q as isScopedElementView, d as isViewRuleAutoLayout, f as isViewRuleGlobalPredicateRef, g as isViewRuleGlobalStyle, e as isViewRuleGroup, c as isViewRulePredicate, b as isViewRuleStyle } from '../shared/core.Bk7wEZFG.mjs';
+import { i as invariant } from '../shared/core.Cy9smucx.mjs';
+import '../shared/core.DbRvwARP.mjs';
 
+var BBox;
+((BBox2) => {
+  function center({ x, y, width, height }) {
+    return {
+      x: x + width / 2,
+      y: y + height / 2
+    };
+  }
+  BBox2.center = center;
+  function fromPoints(points) {
+    const { x1, y1, x2, y2 } = RectBox.fromPoints(points);
+    return {
+      x: x1,
+      y: y1,
+      width: x2 - x1,
+      height: y2 - y1
+    };
+  }
+  BBox2.fromPoints = fromPoints;
+  function merge(...boxes) {
+    invariant(boxes.length > 0, "No boxes provided");
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const box of boxes) {
+      minX = Math.min(minX, box.x);
+      minY = Math.min(minY, box.y);
+      maxX = Math.max(maxX, box.x + box.width);
+      maxY = Math.max(maxY, box.y + box.height);
+    }
+    return {
+      x: minX,
+      y: minY,
+      width: maxX - minX,
+      height: maxY - minY
+    };
+  }
+  BBox2.merge = merge;
+  function toRectBox(box) {
+    return {
+      x1: box.x,
+      y1: box.y,
+      x2: box.x + box.width,
+      y2: box.y + box.height
+    };
+  }
+  BBox2.toRectBox = toRectBox;
+})(BBox || (BBox = {}));
+var RectBox;
+((RectBox2) => {
+  function center({ x1, y1, x2, y2 }) {
+    return {
+      x: (x1 + x2) / 2,
+      y: (y1 + y2) / 2
+    };
+  }
+  RectBox2.center = center;
+  function fromPoints(points) {
+    invariant(points.length > 0, "At least one point is required");
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const [x, y] of points) {
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+    }
+    return {
+      x1: minX,
+      y1: minY,
+      x2: maxX,
+      y2: maxY
+    };
+  }
+  RectBox2.fromPoints = fromPoints;
+  function merge(...boxes) {
+    invariant(boxes.length > 0, "No boxes provided");
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const box of boxes) {
+      minX = Math.min(minX, box.x1);
+      minY = Math.min(minY, box.y1);
+      maxX = Math.max(maxX, box.x2);
+      maxY = Math.max(maxY, box.y2);
+    }
+    return {
+      x1: minX,
+      y1: minY,
+      x2: maxX,
+      y2: maxY
+    };
+  }
+  RectBox2.merge = merge;
+  function toBBox(box) {
+    return {
+      x: box.x1,
+      y: box.y1,
+      width: box.x2 - box.x1,
+      height: box.y2 - box.y1
+    };
+  }
+  RectBox2.toBBox = toBBox;
+})(RectBox || (RectBox = {}));
+
+function isTagColorSpecified(spec) {
+  const color = typeof spec === "string" ? spec : spec.color;
+  return color.startsWith("#") || color.startsWith("rgb");
+}
+
+const BorderStyles = ["solid", "dashed", "dotted", "none"];
+const ElementShapes = [
+  "rectangle",
+  "person",
+  "browser",
+  "mobile",
+  "cylinder",
+  "storage",
+  "queue"
+];
 const ThemeColors = [
   "amber",
   "blue",
@@ -14,7 +141,7 @@ const ThemeColors = [
   "sky"
 ];
 function isThemeColor(color) {
-  return color in ThemeColors;
+  return ThemeColors.includes(color);
 }
 
-export { ThemeColors, isThemeColor };
+export { BBox, BorderStyles, ElementShapes, RectBox, ThemeColors, isTagColorSpecified, isThemeColor };

package/dist/utils/index.d.mts

@@ -1,36 +1,7 @@
-export { I as IterableContainer, R as ReorderedArray, a as ancestorsFqn, c as commonAncestor, b as compareByFqnHierarchically, d as compareFqnHierarchically, h as hierarchyDistance, e as hierarchyLevel, i as isAncestor, f as isDescendantOf, g as isSameHierarchy, n as nameFromFqn, p as parentFqn, s as sortByFqnHierarchically, j as sortNaturalByFqn, k as sortParentsFirst } from '../shared/core.D2830qgg.mjs';
-import { N as NonEmptyArray, I as IteratorLike } from '../shared/core.SjLhMA7a.mjs';
-import { IsNumericLiteral } from 'type-fest';
-
-/**
- * Mnemonist DefaultMap Typings
- * =============================
- */
-declare class DefaultMap<K, V> implements Iterable<[K, V]> {
-
-  // Members
-  size: number;
-
-  // Constructor
-  constructor(factory: (key: K, index: number) => V);
-
-  // Methods
-  clear(): void;
-  set(key: K, value: V): this;
-  delete(key: K): boolean;
-  has(key: K): boolean;
-  get(key: K): V;
-  peek(key: K): V | undefined;
-  forEach(callback: (value: V, key: K, map: this) => void, scope?: any): void;
-  keys(): IterableIterator<K>;
-  values(): IterableIterator<V>;
-  entries(): IterableIterator<[K, V]>;
-  [Symbol.iterator](): IterableIterator<[K, V]>;
-  inspect(): any;
-
-  // Statics
-  static autoIncrement(): number;
-}
+export { D as DefaultMap } from '../shared/core.CywrQs86.mjs';
+export { I as IterableContainer, R as ReorderedArray, a as ancestorsFqn, c as commonAncestor, b as compareByFqnHierarchically, d as compareFqnHierarchically, h as hierarchyDistance, e as hierarchyLevel, i as isAncestor, f as isDescendantOf, g as isSameHierarchy, n as nameFromFqn, p as parentFqn, s as sortByFqnHierarchically, j as sortNaturalByFqn, k as sortParentsFirst } from '../shared/core.Pf5I9o0e.mjs';
+import { d as NonEmptyArray, I as IteratorLike } from '../shared/core.BuO4ncfY.mjs';
+import { Tagged, Simplify, Or, IfNever, IsLiteral, And, GreaterThan, IsNever, IsEqual, ReadonlyTuple, IsNumericLiteral } from 'type-fest';
 
 /**
  * Mnemonist DefaultWeakMap Typings
@@ -245,6 +216,10 @@ declare class BiMap<K, V> implements Iterable<[K, V]> {
   static from<I, J>(iterable: Iterable<[I, J]> | {[key: string]: J}): BiMap<I, J>;
 }
 
+declare function nonNullable<T>(value: T, message?: string | (() => string)): NonNullable<T>;
+declare function invariant(condition: any, message?: string): asserts condition;
+declare function nonexhaustive(value: never): never;
+
 /**
  * Common head of two arrays
  *
@@ -253,6 +228,26 @@ declare class BiMap<K, V> implements Iterable<[K, V]> {
 declare function commonHead<T>(sources: ReadonlyArray<T>, targets: ReadonlyArray<T>, equals?: (a: T, b: T) => boolean): T[];
 
 declare function compareNatural(a: string | undefined, b: string | undefined): -1 | 0 | 1;
+/**
+ * Compares two strings hierarchically based on their depth.
+ * From parent nodes to leaves
+ *
+ * @example
+ * const lines = [
+ *   'a.b.c',
+ *   'a',
+ *   'a.b',
+ *   'a.c.c',
+ * ]
+ * lines.sort(compareNaturalHierarchically('.'))
+ * // [
+ * //   'a',
+ * //   'a.b',
+ * //   'a.b.c',
+ * //   'a.c.c',
+ * // ]
+ */
+declare function compareNaturalHierarchically(separator?: string): (a: string | undefined, b: string | undefined) => number;
 
 declare function getOrCreate<K, V>(map: Map<K, V>, key: K, create: (key: K) => V): V;
 
@@ -270,19 +265,155 @@ declare function getOrCreate<K, V>(map: Map<K, V>, key: K, create: (key: K) => V
  */
 type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
 
-type ArraySetRequired<T extends IterableContainer, Min extends number, Iteration extends ReadonlyArray<unknown> = []> = number extends Min ? never : Iteration["length"] extends Min ? T : T extends readonly [] ? never : T extends [infer Head, ...infer Rest] ? [
-    Head,
-    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
-] : T extends readonly [infer Head, ...infer Rest] ? readonly [
-    Head,
-    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
-] : T extends Array<infer Item> ? [
-    Item,
-    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
-] : T extends ReadonlyArray<infer Item> ? readonly [
-    Item,
-    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
-] : never;
+declare const RemedaErrorSymbol: unique symbol;
+type RemedaTypeErrorOptions = {
+    type?: unknown;
+    metadata?: unknown;
+};
+/**
+ * Used for reporting type errors in a more useful way than `never`.
+ */
+type RemedaTypeError<Name extends string, Message extends string, Options extends RemedaTypeErrorOptions = {}> = Tagged<Options extends {
+    type: infer T;
+} ? T : typeof RemedaErrorSymbol, `RemedaTypeError(${Name}): ${Message}.`, Options extends {
+    metadata: infer Metadata;
+} ? Metadata : never>;
+
+/**
+ * Takes a tuple and returns the types that make up its parts. These parts
+ * follow TypeScript's only supported format for arrays/tuples:
+ * [<required>, <optional>, ...<rest>[], <suffix>].
+ *
+ * There are some limitations to what shapes TypeScript supports:
+ * tuples can only have a suffix if they also have a non-never rest element,
+ * **and** tuples cannot have both an optional part and a suffix; this means
+ * there are only 10 possible shapes for tuples:
+ *   1.  Empty Tuples: `[]`.
+ *   2.  Fixed Tuples: `[string, number]`.
+ *   3.  Optional Tuples: `[string?, number?]`.
+ *   4.  Mixed Tuples: `[string, number?]`.
+ *   5.  Arrays: `Array<string>`.
+ *   6.  Fixed-Prefix Arrays: `[string, ...Array<string>]`.
+ *   7.  Optional-Prefix Arrays: `[number?, ...Array<boolean>]`.
+ *   8.  Mixed-Prefix Arrays: `[string, number?, ...Array<boolean>]`.
+ *   9.  Fixed-Suffix Arrays: `[...Array<string>, string]`.
+ *   10. Fixed-Elements Arrays: `[string, ...Array<string>, string]`.
+ *
+ * @example [
+ *   ...TupleParts<T>["required"],
+ *   ...Partial<TupleParts<T>["optional"]>,
+ *   ...CoercedArray<TupleParts<T>["item"]>,
+ *   ...TupleParts<T>["suffix"],
+ * ].
+ */
+type TupleParts<T extends IterableContainer, Prefix extends Array<unknown> = []> = T extends readonly [infer Head, ...infer Tail] ? TupleParts<Tail, [...Prefix, Head]> : Simplify<{
+    /**
+     * A fixed tuple that defines the part of the tuple where all its
+     * elements are required. This will always be the first part of the
+     * tuple and will never contain any optional or rest elements. When the
+     * array doesn't have a required part this will be an empty tuple
+     * (`[]`).
+     */
+    required: Prefix;
+} & TuplePartsWithoutRequired<T>>;
+type TuplePartsWithoutRequired<T extends IterableContainer, Suffix extends Array<unknown> = []> = T extends readonly [...infer Head, infer Tail] ? TuplePartsWithoutRequired<Head, [Tail, ...Suffix]> : (Suffix extends readonly [] ? TuplePartsWithoutFixed<T> : // When the suffix is not empty we can skip the optional part and go
+{
+    optional: [];
+} & TuplePartsRest<T>) & {
+    /**
+     * A *fixed* tuple that defines the part of a tuple **after** a non-never
+     * rest parameter. These could never be optional elements, and could
+     * never contain another rest element. When the array doesn't have a
+     * required part this will be an empty tuple (`[]`).
+     */
+    suffix: Suffix;
+};
+type TuplePartsWithoutFixed<T extends IterableContainer, Optional extends Array<unknown> = []> = T extends readonly [(infer Head)?, ...infer Tail] ? Or<T extends readonly [] ? true : false, Array<T[number]> extends Tail ? true : false> extends true ? {
+    /**
+     * A *fixed* tuple that defines the part of a tuple where all its
+     * elements are suffixed with the optional operator (`?`); but with
+     * the optional operator removed (e.g. `[string?]` would be
+     * represented as `[string]`). These elements can only follow the
+     * `required` part (which could be empty).
+     * To add optional operator back wrap the result with the built-in
+     * `Partial` type.
+     * When the array doesn't have a required part this will be an empty
+     * tuple (`[]`).
+     *
+     * @example Partial<TupleParts<T>["optional"]>
+     */
+    optional: Optional;
+} & TuplePartsRest<T> : TuplePartsWithoutFixed<Tail, [...Optional, Head | undefined]> : RemedaTypeError<"TupleParts", "Unexpected tuple shape", {
+    type: never;
+    metadata: T;
+}>;
+type TuplePartsRest<T extends IterableContainer> = {
+    /**
+     * The type for the rest parameter of the tuple, if any. Unlike the
+     * other parts of the tuple, this is a single type and not
+     * represented as an array/tuple. When a tuple doesn't have a rest
+     * element, this will be `never`. To convert this to a matching array
+     * type that could be spread into a new type use the `CoercedArray`
+     * type which handles the `never` case correctly.
+     *
+     * @example CoercedArray<TupleParts<T>["item"]>
+     */
+    item: T extends readonly [] ? never : T[number];
+};
+
+/**
+ * We built our own version of Subtract instead of using type-fest's one
+ * because we needed a simpler implementation that isn't as prone to excessive
+ * recursion issues and that is clamped at 0 so that we don't need to handle
+ * negative values using even more utilities.
+ */
+type ClampedIntegerSubtract<Minuend, Subtrahend, SubtrahendBag extends Array<unknown> = [], ResultBag extends Array<unknown> = []> = [...SubtrahendBag, ...ResultBag]["length"] extends Minuend ? ResultBag["length"] : SubtrahendBag["length"] extends Subtrahend ? ClampedIntegerSubtract<Minuend, Subtrahend, SubtrahendBag, [
+    ...ResultBag,
+    unknown
+]> : ClampedIntegerSubtract<Minuend, Subtrahend, [
+    ...SubtrahendBag,
+    unknown
+], ResultBag>;
+
+/**
+ * `never[]` and `[]` are not the same type, and in some cases they aren't
+ * interchangeable.
+ *
+ * This type makes it easier to use the result of TupleParts when the input is a
+ * fixed-length tuple but we still want to spread the rest of the array. e.g.
+ * `[...CoercedArray<TupleParts<T>["item"]>, ...TupleParts<T>["suffix"]]`.
+ *
+ */
+type CoercedArray<T> = IfNever<T, [], Array<T>>;
+
+type ArrayRequiredPrefix<T extends IterableContainer, N extends number> = IsLiteral<N> extends true ? T extends unknown ? ClampedIntegerSubtract<N, [
+    ...TupleParts<T>["required"],
+    ...TupleParts<T>["suffix"]
+]["length"]> extends infer Remainder extends number ? Remainder extends 0 ? T : And<GreaterThan<Remainder, TupleParts<T>["optional"]["length"]>, IsNever<TupleParts<T>["item"]>> extends true ? RemedaTypeError<"ArrayRequiredPrefix", "The input tuple cannot satisfy the minimum", {
+    type: never;
+    metadata: [T, N];
+}> : WithSameReadonly<T, [
+    ...TupleParts<T>["required"],
+    ...OptionalTupleRequiredPrefix<TupleParts<T>["optional"], Remainder>,
+    ...ReadonlyTuple<TupleParts<T>["item"], ClampedIntegerSubtract<Remainder, TupleParts<T>["optional"]["length"]>>,
+    ...CoercedArray<TupleParts<T>["item"]>,
+    ...TupleParts<T>["suffix"]
+]> : RemedaTypeError<"ArrayRequiredPrefix", "Remainder didn't compute to a number?!", {
+    type: never;
+    metadata: [T, N];
+}> : RemedaTypeError<"ArrayRequiredPrefix", "Failed to distribute union?!", {
+    type: never;
+    metadata: T;
+}> : RemedaTypeError<"ArrayRequiredPrefix", "Only literal minimums are supported!", {
+    type: never;
+    metadata: N;
+}>;
+type WithSameReadonly<Source, Destination> = IsEqual<Source, Readonly<Source>> extends true ? Readonly<Destination> : Destination;
+type OptionalTupleRequiredPrefix<T extends Array<unknown>, N, Prefix extends Array<unknown> = []> = Prefix["length"] extends N ? [
+    ...Prefix,
+    ...Partial<T>
+] : T extends readonly [infer Head, ...infer Rest] ? OptionalTupleRequiredPrefix<Rest, N, [...Prefix, Head]> : Prefix;
+
 /**
  * Checks if the given array has at least the defined number of elements. When
  * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
@@ -305,7 +436,7 @@ type ArraySetRequired<T extends IterableContainer, Min extends number, Iteration
  * @dataFirst
  * @category Array
  */
-declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArraySetRequired<T, N>;
+declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArrayRequiredPrefix<T, N>;
 declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
 /**
  * Checks if the given array has at least the defined number of elements. When
@@ -331,7 +462,7 @@ declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
  * @dataLast
  * @category Array
  */
-declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArraySetRequired<T, N>;
+declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArrayRequiredPrefix<T, N>;
 declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
 
 declare function isString(value: unknown): value is string;
@@ -364,6 +495,7 @@ declare function ifilter<T>(iterable: Iterable<T>, predicate: (v: T) => boolean)
  * @signature
  *   ifind(predicate)(data)
  */
+declare function ifind<T, S extends T>(predicate: (item: T) => item is S): (iterable: Iterable<T>) => S | undefined;
 declare function ifind<T>(predicate: (item: T) => boolean): (iterable: Iterable<T>) => T | undefined;
 /**
  * Finds the first element in the iterable that satisfies the predicate.
@@ -371,11 +503,21 @@ declare function ifind<T>(predicate: (item: T) => boolean): (iterable: Iterable<
  * @signature
  *  ifind(data, predicate)
  */
+declare function ifind<T, S extends T>(iterable: Iterable<T>, predicate: (item: T) => item is S): S | undefined;
 declare function ifind<T>(iterable: Iterable<T>, predicate: (item: T) => boolean): T | undefined;
 
 declare function iflat(): <T>(iterable: Iterable<IteratorLike<T>>) => IteratorLike<T>;
 declare function iflat<T>(iterable: Iterable<IteratorLike<T>>): IteratorLike<T>;
 
+declare function ihead<T>(): (iterable: Iterable<T>) => T | undefined;
+/**
+ * Finds the first element in the iterable that satisfies the predicate.
+ * Data first version of `find`.
+ * @signature
+ *  ifind(data, predicate)
+ */
+declare function ihead<T>(iterable: Iterable<T>): T | undefined;
+
 type MapFunction<T, S> = (item: T) => S;
 /**
  * Maps an iterable using a mapper function.
@@ -422,18 +564,44 @@ declare function toSet<T>(iterable: Iterable<T>): Set<T>;
 declare function iunique(): <T>(iterable: Iterable<T>) => IteratorLike<T>;
 declare function iunique<T>(iterable: Iterable<T>): IteratorLike<T>;
 
+/**
+ * Saves the value returned by fn() in a hidden property tag of obj object, so next time memoizeProp() is called,
+ * that value will be returned, and fn won't be called.
+ *
+ * @example
+ * ```ts
+ * class Model {
+ *   // using same Symbol
+ *   get computed1() {
+ *     return memoizeProp(this, Symbol.for('computed1'), () => doOnce())
+ *   }
+ *   // using string
+ *   get computed2() {
+ *     return memoizeProp(this, 'computed2', () => doOnce())
+ *   }
+ *
+ * }
+ * ```
+ */
+declare function memoizeProp<Tag extends symbol | string, Res>(obj: object, tag: Tag, fn: () => Res): Res;
+
 declare function delay(): Promise<string>;
 declare function delay(ms: number): Promise<string>;
 declare function delay(randomFrom: number, randomTo: number): Promise<string>;
 
+type RelationshipLike = {
+    source: {
+        model: string;
+    };
+    target: {
+        model: string;
+    };
+};
 /**
  * Compares two relations hierarchically.
  * From the most general (implicit) to the most specific.
  */
-declare const compareRelations: <T extends {
-    source: string;
-    target: string;
-}>(a: T, b: T) => number;
+declare const compareRelations: <T extends RelationshipLike>(a: T, b: T) => number;
 
 /**
  * Returns new set as a union of given sets
@@ -456,4 +624,4 @@ declare function stringHash(str: string): string;
 
 declare function objectHash(value: any): string;
 
-export { BiMap, DefaultMap, DefaultWeakMap, LinkedList, MultiMap, Queue, Stack, commonHead, compareNatural, compareRelations, delay, difference, equals as equalsSet, getOrCreate, hasAtLeast, ifilter, ifind, iflat, imap, intersection, ireduce, isIterable, isNonEmptyArray, isString, isome, iunique, objectHash, stringHash, symmetricDifference, toArray, toSet, union };
+export { BiMap, DefaultWeakMap, LinkedList, MultiMap, Queue, Stack, commonHead, compareNatural, compareNaturalHierarchically, compareRelations, delay, difference, equals as equalsSet, getOrCreate, hasAtLeast, ifilter, ifind, iflat, ihead, imap, intersection, invariant, ireduce, isIterable, isNonEmptyArray, isString, isome, iunique, memoizeProp, nonNullable, nonexhaustive, objectHash, stringHash, symmetricDifference, toArray, toSet, union };