@likec4/core 1.41.0 → 1.42.1

package/dist/shared/core.fHR_8Tnq.d.mts

@@ -0,0 +1,450 @@
+import { Tagged, NonEmptyTuple, PartialDeep, WritableDeep, Except } from 'type-fest';
+import { s as BorderStyle, q as ShapeSize, r as SpacingSize, p as TextSize, Q as Color, u as ElementShape, v as RelationshipLineType, y as RelationshipArrowType, b as LikeC4Theme, L as LikeC4StyleDefaults } from './core.CQngdcuj.mjs';
+import { I as Icon, M as MarkdownOrString, d as RelationId, P as ProjectId, N as NodeId, j as EdgeId, m as StepEdgeKind } from './core.DX-WYEPA.mjs';
+import { A as Any, n as WithOptionalTags, o as WithOptionalLinks, h as StrictViewId, f as _stage, g as _type, F as Fqn, R as RelationKind, W as WithDescriptionAndTech, q as WithMetadata, r as WithNotation, j as ElementKind, x as WithTags, t as DeploymentKind, s as DeploymentFqn } from './core.Dgs6-nuz.mjs';
+import { FqnRef } from '../types/fqnRef.mjs';
+import { N as NonEmptyArray, E as ExclusiveUnion, a as NonEmptyReadonlyArray } from './core.D5fzJWbF.mjs';
+import { ModelExpression, ModelFqnExpr } from '../types/expression-model.mjs';
+
+type Point = readonly [x: number, y: number];
+interface XYPoint {
+    x: number;
+    y: number;
+}
+interface BBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+declare namespace BBox {
+    function center({ x, y, width, height }: BBox): XYPoint;
+    function fromPoints(points: Point[]): BBox;
+    function merge(...boxes: BBox[]): BBox;
+    function toRectBox(box: BBox): RectBox;
+    function expand(box: BBox, plus: number): BBox;
+    function shrink(box: BBox, minus: number): BBox;
+}
+interface RectBox {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+declare namespace RectBox {
+    function center({ x1, y1, x2, y2 }: RectBox): XYPoint;
+    function fromPoints(points: Point[]): RectBox;
+    function merge(...boxes: RectBox[]): RectBox;
+    function toBBox(box: RectBox): BBox;
+}
+
+interface AnyIncludePredicate<Expr> {
+    include: Expr[];
+    exclude?: never;
+}
+interface AnyExcludePredicate<Expr> {
+    include?: never;
+    exclude: Expr[];
+}
+interface AnyViewRuleStyle<Expr> {
+    targets: Expr[];
+    notation?: string;
+    style: {
+        border?: BorderStyle;
+        opacity?: number;
+        multiple?: boolean;
+        size?: ShapeSize;
+        padding?: SpacingSize;
+        textSize?: TextSize;
+        color?: Color;
+        shape?: ElementShape;
+        icon?: Icon;
+    };
+}
+interface ViewRuleGlobalStyle {
+    styleId: GlobalStyleID;
+}
+declare function isViewRuleGlobalStyle(rule: object): rule is ViewRuleGlobalStyle;
+interface ViewRuleGlobalPredicateRef {
+    predicateId: GlobalPredicateId;
+}
+declare function isViewRuleGlobalPredicateRef(rule: object): rule is ViewRuleGlobalPredicateRef;
+type AutoLayoutDirection = 'TB' | 'BT' | 'LR' | 'RL';
+declare function isAutoLayoutDirection(autoLayout: unknown): autoLayout is AutoLayoutDirection;
+interface ViewRuleAutoLayout {
+    direction: AutoLayoutDirection;
+    nodeSep?: number;
+    rankSep?: number;
+}
+declare function isViewRuleAutoLayout(rule: object): rule is ViewRuleAutoLayout;
+interface ViewAutoLayout {
+    direction: ViewRuleAutoLayout['direction'];
+    rankSep?: number;
+    nodeSep?: number;
+}
+type ViewManualLayout = {
+    readonly hash: string;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly autoLayout: ViewAutoLayout;
+    readonly nodes: Record<string, {
+        isCompound: boolean;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    readonly edges: Record<string, {
+        dotpos?: string;
+        points: NonEmptyArray<Point>;
+        controlPoints?: NonEmptyArray<XYPoint>;
+        labelBBox?: BBox;
+    }>;
+};
+type ViewType = 'element' | 'dynamic' | 'deployment';
+interface BaseViewProperties<A extends Any> extends WithOptionalTags<A>, WithOptionalLinks {
+    readonly id: StrictViewId<A>;
+    readonly title: string | null;
+    readonly description: MarkdownOrString | null;
+    /**
+     * Source file containing this view, relative to the project root.
+     * Undefined if the view is auto-generated.
+     */
+    readonly sourcePath?: string | undefined;
+}
+interface BaseParsedViewProperties<A extends Any> extends BaseViewProperties<A> {
+    /**
+     * Internal field to identify the stage of the view.
+     * This is used to create the correct type of the view.
+     */
+    readonly [_stage]: 'parsed';
+    /**
+     * URI to the source file of this view.
+     * Undefined if the view is auto-generated.
+     */
+    readonly docUri?: string | undefined;
+    /**
+     * If the view is changed manually this field contains the layout data.
+     */
+    readonly manualLayout?: ViewManualLayout | undefined;
+}
+type NodeNotation = {
+    kinds: string[];
+    shape: ElementShape;
+    color: Color;
+    title: string;
+};
+interface ViewWithNotation {
+    notation?: {
+        nodes: NodeNotation[];
+    };
+}
+interface ViewWithHash {
+    /**
+     * Hash of the view object.
+     * This is used to detect changes in layout
+     */
+    hash: string;
+}
+
+/**
+ * Predicates scoped to logical model
+ */
+interface ElementViewIncludePredicate<A extends Any = Any> extends AnyIncludePredicate<ModelExpression<A>> {
+}
+interface ElementViewExcludePredicate<A extends Any = Any> extends AnyExcludePredicate<ModelExpression<A>> {
+}
+type ElementViewPredicate<A extends Any = Any> = ElementViewIncludePredicate<A> | ElementViewExcludePredicate<A>;
+interface ElementViewRuleGroup<A extends Any = Any> {
+    groupRules: Array<ElementViewPredicate<A> | ElementViewRuleGroup<A>>;
+    title: string | null;
+    color?: Color;
+    border?: BorderStyle;
+    opacity?: number;
+    multiple?: boolean;
+    size?: ShapeSize;
+    padding?: SpacingSize;
+    textSize?: TextSize;
+}
+declare function isViewRuleGroup<A extends Any>(rule: ElementViewRule<A>): rule is ElementViewRuleGroup<A>;
+interface ElementViewRuleStyle<A extends Any = Any> extends AnyViewRuleStyle<ModelFqnExpr<A>> {
+}
+type ElementViewRule<A extends Any = Any> = ExclusiveUnion<{
+    IncludePredicate: ElementViewIncludePredicate<A>;
+    ExcludePredicate: ElementViewExcludePredicate<A>;
+    Group: ElementViewRuleGroup<A>;
+    Style: ElementViewRuleStyle<A>;
+    GlobalStyle: ViewRuleGlobalStyle;
+    GlobalPredicateRef: ViewRuleGlobalPredicateRef;
+    AutoLayout: ViewRuleAutoLayout;
+}>;
+interface ParsedElementView<A extends Any = Any> extends BaseParsedViewProperties<A> {
+    [_type]: 'element';
+    readonly rules: ElementViewRule<A>[];
+    readonly viewOf?: Fqn<A>;
+    readonly extends?: StrictViewId<A>;
+}
+
+interface DynamicStep<A extends Any = Any> {
+    readonly source: Fqn<A>;
+    readonly target: Fqn<A>;
+    readonly title?: string | null;
+    readonly kind?: RelationKind<A>;
+    readonly description?: MarkdownOrString;
+    readonly technology?: string;
+    readonly notation?: string;
+    readonly notes?: MarkdownOrString;
+    readonly color?: Color;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+    readonly isBackward?: boolean;
+    readonly navigateTo?: StrictViewId<A>;
+    /**
+     * Path to the AST node relative to the view body ast
+     * Used to locate the step in the source code
+     */
+    readonly astPath: string;
+}
+interface DynamicStepsSeries<A extends Any = Any> {
+    readonly seriesId: string;
+    readonly __series: NonEmptyReadonlyArray<DynamicStep<A>>;
+}
+interface DynamicStepsParallel<A extends Any = Any> {
+    readonly parallelId: string;
+    readonly __parallel: NonEmptyReadonlyArray<DynamicStep<A> | DynamicStepsSeries<A>>;
+}
+declare function getParallelStepsPrefix(id: string): string | null;
+type DynamicViewStep<A extends Any = Any> = ExclusiveUnion<{
+    Step: DynamicStep<A>;
+    Series: DynamicStepsSeries<A>;
+    Parallel: DynamicStepsParallel<A>;
+}>;
+declare function isDynamicStep<A extends Any>(step: DynamicViewStep<A> | undefined): step is DynamicStep<A>;
+declare function isDynamicStepsParallel<A extends Any>(step: DynamicViewStep<A> | undefined): step is DynamicStepsParallel<A>;
+declare function isDynamicStepsSeries<A extends Any>(step: DynamicViewStep<A> | undefined): step is DynamicStepsSeries<A>;
+interface DynamicViewIncludeRule<A extends Any = Any> {
+    include: ModelFqnExpr.Any<A>[];
+}
+type DynamicViewRule<A extends Any = Any> = ExclusiveUnion<{
+    Include: DynamicViewIncludeRule<A>;
+    GlobalPredicateRef: ViewRuleGlobalPredicateRef;
+    ElementViewRuleStyle: ElementViewRuleStyle<A>;
+    GlobalStyle: ViewRuleGlobalStyle;
+    AutoLayout: ViewRuleAutoLayout;
+}>;
+type DynamicViewDisplayVariant = 'diagram' | 'sequence';
+interface ParsedDynamicView<A extends Any = Any> extends BaseParsedViewProperties<A> {
+    [_type]: 'dynamic';
+    /**
+     * How to display the dynamic view
+     * - `diagram`: display as a regular likec4 view
+     * - `sequence`: display as a sequence diagram
+     *
+     * @default 'diagram'
+     */
+    readonly variant?: DynamicViewDisplayVariant;
+    readonly steps: DynamicViewStep<A>[];
+    readonly rules: DynamicViewRule<A>[];
+}
+
+type GlobalPredicateId = Tagged<string, 'GlobalPredicateId'>;
+type GlobalPredicates<A extends Any = Any> = NonEmptyArray<ElementViewPredicate<A>>;
+type GlobalDynamicPredicates<A extends Any = Any> = NonEmptyArray<DynamicViewIncludeRule<A>>;
+type GlobalStyleID = Tagged<string, 'GlobalStyleID'>;
+type GlobalStyles<A extends Any = Any> = NonEmptyTuple<ElementViewRuleStyle<A>>;
+interface ModelGlobals<A extends Any = Any> {
+    readonly predicates: Record<GlobalPredicateId, GlobalPredicates<A>>;
+    readonly dynamicPredicates: Record<GlobalPredicateId, GlobalDynamicPredicates<A>>;
+    readonly styles: Record<GlobalStyleID, GlobalStyles<A>>;
+}
+
+interface ElementStyle {
+    readonly icon?: Icon;
+    readonly shape?: ElementShape;
+    readonly color?: Color;
+    readonly border?: BorderStyle;
+    /**
+     * In percentage 0-100, 0 is fully transparent
+     *
+     * @default 100
+     */
+    readonly opacity?: number;
+    /**
+     * If true, the element is rendered as multiple shapes
+     * @default false
+     */
+    readonly multiple?: boolean;
+    /**
+     * Shape size
+     *
+     * @default 'md'
+     */
+    readonly size?: ShapeSize;
+    readonly padding?: SpacingSize;
+    readonly textSize?: TextSize;
+}
+type WithSizes = Pick<ElementStyle, 'size' | 'padding' | 'textSize'>;
+/**
+ * Ensures that the sizes are set to default values if they are not set
+ */
+declare function ensureSizes<S extends WithSizes>({ size, padding, textSize, ...rest }: S, defaultSize?: "xs" | "sm" | "md" | "lg" | "xl"): Omit<S, 'size' | 'padding' | 'textSize'> & Required<WithSizes>;
+interface Element<A extends Any = Any> extends WithDescriptionAndTech, WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A>, WithNotation {
+    readonly id: Fqn<A>;
+    readonly kind: ElementKind<A>;
+    readonly title: string;
+    readonly style: ElementStyle;
+}
+interface AbstractRelationship<A extends Any> extends WithDescriptionAndTech, WithOptionalTags<A>, WithOptionalLinks, WithMetadata<A> {
+    readonly id: RelationId;
+    readonly title?: string | null;
+    readonly kind?: RelationKind<A>;
+    readonly color?: Color;
+    readonly line?: RelationshipLineType;
+    readonly head?: RelationshipArrowType;
+    readonly tail?: RelationshipArrowType;
+    readonly navigateTo?: StrictViewId<A>;
+}
+/**
+ * Relationship between two model elements
+ */
+interface Relationship<A extends Any = Any> extends AbstractRelationship<A> {
+    readonly source: FqnRef.ModelRef<A>;
+    readonly target: FqnRef.ModelRef<A>;
+}
+/**
+ * Backward compatibility alias
+ * @deprecated Use {@link Relationship} instead
+ */
+type ModelRelation<A extends Any = Any> = Relationship<A>;
+
+type LikeC4ProjectTheme = PartialDeep<WritableDeep<LikeC4Theme>, {
+    recurseIntoArrays: false;
+    allowUndefinedInNonTupleArrays: false;
+}>;
+type LikeC4ProjectStyleDefaults = PartialDeep<WritableDeep<LikeC4StyleDefaults>, {
+    recurseIntoArrays: false;
+    allowUndefinedInNonTupleArrays: false;
+}>;
+interface LikeC4ProjectStylesConfig {
+    theme?: LikeC4ProjectTheme;
+    defaults?: LikeC4ProjectStyleDefaults;
+}
+/**
+ * Configuration of the project, as read from the config file.
+ * LikeC4 projects encapsulate models, and can import from each other
+ */
+interface LikeC4Project {
+    /**
+     * ID of the project, casted to {@link scalar.ProjectId}
+     */
+    readonly id: ProjectId;
+    title?: string;
+    /**
+     * Custom styles
+     */
+    styles?: LikeC4ProjectStylesConfig | undefined;
+}
+
+type ComputedNodeStyle = Except<ElementStyle, 'icon' | 'shape' | 'color', {
+    requireExactProps: true;
+}>;
+interface ComputedNode<A extends Any = Any> extends WithTags<A>, WithOptionalLinks {
+    id: NodeId;
+    kind: ElementKind<A> | DeploymentKind<A> | '@group';
+    parent: NodeId | null;
+    /**
+     * Reference to model element
+     */
+    modelRef?: Fqn<A>;
+    /**
+     * Reference to deployment element
+     */
+    deploymentRef?: DeploymentFqn<A>;
+    title: string;
+    /**
+     * Description of the node
+     * either summary or description
+     */
+    description?: MarkdownOrString | null;
+    technology?: string | null;
+    children: NodeId[];
+    inEdges: EdgeId[];
+    outEdges: EdgeId[];
+    shape: ElementShape;
+    color: Color;
+    icon?: Icon;
+    style: ComputedNodeStyle;
+    navigateTo?: StrictViewId<A> | null;
+    level: number;
+    depth?: number | null;
+    /**
+     * If this node was customized in the view
+     */
+    isCustomized?: boolean;
+    notation?: string | null;
+}
+interface ComputedEdge<A extends Any = Any> extends WithOptionalTags<A> {
+    id: EdgeId;
+    parent: NodeId | null;
+    source: NodeId;
+    target: NodeId;
+    label: string | null;
+    description?: MarkdownOrString | null;
+    technology?: string | null;
+    relations: RelationId[];
+    kind?: RelationKind<A> | typeof StepEdgeKind;
+    notation?: string;
+    notes?: MarkdownOrString;
+    color: Color;
+    line: RelationshipLineType;
+    head?: RelationshipArrowType;
+    tail?: RelationshipArrowType;
+    navigateTo?: StrictViewId<A> | null;
+    /**
+     * If this edge is derived from custom relationship predicate
+     */
+    isCustomized?: boolean;
+    /**
+     * Path to the AST node relative to the view body ast
+     * Available only in dynamic views
+     * @internal
+     */
+    astPath?: string;
+    /**
+     * For layouting purposes
+     * @default 'forward'
+     */
+    dir?: 'forward' | 'back' | 'both';
+}
+interface BaseComputedViewProperties<A extends Any> extends BaseViewProperties<A>, ViewWithHash, ViewWithNotation {
+    readonly [_stage]: 'computed';
+    readonly autoLayout: ViewAutoLayout;
+    readonly nodes: ComputedNode<A>[];
+    readonly edges: ComputedEdge<A>[];
+    /**
+     * If the view is changed manually this field contains the layout data.
+     */
+    readonly manualLayout?: ViewManualLayout | undefined;
+}
+interface ComputedElementView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+    readonly [_type]: 'element';
+    readonly viewOf?: Fqn<A>;
+    readonly extends?: StrictViewId<A>;
+}
+interface ComputedDeploymentView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+    readonly [_type]: 'deployment';
+}
+interface ComputedDynamicView<A extends Any = Any> extends BaseComputedViewProperties<A> {
+    readonly [_type]: 'dynamic';
+    /**
+     * How to display the dynamic view
+     * - `diagram`: display as a regular likec4 view
+     * - `sequence`: display as a sequence diagram
+     */
+    readonly variant: DynamicViewDisplayVariant;
+}
+
+export { type DynamicViewIncludeRule as $, type AbstractRelationship as A, BBox as B, type ViewWithNotation as C, type ViewWithHash as D, type ElementStyle as E, type ComputedNodeStyle as F, type GlobalPredicateId as G, type ComputedNode as H, type ComputedEdge as I, type ComputedElementView as J, type ComputedDeploymentView as K, type LikeC4ProjectTheme as L, type ModelGlobals as M, type NodeNotation as N, type ComputedDynamicView as O, type Point as P, type DynamicStep as Q, RectBox as R, type DynamicStepsSeries as S, type DynamicStepsParallel as T, getParallelStepsPrefix as U, type ViewRuleGlobalStyle as V, type DynamicViewStep as W, type XYPoint as X, isDynamicStep as Y, isDynamicStepsParallel as Z, isDynamicStepsSeries as _, type GlobalPredicates as a, type DynamicViewRule as a0, type DynamicViewDisplayVariant as a1, type ParsedDynamicView as a2, type ElementViewIncludePredicate as a3, type ElementViewExcludePredicate as a4, type ElementViewPredicate as a5, type ElementViewRuleGroup as a6, isViewRuleGroup as a7, type ElementViewRuleStyle as a8, type ElementViewRule as a9, type ParsedElementView as aa, type GlobalDynamicPredicates as b, type GlobalStyleID as c, type GlobalStyles as d, ensureSizes as e, type Element as f, type Relationship as g, type ModelRelation as h, type LikeC4ProjectStyleDefaults as i, type LikeC4ProjectStylesConfig as j, type LikeC4Project as k, type AnyIncludePredicate as l, type AnyExcludePredicate as m, type AnyViewRuleStyle as n, isViewRuleGlobalStyle as o, type ViewRuleGlobalPredicateRef as p, isViewRuleGlobalPredicateRef as q, type AutoLayoutDirection as r, isAutoLayoutDirection as s, type ViewRuleAutoLayout as t, isViewRuleAutoLayout as u, type ViewAutoLayout as v, type ViewManualLayout as w, type ViewType as x, type BaseViewProperties as y, type BaseParsedViewProperties as z };

