@likec4/core 1.38.0 → 1.39.0

package/dist/types/fqnRef.mjs

@@ -0,0 +1,46 @@
+import { isString } from 'remeda';
+import { a as GlobalFqn } from '../shared/core.Be1n9a0i.mjs';
+import '../shared/core.D4npX2q8.mjs';
+
+var FqnRef;
+((FqnRef2) => {
+  function isElementRef(ref) {
+    return "model" in ref && !("project" in ref);
+  }
+  FqnRef2.isElementRef = isElementRef;
+  function isImportRef(ref) {
+    return "project" in ref && "model" in ref;
+  }
+  FqnRef2.isImportRef = isImportRef;
+  function flatten(ref) {
+    if (isString(ref)) {
+      throw new Error(`Expected FqnRef, got: "${ref}"`);
+    }
+    if (isImportRef(ref)) {
+      return GlobalFqn(ref.project, ref.model);
+    }
+    if (isElementRef(ref)) {
+      return ref.model;
+    }
+    throw new Error("Expected FqnRef.ModelRef or FqnRef.ImportRef");
+  }
+  FqnRef2.flatten = flatten;
+  function isModelRef(ref) {
+    return isElementRef(ref) || isImportRef(ref);
+  }
+  FqnRef2.isModelRef = isModelRef;
+  function isInsideInstanceRef(ref) {
+    return "deployment" in ref && "element" in ref;
+  }
+  FqnRef2.isInsideInstanceRef = isInsideInstanceRef;
+  function isDeploymentElementRef(ref) {
+    return "deployment" in ref && !("element" in ref);
+  }
+  FqnRef2.isDeploymentElementRef = isDeploymentElementRef;
+  function isDeploymentRef(ref) {
+    return isDeploymentElementRef(ref) || isInsideInstanceRef(ref);
+  }
+  FqnRef2.isDeploymentRef = isDeploymentRef;
+})(FqnRef || (FqnRef = {}));
+
+export { FqnRef };

package/dist/types/index.d.mts

@@ -1,8 +1,11 @@
 import { N as NonEmptyArray } from '../shared/core.DuSLYTG6.mjs';
 export { C as Coalesce, E as ExclusiveUnion, I as IteratorLike, K as KeysOf, L as Link, b as NTuple, a as NonEmptyReadonlyArray, P as Predicate } from '../shared/core.DuSLYTG6.mjs';
