Aktueller Stand

backend/node_modules/effect/dist/esm/internal/hashMap/array.js

@@ -0,0 +1,48 @@
+/** @internal */
+export function arrayUpdate(mutate, at, v, arr) {
+  let out = arr;
+  if (!mutate) {
+    const len = arr.length;
+    out = new Array(len);
+    for (let i = 0; i < len; ++i) out[i] = arr[i];
+  }
+  out[at] = v;
+  return out;
+}
+/** @internal */
+export function arraySpliceOut(mutate, at, arr) {
+  const newLen = arr.length - 1;
+  let i = 0;
+  let g = 0;
+  let out = arr;
+  if (mutate) {
+    i = g = at;
+  } else {
+    out = new Array(newLen);
+    while (i < at) out[g++] = arr[i++];
+  }
+  ++i;
+  while (i <= newLen) out[g++] = arr[i++];
+  if (mutate) {
+    out.length = newLen;
+  }
+  return out;
+}
+/** @internal */
+export function arraySpliceIn(mutate, at, v, arr) {
+  const len = arr.length;
+  if (mutate) {
+    let i = len;
+    while (i >= at) arr[i--] = arr[i];
+    arr[at] = v;
+    return arr;
+  }
+  let i = 0,
+    g = 0;
+  const out = new Array(len + 1);
+  while (i < at) out[g++] = arr[i++];
+  out[at] = v;
+  while (i < len) out[++g] = arr[i++];
+  return out;
+}
+//# sourceMappingURL=array.js.map

backend/node_modules/effect/dist/esm/internal/hashMap/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","names":["arrayUpdate","mutate","at","v","arr","out","len","length","Array","i","arraySpliceOut","newLen","g","arraySpliceIn"],"sources":["../../../../src/internal/hashMap/array.ts"],"sourcesContent":[null],"mappings":"AAAA;AACA,OAAM,SAAUA,WAAWA,CAAIC,MAAe,EAAEC,EAAU,EAAEC,CAAI,EAAEC,GAAa;EAC7E,IAAIC,GAAG,GAAGD,GAAG;EACb,IAAI,CAACH,MAAM,EAAE;IACX,MAAMK,GAAG,GAAGF,GAAG,CAACG,MAAM;IACtBF,GAAG,GAAG,IAAIG,KAAK,CAACF,GAAG,CAAC;IACpB,KAAK,IAAIG,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,GAAG,EAAE,EAAEG,CAAC,EAAEJ,GAAG,CAACI,CAAC,CAAC,GAAGL,GAAG,CAACK,CAAC,CAAE;EAChD;EACAJ,GAAG,CAACH,EAAE,CAAC,GAAGC,CAAC;EACX,OAAOE,GAAG;AACZ;AAEA;AACA,OAAM,SAAUK,cAAcA,CAAIT,MAAe,EAAEC,EAAU,EAAEE,GAAa;EAC1E,MAAMO,MAAM,GAAGP,GAAG,CAACG,MAAM,GAAG,CAAC;EAC7B,IAAIE,CAAC,GAAG,CAAC;EACT,IAAIG,CAAC,GAAG,CAAC;EACT,IAAIP,GAAG,GAAGD,GAAG;EACb,IAAIH,MAAM,EAAE;IACVQ,CAAC,GAAGG,CAAC,GAAGV,EAAE;EACZ,CAAC,MAAM;IACLG,GAAG,GAAG,IAAIG,KAAK,CAACG,MAAM,CAAC;IACvB,OAAOF,CAAC,GAAGP,EAAE,EAAEG,GAAG,CAACO,CAAC,EAAE,CAAC,GAAGR,GAAG,CAACK,CAAC,EAAE,CAAE;EACrC;EACA,EAAEA,CAAC;EACH,OAAOA,CAAC,IAAIE,MAAM,EAAEN,GAAG,CAACO,CAAC,EAAE,CAAC,GAAGR,GAAG,CAACK,CAAC,EAAE,CAAE;EACxC,IAAIR,MAAM,EAAE;IACVI,GAAG,CAACE,MAAM,GAAGI,MAAM;EACrB;EACA,OAAON,GAAG;AACZ;AAEA;AACA,OAAM,SAAUQ,aAAaA,CAAIZ,MAAe,EAAEC,EAAU,EAAEC,CAAI,EAAEC,GAAa;EAC/E,MAAME,GAAG,GAAGF,GAAG,CAACG,MAAM;EACtB,IAAIN,MAAM,EAAE;IACV,IAAIQ,CAAC,GAAGH,GAAG;IACX,OAAOG,CAAC,IAAIP,EAAE,EAAEE,GAAG,CAACK,CAAC,EAAE,CAAC,GAAGL,GAAG,CAACK,CAAC,CAAE;IAClCL,GAAG,CAACF,EAAE,CAAC,GAAGC,CAAC;IACX,OAAOC,GAAG;EACZ;EACA,IAAIK,CAAC,GAAG,CAAC;IACPG,CAAC,GAAG,CAAC;EACP,MAAMP,GAAG,GAAG,IAAIG,KAAK,CAAIF,GAAG,GAAG,CAAC,CAAC;EACjC,OAAOG,CAAC,GAAGP,EAAE,EAAEG,GAAG,CAACO,CAAC,EAAE,CAAC,GAAGR,GAAG,CAACK,CAAC,EAAE,CAAE;EACnCJ,GAAG,CAACH,EAAE,CAAC,GAAGC,CAAC;EACX,OAAOM,CAAC,GAAGH,GAAG,EAAED,GAAG,CAAC,EAAEO,CAAC,CAAC,GAAGR,GAAG,CAACK,CAAC,EAAE,CAAE;EACpC,OAAOJ,GAAG;AACZ","ignoreList":[]}

