@likec4/core 1.32.2 → 1.33.0

package/dist/shared/core.BTnf14gD.mjs

@@ -0,0 +1,331 @@
+import { c as customInspectSymbol } from './core.C80Z37Eu.mjs';
+import { o } from './core.BgvIuGGU.mjs';
+import { a as intersection, b as stringHash, u as union, d as difference, e as equals } from './core.CpwrZi3D.mjs';
+import { u } from './core.DbRvwARP.mjs';
+import { m } from './core.ByrmCl9I.mjs';
+import { j as isDescendantOf, i as isAncestor, q as isString, C, l as sortNaturalByFqn, k as isSameHierarchy } from './core.C_C-3c1S.mjs';
+import { i as isome } from './core.BoyJPEen.mjs';
+import { i as ifilter } from './core.BH9nN-_I.mjs';
+import { i as invariant } from './core.D4npX2q8.mjs';
+
+function p(...e){return u(t,e)}var t=(e,o)=>e[o];
+
+function isNestedConnection(nested, parent) {
+  if (!parent) {
+    const p = nested;
+    return (n) => isNestedConnection(n, p);
+  }
+  const isSameSource = nested.source === parent.source;
+  const isSameTarget = nested.target === parent.target;
+  if (isSameSource && isSameTarget) {
+    return false;
+  }
+  const isSourceNested = isAncestor(parent.source.id, nested.source.id);
+  const isTargetNested = isAncestor(parent.target.id, nested.target.id);
+  return isSourceNested && isTargetNested || isSameSource && isTargetNested || isSameTarget && isSourceNested;
+}
+function findDeepestNestedConnection(connections, connection) {
+  let deepest = connection;
+  for (const c of connections) {
+    if (isNestedConnection(c, deepest)) {
+      deepest = c;
+    }
+  }
+  return deepest !== connection ? deepest : null;
+}
+function sortDeepestFirst(connections) {
+  const sorted = [];
+  const unsorted = connections.slice();
+  let next;
+  while (next = unsorted.shift()) {
+    let deepest;
+    while (deepest = findDeepestNestedConnection(unsorted, next)) {
+      const index = unsorted.indexOf(deepest);
+      sorted.push(unsorted.splice(index, 1)[0]);
+    }
+    sorted.push(next);
+  }
+  return sorted;
+}
+const boundaryHierarchy = (conn) => conn.boundary?.id ? `.${conn.boundary.id}` : "";
+function sortConnectionsByBoundaryHierarchy(connections, sort) {
+  if (!connections || isString(connections)) {
+    const dir = connections ?? "asc";
+    return (arr) => _sortByBoundary(arr, dir);
+  }
+  return _sortByBoundary(connections, sort ?? "asc");
+}
+function _sortByBoundary(connections, order) {
+  return C(
+    connections,
+    m((conn) => ({
+      id: boundaryHierarchy(conn),
+      conn
+    })),
+    sortNaturalByFqn(order),
+    m(p("conn"))
+  );
+}
+function findAscendingConnections(connections, connection) {
+  return connections.filter((c) => isNestedConnection(connection, c));
+}
+function findDescendantConnections(connections, connection) {
+  return connections.filter(isNestedConnection(connection));
+}
+function mergeConnections(connections) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const conn of connections) {
+    const existing = map2.get(conn.id);
+    if (existing) {
+      map2.set(conn.id, conn.mergeWith(existing));
+    } else {
+      map2.set(conn.id, conn);
+    }
+  }
+  return [...map2.values()];
+}
+function differenceConnections(source, exclude) {
+  const minus = new Map([...exclude].map((c) => [c.id, c]));
+  return [...source].reduce((acc, c) => {
+    const other = minus.get(c.id);
+    if (!other) {
+      acc.push(c);
+      return acc;
+    }
+    const updated = c.difference(other);
+    if (updated.nonEmpty()) {
+      acc.push(updated);
+    }
+    return acc;
+  }, []);
+}
+function hasSameSourceTarget(a, b) {
+  if (b) {
+    return a.source === b.source && a.target === b.target;
+  }
+  return (b2) => a.source === b2.source && a.target === b2.target;
+}
+function hasSameSource(a, b) {
+  if (b) {
+    return a.source === b.source;
+  }
+  return (b2) => a.source === b2.source;
+}
+function hasSameTarget(a, b) {
+  if (b) {
+    return a.target === b.target;
+  }
+  return (b2) => a.target === b2.target;
+}
+function isOutgoing(a, source) {
+  if (!source) {
+    const _source = a;
+    return (b) => isOutgoing(b, _source);
+  }
+  const at = a;
+  return isDescendantOf(at.source, source) && !isDescendantOf(at.target, source);
+}
+function isIncoming(a, target) {
+  if (!target) {
+    const _target = a;
+    return (b) => isIncoming(b, _target);
+  }
+  const at = a;
+  return isDescendantOf(at.target, target) && !isDescendantOf(at.source, target);
+}
+function isAnyInOut(a, source) {
+  if (!source) {
+    const _source = a;
+    return (b) => isAnyInOut(b, _source);
+  }
+  const at = a;
+  return isDescendantOf(at.source, source) !== isDescendantOf(at.target, source);
+}
+
+function findConnection(source, target, direction = "directed") {
+  if (source === target) {
+    return [];
+  }
+  if (isSameHierarchy(source, target)) {
+    return [];
+  }
+  const directedIntersection = intersection(source.allOutgoing, target.allIncoming);
+  const directed = directedIntersection.size > 0 ? new ConnectionModel(
+    source,
+    target,
+    directedIntersection
+  ) : null;
+  if (direction === "directed") {
+    return directed ? [directed] : [];
+  }
+  const reverseIntersection = intersection(source.allIncoming, target.allOutgoing);
+  const reverse = reverseIntersection.size > 0 ? new ConnectionModel(
+    target,
+    source,
+    reverseIntersection
+  ) : null;
+  if (directed && reverse) {
+    return [directed, reverse];
+  }
+  if (directed) {
+    return [directed];
+  }
+  if (reverse) {
+    return [reverse];
+  }
+  return [];
+}
+function findConnectionsBetween(element, others, direction = "both") {
+  if (element.allIncoming.size === 0 && element.allOutgoing.size === 0) {
+    return [];
+  }
+  const outgoing = [];
+  const incoming = [];
+  for (const _other of others) {
+    if (element === _other) {
+      continue;
+    }
+    for (const found of findConnection(element, _other, direction)) {
+      if (found.source === element) {
+        outgoing.push(found);
+      } else {
+        incoming.push(found);
+      }
+    }
+  }
+  return [
+    ...outgoing,
+    ...incoming
+  ];
+}
+function findConnectionsWithin(elements) {
+  return [...elements].reduce((acc, el, index, array) => {
+    if (index === array.length - 1) {
+      return acc;
+    }
+    acc.push(
+      ...findConnectionsBetween(el, array.slice(index + 1), "both")
+    );
+    return acc;
+  }, []);
+}
+
+const modelConnection = {
+  __proto__: null,
+  findConnection: findConnection,
+  findConnectionsBetween: findConnectionsBetween,
+  findConnectionsWithin: findConnectionsWithin
+};
+
+class ConnectionModel {
+  constructor(source, target, relations = /* @__PURE__ */ new Set()) {
+    this.source = source;
+    this.target = target;
+    this.relations = relations;
+    this.id = stringHash(`model:${source.id}:${target.id}`);
+  }
+  id;
+  _boundary;
+  /**
+   * Common ancestor of the source and target elements.
+   * Represents the boundary of the connection.
+   */
+  get boundary() {
+    return this._boundary ??= this.source.commonAncestor(this.target);
+  }
+  /**
+   * Human readable expression of the connection
+   * Mostly used for testing and debugging
+   */
+  get expression() {
+    return `${this.source.id} -> ${this.target.id}`;
+  }
+  /**
+   * Returns true if only includes relations between the source and target elements.
+   */
+  get isDirect() {
+    return this.nonEmpty() && !this.isImplicit;
+  }
+  /**
+   * Returns true if includes relations between nested elements of the source and target elements.
+   */
+  get isImplicit() {
+    return this.nonEmpty() && isome(this.relations, o(hasSameSourceTarget(this)));
+  }
+  get directRelations() {
+    return new Set(ifilter(this.relations, hasSameSourceTarget(this)));
+  }
+  nonEmpty() {
+    return this.relations.size > 0;
+  }
+  mergeWith(other) {
+    invariant(this.source.id === other.source.id, "Cannot merge connections with different sources");
+    invariant(this.target.id === other.target.id, "Cannot merge connections with different targets");
+    return new ConnectionModel(
+      this.source,
+      this.target,
+      union(this.relations, other.relations)
+    );
+  }
+  difference(other) {
+    return new ConnectionModel(
+      this.source,
+      this.target,
+      difference(this.relations, other.relations)
+    );
+  }
+  intersect(other) {
+    invariant(other instanceof ConnectionModel, "Cannot intersect connection with different type");
+    return new ConnectionModel(
+      this.source,
+      this.target,
+      intersection(this.relations, other.relations)
+    );
+  }
+  equals(other) {
+    invariant(other instanceof ConnectionModel, "Cannot merge connection with different type");
+    const _other = other;
+    return this.id === _other.id && this.source.id === _other.source.id && this.target.id === _other.target.id && equals(this.relations, _other.relations);
+  }
+  /**
+   * Returns a new instance with the updated relations.
+   *
+   * @param relations - A readonly set of `RelationshipModel` instances representing the new relations.
+   * @returns A new `ConnectionModel` instance with the updated relations.
+   */
+  update(relations) {
+    return new ConnectionModel(
+      this.source,
+      this.target,
+      relations
+    );
+  }
+  [customInspectSymbol](depth, inspectOptions, inspect) {
+    const asString = this.toString();
+    Object.defineProperty(asString, "constructor", {
+      value: ConnectionModel,
+      enumerable: false
+    });
+    return asString;
+  }
+  toString() {
+    return [
+      this.expression,
+      this.relations.size ? "  relations:" : "  relations: [ ]",
+      ...[...this.relations].map((c) => "    " + c.expression)
+    ].join("\n");
+  }
+  /**
+   * Creates a new connection with reversed direction (target becomes source and vice versa)
+   * @param search - When true, attempts to find an existing connection between the reversed nodes
+   */
+  reversed(search = false) {
+    if (!search) {
+      return new ConnectionModel(this.target, this.source);
+    }
+    const [found] = findConnection(this.target, this.source, "directed");
+    return found ?? new ConnectionModel(this.target, this.source, /* @__PURE__ */ new Set());
+  }
+}
+
+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, p, findConnection as q, findConnectionsWithin as r, sortConnectionsByBoundaryHierarchy as s };

