@likec4/core 1.46.4 → 1.48.0

package/dist/_chunks/index3.d.mts

@@ -0,0 +1,146 @@
+import { Ct as NTuple } from "./_aux.mjs";
+import { S as Tag } from "./scalar.mjs";
+import { B as ShapeSize, C as BorderStyle, F as LikeC4Theme, G as ThemeColorValues, H as SpacingSize, M as IconSize, N as LikeC4StyleDefaults, O as ElementColorValues, P as LikeC4StylesConfig, R as RelationshipColorValues, T as ColorLiteral, U as TextSize, W as ThemeColor, j as IconPosition, w as Color } from "./expression.mjs";
+import { Z as ComputedNodeStyle, ct as TagSpecification, nt as LikeC4ProjectStylesConfig } from "./index2.mjs";
+import { LiteralUnion } from "type-fest";
+
+//#region src/styles/LikeC4Styles.d.ts
+/**
+ * Styles of a LikeC4 project
+ *
+ * Accepts an array of LikeC4ProjectStylesConfig objects as a parameter
+ * and constructs a LikeC4Styles merged with the default styles.
+ *
+ * The class provides methods to get the default element colors, relationship
+ * colors, group colors, font size in pixels, padding in pixels, and to compute
+ * the ThemeColorValues from a given color.
+ */
+declare class LikeC4Styles {
+  protected config: LikeC4StylesConfig;
+  readonly theme: LikeC4Theme;
+  readonly defaults: LikeC4StyleDefaults;
+  static readonly DEFAULT: LikeC4Styles;
+  static from(...configs: Array<LikeC4ProjectStylesConfig | undefined | null>): LikeC4Styles;
+  private constructor();
+  /**
+   * Default element colors
+   */
+  get elementColors(): ElementColorValues;
+  /**
+   * Default relationship colors
+   */
+  get relationshipColors(): RelationshipColorValues;
+  /**
+   * Default group colors
+   */
+  get groupColors(): ElementColorValues;
+  isDefaultColor(color: LiteralUnion<ThemeColor, string>): color is ThemeColor;
+  /**
+   * Get color values
+   *
+   * @param color - The color to use
+   * @default color From the defaults
+   */
+  colors(color?: LiteralUnion<ThemeColor, string>): ThemeColorValues;
+  private compoundColorsCache;
+  /**
+   * Get colors for compound nodes
+   *
+   * @param baseElementColors - The base element colors to compute from
+   */
+  colorsForCompounds<Depth extends number = 6>(baseElementColors: ElementColorValues, depth?: Depth): NTuple<ElementColorValues, Depth>;
+  /**
+   * Get font size in pixels
+   *
+   * @param textSize - The text size to use
+   * @default textSize From the defaults
+   */
+  fontSize(textSize?: TextSize): number;
+  /**
+   * Get padding in pixels
+   *
+   * @param paddingSize - The padding size to use
+   * @default paddingSize From the defaults
+   */
+  padding(paddingSize?: SpacingSize): number;
+  /**
+   * Get icon size in pixels
+   *
+   * @param iconSize - The icon size to use
+   * @default iconSize From the defaults
+   */
+  iconSize(iconSize?: IconSize): number;
+  isThemeColor(color: string): color is ThemeColor;
+  /**
+   * Calculate sizes and values based on the node styles
+   *
+   * @example
+   * ```typescript
+   * const { sizes, values } = styles.nodeSizes(node.style)
+   *
+   * // sizes
+   * sizes.size     // enum Size
+   * sizes.padding  // enum SpacingSize
+   * sizes.textSize // enum TextSize
+   * sizes.iconSize // enum ShapeSize
+   *
+   * // values
+   * values.sizes    // { width: number, height: number }
+   * values.padding  // number
+   * values.textSize // number
+   * values.iconSize // number
+   * ```
+   */
+  nodeSizes(nodestyles: ComputedNodeStyle): {
+    sizes: Omit<{
+      icon?: never;
+      readonly iconColor?: Color;
+      readonly iconSize?: IconSize;
+      readonly iconPosition?: IconPosition;
+      shape?: never;
+      color?: never;
+      readonly border?: BorderStyle;
+      readonly opacity?: number;
+      readonly multiple?: boolean;
+      readonly size?: ShapeSize;
+      readonly padding?: SpacingSize;
+      readonly textSize?: TextSize;
+    }, "iconSize" | "size" | "padding" | "textSize"> & Required<{
+      readonly iconSize?: IconSize;
+      readonly size?: ShapeSize;
+      readonly padding?: SpacingSize;
+      readonly textSize?: TextSize;
+    }>;
+    values: {
+      sizes: {
+        readonly width: number;
+        readonly height: number;
+      };
+      padding: number;
+      textSize: number;
+      iconSize: number;
+    };
+  };
+  /**
+   * Compute ThemeColorValues from a given color
+   * @param color - HEX, RGB, RGBA, etc.
+   */
+  computeFrom(color: string): ThemeColorValues;
+  equals(other: LikeC4Styles): boolean;
+}
+//#endregion
+//#region src/styles/assignTagColors.d.ts
+declare function assignTagColors(tags: {
+  [kind: string]: Partial<TagSpecification>;
+}): Record<Tag, TagSpecification>;
+//#endregion
+//#region src/styles/compute-color-values.d.ts
+declare function computeColorValues(color: ColorLiteral): ThemeColorValues;
+//#endregion
+//#region src/styles/defaults.d.ts
+declare const styleDefaults: LikeC4StyleDefaults;
+//#endregion
+//#region src/styles/theme.d.ts
+declare const defaultTheme: LikeC4Theme;
+//#endregion
+export { LikeC4Styles as a, assignTagColors as i, styleDefaults as n, computeColorValues as r, defaultTheme as t };