package/dist/shared/{core.D0EgVMQK.mjs → core.lRvxPoao.mjs}

@@ -1,9 +1,11 @@
-import { pipe, map, isNot } from 'remeda';
-import { c as customInspectSymbol } from './core.BVNaR17u.mjs';
-import { i as intersection, a as stringHash, u as union, d as difference, e as equals } from './core.4u1dVmfX.mjs';
-import { b as isDescendantOf, i as isAncestor, e as isString, s as sortNaturalByFqn, d as isSameHierarchy } from './core.DgttqsJc.mjs';
-import { i as isome } from './core.Be4Jy9Qx.mjs';
-import { i as ifilter } from './core.CCD1ID81.mjs';
+import { c as customInspectSymbol } from './core.B7KhhkRY.mjs';
+import { e } from './core.BoYfZOBm.mjs';
+import { i as intersection, a as stringHash, u as union, d as difference, e as equals } from './core.C2TiyjI6.mjs';
+import { t } from './core.OHD4KXm9.mjs';
+import { t as t$1 } from './core.CbT8JVYL.mjs';
+import { b as isDescendantOf, i as isAncestor, e as isString, s as sortNaturalByFqn, d as isSameHierarchy } from './core.DRhg-gVU.mjs';
+import { i as isome } from './core.FZ305VYd.mjs';
+import { i as ifilter } from './core.DRJma0Ol.mjs';
 import { i as invariant } from './core.D4npX2q8.mjs';
 
 function isNestedConnection(nested, parent) {
@@ -54,14 +56,14 @@ function sortConnectionsByBoundaryHierarchy(connections, sort) {
   return _sortByBoundary(connections, sort ?? "asc");
 }
 function _sortByBoundary(connections, order) {
-  return pipe(
+  return t(
     connections,
-    map((conn) => ({
+    t$1((conn) => ({
       id: boundaryHierarchy(conn),
       conn
     })),
     sortNaturalByFqn(order),
-    map((p) => p.conn)
+    t$1((p) => p.conn)
   );
 }
 function findAscendingConnections(connections, connection) {
@@ -248,7 +250,7 @@ class ConnectionModel {
    * Returns true if includes relations between nested elements of the source and target elements.
    */
   get isImplicit() {
-    return this.nonEmpty() && isome(this.relations, isNot(hasSameSourceTarget(this)));
+    return this.nonEmpty() && isome(this.relations, e(hasSameSourceTarget(this)));
   }
   get directRelations() {
     return new Set(ifilter(this.relations, hasSameSourceTarget(this)));
@@ -298,7 +300,7 @@ class ConnectionModel {
       relations
     );
   }
-  [customInspectSymbol](depth, inspectOptions, inspect) {
+  [customInspectSymbol](_depth, _inspectOptions, _inspect) {
     const asString = this.toString();
     Object.defineProperty(asString, "constructor", {
       value: ConnectionModel,
@@ -326,4 +328,4 @@ class ConnectionModel {
   }
 }
 
-export { ConnectionModel as C, findConnectionsBetween as a, findConnectionsWithin as b, findAscendingConnections as c, differenceConnections as d, findDeepestNestedConnection as e, findConnection as f, findDescendantConnections as g, hasSameSource as h, hasSameSourceTarget as i, hasSameTarget as j, isAnyInOut as k, isIncoming as l, isNestedConnection as m, isOutgoing as n, mergeConnections as o, sortDeepestFirst as p, modelConnection as q, sortConnectionsByBoundaryHierarchy as s };
+export { ConnectionModel as C, findDeepestNestedConnection as a, findDescendantConnections as b, hasSameSourceTarget as c, differenceConnections as d, hasSameTarget as e, findAscendingConnections as f, isIncoming as g, hasSameSource as h, isAnyInOut as i, isNestedConnection as j, isOutgoing as k, sortDeepestFirst as l, mergeConnections as m, modelConnection as n, findConnectionsBetween as o, findConnection as p, findConnectionsWithin as q, sortConnectionsByBoundaryHierarchy as s };

package/dist/shared/{core.CaT0SUUK.mjs → core.rCeaAqgW.mjs}

@@ -10,89 +10,6 @@ function requireSupport () {
 	return support;
 }
 
-/**
- * Obliterator ForEach Function
- * =============================
- *
- * Helper function used to easily iterate over mixed values.
- */
-
-var foreach;
-var hasRequiredForeach;
-
-function requireForeach () {
-	if (hasRequiredForeach) return foreach;
-	hasRequiredForeach = 1;
-	var support = requireSupport();
-
-	var ARRAY_BUFFER_SUPPORT = support.ARRAY_BUFFER_SUPPORT;
-	var SYMBOL_SUPPORT = support.SYMBOL_SUPPORT;
-
-	/**
-	 * Function able to iterate over almost any iterable JS value.
-	 *
-	 * @param  {any}      iterable - Iterable value.
-	 * @param  {function} callback - Callback function.
-	 */
-	foreach = function forEach(iterable, callback) {
-	  var iterator, k, i, l, s;
-
-	  if (!iterable) throw new Error('obliterator/forEach: invalid iterable.');
-
-	  if (typeof callback !== 'function')
-	    throw new Error('obliterator/forEach: expecting a callback.');
-
-	  // The target is an array or a string or function arguments
-	  if (
-	    Array.isArray(iterable) ||
-	    (ARRAY_BUFFER_SUPPORT && ArrayBuffer.isView(iterable)) ||
-	    typeof iterable === 'string' ||
-	    iterable.toString() === '[object Arguments]'
-	  ) {
-	    for (i = 0, l = iterable.length; i < l; i++) callback(iterable[i], i);
-	    return;
-	  }
-
-	  // The target has a #.forEach method
-	  if (typeof iterable.forEach === 'function') {
-	    iterable.forEach(callback);
-	    return;
-	  }
-
-	  // The target is iterable
-	  if (
-	    SYMBOL_SUPPORT &&
-	    Symbol.iterator in iterable &&
-	    typeof iterable.next !== 'function'
-	  ) {
-	    iterable = iterable[Symbol.iterator]();
-	  }
-
-	  // The target is an iterator
-	  if (typeof iterable.next === 'function') {
-	    iterator = iterable;
-	    i = 0;
-
-	    while (((s = iterator.next()), s.done !== true)) {
-	      callback(s.value, i);
-	      i++;
-	    }
-
-	    return;
-	  }
-
-	  // The target is a plain object
-	  for (k in iterable) {
-	    if (iterable.hasOwnProperty(k)) {
-	      callback(iterable[k], k);
-	    }
-	  }
-
-	  return;
-	};
-	return foreach;
-}
-
 /**
  * Obliterator Iterator Class
  * ===========================
@@ -198,4 +115,4 @@ function requireIterator () {
 	return iterator;
 }
 
-export { requireForeach as a, requireSupport as b, requireIterator as r };
+export { requireIterator as a, requireSupport as r };

package/dist/shared/{core.zxTBF_PD.d.mts → core.s9uwOt60.d.mts}

@@ -1,6 +1,6 @@
-import { C as Connection, c as customInspectSymbol } from './core.xSQO0XYD.mjs';
-import { E as ElementModel, R as RelationshipModel } from './core.BXsxn-hf.mjs';
-import { A as Any, U as Unknown, K as EdgeId } from './core.BhpgpOep.mjs';
+import { C as Connection, c as customInspectSymbol } from './core.DIol3syK.mjs';
+import { E as ElementModel, R as RelationshipModel } from './core.D0PjZzIS.mjs';
+import { A as Any, U as Unknown, v as EdgeId } from './core.Dgs6-nuz.mjs';
 
 /**
  * Connection refers to any relationships between two elements,
@@ -46,7 +46,7 @@ declare class ConnectionModel<A extends Any = Unknown> implements Connection<Ele
      * @returns A new `ConnectionModel` instance with the updated relations.
      */
     update(relations: ReadonlySet<RelationshipModel<A>>): ConnectionModel<A>;
-    [customInspectSymbol](depth: any, inspectOptions: any, inspect: any): string;
+    [customInspectSymbol](_depth: any, _inspectOptions: any, _inspect: any): string;
     toString(): string;
     /**
      * Creates a new connection with reversed direction (target becomes source and vice versa)