effect 2.0.0-next.38 → 2.0.0-next.39

package/internal/Either.esm.js

@@ -0,0 +1,95 @@
+import { symbol, equals } from '../Equal/dist/effect-Equal.esm.js';
+import { dual } from '../Function/dist/effect-Function.esm.js';
+import { symbol as symbol$1, combine, hash } from '../Hash/dist/effect-Hash.esm.js';
+import { toJSON, NodeInspectSymbol, toString } from '../Inspectable/dist/effect-Inspectable.esm.js';
+import { none, some, isNone } from './Option.esm.js';
+import { EffectProto } from './Effectable.esm.js';
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @internal
+ */
+const TypeId = /*#__PURE__*/Symbol.for("effect/Either");
+const CommonProto = {
+  ...EffectProto,
+  [TypeId]: {
+    _A: _ => _
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  toString() {
+    return toString(this.toJSON());
+  }
+};
+const RightProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(CommonProto), {
+  _tag: "Right",
+  _op: "Right",
+  [symbol](that) {
+    return isEither(that) && isRight(that) && equals(that.right, this.right);
+  },
+  [symbol$1]() {
+    return combine(hash(this._tag))(hash(this.right));
+  },
+  toJSON() {
+    return {
+      _id: "Either",
+      _tag: this._tag,
+      right: toJSON(this.right)
+    };
+  }
+});
+const LeftProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(CommonProto), {
+  _tag: "Left",
+  _op: "Left",
+  [symbol](that) {
+    return isEither(that) && isLeft(that) && equals(that.left, this.left);
+  },
+  [symbol$1]() {
+    return combine(hash(this._tag))(hash(this.left));
+  },
+  toJSON() {
+    return {
+      _id: "Either",
+      _tag: this._tag,
+      left: toJSON(this.left)
+    };
+  }
+});
+
+/** @internal */
+const isEither = input => typeof input === "object" && input != null && TypeId in input;
+
+/** @internal */
+const isLeft = ma => ma._tag === "Left";
+
+/** @internal */
+const isRight = ma => ma._tag === "Right";
+
+/** @internal */
+const left = left => {
+  const a = Object.create(LeftProto);
+  a.left = left;
+  return a;
+};
+
+/** @internal */
+const right = right => {
+  const a = Object.create(RightProto);
+  a.right = right;
+  return a;
+};
+
+/** @internal */
+const getLeft = self => isRight(self) ? none : some(self.left);
+
+/** @internal */
+const getRight = self => isLeft(self) ? none : some(self.right);
+
+/** @internal */
+const fromOption = /*#__PURE__*/dual(2, (self, onNone) => isNone(self) ? left(onNone()) : right(self.value));
+
+export { TypeId, fromOption, getLeft, getRight, isEither, isLeft, isRight, left, right };

package/internal/Encoding/Base64.esm.js

@@ -0,0 +1,74 @@
+import { left, right } from '../../Either/dist/effect-Either.esm.js';
+import { DecodeException } from './Common.esm.js';
+
+/** @internal */
+const encode = bytes => {
+  const length = bytes.length;
+  let result = "";
+  let i;
+  for (i = 2; i < length; i += 3) {
+    result += base64abc[bytes[i - 2] >> 2];
+    result += base64abc[(bytes[i - 2] & 0x03) << 4 | bytes[i - 1] >> 4];
+    result += base64abc[(bytes[i - 1] & 0x0f) << 2 | bytes[i] >> 6];
+    result += base64abc[bytes[i] & 0x3f];
+  }
+  if (i === length + 1) {
+    // 1 octet yet to write
+    result += base64abc[bytes[i - 2] >> 2];
+    result += base64abc[(bytes[i - 2] & 0x03) << 4];
+    result += "==";
+  }
+  if (i === length) {
+    // 2 octets yet to write
+    result += base64abc[bytes[i - 2] >> 2];
+    result += base64abc[(bytes[i - 2] & 0x03) << 4 | bytes[i - 1] >> 4];
+    result += base64abc[(bytes[i - 1] & 0x0f) << 2];
+    result += "=";
+  }
+  return result;
+};
+
+/** @internal */
+const decode = str => {
+  const length = str.length;
+  if (length % 4 !== 0) {
+    return left(DecodeException(str, `Length must be a multiple of 4, but is ${length}`));
+  }
+  const index = str.indexOf("=");
+  if (index !== -1 && (index < length - 2 || index === length - 2 && str[length - 1] !== "=")) {
+    return left(DecodeException(str, "Found a '=' character, but it is not at the end"));
+  }
+  try {
+    const missingOctets = str.endsWith("==") ? 2 : str.endsWith("=") ? 1 : 0;
+    const result = new Uint8Array(3 * (length / 4));
+    for (let i = 0, j = 0; i < length; i += 4, j += 3) {
+      const buffer = getBase64Code(str.charCodeAt(i)) << 18 | getBase64Code(str.charCodeAt(i + 1)) << 12 | getBase64Code(str.charCodeAt(i + 2)) << 6 | getBase64Code(str.charCodeAt(i + 3));
+      result[j] = buffer >> 16;
+      result[j + 1] = buffer >> 8 & 0xff;
+      result[j + 2] = buffer & 0xff;
+    }
+    return right(result.subarray(0, result.length - missingOctets));
+  } catch (e) {
+    return left(DecodeException(str, e instanceof Error ? e.message : "Invalid input"));
+  }
+};
+
+/** @internal */
+function getBase64Code(charCode) {
+  if (charCode >= base64codes.length) {
+    throw new TypeError(`Invalid character ${String.fromCharCode(charCode)}`);
+  }
+  const code = base64codes[charCode];
+  if (code === 255) {
+    throw new TypeError(`Invalid character ${String.fromCharCode(charCode)}`);
+  }
+  return code;
+}
+
+/** @internal */
+const base64abc = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/"];
+
+/** @internal */
+const base64codes = [255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255, 0, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255, 255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51];
+
+export { decode, encode };