-export { A as Any, A as AnyAux, a as Aux, E as ExtractOnStage, M as ModelStage, S as SpecAux, U as Unknown, b as UnknownComputed, c as UnknownLayouted, d as UnknownParsed, e as _stage, f as _type, _ as aux, i as isOnStage } from '../shared/core.O6FG0HF9.mjs';
-import { aR as ViewManualLayout, aM as AutoLayoutDirection } from '../shared/core.CE_hG7EJ.mjs';
-export { Y as AbstractRelationship, ae as AndOperator, aG as AnyExcludePredicate, aF as AnyIncludePredicate, as as AnyView, aH as AnyViewRuleStyle, H as AuxFromDump, A as AuxFromLikeC4ModelData, B as BBox, aU as BaseParsedViewProperties, aT as BaseViewProperties, a$ as ComputedDeploymentView, b0 as ComputedDynamicView, aZ as ComputedEdge, a_ as ComputedElementView, C as ComputedLikeC4ModelData, aY as ComputedNode, aq as ComputedView, V as DefaultArrowType, J as DefaultElementShape, U as DefaultLineStyle, N as DefaultPaddingSize, W as DefaultRelationshipColor, K as DefaultShapeSize, O as DefaultTextSize, I as DefaultThemeColor, q as DeployedInstance, r as DeploymentElement, s as DeploymentElementRef, D as DeploymentElementStyle, p as DeploymentNode, w as DeploymentRelation, v as DeploymentRelationship, b7 as DeploymentViewExcludePredicate, b6 as DeploymentViewIncludePredicate, b8 as DeploymentViewPredicate, ba as DeploymentViewRule, b9 as DeploymentViewRuleStyle, b2 as DiagramEdge, b1 as DiagramNode, ao as DiagramView, bg as DynamicViewIncludeRule, bd as DynamicViewParallelSteps, bh as DynamicViewRule, bc as DynamicViewStep, bf as DynamicViewStepOrParallel, T as Element, $ as ElementSpecification, Q as ElementStyle, bl as ElementViewExcludePredicate, bk as ElementViewIncludePredicate, bm as ElementViewPredicate, bq as ElementViewRule, bn as ElementViewRuleGroup, bp as ElementViewRuleStyle, a4 as EqualOperator, E as Expression, aj as Filterable, F as FqnExpr, f as FqnRef, j as GlobalDynamicPredicates, G as GlobalPredicateId, i as GlobalPredicates, k as GlobalStyleID, l as GlobalStyles, a7 as KindEqual, b4 as LayoutedDeploymentView, b5 as LayoutedDynamicView, b3 as LayoutedElementView, L as LayoutedLikeC4ModelData, ao as LayoutedView, o as LikeC4ModelData, y as LikeC4ModelDump, am as LikeC4Project, an as LikeC4View, e as ModelExpression, M as ModelFqnExpr, m as ModelGlobals, _ as ModelRelation, d as ModelRelationExpr, aV as NodeNotation, ac as NotOperator, ak as OperatorPredicate, ag as OrOperator, bb as ParsedDeploymentView, bi as ParsedDynamicView, br as ParsedElementView, n as ParsedLikeC4ModelData, an as ParsedView, a9 as Participant, aa as ParticipantOperator, g as Point, P as PredicateSelector, ar as ProcessedView, z as ProjectDump, h as RectBox, c as RelationExpr, Z as Relationship, a2 as RelationshipSpecification, R as RichText, a as RichTextEmpty, b as RichTextOrEmpty, x as SpecTypesFromDump, a3 as Specification, S as SpecificationDump, a5 as TagEqual, a0 as TagSpecification, aQ as ViewAutoLayout, at as ViewOnStage, av as ViewRule, aO as ViewRuleAutoLayout, aK as ViewRuleGlobalPredicateRef, aI as ViewRuleGlobalStyle, aw as ViewRulePredicate, aS as ViewType, aX as ViewWithHash, aW as ViewWithNotation, au as ViewWithType, ai as WhereOperator, X as XYPoint, be as getParallelStepsPrefix, af as isAndOperator, aN as isAutoLayoutDirection, az as isComputedView, u as isDeployedInstance, t as isDeploymentNode, aD as isDeploymentView, ap as isDiagramView, aE as isDynamicView, bj as isDynamicViewParallelSteps, aA as isElementView, aC as isExtendsElementView, a8 as isKindEqual, ap as isLayoutedView, ad as isNotOperator, ah as isOrOperator, ab as isParticipantOperator, aB as isScopedElementView, a1 as isTagColorSpecified, a6 as isTagEqual, aP as isViewRuleAutoLayout, aL as isViewRuleGlobalPredicateRef, aJ as isViewRuleGlobalStyle, bo as isViewRuleGroup, ax as isViewRulePredicate, ay as isViewRuleStyle, al as whereOperatorAsPredicate } from '../shared/core.CE_hG7EJ.mjs';
+export { A as Any, A as AnyAux, a as Aux, E as ExtractOnStage, M as ModelStage, S as SpecAux, U as Unknown, b as UnknownComputed, c as UnknownLayouted, d as UnknownParsed, e as _stage, f as _type, _ as aux, i as isOnStage } from '../shared/core.DdzRtJ9d.mjs';
+export { A as AndOperator, a as EqualOperator, E as Expression, j as Filterable, F as FqnExpr, K as KindEqual, N as NotOperator, k as OperatorPredicate, O as OrOperator, c as Participant, d as ParticipantOperator, P as PredicateSelector, R as RelationExpr, T as TagEqual, W as WhereOperator, g as isAndOperator, b as isKindEqual, f as isNotOperator, h as isOrOperator, e as isParticipantOperator, i as isTagEqual, w as whereOperatorAsPredicate } from '../shared/core.20m8Um0g.mjs';
+export { ModelExpression, ModelFqnExpr, ModelRelationExpr } from './expression-model.mjs';
+export { FqnRef } from './fqnRef.mjs';
+import { ar as ViewManualLayout, am as AutoLayoutDirection } from '../shared/core.aWJgARyY.mjs';
+export { K as AbstractRelationship, ag as AnyExcludePredicate, af as AnyIncludePredicate, a2 as AnyView, ah as AnyViewRuleStyle, u as AuxFromDump, A as AuxFromLikeC4ModelData, B as BBox, au as BaseParsedViewProperties, at as BaseViewProperties, aB as ComputedDeploymentView, aC as ComputedDynamicView, az as ComputedEdge, aA as ComputedElementView, C as ComputedLikeC4ModelData, ay as ComputedNode, a0 as ComputedView, I as DefaultArrowType, w as DefaultElementShape, H as DefaultLineStyle, y as DefaultPaddingSize, J as DefaultRelationshipColor, x as DefaultShapeSize, z as DefaultTextSize, v as DefaultThemeColor, k as DeployedInstance, l as DeploymentElement, m as DeploymentElementRef, D as DeploymentElementStyle, j as DeploymentNode, q as DeploymentRelation, p as DeploymentRelationship, aJ as DeploymentViewExcludePredicate, aI as DeploymentViewIncludePredicate, aK as DeploymentViewPredicate, aM as DeploymentViewRule, aL as DeploymentViewRuleStyle, aE as DiagramEdge, aD as DiagramNode, _ as DiagramView, aS as DynamicViewIncludeRule, aP as DynamicViewParallelSteps, aT as DynamicViewRule, aO as DynamicViewStep, aR as DynamicViewStepOrParallel, F as Element, Q as ElementSpecification, E as ElementStyle, aX as ElementViewExcludePredicate, aW as ElementViewIncludePredicate, aY as ElementViewPredicate, b0 as ElementViewRule, aZ as ElementViewRuleGroup, a$ as ElementViewRuleStyle, e as GlobalDynamicPredicates, G as GlobalPredicateId, d as GlobalPredicates, f as GlobalStyleID, g as GlobalStyles, aG as LayoutedDeploymentView, aH as LayoutedDynamicView, aF as LayoutedElementView, L as LayoutedLikeC4ModelData, _ as LayoutedView, i as LikeC4ModelData, s as LikeC4ModelDump, Y as LikeC4Project, Z as LikeC4View, M as ModelGlobals, O as ModelRelation, av as NodeNotation, aN as ParsedDeploymentView, aU as ParsedDynamicView, b1 as ParsedElementView, h as ParsedLikeC4ModelData, Z as ParsedView, P as Point, a1 as ProcessedView, t as ProjectDump, c as RectBox, N as Relationship, V as RelationshipSpecification, R as RichText, a as RichTextEmpty, b as RichTextOrEmpty, r as SpecTypesFromDump, W as Specification, S as SpecificationDump, T as TagSpecification, aq as ViewAutoLayout, a3 as ViewOnStage, a5 as ViewRule, ao as ViewRuleAutoLayout, ak as ViewRuleGlobalPredicateRef, ai as ViewRuleGlobalStyle, a6 as ViewRulePredicate, as as ViewType, ax as ViewWithHash, aw as ViewWithNotation, a4 as ViewWithType, X as XYPoint, aQ as getParallelStepsPrefix, an as isAutoLayoutDirection, a9 as isComputedView, o as isDeployedInstance, n as isDeploymentNode, ad as isDeploymentView, $ as isDiagramView, ae as isDynamicView, aV as isDynamicViewParallelSteps, aa as isElementView, ac as isExtendsElementView, $ as isLayoutedView, ab as isScopedElementView, U as isTagColorSpecified, ap as isViewRuleAutoLayout, al as isViewRuleGlobalPredicateRef, aj as isViewRuleGlobalStyle, a_ as isViewRuleGroup, a7 as isViewRulePredicate, a8 as isViewRuleStyle } from '../shared/core.aWJgARyY.mjs';
 import { F as Fqn, D as DeploymentFqn } from '../shared/core.DX-WYEPA.mjs';
 export { A as AnyFqn, B as BuiltInIcon, b as DeploymentKind, j as EdgeId, E as ElementKind, e as GlobalFqn, G as GroupElementKind, I as Icon, a as IconUrl, M as MarkdownOrString, N as NodeId, P as ProjectId, d as RelationId, R as RelationKind, c as RelationshipKind, k as StepEdgeId, S as StepEdgeIdLiteral, m as StepEdgeKind, T as Tag, V as ViewId, o as extractStep, f as flattenMarkdownOrString, g as isGlobalFqn, i as isGroupElementKind, n as isStepEdgeId, s as scalar, h as splitGlobalFqn, l as stepEdgeId } from '../shared/core.DX-WYEPA.mjs';
 import { b as BorderStyle, c as ElementShape, h as ThemeColor } from '../shared/core.CzdwsPmY.mjs';