backend/node_modules/effect/dist/esm/internal/hashMap/bitwise.js

@@ -0,0 +1,29 @@
+import { MASK } from "./config.js";
+/**
+ * Hamming weight.
+ *
+ * Taken from: http://jsperf.com/hamming-weight
+ *
+ * @internal
+ */
+export function popcount(x) {
+  x -= x >> 1 & 0x55555555;
+  x = (x & 0x33333333) + (x >> 2 & 0x33333333);
+  x = x + (x >> 4) & 0x0f0f0f0f;
+  x += x >> 8;
+  x += x >> 16;
+  return x & 0x7f;
+}
+/** @internal */
+export function hashFragment(shift, h) {
+  return h >>> shift & MASK;
+}
+/** @internal */
+export function toBitmap(x) {
+  return 1 << x;
+}
+/** @internal */
+export function fromBitmap(bitmap, bit) {
+  return popcount(bitmap & bit - 1);
+}
+//# sourceMappingURL=bitwise.js.map

backend/node_modules/effect/dist/esm/internal/hashMap/bitwise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitwise.js","names":["MASK","popcount","x","hashFragment","shift","h","toBitmap","fromBitmap","bitmap","bit"],"sources":["../../../../src/internal/hashMap/bitwise.ts"],"sourcesContent":[null],"mappings":"AAAA,SAASA,IAAI,QAAQ,aAAa;AAElC;;;;;;;AAOA,OAAM,SAAUC,QAAQA,CAACC,CAAS;EAChCA,CAAC,IAAKA,CAAC,IAAI,CAAC,GAAI,UAAU;EAC1BA,CAAC,GAAG,CAACA,CAAC,GAAG,UAAU,KAAMA,CAAC,IAAI,CAAC,GAAI,UAAU,CAAC;EAC9CA,CAAC,GAAIA,CAAC,IAAIA,CAAC,IAAI,CAAC,CAAC,GAAI,UAAU;EAC/BA,CAAC,IAAIA,CAAC,IAAI,CAAC;EACXA,CAAC,IAAIA,CAAC,IAAI,EAAE;EACZ,OAAOA,CAAC,GAAG,IAAI;AACjB;AAEA;AACA,OAAM,SAAUC,YAAYA,CAACC,KAAa,EAAEC,CAAS;EACnD,OAAQA,CAAC,KAAKD,KAAK,GAAIJ,IAAI;AAC7B;AAEA;AACA,OAAM,SAAUM,QAAQA,CAACJ,CAAS;EAChC,OAAO,CAAC,IAAIA,CAAC;AACf;AAEA;AACA,OAAM,SAAUK,UAAUA,CAACC,MAAc,EAAEC,GAAW;EACpD,OAAOR,QAAQ,CAACO,MAAM,GAAIC,GAAG,GAAG,CAAE,CAAC;AACrC","ignoreList":[]}