package/dist/_chunks/index4.d.mts

@@ -0,0 +1,62 @@
+import { Dt as ReorderedArray, yt as IterableContainer } from "./_aux.mjs";
+import { n as Connection } from "./const.mjs";
+
+//#region src/model/connection/ops.d.ts
+/**
+ * Check if connection is nested inside another connection
+ * (i.e. between descendants)
+ */
+declare function isNestedConnection<T extends {
+  id: string;
+}>(parent: WithSourceTarget<NoInfer<T>>): (nested: WithSourceTarget<T>) => boolean;
+declare function isNestedConnection<T extends {
+  id: string;
+}>(nested: WithSourceTarget<T>, parent: WithSourceTarget<T>): boolean;
+type ConnectionElemId = Connection<{
+  readonly id: string;
+}, any>;
+declare function findDeepestNestedConnection<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): C | null;
+declare function sortDeepestFirst<C extends ConnectionElemId>(connections: ReadonlyArray<C>): C[];
+type WithBoundary = {
+  id: string;
+  boundary: null | {
+    id: string;
+  };
+};
+declare function sortConnectionsByBoundaryHierarchy(sort?: 'asc' | 'desc'): <T extends WithBoundary, A extends IterableContainer<T>>(array: A) => ReorderedArray<A>;
+declare function sortConnectionsByBoundaryHierarchy<T extends WithBoundary, A extends IterableContainer<T>>(array: A, sort?: 'asc' | 'desc'): ReorderedArray<A>;
+/**
+ * Find connections that includes given connection (i.e between it's ancestors)
+ */
+declare function findAscendingConnections<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): Array<C>;
+/**
+ * Find connections that given connection includes (i.e between it's descendants)
+ */
+declare function findDescendantConnections<C extends ConnectionElemId>(connections: ReadonlyArray<C>, connection: C): Array<C>;
+declare function mergeConnections<C extends IterableContainer<Connection<any, any>>>(connections: C): Array<C[number]>;
+/**
+ * Excludes the values existing in `other` array.
+ * The output maintains the same order as the input.
+ */
+declare function differenceConnections<C extends Connection<any, any>>(source: Iterable<C>, exclude: Iterable<C>): C[];
+type WithSourceTarget<T = unknown> = {
+  source: T;
+  target: T;
+};
+declare function hasSameSourceTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
+declare function hasSameSourceTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
+declare function hasSameSource<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
+declare function hasSameSource<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
+declare function hasSameTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean;
+declare function hasSameTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean;
+type WithId<T> = {
+  id: T;
+};
+declare function isOutgoing<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
+declare function isOutgoing<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean;
+declare function isIncoming<T extends string>(target: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
+declare function isIncoming<T extends string>(a: WithSourceTarget<WithId<T>>, target: WithId<T>): boolean;
+declare function isAnyInOut<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean;
+declare function isAnyInOut<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean;
+//#endregion
+export { hasSameSource as a, isAnyInOut as c, isOutgoing as d, mergeConnections as f, findDescendantConnections as i, isIncoming as l, sortDeepestFirst as m, findAscendingConnections as n, hasSameSourceTarget as o, sortConnectionsByBoundaryHierarchy as p, findDeepestNestedConnection as r, hasSameTarget as s, differenceConnections as t, isNestedConnection as u };

package/dist/_chunks/index5.d.mts

@@ -0,0 +1,42 @@
+import { n as Any } from "./_aux.mjs";
+import { C as ElementModel, S as NodeModel, T as RelationshipModel, a as DeploymentNodeModel, c as NestedElementOfDeployedInstanceModel, i as DeploymentElementModel, r as DeployedInstanceModel, s as DeploymentRelationModel, w as AnyRelationshipModel, x as EdgeModel, y as LikeC4ViewModel } from "./LikeC4Model.mjs";
+
+//#region src/model/guards.d.ts
+type AnyModel<A extends Any> = DeploymentNodeModel<A> | DeployedInstanceModel<A> | DeploymentRelationModel<A> | AnyRelationshipModel<A> | NestedElementOfDeployedInstanceModel<A> | ElementModel<A> | RelationshipModel<A> | LikeC4ViewModel<A> | NodeModel<A> | EdgeModel<A>;
+declare function isDeploymentNodeModel<M extends Any>(model: AnyModel<M>): model is DeploymentNodeModel<M>;
+declare function isDeployedInstanceModel<M extends Any>(model: AnyModel<M>): model is DeployedInstanceModel<M>;
+declare function isDeploymentElementModel<M extends Any>(model: AnyModel<M>): model is DeploymentElementModel<M>;
+declare function isNestedElementOfDeployedInstanceModel<M extends Any>(model: AnyModel<M>): model is NestedElementOfDeployedInstanceModel<M>;
+declare function isDeploymentRelationModel<M extends Any>(x: AnyModel<M>): x is DeploymentRelationModel<M>;
+declare function isRelationModel<M extends Any>(x: AnyModel<M>): x is RelationshipModel<M>;
+declare function isElementModel<M extends Any>(element: AnyModel<M>): element is ElementModel<M>;
+declare function isLikeC4ViewModel<M extends Any>(view: AnyModel<M>): view is LikeC4ViewModel<M>;
+declare function isNodeModel<M extends Any>(node: AnyModel<M>): node is NodeModel<M>;
+declare function isEdgeModel<M extends Any>(edge: AnyModel<M>): edge is EdgeModel<M>;
+//#endregion
+//#region src/model/utils/view-title-path.d.ts
+declare const VIEW_FOLDERS_SEPARATOR = "/";
+/**
+ * Normalizes view path by removing spaces from segments, removing empty segments,
+ * and removing leading/trailing slashes
+ * @example
+ * normalizeViewPath('One / Tw o / Thre e') === 'One/Tw o/Thre e'
+ */
+declare const normalizeViewPath: (title: string) => string;
+/**
+ * Returns view group path if it is used as a path
+ * Returns empty string if it is not a path
+ * @example
+ * getViewFolderPath('One / Tw o / Thre e') === 'One/Tw o'
+ * getViewFolderPath('One') === ''
+ */
+declare const getViewFolderPath: (title: string) => string | null;
+/**
+ * Returns view title if it is used as a path
+ * @example
+ * getViewTitleFromPath('One / Tw o / Thre e') === 'Thre e'
+ * getViewTitleFromPath('One') === 'One'
+ */
+declare const extractViewTitleFromPath: (title: string) => string;
+//#endregion
+export { isDeployedInstanceModel as a, isDeploymentRelationModel as c, isLikeC4ViewModel as d, isNestedElementOfDeployedInstanceModel as f, normalizeViewPath as i, isEdgeModel as l, isRelationModel as m, extractViewTitleFromPath as n, isDeploymentElementModel as o, isNodeModel as p, getViewFolderPath as r, isDeploymentNodeModel as s, VIEW_FOLDERS_SEPARATOR as t, isElementModel as u };

package/dist/_chunks/index6.d.mts

@@ -0,0 +1,43 @@
+import { G as Unknown, Y as ViewId, n as Any, p as ElementId } from "./_aux.mjs";
+import { C as ElementModel, T as RelationshipModel, n as LikeC4Model } from "./LikeC4Model.mjs";
+
+//#region src/compute-view/relationships-view/_types.d.ts
+type RelationshipsViewData<M extends Any = Unknown> = {
+  incomers: ReadonlySet<ElementModel<M>>;
+  incoming: ReadonlySet<RelationshipModel<M>>;
+  subjects: ReadonlySet<ElementModel<M>>;
+  outgoing: ReadonlySet<RelationshipModel<M>>;
+  outgoers: ReadonlySet<ElementModel<M>>;
+};
+//#endregion
+//#region src/compute-view/relationships-view/compute.d.ts
+declare function computeRelationshipsView<M extends Any>(subjectId: ElementId<M>, likec4model: LikeC4Model<M>, scopeViewId: ViewId<M> | null, scope?: 'global' | 'view'): RelationshipsViewData<M>;
+//#endregion
+//#region src/compute-view/relationships-view/utils.d.ts
+declare function treeFromElements<M extends Any>(elements: Iterable<ElementModel<M>>): {
+  sorted: readonly ElementModel<M>[];
+  byId: (id: ElementId<M>) => ElementModel<M>;
+  root: ReadonlySet<ElementModel<M>>;
+  parent: (el: ElementModel<M>) => ElementModel<M> | null;
+  children: (el: ElementModel<M>) => ReadonlyArray<ElementModel<M>>;
+  /**
+   * Flattens the tree structure by removing redundant hierarchy levels.
+   * @example
+   *   A
+   *   └── B
+   *       ├── C
+   *       │   └── D
+   *       │       └── E
+   *       └── F
+   *           └── G
+   * becomes
+   *   A
+   *   ├── C
+   *   │   └── E
+   *   └── F
+   *       └── G
+   */
+  flatten: () => Set<ElementModel<M>>;
+};
+//#endregion
+export { computeRelationshipsView as n, RelationshipsViewData as r, treeFromElements as t };

package/dist/{shared/core.OtRNdMxy.d.mts → _chunks/index7.d.mts}

@@ -1,193 +1,42 @@
-import { I as IterableContainer, R as ReorderedArray, N as NonEmptyArray } from './core.DB0Ue5Wx.mjs';
-import { F as Fqn } from './core.C_3y3eqV.mjs';
-import { SetRequired, SetNonNullable } from 'type-fest';
+import { Dt as ReorderedArray, wt as NonEmptyArray, yt as IterableContainer } from "./_aux.mjs";
+import { s as Fqn } from "./scalar.mjs";
+import { SetNonNullable, SetRequired } from "type-fest";
 
+//#region src/utils/invariant.d.ts
+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;
+//#endregion
+//#region src/utils/common-head.d.ts
 /**
- * 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
- * ===========================
+ * Common head of two arrays
+ *
+ * @param equals - Equality function, defaults to `Object.is`
  */
-
-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;
-
+declare function commonHead<T>(sources: ReadonlyArray<T>, targets: ReadonlyArray<T>, equals?: (a: T, b: T) => boolean): T[];
+//#endregion
+//#region src/utils/compare-natural.d.ts
+declare function compareNatural(a: string | undefined, b: string | undefined): -1 | 0 | 1;
 /**
- * Mnemonist BiMap Typings
- * ========================
+ * Compares two strings lexicographically first, then hierarchically based on their depth.\
+ * From parent nodes to leaves
+ *
+ * @example
+ * const lines = [
+ *   'b.c',
+ *   'b',
+ *   'a.b.c',
+ * ]
+ * lines.sort(compareNaturalHierarchically('.'))
+ * // [
+ * //   'a.b.c',
+ * //   'b',
+ * //   'b.c',
+ * // ]
  */
-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;
-
+declare function compareNaturalHierarchically(separator?: string, deepestFirst?: boolean): (a: string | undefined, b: string | undefined) => number;
+//#endregion
+//#region src/utils/fqn.d.ts
 declare function parentFqn<E extends string>(fqn: E): E | null;
 declare function nameFromFqn<E extends string>(fqn: E): string;
 /**
@@ -197,7 +46,7 @@ declare function nameFromFqn<E extends string>(fqn: E): string;
  *  isAncestor(another)(ancestor)
  */
 declare function isAncestor<A extends string | {
-    id: string;
+  id: string;
 }>(another: NoInfer<A>): (ancestor: A) => boolean;
 /**
  * Check if one element is an ancestor of another
@@ -205,12 +54,12 @@ declare function isAncestor<A extends string | {
  *   isAncestor(ancestor, another)
  */
 declare function isAncestor<A extends string | {
-    id: string;
+  id: string;
 }>(ancestor: A, another: A): boolean;
 declare function isSameHierarchy<T extends string>(one: NoInfer<T> | WithId<NoInfer<T>>): (another: T | WithId<T>) => boolean;
 declare function isSameHierarchy<T extends string>(one: T | WithId<T>, another: T | WithId<T>): boolean;
 type WithId<T = string> = {
-    id: T;
+  id: T;
 };
 declare function isDescendantOf<T extends string>(ancestor: WithId<T>): (descedant: WithId<T>) => boolean;
 declare function isDescendantOf<T extends string>(descedant: WithId<T>, ancestor: WithId<T>): boolean;
@@ -219,7 +68,7 @@ declare function isDescendantOf<T extends string>(descedant: WithId<T>, ancestor
  * Root element has depth 1
  */
 declare function hierarchyLevel<E extends string | {
-    id: Fqn;
+  id: Fqn;
 }>(elementOfFqn: E): number;
 /**
  * Calculate the distance as number of steps from one element to another, i.e.
@@ -229,7 +78,7 @@ declare function hierarchyLevel<E extends string | {
  * Can be used for hierarchical clustering
  */
 declare function hierarchyDistance<E extends string | {
-    id: Fqn;
+  id: Fqn;
 }>(one: E, another: E): number;
 declare function commonAncestor<E extends string>(first: E, second: E): E | null;
 /**
@@ -249,7 +98,7 @@ declare function ancestorsFqn<Id extends string>(fqn: Id): Id[];
  */
 declare function compareFqnHierarchically<T extends string = string>(a: T, b: T): -1 | 0 | 1;
 declare function compareByFqnHierarchically<T extends {
-    id: string;
+  id: string;
 }>(a: T, b: T): -1 | 0 | 1;
 /**
  * Sorts an array of objects hierarchically based on their fully qualified names (FQN).
@@ -277,13 +126,13 @@ declare function compareByFqnHierarchically<T extends {
  * ```
  */
 declare function sortByFqnHierarchically<T extends {
-    id: string;
+  id: string;
 }, A extends IterableContainer<T>>(array: A): ReorderedArray<A>;
 /**
  * Keeps initial order of the elements, but ensures that parents are before children
  */
 declare function sortParentsFirst<T extends {
-    id: string;
+  id: string;
 }, A extends IterableContainer<T>>(array: A): ReorderedArray<A>;
 /**
  * Sorts an array of objects naturally by their fully qualified name (FQN) identifier.
@@ -303,7 +152,12 @@ declare function sortParentsFirst<T extends {
  */
 declare function sortNaturalByFqn(sort?: 'asc' | 'desc'): <I extends WithId<string>, A extends IterableContainer<I>>(array: A) => ReorderedArray<A>;
 declare function sortNaturalByFqn<A extends IterableContainer<WithId>>(array: A, sort?: 'asc' | 'desc'): ReorderedArray<A>;
-
+//#endregion
+//#region src/utils/getOrCreate.d.ts
+declare function getOrCreate<K, V>(map: Map<K, V>, key: K, create: (key: K) => V): V;
+declare function getOrCreate<K extends WeakKey, V>(map: WeakMap<K, V>, key: K, create: (key: K) => V): V;
+//#endregion
+//#region src/utils/guards.d.ts
 declare function isString(value: unknown): value is string;
 declare function isNonEmptyArray<A>(arr: ArrayLike<A> | undefined): arr is NonEmptyArray<A>;
 declare function hasProp<T extends object, P extends keyof T & string>(value: T, path: P): value is SetRequired<SetNonNullable<T, P>, P>;
@@ -327,7 +181,8 @@ type Guarded<G> = G extends Guard<infer N> ? N : never;
  * ```
  */
 declare function isAnyOf<const Predicates extends NonEmptyArray<Guard>>(...predicates: Predicates): (value: unknown) => value is Guarded<Predicates[number]>;
-
+//#endregion
+//#region src/utils/memoize-prop.d.ts
 /**
  * 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.
@@ -348,5 +203,66 @@ declare function isAnyOf<const Predicates extends NonEmptyArray<Guard>>(...predi
  * ```
  */
 declare function memoizeProp<Tag extends symbol | string, Res>(obj: object, tag: Tag, fn: () => Res): Res;
-
-export { BiMap as B, DefaultWeakMap as D, LinkedList as L, MultiMap as M, Queue as Q, ancestorsFqn as a, isAncestor as b, isDescendantOf as c, isNonEmptyArray as d, isSameHierarchy as e, isString as f, nonexhaustive as g, hasProp as h, invariant as i, nonNullable as j, sortParentsFirst as k, commonAncestor as l, memoizeProp as m, nameFromFqn as n, compareByFqnHierarchically as o, parentFqn as p, compareFqnHierarchically as q, hierarchyDistance as r, sortNaturalByFqn as s, hierarchyLevel as t, sortByFqnHierarchically as u, isAnyOf as v };
+//#endregion
+//#region src/utils/promises.d.ts
+declare function delay(): Promise<string>;
+declare function delay(ms: number): Promise<string>;
+declare function delay(randomFrom: number, randomTo: number): Promise<string>;
+declare function promiseNextTick(): Promise<void>;
+declare function onNextTick(fn: () => Promise<void> | void): void;
+//#endregion
+//#region src/utils/relations.d.ts
+type RelationshipLike = {
+  source: {
+    id: string;
+  };
+  target: {
+    id: string;
+  };
+};
+/**
+ * Compares two relations hierarchically.
+ * From the most general (implicit) to the most specific (deepest in the tree)
+ */
+declare const compareRelations: <T extends RelationshipLike>(a: T, b: T) => number;
+//#endregion
+//#region src/utils/set.d.ts
+/**
+ * Returns new set as a union of given sets
+ * Keeps order of elements
+ */
+declare function union<T>(...sets: ReadonlySet<T>[]): Set<T>;
+/**
+ * Returns new set as an intersection of all sets
+ * Keeps order from the first set
+ */
+declare function intersection<T>(first: ReadonlySet<T>, ...sets: NonEmptyArray<ReadonlySet<NoInfer<T>>>): Set<T>;
+/**
+ * Returns new set as a difference of two sets (A-B)
+ * Keeps order from the first set
+ */
+declare function difference<T>(a: ReadonlySet<T>, b: ReadonlySet<NoInfer<T>>): Set<T>;
+declare function equals<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): boolean;
+declare function symmetricDifference<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): Set<T>;
+//#endregion
+//#region src/utils/object-hash.d.ts
+declare function objectHash(value: any): string;
+//#endregion
+//#region src/utils/string-hash.d.ts
+/**
+ * @see https://gist.github.com/victor-homyakov/bcb7d7911e4a388b1c810f8c3ce17bcf
+ */
+declare function stringHash(str: string): string;
+//#endregion
+//#region src/utils/markdown/to-html.d.ts
+declare function markdownToHtml(markdown: string): string;
+//#endregion
+//#region src/utils/markdown/to-text.d.ts
+/**
+ * Converts markdown to plain text, removing any markdown formatting.
+ * @param markdown - The markdown to convert.
+ * @returns The plain text.
+ */
+declare function markdownToText(markdown: string): string;
+//#endregion
+export { parentFqn as A, compareFqnHierarchically as C, isDescendantOf as D, isAncestor as E, compareNaturalHierarchically as F, commonHead as I, invariant as L, sortNaturalByFqn as M, sortParentsFirst as N, isSameHierarchy as O, compareNatural as P, nonNullable as R, compareByFqnHierarchically as S, hierarchyLevel as T, isNonEmptyArray as _, difference as a, ancestorsFqn as b, symmetricDifference as c, delay as d, onNextTick as f, isAnyOf as g, hasProp as h, objectHash as i, sortByFqnHierarchically as j, nameFromFqn as k, union as l, memoizeProp as m, markdownToHtml as n, equals as o, promiseNextTick as p, stringHash as r, intersection as s, markdownToText as t, compareRelations as u, isString as v, hierarchyDistance as w, commonAncestor as x, getOrCreate as y, nonexhaustive as z };