package/dist/types/index.mjs

@@ -1,15 +1,15 @@
 export { _ as aux } from './_aux.mjs';
-export { F as FqnRef, _ as _stage, a as _type, h as isAndOperator, c as isDeployedInstance, b as isDeploymentNode, e as isKindEqual, g as isNotOperator, i as isOnStage, j as isOrOperator, f as isParticipantOperator, d as isTagEqual, w as whereOperatorAsPredicate } from '../shared/core.DK6I-Nr7.mjs';
-export { E as Expression, F as FqnExpr, b as ModelExpression, M as ModelFqnExpr, a as ModelRelationExpr, R as RelationExpr, p as getParallelStepsPrefix, n as isAutoLayoutDirection, d as isComputedView, j as isDeploymentView, e as isDiagramView, k as isDynamicView, q as isDynamicViewParallelSteps, f as isElementView, h as isExtendsElementView, e as isLayoutedView, g as isScopedElementView, o as isViewRuleAutoLayout, m as isViewRuleGlobalPredicateRef, l as isViewRuleGlobalStyle, r as isViewRuleGroup, i as isViewRulePredicate, c as isViewRuleStyle } from '../shared/core.BW8K1y6R.mjs';
+export { _ as _stage, a as _type, h as isAndOperator, c as isDeployedInstance, b as isDeploymentNode, e as isKindEqual, g as isNotOperator, i as isOnStage, j as isOrOperator, f as isParticipantOperator, d as isTagEqual, w as whereOperatorAsPredicate } from '../shared/core.yHe79zEl.mjs';
+export { Expression, FqnExpr, RelationExpr } from './expression.mjs';
+export { ModelExpression, ModelFqnExpr, ModelRelationExpr } from './expression-model.mjs';
+export { FqnRef } from './fqnRef.mjs';
 export { B as BBox, a as BorderStyles, E as ElementShapes, R as RectBox, T as ThemeColors, i as isTagColorSpecified, b as isThemeColor } from '../shared/core.CxGKeL-L.mjs';