backend/node_modules/effect/dist/esm/internal/hashMap/config.js

@@ -0,0 +1,11 @@
+/** @internal */
+export const SIZE = 5;
+/** @internal */
+export const BUCKET_SIZE = /*#__PURE__*/Math.pow(2, SIZE);
+/** @internal */
+export const MASK = BUCKET_SIZE - 1;
+/** @internal */
+export const MAX_INDEX_NODE = BUCKET_SIZE / 2;
+/** @internal */
+export const MIN_ARRAY_NODE = BUCKET_SIZE / 4;
+//# sourceMappingURL=config.js.map

backend/node_modules/effect/dist/esm/internal/hashMap/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":["SIZE","BUCKET_SIZE","Math","pow","MASK","MAX_INDEX_NODE","MIN_ARRAY_NODE"],"sources":["../../../../src/internal/hashMap/config.ts"],"sourcesContent":[null],"mappings":"AAAA;AACA,OAAO,MAAMA,IAAI,GAAG,CAAC;AAErB;AACA,OAAO,MAAMC,WAAW,gBAAGC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEH,IAAI,CAAC;AAE5C;AACA,OAAO,MAAMI,IAAI,GAAGH,WAAW,GAAG,CAAC;AAEnC;AACA,OAAO,MAAMI,cAAc,GAAGJ,WAAW,GAAG,CAAC;AAE7C;AACA,OAAO,MAAMK,cAAc,GAAGL,WAAW,GAAG,CAAC","ignoreList":[]}

backend/node_modules/effect/dist/esm/internal/hashMap/keySet.js

@@ -0,0 +1,6 @@
+import { makeImpl } from "../hashSet.js";
+/** @internal */
+export function keySet(self) {
+  return makeImpl(self);
+}
+//# sourceMappingURL=keySet.js.map

backend/node_modules/effect/dist/esm/internal/hashMap/keySet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keySet.js","names":["makeImpl","keySet","self"],"sources":["../../../../src/internal/hashMap/keySet.ts"],"sourcesContent":[null],"mappings":"AAEA,SAASA,QAAQ,QAAQ,eAAe;AAExC;AACA,OAAM,SAAUC,MAAMA,CAAOC,IAAmB;EAC9C,OAAOF,QAAQ,CAACE,IAAI,CAAC;AACvB","ignoreList":[]}

backend/node_modules/effect/dist/esm/internal/hashMap/node.js