package/dist/shared/core.BgvIuGGU.mjs

@@ -0,0 +1,3 @@
+function o(a){return t=>!a(t)}
+
+export { o };

package/dist/shared/core.BoyJPEen.mjs

@@ -0,0 +1,21 @@
+import { t } from './core.BH9nN-_I.mjs';
+import { i as invariant } from './core.D4npX2q8.mjs';
+
+function isome(arg1, arg2) {
+  const pred = arg2 ?? arg1;
+  invariant(t(pred));
+  function _some(iter) {
+    for (const value of iter) {
+      if (pred(value)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  if (!arg2) {
+    return _some;
+  }
+  return _some(arg1);
+}
+
+export { isome as i };

package/dist/shared/{core.CUYDgv2-.mjs → core.Br7Fab9l.mjs}

@@ -1,4 +1,7 @@
-import { i as invariant, t as t$1, a as nonexhaustive } from './core.Cy9smucx.mjs';
+import { t as t$1 } from './core.zLlww-07.mjs';
+import { n as n$1 } from './core.D56nCp7e.mjs';
+import { i as invariant, n as nonexhaustive } from './core.D4npX2q8.mjs';
+import { o } from './core.BgvIuGGU.mjs';
 import { u } from './core.DbRvwARP.mjs';
 
 function isOnStage(value, stage) {
@@ -7,16 +10,19 @@ function isOnStage(value, stage) {
 const _stage = "_stage";
 const _type = "_type";
 
-function n$1(e){return !!e}
-
 function n(e){return e==null}
 
-function o(a){return t=>!a(t)}
-
 function t(...a){return u(e,a)}var e=(a,o)=>o.every(l=>l(a));
 
 function y(...a){return u(r,a)}var r=(a,o)=>o.some(e=>e(a));
 
+function flattenMarkdownOrString(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  const content = t$1(value) ? value : value.txt ?? value.md;
+  return n$1(content?.trim()) ? content : null;
+}
 function Fqn(name, parent) {
   return parent ? parent + "." + name : name;
 }
@@ -121,15 +127,6 @@ function isDeployedInstance(el) {
   return "element" in el && n$1(el.element);
 }
 
-const DefaultThemeColor = "primary";
-const DefaultElementShape = "rectangle";
-const DefaultShapeSize = "md";
-const DefaultPaddingSize = "md";
-const DefaultTextSize = "md";
-const DefaultLineStyle = "dashed";
-const DefaultArrowType = "normal";
-const DefaultRelationshipColor = "gray";
-
 function isTagEqual(operator) {
   return "tag" in operator;
 }
@@ -211,4 +208,4 @@ function participantIs(participant, predicate) {
   };
 }
 
-export { DeploymentFqn as A, GlobalFqn as B, isGlobalFqn as C, DefaultElementShape as D, splitGlobalFqn as E, FqnRef as F, GroupElementKind as G, EdgeId as H, extractStep as I, NodeId as N, RelationId as R, StepEdgeKind as S, ViewId as V, _type as _, DefaultThemeColor as a, _stage as b, n$1 as c, isStepEdgeId as d, isGroupElementKind as e, DefaultArrowType as f, DefaultLineStyle as g, DefaultRelationshipColor as h, isDeployedInstance as i, isOnStage as j, isDeploymentNode as k, DefaultShapeSize as l, DefaultPaddingSize as m, n, o, DefaultTextSize as p, isTagEqual as q, isKindEqual as r, stepEdgeId as s, isParticipantOperator as t, isNotOperator as u, isAndOperator as v, whereOperatorAsPredicate as w, isOrOperator as x, y, Fqn as z };
+export { DeploymentFqn as D, EdgeId as E, FqnRef as F, GroupElementKind as G, NodeId as N, RelationId as R, StepEdgeKind as S, ViewId as V, _stage as _, _type as a, isDeploymentNode as b, isDeployedInstance as c, isTagEqual as d, isKindEqual as e, isParticipantOperator as f, isNotOperator as g, isAndOperator as h, isOnStage as i, isOrOperator as j, flattenMarkdownOrString as k, Fqn as l, isGroupElementKind as m, GlobalFqn as n, isGlobalFqn as o, stepEdgeId as p, isStepEdgeId as q, extractStep as r, splitGlobalFqn as s, n as t, whereOperatorAsPredicate as w, y };

package/dist/shared/{core.BrCnZFTn.mjs → core.Btl47GOn.mjs}

@@ -1,5 +1,5 @@
-import { t } from './core.rmvsy0n3.mjs';
-import { i as invariant } from './core.Cy9smucx.mjs';
+import { t } from './core.BH9nN-_I.mjs';
+import { i as invariant } from './core.D4npX2q8.mjs';
 
 function imap(arg1, arg2) {
   const mapper = arg2 ?? arg1;
@@ -29,4 +29,4 @@ function toSet(iterable) {
   return (it) => new Set(it);
 }
 
-export { toArray as a, imap as i, toSet as t };
+export { toSet as a, imap as i, toArray as t };

package/dist/shared/core.ByrmCl9I.mjs

@@ -0,0 +1,5 @@
+import { u } from './core.DbRvwARP.mjs';
+
+function m(...a){return u(o,a,p)}var o=(a,e)=>a.map(e),p=a=>(e,t,r)=>({done:false,hasNext:true,next:a(e,t,r)});
+
+export { m };

package/dist/shared/core.C80Z37Eu.mjs

@@ -0,0 +1,29 @@
+import { i as isAncestor } from './core.C_C-3c1S.mjs';
+
+var Connection;
+((Connection2) => {
+  Connection2.isInside = (fqn) => {
+    return (connection) => isAncestor(fqn, connection.source.id) && isAncestor(fqn, connection.target.id);
+  };
+  Connection2.isDirectedBetween = (source, target) => {
+    return (connection) => (connection.source.id === source || isAncestor(source, connection.source.id)) && (connection.target.id === target || isAncestor(target, connection.target.id));
+  };
+  Connection2.isAnyBetween = (source, target) => {
+    const forward = (0, Connection2.isDirectedBetween)(source, target), backward = (0, Connection2.isDirectedBetween)(target, source);
+    return (connection) => forward(connection) || backward(connection);
+  };
+  Connection2.isIncoming = (target) => {
+    return (connection) => (connection.target.id === target || isAncestor(target, connection.target.id)) && !isAncestor(target, connection.source.id);
+  };
+  Connection2.isOutgoing = (source) => {
+    return (connection) => (connection.source.id === source || isAncestor(source, connection.source.id)) && !isAncestor(source, connection.target.id);
+  };
+  Connection2.isAnyInOut = (source) => {
+    const isIn = (0, Connection2.isIncoming)(source), isOut = (0, Connection2.isOutgoing)(source);
+    return (connection) => isIn(connection) || isOut(connection);
+  };
+})(Connection || (Connection = {}));
+
+const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+
+export { Connection as C, customInspectSymbol as c };

package/dist/shared/{core.Pf5I9o0e.d.mts → core.CF82MWyh.d.mts}

@@ -1,4 +1,4 @@
-import { F as Fqn } from './core.BuO4ncfY.mjs';
+import { F as Fqn } from './core.668kXpZq.mjs';
 
 declare function parentFqn<E extends string>(fqn: E): E | null;
 declare function nameFromFqn<E extends string>(fqn: E): string;

package/dist/shared/{core.rmvsy0n3.mjs → core.C_C-3c1S.mjs}

@@ -1,189 +1,13 @@
-import { t as t$1, i as invariant } from './core.Cy9smucx.mjs';
+import { t } from './core.zLlww-07.mjs';
 
 var e={done:true,hasNext:false},s={done:false,hasNext:false},a=()=>e;
 
 function C(t,...o){let n=t,u=o.map(e=>"lazy"in e?y(e):void 0),p=0;for(;p<o.length;){if(u[p]===void 0||!B(n)){let i=o[p];n=i(n),p+=1;continue}let r=[];for(let i=p;i<o.length;i++){let l=u[i];if(l===void 0||(r.push(l),l.isSingle))break}let a=[];for(let i of n)if(f(i,a,r))break;let{isSingle:s}=r.at(-1);n=s?a[0]:a,p+=r.length;}return n}function f(t,o,n){if(n.length===0)return o.push(t),false;let u=t,p=s,e=false;for(let[r,a]of n.entries()){let{index:s,items:i}=a;if(i.push(u),p=a(u,s,i),a.index+=1,p.hasNext){if(p.hasMany??false){for(let l of p.next)if(f(l,o,n.slice(r+1)))return  true;return e}u=p.next;}if(!p.hasNext)break;p.done&&(e=true);}return p.hasNext&&o.push(u),e}function y(t){let{lazy:o,lazyArgs:n}=t,u=o(...n);return Object.assign(u,{isSingle:o.single??false,index:0,items:[]})}function B(t){return typeof t=="string"||typeof t=="object"&&t!==null&&Symbol.iterator in t}
 
-function t(n){return typeof n=="function"}
-
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-/**
- * Mnemonist DefaultMap
- * =====================
- *
- * JavaScript implementation of a default map that will return a constructed
- * value any time one tries to access an inexisting key. It's quite similar
- * to python's defaultdict.
- */
-
-var defaultMap;
-var hasRequiredDefaultMap;
-
-function requireDefaultMap () {
-	if (hasRequiredDefaultMap) return defaultMap;
-	hasRequiredDefaultMap = 1;
-	/**
-	 * DefaultMap.
-	 *
-	 * @constructor
-	 */
-	function DefaultMap(factory) {
-	  if (typeof factory !== 'function')
-	    throw new Error('mnemonist/DefaultMap.constructor: expecting a function.');
-
-	  this.items = new Map();
-	  this.factory = factory;
-	  this.size = 0;
-	}
-
-	/**
-	 * Method used to clear the structure.
-	 *
-	 * @return {undefined}
-	 */
-	DefaultMap.prototype.clear = function() {
-
-	  // Properties
-	  this.items.clear();
-	  this.size = 0;
-	};
-
-	/**
-	 * Method used to get the value set for given key. If the key does not exist,
-	 * the value will be created using the provided factory.
-	 *
-	 * @param  {any} key - Target key.
-	 * @return {any}
-	 */
-	DefaultMap.prototype.get = function(key) {
-	  var value = this.items.get(key);
-
-	  if (typeof value === 'undefined') {
-	    value = this.factory(key, this.size);
-	    this.items.set(key, value);
-	    this.size++;
-	  }
-
-	  return value;
-	};
-
-	/**
-	 * Method used to get the value set for given key. If the key does not exist,
-	 * a value won't be created.
-	 *
-	 * @param  {any} key - Target key.
-	 * @return {any}
-	 */
-	DefaultMap.prototype.peek = function(key) {
-	  return this.items.get(key);
-	};
-
-	/**
-	 * Method used to set a value for given key.
-	 *
-	 * @param  {any} key   - Target key.
-	 * @param  {any} value - Value.
-	 * @return {DefaultMap}
-	 */
-	DefaultMap.prototype.set = function(key, value) {
-	  this.items.set(key, value);
-	  this.size = this.items.size;
-
-	  return this;
-	};
-
-	/**
-	 * Method used to test the existence of a key in the map.
-	 *
-	 * @param  {any} key   - Target key.
-	 * @return {boolean}
-	 */
-	DefaultMap.prototype.has = function(key) {
-	  return this.items.has(key);
-	};
-
-	/**
-	 * Method used to delete target key.
-	 *
-	 * @param  {any} key   - Target key.
-	 * @return {boolean}
-	 */
-	DefaultMap.prototype.delete = function(key) {
-	  var deleted = this.items.delete(key);
-
-	  this.size = this.items.size;
-
-	  return deleted;
-	};
-
-	/**
-	 * Method used to iterate over each of the key/value pairs.
-	 *
-	 * @param  {function}  callback - Function to call for each item.
-	 * @param  {object}    scope    - Optional scope.
-	 * @return {undefined}
-	 */
-	DefaultMap.prototype.forEach = function(callback, scope) {
-	  scope = arguments.length > 1 ? scope : this;
-
-	  this.items.forEach(callback, scope);
-	};
-
-	/**
-	 * Iterators.
-	 */
-	DefaultMap.prototype.entries = function() {
-	  return this.items.entries();
-	};
-
-	DefaultMap.prototype.keys = function() {
-	  return this.items.keys();
-	};
-
-	DefaultMap.prototype.values = function() {
-	  return this.items.values();
-	};
-
-	/**
-	 * Attaching the #.entries method to Symbol.iterator if possible.
-	 */
-	if (typeof Symbol !== 'undefined')
-	  DefaultMap.prototype[Symbol.iterator] = DefaultMap.prototype.entries;
-
-	/**
-	 * Convenience known methods.
-	 */
-	DefaultMap.prototype.inspect = function() {
-	  return this.items;
-	};
-
-	if (typeof Symbol !== 'undefined')
-	  DefaultMap.prototype[Symbol.for('nodejs.util.inspect.custom')] = DefaultMap.prototype.inspect;
-
-	/**
-	 * Typical factories.
-	 */
-	DefaultMap.autoIncrement = function() {
-	  var i = 0;
-
-	  return function() {
-	    return i++;
-	  };
-	};
-
-	/**
-	 * Exporting.
-	 */
-	defaultMap = DefaultMap;
-	return defaultMap;
-}
-
-var defaultMapExports = /*@__PURE__*/ requireDefaultMap();
-const DefaultMap = /*@__PURE__*/getDefaultExportFromCjs(defaultMapExports);
-
 var naturalCompareLite = {exports: {}};
 
 var hasRequiredNaturalCompareLite;
@@ -253,13 +77,13 @@ const compare = /*@__PURE__*/getDefaultExportFromCjs(naturalCompareLiteExports);
 
 function compareNatural(a, b) {
   if (a === b) return 0;
-  if (t$1(a)) {
-    if (t$1(b)) {
+  if (t(a)) {
+    if (t(b)) {
       return compare(a, b);
     }
     return 1;
   }
-  return t$1(b) ? -1 : 0;
+  return t(b) ? -1 : 0;
 }
 function compareNaturalHierarchically(separator = ".") {
   return (a, b) => {
@@ -448,21 +272,4 @@ function sortNaturalByFqn(array, sort) {
   }).map(({ item }) => item);
 }
 
-function ifilter(arg1, arg2) {
-  const pred = arg2 ?? arg1;
-  invariant(t(pred));
-  function* _filter(iter) {
-    for (const value of iter) {
-      if (pred(value)) {
-        yield value;
-      }
-    }
-    return;
-  }
-  if (!arg2) {
-    return _filter;
-  }
-  return _filter(arg1);
-}
-
-export { C, DefaultMap as D, isAncestor as a, ifilter as b, isNonEmptyArray as c, isSameHierarchy as d, a as e, s as f, getDefaultExportFromCjs as g, compareByFqnHierarchically as h, isDescendantOf as i, sortByFqnHierarchically as j, commonAncestor as k, ancestorsFqn as l, compareNatural as m, nameFromFqn as n, compareNaturalHierarchically as o, parentFqn as p, compareFqnHierarchically as q, hierarchyDistance as r, sortParentsFirst as s, t, hierarchyLevel as u, sortNaturalByFqn as v, isString as w };
+export { C, compareNaturalHierarchically as a, ancestorsFqn as b, compareNatural as c, commonAncestor as d, compareByFqnHierarchically as e, compareFqnHierarchically as f, hierarchyLevel as g, hierarchyDistance as h, isAncestor as i, isDescendantOf as j, isSameHierarchy as k, sortNaturalByFqn as l, sortParentsFirst as m, nameFromFqn as n, isNonEmptyArray as o, parentFqn as p, isString as q, getDefaultExportFromCjs as r, sortByFqnHierarchically as s, s as t, a as u };