-export { f as DefaultArrowType, a as DefaultElementShape, e as DefaultLineStyle, c as DefaultPaddingSize, g as DefaultRelationshipColor, b as DefaultShapeSize, d as DefaultTextSize, D as DefaultThemeColor, R as RichText } from '../shared/core.H8NbNp2X.mjs';
-export { D as DeploymentFqn, E as EdgeId, F as Fqn, a as GlobalFqn, G as GroupElementKind, N as NodeId, P as ProjectId, R as RelationId, S as StepEdgeKind, V as ViewId, g as extractStep, f as flattenMarkdownOrString, b as isGlobalFqn, i as isGroupElementKind, e as isStepEdgeId, s as scalar, c as splitGlobalFqn, d as stepEdgeId } from '../shared/core.BL_xjl90.mjs';
-import '../shared/core.zLlww-07.mjs';
-import '../shared/core.CnIyafWn.mjs';
-import '../shared/core.BgvIuGGU.mjs';
-import '../shared/core.DbRvwARP.mjs';
+export { f as DefaultArrowType, a as DefaultElementShape, e as DefaultLineStyle, c as DefaultPaddingSize, g as DefaultRelationshipColor, b as DefaultShapeSize, d as DefaultTextSize, D as DefaultThemeColor, R as RichText } from '../shared/core.BqVo8LrH.mjs';
+export { D as DeploymentFqn, E as EdgeId, F as Fqn, a as GlobalFqn, G as GroupElementKind, N as NodeId, P as ProjectId, R as RelationId, S as StepEdgeKind, V as ViewId, g as extractStep, f as flattenMarkdownOrString, b as isGlobalFqn, i as isGroupElementKind, e as isStepEdgeId, s as scalar, c as splitGlobalFqn, d as stepEdgeId } from '../shared/core.Be1n9a0i.mjs';
+export { n as getParallelStepsPrefix, l as isAutoLayoutDirection, b as isComputedView, g as isDeploymentView, c as isDiagramView, h as isDynamicView, o as isDynamicViewParallelSteps, d as isElementView, f as isExtendsElementView, c as isLayoutedView, e as isScopedElementView, m as isViewRuleAutoLayout, k as isViewRuleGlobalPredicateRef, j as isViewRuleGlobalStyle, p as isViewRuleGroup, i as isViewRulePredicate, a as isViewRuleStyle } from '../shared/core.T-eLZTW_.mjs';
+import 'remeda';
 import '../shared/core.D4npX2q8.mjs';