package/internal/Encoding/Base64Url.esm.js

@@ -0,0 +1,24 @@
+import { left } from '../../Either/dist/effect-Either.esm.js';
+import { encode as encode$1, decode as decode$1 } from './Base64.esm.js';
+import { DecodeException } from './Common.esm.js';
+
+/** @internal */
+const encode = data => encode$1(data).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+
+/** @internal */
+const decode = str => {
+  const length = str.length;
+  if (length % 4 === 1) {
+    return left(DecodeException(str, `Length should be a multiple of 4, but is ${length}`));
+  }
+  if (!/^[-_A-Z0-9]*?={0,2}$/i.test(str)) {
+    return left(DecodeException(str, "Invalid input"));
+  }
+
+  // Some variants allow or require omitting the padding '=' signs
+  let sanitized = length % 4 === 2 ? `${str}==` : length % 4 === 3 ? `${str}=` : str;
+  sanitized = sanitized.replace(/-/g, "+").replace(/_/g, "/");
+  return decode$1(sanitized);
+};
+
+export { decode, encode };

package/internal/Encoding/Common.esm.js

@@ -0,0 +1,21 @@
+/** @internal */
+const DecodeExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Encoding/errors/Decode");
+
+/** @internal */
+const DecodeException = (input, message) => ({
+  _tag: "DecodeException",
+  [DecodeExceptionTypeId]: DecodeExceptionTypeId,
+  input,
+  message
+});
+
+/** @internal */
+const isDecodeException = u => typeof u === "object" && u != null && DecodeExceptionTypeId in u;
+
+/** @interal */
+const encoder = /*#__PURE__*/new TextEncoder();
+
+/** @interal */
+const decoder = /*#__PURE__*/new TextDecoder();
+
+export { DecodeException, DecodeExceptionTypeId, decoder, encoder, isDecodeException };

package/internal/Encoding/Hex.esm.js

@@ -0,0 +1,55 @@
+import { left, right } from '../../Either/dist/effect-Either.esm.js';
+import { DecodeException } from './Common.esm.js';
+
+/** @internal */
+const encode = bytes => {
+  let result = "";
+  for (let i = 0; i < bytes.length; ++i) {
+    result += bytesToHex[bytes[i]];
+  }
+  return result;
+};
+
+/** @internal */
+const decode = str => {
+  const bytes = new TextEncoder().encode(str);
+  if (bytes.length % 2 !== 0) {
+    return left(DecodeException(str, `Length must be a multiple of 2, but is ${bytes.length}`));
+  }
+  try {
+    const length = bytes.length / 2;
+    const result = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+      const a = fromHexChar(bytes[i * 2]);
+      const b = fromHexChar(bytes[i * 2 + 1]);
+      result[i] = a << 4 | b;
+    }
+    return right(result);
+  } catch (e) {
+    return left(DecodeException(str, e instanceof Error ? e.message : "Invalid input"));
+  }
+};
+
+/** @internal */
+const bytesToHex = ["00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0a", "0b", "0c", "0d", "0e", "0f", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "1a", "1b", "1c", "1d", "1e", "1f", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "2a", "2b", "2c", "2d", "2e", "2f", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "3a", "3b", "3c", "3d", "3e", "3f", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "4a", "4b", "4c", "4d", "4e", "4f", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "5a", "5b", "5c", "5d", "5e", "5f", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6a", "6b", "6c", "6d", "6e", "6f", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "7a", "7b", "7c", "7d", "7e", "7f", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "8a", "8b", "8c", "8d", "8e", "8f", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9a", "9b", "9c", "9d", "9e", "9f", "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "aa", "ab", "ac", "ad", "ae", "af", "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7", "b8", "b9", "ba", "bb", "bc", "bd", "be", "bf", "c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "ca", "cb", "cc", "cd", "ce", "cf", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "da", "db", "dc", "dd", "de", "df", "e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7", "e8", "e9", "ea", "eb", "ec", "ed", "ee", "ef", "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "fa", "fb", "fc", "fd", "fe", "ff"];
+
+/** @internal */
+const fromHexChar = byte => {
+  // '0' <= byte && byte <= '9'
+  if (48 <= byte && byte <= 57) {
+    return byte - 48;
+  }
+
+  // 'a' <= byte && byte <= 'f'
+  if (97 <= byte && byte <= 102) {
+    return byte - 97 + 10;
+  }
+
+  // 'A' <= byte && byte <= 'F'
+  if (65 <= byte && byte <= 70) {
+    return byte - 65 + 10;
+  }
+  throw new TypeError("Invalid input");
+};
+
+export { decode, encode };

package/internal/HashMap/array.esm.js

@@ -0,0 +1,51 @@
+/** @internal */
+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 */
+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 */
+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;
+}
+
+export { arraySpliceIn, arraySpliceOut, arrayUpdate };

