@likec4/core 1.30.0 → 1.32.0

package/dist/shared/core.DoK86JEe.mjs

@@ -0,0 +1,518 @@
+import { u } from './core.DbRvwARP.mjs';
+import { t } from './core.rmvsy0n3.mjs';
+import { i as invariant } from './core.Cy9smucx.mjs';
+
+function i(...e){return u(n,e)}var n=(e,r)=>e.length>=r;
+
+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)});
+
+var set = {};
+
+/**
+ * Mnemonist Set
+ * ==============
+ *
+ * Useful function related to sets such as union, intersection and so on...
+ */
+
+var hasRequiredSet;
+
+function requireSet () {
+	if (hasRequiredSet) return set;
+	hasRequiredSet = 1;
+	(function (exports) {
+		// TODO: optimize versions for less variadicities
+
+		/**
+		 * Variadic function computing the intersection of multiple sets.
+		 *
+		 * @param  {...Set} sets - Sets to intersect.
+		 * @return {Set}         - The intesection.
+		 */
+		exports.intersection = function() {
+		  if (arguments.length < 2)
+		    throw new Error('mnemonist/Set.intersection: needs at least two arguments.');
+
+		  var I = new Set();
+
+		  // First we need to find the smallest set
+		  var smallestSize = Infinity,
+		      smallestSet = null;
+
+		  var s, i, l = arguments.length;
+
+		  for (i = 0; i < l; i++) {
+		    s = arguments[i];
+
+		    // If one of the set has no items, we can stop right there
+		    if (s.size === 0)
+		      return I;
+
+		    if (s.size < smallestSize) {
+		      smallestSize = s.size;
+		      smallestSet = s;
+		    }
+		  }
+
+		  // Now we need to intersect this set with the others
+		  var iterator = smallestSet.values(),
+		      step,
+		      item,
+		      add,
+		      set;
+
+		  // TODO: we can optimize by iterating each next time over the current intersection
+		  // but this probably means more RAM to consume since we'll create n-1 sets rather than
+		  // only the one.
+		  while ((step = iterator.next(), !step.done)) {
+		    item = step.value;
+		    add = true;
+
+		    for (i = 0; i < l; i++) {
+		      set = arguments[i];
+
+		      if (set === smallestSet)
+		        continue;
+
+		      if (!set.has(item)) {
+		        add = false;
+		        break;
+		      }
+		    }
+
+		    if (add)
+		      I.add(item);
+		  }
+
+		  return I;
+		};
+
+		/**
+		 * Variadic function computing the union of multiple sets.
+		 *
+		 * @param  {...Set} sets - Sets to unite.
+		 * @return {Set}         - The union.
+		 */
+		exports.union = function() {
+		  if (arguments.length < 2)
+		    throw new Error('mnemonist/Set.union: needs at least two arguments.');
+
+		  var U = new Set();
+
+		  var i, l = arguments.length;
+
+		  var iterator,
+		      step;
+
+		  for (i = 0; i < l; i++) {
+		    iterator = arguments[i].values();
+
+		    while ((step = iterator.next(), !step.done))
+		      U.add(step.value);
+		  }
+
+		  return U;
+		};
+
+		/**
+		 * Function computing the difference between two sets.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {Set}   - The difference.
+		 */
+		exports.difference = function(A, B) {
+
+		  // If first set is empty
+		  if (!A.size)
+		    return new Set();
+
+		  if (!B.size)
+		    return new Set(A);
+
+		  var D = new Set();
+
+		  var iterator = A.values(),
+		      step;
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (!B.has(step.value))
+		      D.add(step.value);
+		  }
+
+		  return D;
+		};
+
+		/**
+		 * Function computing the symmetric difference between two sets.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {Set}   - The symmetric difference.
+		 */
+		exports.symmetricDifference = function(A, B) {
+		  var S = new Set();
+
+		  var iterator = A.values(),
+		      step;
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (!B.has(step.value))
+		      S.add(step.value);
+		  }
+
+		  iterator = B.values();
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (!A.has(step.value))
+		      S.add(step.value);
+		  }
+
+		  return S;
+		};
+
+		/**
+		 * Function returning whether A is a subset of B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {boolean}
+		 */
+		exports.isSubset = function(A, B) {
+		  var iterator = A.values(),
+		      step;
+
+		  // Shortcuts
+		  if (A === B)
+		    return true;
+
+		  if (A.size > B.size)
+		    return false;
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (!B.has(step.value))
+		      return false;
+		  }
+
+		  return true;
+		};
+
+		/**
+		 * Function returning whether A is a superset of B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {boolean}
+		 */
+		exports.isSuperset = function(A, B) {
+		  return exports.isSubset(B, A);
+		};
+
+		/**
+		 * Function adding the items of set B to the set A.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 */
+		exports.add = function(A, B) {
+		  var iterator = B.values(),
+		      step;
+
+		  while ((step = iterator.next(), !step.done))
+		    A.add(step.value);
+
+		  return;
+		};
+
+		/**
+		 * Function subtracting the items of set B from the set A.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 */
+		exports.subtract = function(A, B) {
+		  var iterator = B.values(),
+		      step;
+
+		  while ((step = iterator.next(), !step.done))
+		    A.delete(step.value);
+
+		  return;
+		};
+
+		/**
+		 * Function intersecting the items of A & B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 */
+		exports.intersect = function(A, B) {
+		  var iterator = A.values(),
+		      step;
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (!B.has(step.value))
+		      A.delete(step.value);
+		  }
+
+		  return;
+		};
+
+		/**
+		 * Function disjuncting the items of A & B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 */
+		exports.disjunct = function(A, B) {
+		  var iterator = A.values(),
+		      step;
+
+		  var toRemove = [];
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (B.has(step.value))
+		      toRemove.push(step.value);
+		  }
+
+		  iterator = B.values();
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (!A.has(step.value))
+		      A.add(step.value);
+		  }
+
+		  for (var i = 0, l = toRemove.length; i < l; i++)
+		    A.delete(toRemove[i]);
+
+		  return;
+		};
+
+		/**
+		 * Function returning the size of the intersection of A & B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {number}
+		 */
+		exports.intersectionSize = function(A, B) {
+		  var tmp;
+
+		  // We need to know the smallest set
+		  if (A.size > B.size) {
+		    tmp = A;
+		    A = B;
+		    B = tmp;
+		  }
+
+		  if (A.size === 0)
+		    return 0;
+
+		  if (A === B)
+		    return A.size;
+
+		  var iterator = A.values(),
+		      step;
+
+		  var I = 0;
+
+		  while ((step = iterator.next(), !step.done)) {
+		    if (B.has(step.value))
+		      I++;
+		  }
+
+		  return I;
+		};
+
+		/**
+		 * Function returning the size of the union of A & B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {number}
+		 */
+		exports.unionSize = function(A, B) {
+		  var I = exports.intersectionSize(A, B);
+
+		  return A.size + B.size - I;
+		};
+
+		/**
+		 * Function returning the Jaccard similarity between A & B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {number}
+		 */
+		exports.jaccard = function(A, B) {
+		  var I = exports.intersectionSize(A, B);
+
+		  if (I === 0)
+		    return 0;
+
+		  var U = A.size + B.size - I;
+
+		  return I / U;
+		};
+
+		/**
+		 * Function returning the overlap coefficient between A & B.
+		 *
+		 * @param  {Set} A - First set.
+		 * @param  {Set} B - Second set.
+		 * @return {number}
+		 */
+		exports.overlap = function(A, B) {
+		  var I = exports.intersectionSize(A, B);
+
+		  if (I === 0)
+		    return 0;
+
+		  return I / Math.min(A.size, B.size);
+		}; 
+	} (set));
+	return set;
+}
+
+var setExports = /*@__PURE__*/ requireSet();
+
+function getOrCreate(map, key, create) {
+  let entry = map.get(key);
+  if (!entry) {
+    entry = create(key);
+    map.set(key, entry);
+  }
+  return entry;
+}
+
+function ifind(arg1, arg2) {
+  const pred = arg2 ?? arg1;
+  invariant(t(pred));
+  function _find(iter) {
+    for (const value of iter) {
+      if (pred(value)) {
+        return value;
+      }
+    }
+    return;
+  }
+  if (!arg2) {
+    return _find;
+  }
+  return _find(arg1);
+}
+
+function ihead(iterable) {
+  if (!iterable) {
+    return _head;
+  }
+  return _head(iterable);
+}
+function _head(iter) {
+  for (const value of iter) {
+    return value;
+  }
+  return;
+}
+
+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);
+}
+
+function memoizeProp(obj, tag, fn) {
+  const tagSymbol = typeof tag === "symbol" ? tag : Symbol.for(tag);
+  if (!obj.hasOwnProperty(tagSymbol)) {
+    Object.defineProperty(obj, tagSymbol, {
+      enumerable: false,
+      writable: false,
+      value: fn()
+    });
+  }
+  return obj[tagSymbol];
+}
+
+function union(...sets) {
+  let result = /* @__PURE__ */ new Set();
+  for (const set of sets) {
+    for (const value of set) {
+      result.add(value);
+    }
+  }
+  return result;
+}
+function intersection(first, ...sets) {
+  let result = /* @__PURE__ */ new Set();
+  if (first.size === 0) {
+    return result;
+  }
+  let other = i(sets, 2) ? setExports.intersection(...sets) : sets[0];
+  if (other.size === 0) {
+    return result;
+  }
+  for (const value of first) {
+    if (other.has(value)) {
+      result.add(value);
+    }
+  }
+  return result;
+}
+function difference(a, b) {
+  if (a.size === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  if (b.size === 0) {
+    return new Set(a);
+  }
+  let result = /* @__PURE__ */ new Set();
+  for (const value of a) {
+    if (!b.has(value)) {
+      result.add(value);
+    }
+  }
+  return result;
+}
+function equals(a, b) {
+  return a.size === b.size && [...a].every((value) => b.has(value));
+}
+function symmetricDifference(a, b) {
+  return setExports.symmetricDifference(a, b);
+}
+function hasIntersection(a, b) {
+  if (a.size === 0 || b.size === 0) {
+    return false;
+  }
+  if (b.size < a.size) {
+    [a, b] = [b, a];
+  }
+  for (const value of a) {
+    if (b.has(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function stringHash(str) {
+  let hash = 5381;
+  const len = str.length;
+  invariant(len > 0, "stringHash: empty string");
+  for (let i = 0; i < len; i++) {
+    hash = hash * 33 ^ str.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(36);
+}
+
+export { intersection as a, isome as b, ifind as c, difference as d, ihead as e, memoizeProp as f, getOrCreate as g, hasIntersection as h, i, equals as j, stringHash as k, m, symmetricDifference as s, union as u };