-import '../shared/core.B0oEIXqd.mjs';
+import '../shared/core.CUw_2J9j.mjs';
 import 'rehype-raw';
 import 'rehype-sanitize';
 import 'rehype-stringify';

package/dist/types/scalar.mjs

@@ -1,4 +1,3 @@
-import '../shared/core.CnIyafWn.mjs';
-import '../shared/core.zLlww-07.mjs';
+import 'remeda';
 import '../shared/core.D4npX2q8.mjs';
-export { D as DeploymentFqn, E as EdgeId, F as Fqn, a as GlobalFqn, G as GroupElementKind, N as NodeId, P as ProjectId, R as RelationId, S as StepEdgeKind, V as ViewId, g as extractStep, f as flattenMarkdownOrString, b as isGlobalFqn, i as isGroupElementKind, e as isStepEdgeId, c as splitGlobalFqn, d as stepEdgeId } from '../shared/core.BL_xjl90.mjs';
+export { D as DeploymentFqn, E as EdgeId, F as Fqn, a as GlobalFqn, G as GroupElementKind, N as NodeId, P as ProjectId, R as RelationId, S as StepEdgeKind, V as ViewId, g as extractStep, f as flattenMarkdownOrString, b as isGlobalFqn, i as isGroupElementKind, e as isStepEdgeId, c as splitGlobalFqn, d as stepEdgeId } from '../shared/core.Be1n9a0i.mjs';

package/dist/utils/index.d.mts

@@ -1,138 +1,11 @@
 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.wwaSalox.mjs';
+export { B as BiMap, D as DefaultWeakMap, L as LinkedList, M as MultiMap, Q as Queue, i as invariant, a as isNonEmptyArray, b as isString, m as memoizeProp, c as nonNullable, n as nonexhaustive } from '../shared/core.PHwHXzkG.mjs';
+export { I as IterableContainer, R as ReorderedArray, a as ancestorsFqn, e as commonAncestor, f as compareByFqnHierarchically, g as compareFqnHierarchically, h as hierarchyDistance, j as hierarchyLevel, i as isAncestor, b as isDescendantOf, c as isSameHierarchy, n as nameFromFqn, p as parentFqn, k as sortByFqnHierarchically, s as sortNaturalByFqn, d as sortParentsFirst } from '../shared/core.DM3vdkO_.mjs';
 import { N as NonEmptyArray } from '../shared/core.DuSLYTG6.mjs';
-import { Tagged, Simplify, Or, IfNever, IsLiteral, And, GreaterThan, IsNever, IsEqual, ReadonlyTuple, IsNumericLiteral } from 'type-fest';
-export { ifilter, ifind, ifirst, iflat, ihead, imap, ireduce, isIterable, isome, iunique, toArray, toSet } from './iterable/index.mjs';
+export { ifilter, ifind, ifirst, iflat, ihead, imap, ireduce, isome, iunique, toArray, toSet } from './iterable/index.mjs';
+export { i as isIterable } from '../shared/core.DXhDWKFZ.mjs';
 import '../shared/core.DX-WYEPA.mjs';