package/internal/HashMap/bitwise.esm.js

@@ -0,0 +1,34 @@
+import { MASK } from './config.esm.js';
+
+/**
+ * Hamming weight.
+ *
+ * Taken from: http://jsperf.com/hamming-weight
+ *
+ * @internal
+ */
+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 */
+function hashFragment(shift, h) {
+  return h >>> shift & MASK;
+}
+
+/** @internal */
+function toBitmap(x) {
+  return 1 << x;
+}
+
+/** @internal */
+function fromBitmap(bitmap, bit) {
+  return popcount(bitmap & bit - 1);
+}
+
+export { fromBitmap, hashFragment, popcount, toBitmap };

package/internal/HashMap/config.esm.js

@@ -0,0 +1,16 @@
+/** @internal */
+const SIZE = 5;
+
+/** @internal */
+const BUCKET_SIZE = /*#__PURE__*/Math.pow(2, SIZE);
+
+/** @internal */
+const MASK = BUCKET_SIZE - 1;
+
+/** @internal */
+const MAX_INDEX_NODE = BUCKET_SIZE / 2;
+
+/** @internal */
+const MIN_ARRAY_NODE = BUCKET_SIZE / 4;
+
+export { BUCKET_SIZE, MASK, MAX_INDEX_NODE, MIN_ARRAY_NODE, SIZE };

package/internal/HashMap/keySet.esm.js

@@ -0,0 +1,8 @@
+import { makeImpl } from '../HashSet.esm.js';
+
+/** @internal */
+function keySet(self) {
+  return makeImpl(self);
+}
+
+export { keySet };

package/internal/HashMap/node.esm.js

@@ -0,0 +1,253 @@
+import { equals } from '../../Equal/dist/effect-Equal.esm.js';
+import { arraySpliceOut, arrayUpdate, arraySpliceIn } from './array.esm.js';
+import { hashFragment, toBitmap, fromBitmap } from './bitwise.esm.js';
+import { SIZE, MAX_INDEX_NODE, MIN_ARRAY_NODE } from './config.esm.js';
+import { Stack } from '../Stack.esm.js';
+import { none, isNone } from '../../Option/dist/effect-Option.esm.js';
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+class EmptyNode {
+  _tag = "EmptyNode";
+  modify(edit, _shift, f, hash, key, size) {
+    const v = f(none());
+    if (isNone(v)) return new EmptyNode();
+    ++size.value;
+    return new LeafNode(edit, hash, key, v);
+  }
+}
+
+/** @internal */
+function isEmptyNode(a) {
+  return a instanceof EmptyNode;
+}
+
+/** @internal */
+function isLeafNode(node) {
+  return isEmptyNode(node) || node._tag === "LeafNode" || node._tag === "CollisionNode";
+}
+
+/** @internal */
+function canEditNode(node, edit) {
+  return isEmptyNode(node) ? false : edit === node.edit;
+}
+
+/** @internal */
+class LeafNode {
+  _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 (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(none());
+    if (isNone(v)) return this;
+    ++size.value;
+    return mergeLeaves(edit, shift, this.hash, this, hash, new LeafNode(edit, hash, key, v));
+  }
+}
+
+/** @internal */
+class CollisionNode {
+  _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(none());
+    if (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 (isNone(newValue)) {
+          --size.value;
+          return arraySpliceOut(mutate, i, list);
+        }
+        return arrayUpdate(mutate, i, new LeafNode(edit, hash, key, newValue), list);
+      }
+    }
+    const newValue = f(none());
+    if (isNone(newValue)) return list;
+    ++size.value;
+    return arrayUpdate(mutate, len, new LeafNode(edit, hash, key, newValue), list);
+  }
+}
+
+/** @internal */
+class IndexedNode {
+  _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 */
+class ArrayNode {
+  _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)) {
+      ++count;
+      newChildren = arrayUpdate(canEdit, frag, newChild, children);
+    } else if (!isEmptyNode(child) && isEmptyNode(newChild)) {
+      --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;
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const res = mergeLeavesInner(edit, currentShift, h1, n1, h2, n2);
+    if (typeof res === "function") {
+      stack = new Stack(res, stack);
+      currentShift = currentShift + SIZE;
+    } else {
+      let final = res;
+      while (stack != null) {
+        final = stack.value(final);
+        stack = stack.previous;
+      }
+      return final;
+    }
+  }
+}
+
+export { ArrayNode, CollisionNode, EmptyNode, IndexedNode, LeafNode, canEditNode, isEmptyNode, isLeafNode };