@@ -0,0 +1,253 @@
+import { equals } from "../../Equal.js";
+import * as O from "../../Option.js";
+import { isTagged } from "../../Predicate.js";
+import * as Stack from "../stack.js";
+import { arraySpliceIn, arraySpliceOut, arrayUpdate } from "./array.js";
+import { fromBitmap, hashFragment, toBitmap } from "./bitwise.js";
+import { MAX_INDEX_NODE, MIN_ARRAY_NODE, SIZE } from "./config.js";
+/** @internal */
+export class EmptyNode {
+  _tag = "EmptyNode";
+  modify(edit, _shift, f, hash, key, size) {
+    const v = f(O.none());
+    if (O.isNone(v)) return new EmptyNode();
+    ++size.value;
+    return new LeafNode(edit, hash, key, v);
+  }
+}
+/** @internal */
+export function isEmptyNode(a) {
+  return isTagged(a, "EmptyNode");
+}
+/** @internal */
+export function isLeafNode(node) {
+  return isEmptyNode(node) || node._tag === "LeafNode" || node._tag === "CollisionNode";
+}
+/** @internal */
+export function canEditNode(node, edit) {
+  return isEmptyNode(node) ? false : edit === node.edit;
+}
+/** @internal */
+export class LeafNode {
+  edit;
+  hash;
+  key;
+  value;
+  _tag = "LeafNode";
+  constructor(edit, hash, key, value) {
+    this.edit = edit;
+    this.hash = hash;
+    this.key = key;
+    this.value = value;
+  }
+  modify(edit, shift, f, hash, key, size) {
+    if (equals(key, this.key)) {
+      const v = f(this.value);
+      if (v === this.value) return this;else if (O.isNone(v)) {
+        --size.value;
+        return new EmptyNode();
+      }
+      if (canEditNode(this, edit)) {
+        this.value = v;
+        return this;
+      }
+      return new LeafNode(edit, hash, key, v);
+    }
+    const v = f(O.none());
+    if (O.isNone(v)) return this;
+    ++size.value;
+    return mergeLeaves(edit, shift, this.hash, this, hash, new LeafNode(edit, hash, key, v));
+  }
+}
+/** @internal */
+export class CollisionNode {
+  edit;
+  hash;
+  children;
+  _tag = "CollisionNode";
+  constructor(edit, hash, children) {
+    this.edit = edit;
+    this.hash = hash;
+    this.children = children;
+  }
+  modify(edit, shift, f, hash, key, size) {
+    if (hash === this.hash) {
+      const canEdit = canEditNode(this, edit);
+      const list = this.updateCollisionList(canEdit, edit, this.hash, this.children, f, key, size);
+      if (list === this.children) return this;
+      return list.length > 1 ? new CollisionNode(edit, this.hash, list) : list[0]; // collapse single element collision list
+    }
+    const v = f(O.none());
+    if (O.isNone(v)) return this;
+    ++size.value;
+    return mergeLeaves(edit, shift, this.hash, this, hash, new LeafNode(edit, hash, key, v));
+  }
+  updateCollisionList(mutate, edit, hash, list, f, key, size) {
+    const len = list.length;
+    for (let i = 0; i < len; ++i) {
+      const child = list[i];
+      if ("key" in child && equals(key, child.key)) {
+        const value = child.value;
+        const newValue = f(value);
+        if (newValue === value) return list;
+        if (O.isNone(newValue)) {
+          --size.value;
+          return arraySpliceOut(mutate, i, list);
+        }
+        return arrayUpdate(mutate, i, new LeafNode(edit, hash, key, newValue), list);
+      }
+    }
+    const newValue = f(O.none());
+    if (O.isNone(newValue)) return list;
+    ++size.value;
+    return arrayUpdate(mutate, len, new LeafNode(edit, hash, key, newValue), list);
+  }
+}
+/** @internal */
+export class IndexedNode {
+  edit;
+  mask;
+  children;
+  _tag = "IndexedNode";
+  constructor(edit, mask, children) {
+    this.edit = edit;
+    this.mask = mask;
+    this.children = children;
+  }
+  modify(edit, shift, f, hash, key, size) {
+    const mask = this.mask;
+    const children = this.children;
+    const frag = hashFragment(shift, hash);
+    const bit = toBitmap(frag);
+    const indx = fromBitmap(mask, bit);
+    const exists = mask & bit;
+    const canEdit = canEditNode(this, edit);
+    if (!exists) {
+      const _newChild = new EmptyNode().modify(edit, shift + SIZE, f, hash, key, size);
+      if (!_newChild) return this;
+      return children.length >= MAX_INDEX_NODE ? expand(edit, frag, _newChild, mask, children) : new IndexedNode(edit, mask | bit, arraySpliceIn(canEdit, indx, _newChild, children));
+    }
+    const current = children[indx];
+    const child = current.modify(edit, shift + SIZE, f, hash, key, size);
+    if (current === child) return this;
+    let bitmap = mask;
+    let newChildren;
+    if (isEmptyNode(child)) {
+      // remove
+      bitmap &= ~bit;
+      if (!bitmap) return new EmptyNode();
+      if (children.length <= 2 && isLeafNode(children[indx ^ 1])) {
+        return children[indx ^ 1]; // collapse
+      }
+      newChildren = arraySpliceOut(canEdit, indx, children);
+    } else {
+      // modify
+      newChildren = arrayUpdate(canEdit, indx, child, children);
+    }
+    if (canEdit) {
+      this.mask = bitmap;
+      this.children = newChildren;
+      return this;
+    }
+    return new IndexedNode(edit, bitmap, newChildren);
+  }
+}
+/** @internal */
+export class ArrayNode {
+  edit;
+  size;
+  children;
+  _tag = "ArrayNode";
+  constructor(edit, size, children) {
+    this.edit = edit;
+    this.size = size;
+    this.children = children;
+  }
+  modify(edit, shift, f, hash, key, size) {
+    let count = this.size;
+    const children = this.children;
+    const frag = hashFragment(shift, hash);
+    const child = children[frag];
+    const newChild = (child || new EmptyNode()).modify(edit, shift + SIZE, f, hash, key, size);
+    if (child === newChild) return this;
+    const canEdit = canEditNode(this, edit);
+    let newChildren;
+    if (isEmptyNode(child) && !isEmptyNode(newChild)) {
+      // add
+      ++count;
+      newChildren = arrayUpdate(canEdit, frag, newChild, children);
+    } else if (!isEmptyNode(child) && isEmptyNode(newChild)) {
+      // remove
+      --count;
+      if (count <= MIN_ARRAY_NODE) {
+        return pack(edit, count, frag, children);
+      }
+      newChildren = arrayUpdate(canEdit, frag, new EmptyNode(), children);
+    } else {
+      // modify
+      newChildren = arrayUpdate(canEdit, frag, newChild, children);
+    }
+    if (canEdit) {
+      this.size = count;
+      this.children = newChildren;
+      return this;
+    }
+    return new ArrayNode(edit, count, newChildren);
+  }
+}
+function pack(edit, count, removed, elements) {
+  const children = new Array(count - 1);
+  let g = 0;
+  let bitmap = 0;
+  for (let i = 0, len = elements.length; i < len; ++i) {
+    if (i !== removed) {
+      const elem = elements[i];
+      if (elem && !isEmptyNode(elem)) {
+        children[g++] = elem;
+        bitmap |= 1 << i;
+      }
+    }
+  }
+  return new IndexedNode(edit, bitmap, children);
+}
+function expand(edit, frag, child, bitmap, subNodes) {
+  const arr = [];
+  let bit = bitmap;
+  let count = 0;
+  for (let i = 0; bit; ++i) {
+    if (bit & 1) arr[i] = subNodes[count++];
+    bit >>>= 1;
+  }
+  arr[frag] = child;
+  return new ArrayNode(edit, count + 1, arr);
+}
+function mergeLeavesInner(edit, shift, h1, n1, h2, n2) {
+  if (h1 === h2) return new CollisionNode(edit, h1, [n2, n1]);
+  const subH1 = hashFragment(shift, h1);
+  const subH2 = hashFragment(shift, h2);
+  if (subH1 === subH2) {
+    return child => new IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), [child]);
+  } else {
+    const children = subH1 < subH2 ? [n1, n2] : [n2, n1];
+    return new IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), children);
+  }
+}
+function mergeLeaves(edit, shift, h1, n1, h2, n2) {
+  let stack = undefined;
+  let currentShift = shift;
+  while (true) {
+    const res = mergeLeavesInner(edit, currentShift, h1, n1, h2, n2);
+    if (typeof res === "function") {
+      stack = Stack.make(res, stack);
+      currentShift = currentShift + SIZE;
+    } else {
+      let final = res;
+      while (stack != null) {
+        final = stack.value(final);
+        stack = stack.previous;
+      }
+      return final;
+    }
+  }
+}
+//# sourceMappingURL=node.js.map