-
-/**
- * Mnemonist DefaultWeakMap Typings
- * ================================
- */
-declare class DefaultWeakMap<K extends object, V> {
-
-  // Constructor
-  constructor(factory: (key: K) => 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;
-  inspect(): any;
-}
-
-/**
- * Mnemonist LinkedList Typings
- * =============================
- */
-declare class LinkedList<T> implements Iterable<T> {
-
-  // Members
-  size: number;
-
-  // Constructor
-  constructor();
-
-  // Methods
-  clear(): void;
-  first(): T | undefined;
-  last(): T | undefined;
-  peek(): T | undefined;
-  push(value: T): number;
-  shift(): T | undefined;
-  unshift(value: T): number;
-  forEach(callback: (value: T, index: number, list: this) => void, scope?: any): void;
-  toArray(): Array<T>;
-  values(): IterableIterator<T>;
-  entries(): IterableIterator<[number, T]>;
-  [Symbol.iterator](): IterableIterator<T>;
-  toString(): string;
-  toJSON(): Array<T>;
-  inspect(): any;
-
-  // Statics
-  static from<I>(iterable: Iterable<I> | {[key: string]: I}): LinkedList<I>;
-}
-
-/**
- * Mnemonist Queue Typings
- * ========================
- */
-declare class Queue<T> implements Iterable<T> {
-
-  // Members
-  size: number;
-
-  // Constructor
-  constructor();
-
-  // Methods
-  clear(): void;
-  enqueue(item: T): number;
-  dequeue(): T | undefined;
-  peek(): T | undefined;
-  forEach(callback: (item: T, index: number, queue: this) => void, scope?: any): void;
-  toArray(): Array<T>;
-  values(): IterableIterator<T>;
-  entries(): IterableIterator<[number, T]>;
-  [Symbol.iterator](): IterableIterator<T>;
-  toString(): string;
-  toJSON(): Array<T>;
-  inspect(): any;
-
-  // Statics
-  static from<I>(iterable: Iterable<I> | {[key: string]: I}): Queue<I>;
-  static of<I>(...items: Array<I>): Queue<I>;
-}
-
-interface MultiMapConstructor {
-  new <K, V>(container: SetConstructor): MultiMap<K, V, Set<V>>;
-  new <K, V>(container?: ArrayConstructor): MultiMap<K, V, V[]>;
-
-  from<K, V>(
-    iterable: Iterable<[K, V]> | {[key: string]: V},
-    Container: SetConstructor
-  ): MultiMap<K, V, Set<V>>;
-  from<K, V>(
-    iterable: Iterable<[K, V]> | {[key: string]: V},
-    Container?: ArrayConstructor
-  ): MultiMap<K, V, V[]>;
-}
-/**
- * Mnemonist MultiMap Typings
- * ===========================
- */
-
-interface MultiMap<K, V, C extends V[] | Set<V> = V[]> extends Iterable<[K, V]> {
-
-  // Members
-  dimension: number;
-  size: number;
-
-  // Methods
-  clear(): void;
-  set(key: K, value: V): this;
-  delete(key: K): boolean;
-  remove(key: K, value: V): boolean;
-  has(key: K): boolean;
-  get(key: K): C | undefined;
-  multiplicity(key: K): number;
-  forEach(callback: (value: V, key: K, map: this) => void, scope?: any): void;
-  forEachAssociation(callback: (value: C, key: K, map: this) => void, scope?: any): void;
-  keys(): IterableIterator<K>;
-  values(): IterableIterator<V>;
-  entries(): IterableIterator<[K, V]>;
-  containers(): IterableIterator<C>;
-  associations(): IterableIterator<[K, C]>;
-  [Symbol.iterator](): IterableIterator<[K, V]>;
-  inspect(): any;
-  toJSON(): any;
-}
-
-declare const MultiMap: MultiMapConstructor;
+import 'type-fest';
 
 /**
  * Mnemonist Stack Typings
@@ -165,63 +38,6 @@ declare class Stack<T> implements Iterable<T> {
   static of<I>(...items: Array<I>): Stack<I>;
 }
 
-/**
- * Mnemonist BiMap Typings
- * ========================
- */
-declare class InverseMap<K, V> implements Iterable<[K, V]> {
-
-  // Members
-  size: number;
-  inverse: BiMap<V, K>;
-
-  // Constructor
-  constructor(original: BiMap<K, V>);
-
-  // Methods
-  clear(): void;
-  set(key: K, value: V): this;
-  delete(key: K): boolean;
-  has(key: K): boolean;
-  get(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;
-}
-
-declare class BiMap<K, V> implements Iterable<[K, V]> {
-
-  // Members
-  size: number;
-  inverse: InverseMap<V, K>;
-
-  // Constructor
-  constructor();
-
-  // Methods
-  clear(): void;
-  set(key: K, value: V): this;
-  delete(key: K): boolean;
-  has(key: K): boolean;
-  get(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 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
  *
@@ -247,248 +63,10 @@ declare function compareNatural(a: string | undefined, b: string | undefined): -
  * //   'b.c',
  * // ]
  */
-declare function compareNaturalHierarchically(separator?: string): (a: string | undefined, b: string | undefined) => number;
+declare function compareNaturalHierarchically(separator?: string, deepestFirst?: boolean): (a: string | undefined, b: string | undefined) => number;
 
 declare function getOrCreate<K, V>(map: Map<K, V>, key: K, create: (key: K) => V): V;
 
-/**
- * This should only be used for defining generics which extend any kind of JS
- * array under the hood, this includes arrays *AND* tuples (of the form [x, y],
- * and of the form [x, ...y[]], etc...), and their readonly equivalent. This
- * allows us to be more inclusive to what functions can process.
- *
- * @example
- *   function map<T extends IterableContainer>(items: T) { ... }
- *
- * We would've named this `ArrayLike`, but that's already used by typescript...
- * @see This was inspired by the type-definition of Promise.all (https://github.com/microsoft/TypeScript/blob/1df5717b120cddd325deab8b0f2b2c3eecaf2b01/src/lib/es2015.promise.d.ts#L21)
- */
-type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
-
-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
- * that those indices are defined when accessing the array even when using
- * typescript's 'noUncheckedIndexAccess'.
- *
- * @param data - The input array.
- * @param minimum - The minimum number of elements the array must have.
- * @returns True if the array's length is *at least* `minimum`. When `minimum`
- * is a literal value, the output is narrowed to ensure the first items are
- * guaranteed.
- * @signature
- *   R.hasAtLeast(data, minimum)
- * @example
- *   R.hasAtLeast([], 4); // => false
- *
- *   const data: number[] = [1,2,3,4];
- *   R.hasAtLeast(data, 1); // => true
- *   data[0]; // 1, with type `number`
- * @dataFirst
- * @category Array
- */
-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
- * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
- * that those indices are defined when accessing the array even when using
- * typescript's 'noUncheckedIndexAccess'.
- *
- * @param minimum - The minimum number of elements the array must have.
- * @returns True if the array's length is *at least* `minimum`. When `minimum`
- * is a literal value, the output is narrowed to ensure the first items are
- * guaranteed.
- * @signature
- *   R.hasAtLeast(minimum)(data)
- * @example
- *   R.pipe([], R.hasAtLeast(4)); // => false
- *
- *   const data = [[1,2], [3], [4,5]];
- *   R.pipe(
- *     data,
- *     R.filter(R.hasAtLeast(2)),
- *     R.map(([, second]) => second),
- *   ); // => [2,5], with type `number[]`
- * @dataLast
- * @category Array
- */
-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;
-declare function isNonEmptyArray<A>(arr: ArrayLike<A> | undefined): arr is NonEmptyArray<A>;
-
-/**
- * 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>;
@@ -538,4 +116,4 @@ declare function markdownToHtml(markdown: string): string;
  */
 declare function markdownToText(markdown: string): string;
 
-export { BiMap, DefaultWeakMap, LinkedList, MultiMap, Queue, Stack, commonHead, compareNatural, compareNaturalHierarchically, compareRelations, delay, difference, equals as equalsSet, getOrCreate, hasAtLeast, intersection, invariant, isNonEmptyArray, isString, markdownToHtml, markdownToText, memoizeProp, nonNullable, nonexhaustive, objectHash, promiseNextTick, stringHash, symmetricDifference, union };
+export { Stack, commonHead, compareNatural, compareNaturalHierarchically, compareRelations, delay, difference, equals as equalsSet, getOrCreate, intersection, markdownToHtml, markdownToText, objectHash, promiseNextTick, stringHash, symmetricDifference, union };

package/dist/utils/index.mjs

@@ -1,20 +1,21 @@
 export { i as invariant, a as nonNullable, n as nonexhaustive } from '../shared/core.D4npX2q8.mjs';
-export { S as Stack, c as commonHead, o as objectHash } from '../shared/core.HUONfQfd.mjs';
-export { b as ancestorsFqn, d as commonAncestor, e as compareByFqnHierarchically, f as compareFqnHierarchically, c as compareNatural, a as compareNaturalHierarchically, h as hierarchyDistance, g as hierarchyLevel, i as isAncestor, j as isDescendantOf, o as isNonEmptyArray, k as isSameHierarchy, q as isString, n as nameFromFqn, p as parentFqn, s as sortByFqnHierarchically, l as sortNaturalByFqn, m as sortParentsFirst } from '../shared/core.DQj9iv_y.mjs';
+export { S as Stack, c as commonHead, o as objectHash } from '../shared/core.BB6zA-UU.mjs';
+import { g as commonAncestor, h as compareFqnHierarchically } from '../shared/core.DgttqsJc.mjs';
+export { a as ancestorsFqn, l as compareByFqnHierarchically, j as compareNatural, k as compareNaturalHierarchically, m as hierarchyDistance, o as hierarchyLevel, i as isAncestor, b as isDescendantOf, c as isNonEmptyArray, d as isSameHierarchy, e as isString, n as nameFromFqn, p as parentFqn, q as sortByFqnHierarchically, s as sortNaturalByFqn, f as sortParentsFirst } from '../shared/core.DgttqsJc.mjs';
 export { g as getOrCreate } from '../shared/core.DcS-0zys.mjs';
-export { a as markdownToHtml, b as markdownToText, m as memoizeProp } from '../shared/core.B0oEIXqd.mjs';
-export { b as BiMap, d as DefaultWeakMap, l as LinkedList, m as MultiMap, q as Queue, c as compareRelations, a as delay, p as promiseNextTick } from '../shared/core.b2BzqGz0.mjs';
-export { d as difference, e as equalsSet, i as hasAtLeast, a as intersection, b as stringHash, s as symmetricDifference, u as union } from '../shared/core.CpwrZi3D.mjs';
-export { D as DefaultMap } from '../shared/core.yaRvRnMW.mjs';
-export { i as ifilter } from '../shared/core.BH9nN-_I.mjs';
-export { i as ifind, a as ihead } from '../shared/core.DsMrjY2q.mjs';
-export { ifirst, ireduce } from './iterable/index.mjs';
-export { i as iflat, a as isIterable, b as iunique } from '../shared/core.8KM0D6va.mjs';
-export { i as imap, t as toArray, a as toSet } from '../shared/core.Btl47GOn.mjs';
-export { i as isome } from '../shared/core.BoyJPEen.mjs';
-import '../shared/core.DbRvwARP.mjs';
-import '../shared/core.ByrmCl9I.mjs';
-import '../shared/core.zLlww-07.mjs';
+export { b as markdownToHtml, a as markdownToText, m as memoizeProp } from '../shared/core.CUw_2J9j.mjs';
+import { randomInteger } from 'remeda';
+export { d as difference, e as equalsSet, i as intersection, a as stringHash, s as symmetricDifference, u as union } from '../shared/core.4u1dVmfX.mjs';
+export { b as BiMap, d as DefaultWeakMap, l as LinkedList, m as MultiMap, q as Queue } from '../shared/core.DlG1xWt2.mjs';
+export { D as DefaultMap } from '../shared/core.BuoXfSMj.mjs';
+export { i as ifilter } from '../shared/core.CCD1ID81.mjs';
+export { i as ifind, a as ihead } from '../shared/core.GTgsmXS_.mjs';
+export { i as ifirst, a as ireduce } from '../shared/core.ILwny7BV.mjs';
+export { i as iflat, a as iunique } from '../shared/core.CNGyqkJh.mjs';
+export { i as imap, t as toArray, a as toSet } from '../shared/core.DLpidoWc.mjs';
+export { i as isIterable } from '../shared/core.DoM6aM9N.mjs';
+export { i as isome } from '../shared/core.Be4Jy9Qx.mjs';
+import '../shared/core.CaT0SUUK.mjs';
 import 'rehype-raw';
 import 'rehype-sanitize';
 import 'rehype-stringify';
@@ -24,3 +25,43 @@ import 'remark-rehype';
 import 'unified';
 import 'mdast-util-from-markdown';
 import 'mdast-util-to-string';
+
+const DELAY = "LIKEC4_DELAY";
+function delay(...args) {
+  let ms = 100;
+  if (args.length === 2) {
+    ms = randomInteger(args[0], args[1]);
+  } else if (args.length === 1) {
+    ms = args[0];
+  }
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(DELAY);
+    }, ms ?? 100);
+  });
+}
+function promiseNextTick() {
+  return Promise.resolve().then(() => void 0);
+}
+
+const compareRelations = (a, b) => {
+  const parentA = commonAncestor(a.source.model, a.target.model);
+  const parentB = commonAncestor(b.source.model, b.target.model);
+  if (parentA && !parentB) {
+    return 1;
+  }
+  if (!parentA && parentB) {
+    return -1;
+  }
+  const compareParents = parentA && parentB ? compareFqnHierarchically(parentA, parentB) : 0;
+  if (compareParents !== 0) {
+    return compareParents;
+  }
+  const compareSource = compareFqnHierarchically(a.source.model, b.source.model);
+  if (compareSource !== 0) {
+    return compareSource;
+  }
+  return compareFqnHierarchically(a.target.model, b.target.model);
+};
+
+export { commonAncestor, compareFqnHierarchically, compareRelations, delay, promiseNextTick };