rxfy 0.1.2 → 0.2.0

package/dist/index.js

@@ -1,2 +1,4946 @@
-function e(){return"The lib will be there very soon!"}export{e as helloWorld};
-//# sourceMappingURL=index.js.map
+// src/atom/atom.ts
+import { Observable, BehaviorSubject } from "rxjs";
+var Atom = class extends Observable {
+  constructor(value) {
+    const subject$ = new BehaviorSubject(value);
+    super((subscriber) => {
+      const sub = subject$.subscribe(subscriber);
+      return () => sub.unsubscribe();
+    });
+    this.get = () => this.subject$.getValue();
+    this.set = (val) => this.subject$.next(val);
+    this.modify = (fn) => this.set(fn(this.get()));
+    this.subject$ = subject$;
+  }
+};
+function createAtom(value) {
+  return new Atom(value);
+}
+
+// src/edge/edge.ts
+import { catchError, EMPTY, lastValueFrom, map, of, switchMap, take, tap, throwError } from "rxjs";
+
+// src/wrapped/wrapped.ts
+var StatusEnum = /* @__PURE__ */ ((StatusEnum2) => {
+  StatusEnum2["IDLE"] = "IDLE";
+  StatusEnum2["PENDING"] = "PENDING";
+  StatusEnum2["FULFILLED"] = "FULFILLED";
+  StatusEnum2["REJECTED"] = "REJECTED";
+  return StatusEnum2;
+})(StatusEnum || {});
+function createIdle() {
+  return {
+    type: "IDLE" /* IDLE */
+  };
+}
+function createPending() {
+  return {
+    type: "PENDING" /* PENDING */
+  };
+}
+function createFulfilled(value) {
+  return {
+    type: "FULFILLED" /* FULFILLED */,
+    value
+  };
+}
+function createRejected(error) {
+  return {
+    type: "REJECTED" /* REJECTED */,
+    error
+  };
+}
+
+// src/edge/edge.ts
+function toBranded(brand, value) {
+  return { value, brand };
+}
+function isBranded(brand, val) {
+  return val && typeof val === "object" && val.brand === brand;
+}
+function createEdge(state$, queue, loader) {
+  const load = () => {
+    state$.set(createPending());
+    return lastValueFrom(
+      loader().pipe(
+        map((x) => createFulfilled(x)),
+        catchError((x) => of(createRejected(x))),
+        tap((x) => state$.set(x)),
+        take(1)
+      )
+    );
+  };
+  queue.add(async () => {
+    const value = state$.get();
+    if (value.type === "IDLE" /* IDLE */) {
+      await load();
+    }
+  });
+  return {
+    subject$: state$,
+    toObservable: () => state$.pipe(
+      switchMap((x) => {
+        switch (x.type) {
+          case "FULFILLED" /* FULFILLED */:
+            return of(x.value);
+          case "REJECTED" /* REJECTED */:
+            return throwError(() => x.error);
+          default:
+            return EMPTY;
+        }
+      })
+    ),
+    next: () => load()
+  };
+}
+
+// ../../../node_modules/.pnpm/immutable@5.1.1/node_modules/immutable/dist/immutable.es.js
+var DELETE = "delete";
+var SHIFT = 5;
+var SIZE = 1 << SHIFT;
+var MASK = SIZE - 1;
+var NOT_SET = {};
+function MakeRef() {
+  return { value: false };
+}
+function SetRef(ref) {
+  if (ref) {
+    ref.value = true;
+  }
+}
+function OwnerID() {
+}
+function ensureSize(iter) {
+  if (iter.size === void 0) {
+    iter.size = iter.__iterate(returnTrue);
+  }
+  return iter.size;
+}
+function wrapIndex(iter, index) {
+  if (typeof index !== "number") {
+    var uint32Index = index >>> 0;
+    if ("" + uint32Index !== index || uint32Index === 4294967295) {
+      return NaN;
+    }
+    index = uint32Index;
+  }
+  return index < 0 ? ensureSize(iter) + index : index;
+}
+function returnTrue() {
+  return true;
+}
+function wholeSlice(begin, end, size) {
+  return (begin === 0 && !isNeg(begin) || size !== void 0 && begin <= -size) && (end === void 0 || size !== void 0 && end >= size);
+}
+function resolveBegin(begin, size) {
+  return resolveIndex(begin, size, 0);
+}
+function resolveEnd(end, size) {
+  return resolveIndex(end, size, size);
+}
+function resolveIndex(index, size, defaultIndex) {
+  return index === void 0 ? defaultIndex : isNeg(index) ? size === Infinity ? size : Math.max(0, size + index) | 0 : size === void 0 || size === index ? index : Math.min(size, index) | 0;
+}
+function isNeg(value) {
+  return value < 0 || value === 0 && 1 / value === -Infinity;
+}
+var IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
+function isCollection(maybeCollection) {
+  return Boolean(maybeCollection && // @ts-expect-error: maybeCollection is typed as `{}`, need to change in 6.0 to `maybeCollection && typeof maybeCollection === 'object' && IS_COLLECTION_SYMBOL in maybeCollection`
+  maybeCollection[IS_COLLECTION_SYMBOL]);
+}
+var IS_KEYED_SYMBOL = "@@__IMMUTABLE_KEYED__@@";
+function isKeyed(maybeKeyed) {
+  return Boolean(maybeKeyed && // @ts-expect-error: maybeKeyed is typed as `{}`, need to change in 6.0 to `maybeKeyed && typeof maybeKeyed === 'object' && IS_KEYED_SYMBOL in maybeKeyed`
+  maybeKeyed[IS_KEYED_SYMBOL]);
+}
+var IS_INDEXED_SYMBOL = "@@__IMMUTABLE_INDEXED__@@";
+function isIndexed(maybeIndexed) {
+  return Boolean(maybeIndexed && // @ts-expect-error: maybeIndexed is typed as `{}`, need to change in 6.0 to `maybeIndexed && typeof maybeIndexed === 'object' && IS_INDEXED_SYMBOL in maybeIndexed`
+  maybeIndexed[IS_INDEXED_SYMBOL]);
+}
+function isAssociative(maybeAssociative) {
+  return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
+}
+var Collection = function Collection2(value) {
+  return isCollection(value) ? value : Seq(value);
+};
+var KeyedCollection = /* @__PURE__ */ function(Collection3) {
+  function KeyedCollection2(value) {
+    return isKeyed(value) ? value : KeyedSeq(value);
+  }
+  if (Collection3) KeyedCollection2.__proto__ = Collection3;
+  KeyedCollection2.prototype = Object.create(Collection3 && Collection3.prototype);
+  KeyedCollection2.prototype.constructor = KeyedCollection2;
+  return KeyedCollection2;
+}(Collection);
+var IndexedCollection = /* @__PURE__ */ function(Collection3) {
+  function IndexedCollection2(value) {
+    return isIndexed(value) ? value : IndexedSeq(value);
+  }
+  if (Collection3) IndexedCollection2.__proto__ = Collection3;
+  IndexedCollection2.prototype = Object.create(Collection3 && Collection3.prototype);
+  IndexedCollection2.prototype.constructor = IndexedCollection2;
+  return IndexedCollection2;
+}(Collection);
+var SetCollection = /* @__PURE__ */ function(Collection3) {
+  function SetCollection2(value) {
+    return isCollection(value) && !isAssociative(value) ? value : SetSeq(value);
+  }
+  if (Collection3) SetCollection2.__proto__ = Collection3;
+  SetCollection2.prototype = Object.create(Collection3 && Collection3.prototype);
+  SetCollection2.prototype.constructor = SetCollection2;
+  return SetCollection2;
+}(Collection);
+Collection.Keyed = KeyedCollection;
+Collection.Indexed = IndexedCollection;
+Collection.Set = SetCollection;
+var IS_SEQ_SYMBOL = "@@__IMMUTABLE_SEQ__@@";
+function isSeq(maybeSeq) {
+  return Boolean(maybeSeq && // @ts-expect-error: maybeSeq is typed as `{}`, need to change in 6.0 to `maybeSeq && typeof maybeSeq === 'object' && MAYBE_SEQ_SYMBOL in maybeSeq`
+  maybeSeq[IS_SEQ_SYMBOL]);
+}
+var IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
+function isRecord(maybeRecord) {
+  return Boolean(maybeRecord && // @ts-expect-error: maybeRecord is typed as `{}`, need to change in 6.0 to `maybeRecord && typeof maybeRecord === 'object' && IS_RECORD_SYMBOL in maybeRecord`
+  maybeRecord[IS_RECORD_SYMBOL]);
+}
+function isImmutable(maybeImmutable) {
+  return isCollection(maybeImmutable) || isRecord(maybeImmutable);
+}
+var IS_ORDERED_SYMBOL = "@@__IMMUTABLE_ORDERED__@@";
+function isOrdered(maybeOrdered) {
+  return Boolean(maybeOrdered && // @ts-expect-error: maybeOrdered is typed as `{}`, need to change in 6.0 to `maybeOrdered && typeof maybeOrdered === 'object' && IS_ORDERED_SYMBOL in maybeOrdered`
+  maybeOrdered[IS_ORDERED_SYMBOL]);
+}
+var ITERATE_KEYS = 0;
+var ITERATE_VALUES = 1;
+var ITERATE_ENTRIES = 2;
+var REAL_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
+var FAUX_ITERATOR_SYMBOL = "@@iterator";
+var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;
+var Iterator = function Iterator2(next) {
+  this.next = next;
+};
+Iterator.prototype.toString = function toString() {
+  return "[Iterator]";
+};
+Iterator.KEYS = ITERATE_KEYS;
+Iterator.VALUES = ITERATE_VALUES;
+Iterator.ENTRIES = ITERATE_ENTRIES;
+Iterator.prototype.inspect = Iterator.prototype.toSource = function() {
+  return this.toString();
+};
+Iterator.prototype[ITERATOR_SYMBOL] = function() {
+  return this;
+};
+function iteratorValue(type, k, v, iteratorResult) {
+  var value = type === ITERATE_KEYS ? k : type === ITERATE_VALUES ? v : [k, v];
+  iteratorResult ? iteratorResult.value = value : iteratorResult = {
+    value,
+    done: false
+  };
+  return iteratorResult;
+}
+function iteratorDone() {
+  return { value: void 0, done: true };
+}
+function hasIterator(maybeIterable) {
+  if (Array.isArray(maybeIterable)) {
+    return true;
+  }
+  return !!getIteratorFn(maybeIterable);
+}
+function isIterator(maybeIterator) {
+  return maybeIterator && typeof maybeIterator.next === "function";
+}
+function getIterator(iterable) {
+  var iteratorFn = getIteratorFn(iterable);
+  return iteratorFn && iteratorFn.call(iterable);
+}
+function getIteratorFn(iterable) {
+  var iteratorFn = iterable && (REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL] || iterable[FAUX_ITERATOR_SYMBOL]);
+  if (typeof iteratorFn === "function") {
+    return iteratorFn;
+  }
+}
+function isEntriesIterable(maybeIterable) {
+  var iteratorFn = getIteratorFn(maybeIterable);
+  return iteratorFn && iteratorFn === maybeIterable.entries;
+}
+function isKeysIterable(maybeIterable) {
+  var iteratorFn = getIteratorFn(maybeIterable);
+  return iteratorFn && iteratorFn === maybeIterable.keys;
+}
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function isArrayLike(value) {
+  if (Array.isArray(value) || typeof value === "string") {
+    return true;
+  }
+  return value && typeof value === "object" && // @ts-expect-error check that `'length' in value &&`
+  Number.isInteger(value.length) && // @ts-expect-error check that `'length' in value &&`
+  value.length >= 0 && // @ts-expect-error check that `'length' in value &&`
+  (value.length === 0 ? (
+    // Only {length: 0} is considered Array-like.
+    Object.keys(value).length === 1
+  ) : (
+    // An object is only Array-like if it has a property where the last value
+    // in the array-like may be found (which could be undefined).
+    // @ts-expect-error check that `'length' in value &&`
+    value.hasOwnProperty(value.length - 1)
+  ));
+}
+var Seq = /* @__PURE__ */ function(Collection3) {
+  function Seq2(value) {
+    return value === void 0 || value === null ? emptySequence() : isImmutable(value) ? value.toSeq() : seqFromValue(value);
+  }
+  if (Collection3) Seq2.__proto__ = Collection3;
+  Seq2.prototype = Object.create(Collection3 && Collection3.prototype);
+  Seq2.prototype.constructor = Seq2;
+  Seq2.prototype.toSeq = function toSeq3() {
+    return this;
+  };
+  Seq2.prototype.toString = function toString5() {
+    return this.__toString("Seq {", "}");
+  };
+  Seq2.prototype.cacheResult = function cacheResult() {
+    if (!this._cache && this.__iterateUncached) {
+      this._cache = this.entrySeq().toArray();
+      this.size = this._cache.length;
+    }
+    return this;
+  };
+  Seq2.prototype.__iterate = function __iterate2(fn, reverse3) {
+    var cache = this._cache;
+    if (cache) {
+      var size = cache.length;
+      var i = 0;
+      while (i !== size) {
+        var entry = cache[reverse3 ? size - ++i : i++];
+        if (fn(entry[1], entry[0], this) === false) {
+          break;
+        }
+      }
+      return i;
+    }
+    return this.__iterateUncached(fn, reverse3);
+  };
+  Seq2.prototype.__iterator = function __iterator2(type, reverse3) {
+    var cache = this._cache;
+    if (cache) {
+      var size = cache.length;
+      var i = 0;
+      return new Iterator(function() {
+        if (i === size) {
+          return iteratorDone();
+        }
+        var entry = cache[reverse3 ? size - ++i : i++];
+        return iteratorValue(type, entry[0], entry[1]);
+      });
+    }
+    return this.__iteratorUncached(type, reverse3);
+  };
+  return Seq2;
+}(Collection);
+var KeyedSeq = /* @__PURE__ */ function(Seq2) {
+  function KeyedSeq2(value) {
+    return value === void 0 || value === null ? emptySequence().toKeyedSeq() : isCollection(value) ? isKeyed(value) ? value.toSeq() : value.fromEntrySeq() : isRecord(value) ? value.toSeq() : keyedSeqFromValue(value);
+  }
+  if (Seq2) KeyedSeq2.__proto__ = Seq2;
+  KeyedSeq2.prototype = Object.create(Seq2 && Seq2.prototype);
+  KeyedSeq2.prototype.constructor = KeyedSeq2;
+  KeyedSeq2.prototype.toKeyedSeq = function toKeyedSeq3() {
+    return this;
+  };
+  return KeyedSeq2;
+}(Seq);
+var IndexedSeq = /* @__PURE__ */ function(Seq2) {
+  function IndexedSeq2(value) {
+    return value === void 0 || value === null ? emptySequence() : isCollection(value) ? isKeyed(value) ? value.entrySeq() : value.toIndexedSeq() : isRecord(value) ? value.toSeq().entrySeq() : indexedSeqFromValue(value);
+  }
+  if (Seq2) IndexedSeq2.__proto__ = Seq2;
+  IndexedSeq2.prototype = Object.create(Seq2 && Seq2.prototype);
+  IndexedSeq2.prototype.constructor = IndexedSeq2;
+  IndexedSeq2.of = function of3() {
+    return IndexedSeq2(arguments);
+  };
+  IndexedSeq2.prototype.toIndexedSeq = function toIndexedSeq2() {
+    return this;
+  };
+  IndexedSeq2.prototype.toString = function toString5() {
+    return this.__toString("Seq [", "]");
+  };
+  return IndexedSeq2;
+}(Seq);
+var SetSeq = /* @__PURE__ */ function(Seq2) {
+  function SetSeq2(value) {
+    return (isCollection(value) && !isAssociative(value) ? value : IndexedSeq(value)).toSetSeq();
+  }
+  if (Seq2) SetSeq2.__proto__ = Seq2;
+  SetSeq2.prototype = Object.create(Seq2 && Seq2.prototype);
+  SetSeq2.prototype.constructor = SetSeq2;
+  SetSeq2.of = function of3() {
+    return SetSeq2(arguments);
+  };
+  SetSeq2.prototype.toSetSeq = function toSetSeq2() {
+    return this;
+  };
+  return SetSeq2;
+}(Seq);
+Seq.isSeq = isSeq;
+Seq.Keyed = KeyedSeq;
+Seq.Set = SetSeq;
+Seq.Indexed = IndexedSeq;
+Seq.prototype[IS_SEQ_SYMBOL] = true;
+var ArraySeq = /* @__PURE__ */ function(IndexedSeq2) {
+  function ArraySeq2(array) {
+    this._array = array;
+    this.size = array.length;
+  }
+  if (IndexedSeq2) ArraySeq2.__proto__ = IndexedSeq2;
+  ArraySeq2.prototype = Object.create(IndexedSeq2 && IndexedSeq2.prototype);
+  ArraySeq2.prototype.constructor = ArraySeq2;
+  ArraySeq2.prototype.get = function get11(index, notSetValue) {
+    return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;
+  };
+  ArraySeq2.prototype.__iterate = function __iterate2(fn, reverse3) {
+    var array = this._array;
+    var size = array.length;
+    var i = 0;
+    while (i !== size) {
+      var ii = reverse3 ? size - ++i : i++;
+      if (fn(array[ii], ii, this) === false) {
+        break;
+      }
+    }
+    return i;
+  };
+  ArraySeq2.prototype.__iterator = function __iterator2(type, reverse3) {
+    var array = this._array;
+    var size = array.length;
+    var i = 0;
+    return new Iterator(function() {
+      if (i === size) {
+        return iteratorDone();
+      }
+      var ii = reverse3 ? size - ++i : i++;
+      return iteratorValue(type, ii, array[ii]);
+    });
+  };
+  return ArraySeq2;
+}(IndexedSeq);
+var ObjectSeq = /* @__PURE__ */ function(KeyedSeq2) {
+  function ObjectSeq2(object) {
+    var keys2 = Object.keys(object).concat(
+      Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : []
+    );
+    this._object = object;
+    this._keys = keys2;
+    this.size = keys2.length;
+  }
+  if (KeyedSeq2) ObjectSeq2.__proto__ = KeyedSeq2;
+  ObjectSeq2.prototype = Object.create(KeyedSeq2 && KeyedSeq2.prototype);
+  ObjectSeq2.prototype.constructor = ObjectSeq2;
+  ObjectSeq2.prototype.get = function get11(key, notSetValue) {
+    if (notSetValue !== void 0 && !this.has(key)) {
+      return notSetValue;
+    }
+    return this._object[key];
+  };
+  ObjectSeq2.prototype.has = function has5(key) {
+    return hasOwnProperty.call(this._object, key);
+  };
+  ObjectSeq2.prototype.__iterate = function __iterate2(fn, reverse3) {
+    var object = this._object;
+    var keys2 = this._keys;
+    var size = keys2.length;
+    var i = 0;
+    while (i !== size) {
+      var key = keys2[reverse3 ? size - ++i : i++];
+      if (fn(object[key], key, this) === false) {
+        break;
+      }
+    }
+    return i;
+  };
+  ObjectSeq2.prototype.__iterator = function __iterator2(type, reverse3) {
+    var object = this._object;
+    var keys2 = this._keys;
+    var size = keys2.length;
+    var i = 0;
+    return new Iterator(function() {
+      if (i === size) {
+        return iteratorDone();
+      }
+      var key = keys2[reverse3 ? size - ++i : i++];
+      return iteratorValue(type, key, object[key]);
+    });
+  };
+  return ObjectSeq2;
+}(KeyedSeq);
+ObjectSeq.prototype[IS_ORDERED_SYMBOL] = true;
+var CollectionSeq = /* @__PURE__ */ function(IndexedSeq2) {
+  function CollectionSeq2(collection) {
+    this._collection = collection;
+    this.size = collection.length || collection.size;
+  }
+  if (IndexedSeq2) CollectionSeq2.__proto__ = IndexedSeq2;
+  CollectionSeq2.prototype = Object.create(IndexedSeq2 && IndexedSeq2.prototype);
+  CollectionSeq2.prototype.constructor = CollectionSeq2;
+  CollectionSeq2.prototype.__iterateUncached = function __iterateUncached(fn, reverse3) {
+    if (reverse3) {
+      return this.cacheResult().__iterate(fn, reverse3);
+    }
+    var collection = this._collection;
+    var iterator = getIterator(collection);
+    var iterations = 0;
+    if (isIterator(iterator)) {
+      var step;
+      while (!(step = iterator.next()).done) {
+        if (fn(step.value, iterations++, this) === false) {
+          break;
+        }
+      }
+    }
+    return iterations;
+  };
+  CollectionSeq2.prototype.__iteratorUncached = function __iteratorUncached(type, reverse3) {
+    if (reverse3) {
+      return this.cacheResult().__iterator(type, reverse3);
+    }
+    var collection = this._collection;
+    var iterator = getIterator(collection);
+    if (!isIterator(iterator)) {
+      return new Iterator(iteratorDone);
+    }
+    var iterations = 0;
+    return new Iterator(function() {
+      var step = iterator.next();
+      return step.done ? step : iteratorValue(type, iterations++, step.value);
+    });
+  };
+  return CollectionSeq2;
+}(IndexedSeq);
+var EMPTY_SEQ;
+function emptySequence() {
+  return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));
+}
+function keyedSeqFromValue(value) {
+  var seq = maybeIndexedSeqFromValue(value);
+  if (seq) {
+    return seq.fromEntrySeq();
+  }
+  if (typeof value === "object") {
+    return new ObjectSeq(value);
+  }
+  throw new TypeError(
+    "Expected Array or collection object of [k, v] entries, or keyed object: " + value
+  );
+}
+function indexedSeqFromValue(value) {
+  var seq = maybeIndexedSeqFromValue(value);
+  if (seq) {
+    return seq;
+  }
+  throw new TypeError(
+    "Expected Array or collection object of values: " + value
+  );
+}
+function seqFromValue(value) {
+  var seq = maybeIndexedSeqFromValue(value);
+  if (seq) {
+    return isEntriesIterable(value) ? seq.fromEntrySeq() : isKeysIterable(value) ? seq.toSetSeq() : seq;
+  }
+  if (typeof value === "object") {
+    return new ObjectSeq(value);
+  }
+  throw new TypeError(
+    "Expected Array or collection object of values, or keyed object: " + value
+  );
+}
+function maybeIndexedSeqFromValue(value) {
+  return isArrayLike(value) ? new ArraySeq(value) : hasIterator(value) ? new CollectionSeq(value) : void 0;
+}
+var IS_MAP_SYMBOL = "@@__IMMUTABLE_MAP__@@";
+function isMap(maybeMap) {
+  return Boolean(maybeMap && // @ts-expect-error: maybeMap is typed as `{}`, need to change in 6.0 to `maybeMap && typeof maybeMap === 'object' && IS_MAP_SYMBOL in maybeMap`
+  maybeMap[IS_MAP_SYMBOL]);
+}
+function isOrderedMap(maybeOrderedMap) {
+  return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);
+}
+function isValueObject(maybeValue) {
+  return Boolean(maybeValue && // @ts-expect-error: maybeValue is typed as `{}`
+  typeof maybeValue.equals === "function" && // @ts-expect-error: maybeValue is typed as `{}`
+  typeof maybeValue.hashCode === "function");
+}
+function is(valueA, valueB) {
+  if (valueA === valueB || valueA !== valueA && valueB !== valueB) {
+    return true;
+  }
+  if (!valueA || !valueB) {
+    return false;
+  }
+  if (typeof valueA.valueOf === "function" && typeof valueB.valueOf === "function") {
+    valueA = valueA.valueOf();
+    valueB = valueB.valueOf();
+    if (valueA === valueB || valueA !== valueA && valueB !== valueB) {
+      return true;
+    }
+    if (!valueA || !valueB) {
+      return false;
+    }
+  }
+  return !!(isValueObject(valueA) && isValueObject(valueB) && valueA.equals(valueB));
+}
+var imul = typeof Math.imul === "function" && Math.imul(4294967295, 2) === -2 ? Math.imul : function imul2(a, b) {
+  a |= 0;
+  b |= 0;
+  var c = a & 65535;
+  var d = b & 65535;
+  return c * d + ((a >>> 16) * d + c * (b >>> 16) << 16 >>> 0) | 0;
+};
+function smi(i32) {
+  return i32 >>> 1 & 1073741824 | i32 & 3221225471;
+}
+var defaultValueOf = Object.prototype.valueOf;
+function hash(o) {
+  if (o == null) {
+    return hashNullish(o);
+  }
+  if (typeof o.hashCode === "function") {
+    return smi(o.hashCode(o));
+  }
+  var v = valueOf(o);
+  if (v == null) {
+    return hashNullish(v);
+  }
+  switch (typeof v) {
+    case "boolean":
+      return v ? 1108378657 : 1108378656;
+    case "number":
+      return hashNumber(v);
+    case "string":
+      return v.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(v) : hashString(v);
+    case "object":
+    case "function":
+      return hashJSObj(v);
+    case "symbol":
+      return hashSymbol(v);
+    default:
+      if (typeof v.toString === "function") {
+        return hashString(v.toString());
+      }
+      throw new Error("Value type " + typeof v + " cannot be hashed.");
+  }
+}
+function hashNullish(nullish) {
+  return nullish === null ? 1108378658 : (
+    /* undefined */
+    1108378659
+  );
+}
+function hashNumber(n) {
+  if (n !== n || n === Infinity) {
+    return 0;
+  }
+  var hash2 = n | 0;
+  if (hash2 !== n) {
+    hash2 ^= n * 4294967295;
+  }
+  while (n > 4294967295) {
+    n /= 4294967295;
+    hash2 ^= n;
+  }
+  return smi(hash2);
+}
+function cachedHashString(string) {
+  var hashed = stringHashCache[string];
+  if (hashed === void 0) {
+    hashed = hashString(string);
+    if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {
+      STRING_HASH_CACHE_SIZE = 0;
+      stringHashCache = {};
+    }
+    STRING_HASH_CACHE_SIZE++;
+    stringHashCache[string] = hashed;
+  }
+  return hashed;
+}
+function hashString(string) {
+  var hashed = 0;
+  for (var ii = 0; ii < string.length; ii++) {
+    hashed = 31 * hashed + string.charCodeAt(ii) | 0;
+  }
+  return smi(hashed);
+}
+function hashSymbol(sym) {
+  var hashed = symbolMap[sym];
+  if (hashed !== void 0) {
+    return hashed;
+  }
+  hashed = nextHash();
+  symbolMap[sym] = hashed;
+  return hashed;
+}
+function hashJSObj(obj) {
+  var hashed;
+  if (usingWeakMap) {
+    hashed = weakMap.get(obj);
+    if (hashed !== void 0) {
+      return hashed;
+    }
+  }
+  hashed = obj[UID_HASH_KEY];
+  if (hashed !== void 0) {
+    return hashed;
+  }
+  if (!canDefineProperty) {
+    hashed = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];
+    if (hashed !== void 0) {
+      return hashed;
+    }
+    hashed = getIENodeHash(obj);
+    if (hashed !== void 0) {
+      return hashed;
+    }
+  }
+  hashed = nextHash();
+  if (usingWeakMap) {
+    weakMap.set(obj, hashed);
+  } else if (isExtensible !== void 0 && isExtensible(obj) === false) {
+    throw new Error("Non-extensible objects are not allowed as keys.");
+  } else if (canDefineProperty) {
+    Object.defineProperty(obj, UID_HASH_KEY, {
+      enumerable: false,
+      configurable: false,
+      writable: false,
+      value: hashed
+    });
+  } else if (obj.propertyIsEnumerable !== void 0 && obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) {
+    obj.propertyIsEnumerable = function() {
+      return this.constructor.prototype.propertyIsEnumerable.apply(
+        this,
+        arguments
+      );
+    };
+    obj.propertyIsEnumerable[UID_HASH_KEY] = hashed;
+  } else if (obj.nodeType !== void 0) {
+    obj[UID_HASH_KEY] = hashed;
+  } else {
+    throw new Error("Unable to set a non-enumerable property on object.");
+  }
+  return hashed;
+}
+var isExtensible = Object.isExtensible;
+var canDefineProperty = function() {
+  try {
+    Object.defineProperty({}, "@", {});
+    return true;
+  } catch (e) {
+    return false;
+  }
+}();
+function getIENodeHash(node) {
+  if (node && node.nodeType > 0) {
+    switch (node.nodeType) {
+      case 1:
+        return node.uniqueID;
+      case 9:
+        return node.documentElement && node.documentElement.uniqueID;
+    }
+  }
+}
+function valueOf(obj) {
+  return obj.valueOf !== defaultValueOf && typeof obj.valueOf === "function" ? obj.valueOf(obj) : obj;
+}
+function nextHash() {
+  var nextHash2 = ++_objHashUID;
+  if (_objHashUID & 1073741824) {
+    _objHashUID = 0;
+  }
+  return nextHash2;
+}
+var usingWeakMap = typeof WeakMap === "function";
+var weakMap;
+if (usingWeakMap) {
+  weakMap = /* @__PURE__ */ new WeakMap();
+}
+var symbolMap = /* @__PURE__ */ Object.create(null);
+var _objHashUID = 0;
+var UID_HASH_KEY = "__immutablehash__";
+if (typeof Symbol === "function") {
+  UID_HASH_KEY = Symbol(UID_HASH_KEY);
+}
+var STRING_HASH_CACHE_MIN_STRLEN = 16;
+var STRING_HASH_CACHE_MAX_SIZE = 255;
+var STRING_HASH_CACHE_SIZE = 0;
+var stringHashCache = {};
+var ToKeyedSequence = /* @__PURE__ */ function(KeyedSeq2) {
+  function ToKeyedSequence2(indexed, useKeys) {
+    this._iter = indexed;
+    this._useKeys = useKeys;
+    this.size = indexed.size;
+  }
+  if (KeyedSeq2) ToKeyedSequence2.__proto__ = KeyedSeq2;
+  ToKeyedSequence2.prototype = Object.create(KeyedSeq2 && KeyedSeq2.prototype);
+  ToKeyedSequence2.prototype.constructor = ToKeyedSequence2;
+  ToKeyedSequence2.prototype.get = function get11(key, notSetValue) {
+    return this._iter.get(key, notSetValue);
+  };
+  ToKeyedSequence2.prototype.has = function has5(key) {
+    return this._iter.has(key);
+  };
+  ToKeyedSequence2.prototype.valueSeq = function valueSeq2() {
+    return this._iter.valueSeq();
+  };
+  ToKeyedSequence2.prototype.reverse = function reverse3() {
+    var this$1$1 = this;
+    var reversedSequence = reverseFactory(this, true);
+    if (!this._useKeys) {
+      reversedSequence.valueSeq = function() {
+        return this$1$1._iter.toSeq().reverse();
+      };
+    }
+    return reversedSequence;
+  };
+  ToKeyedSequence2.prototype.map = function map5(mapper, context) {
+    var this$1$1 = this;
+    var mappedSequence = mapFactory(this, mapper, context);
+    if (!this._useKeys) {
+      mappedSequence.valueSeq = function() {
+        return this$1$1._iter.toSeq().map(mapper, context);
+      };
+    }
+    return mappedSequence;
+  };
+  ToKeyedSequence2.prototype.__iterate = function __iterate2(fn, reverse3) {
+    var this$1$1 = this;
+    return this._iter.__iterate(function(v, k) {
+      return fn(v, k, this$1$1);
+    }, reverse3);
+  };
+  ToKeyedSequence2.prototype.__iterator = function __iterator2(type, reverse3) {
+    return this._iter.__iterator(type, reverse3);
+  };
+  return ToKeyedSequence2;
+}(KeyedSeq);
+ToKeyedSequence.prototype[IS_ORDERED_SYMBOL] = true;
+var ToIndexedSequence = /* @__PURE__ */ function(IndexedSeq2) {
+  function ToIndexedSequence2(iter) {
+    this._iter = iter;
+    this.size = iter.size;
+  }
+  if (IndexedSeq2) ToIndexedSequence2.__proto__ = IndexedSeq2;
+  ToIndexedSequence2.prototype = Object.create(IndexedSeq2 && IndexedSeq2.prototype);
+  ToIndexedSequence2.prototype.constructor = ToIndexedSequence2;
+  ToIndexedSequence2.prototype.includes = function includes3(value) {
+    return this._iter.includes(value);
+  };
+  ToIndexedSequence2.prototype.__iterate = function __iterate2(fn, reverse3) {
+    var this$1$1 = this;
+    var i = 0;
+    reverse3 && ensureSize(this);
+    return this._iter.__iterate(
+      function(v) {
+        return fn(v, reverse3 ? this$1$1.size - ++i : i++, this$1$1);
+      },
+      reverse3
+    );
+  };
+  ToIndexedSequence2.prototype.__iterator = function __iterator2(type, reverse3) {
+    var this$1$1 = this;
+    var iterator = this._iter.__iterator(ITERATE_VALUES, reverse3);
+    var i = 0;
+    reverse3 && ensureSize(this);
+    return new Iterator(function() {
+      var step = iterator.next();
+      return step.done ? step : iteratorValue(
+        type,
+        reverse3 ? this$1$1.size - ++i : i++,
+        step.value,
+        step
+      );
+    });
+  };
+  return ToIndexedSequence2;
+}(IndexedSeq);
+var ToSetSequence = /* @__PURE__ */ function(SetSeq2) {
+  function ToSetSequence2(iter) {
+    this._iter = iter;
+    this.size = iter.size;
+  }
+  if (SetSeq2) ToSetSequence2.__proto__ = SetSeq2;
+  ToSetSequence2.prototype = Object.create(SetSeq2 && SetSeq2.prototype);
+  ToSetSequence2.prototype.constructor = ToSetSequence2;
+  ToSetSequence2.prototype.has = function has5(key) {
+    return this._iter.includes(key);
+  };
+  ToSetSequence2.prototype.__iterate = function __iterate2(fn, reverse3) {
+    var this$1$1 = this;
+    return this._iter.__iterate(function(v) {
+      return fn(v, v, this$1$1);
+    }, reverse3);
+  };
+  ToSetSequence2.prototype.__iterator = function __iterator2(type, reverse3) {
+    var iterator = this._iter.__iterator(ITERATE_VALUES, reverse3);
+    return new Iterator(function() {
+      var step = iterator.next();
+      return step.done ? step : iteratorValue(type, step.value, step.value, step);
+    });
+  };
+  return ToSetSequence2;
+}(SetSeq);
+var FromEntriesSequence = /* @__PURE__ */ function(KeyedSeq2) {
+  function FromEntriesSequence2(entries3) {
+    this._iter = entries3;
+    this.size = entries3.size;
+  }
+  if (KeyedSeq2) FromEntriesSequence2.__proto__ = KeyedSeq2;
+  FromEntriesSequence2.prototype = Object.create(KeyedSeq2 && KeyedSeq2.prototype);
+  FromEntriesSequence2.prototype.constructor = FromEntriesSequence2;
+  FromEntriesSequence2.prototype.entrySeq = function entrySeq2() {
+    return this._iter.toSeq();
+  };
+  FromEntriesSequence2.prototype.__iterate = function __iterate2(fn, reverse3) {
+    var this$1$1 = this;
+    return this._iter.__iterate(function(entry) {
+      if (entry) {
+        validateEntry(entry);
+        var indexedCollection = isCollection(entry);
+        return fn(
+          indexedCollection ? entry.get(1) : entry[1],
+          indexedCollection ? entry.get(0) : entry[0],
+          this$1$1
+        );
+      }
+    }, reverse3);
+  };
+  FromEntriesSequence2.prototype.__iterator = function __iterator2(type, reverse3) {
+    var iterator = this._iter.__iterator(ITERATE_VALUES, reverse3);
+    return new Iterator(function() {
+      while (true) {
+        var step = iterator.next();
+        if (step.done) {
+          return step;
+        }
+        var entry = step.value;
+        if (entry) {
+          validateEntry(entry);
+          var indexedCollection = isCollection(entry);
+          return iteratorValue(
+            type,
+            indexedCollection ? entry.get(0) : entry[0],
+            indexedCollection ? entry.get(1) : entry[1],
+            step
+          );
+        }
+      }
+    });
+  };
+  return FromEntriesSequence2;
+}(KeyedSeq);
+ToIndexedSequence.prototype.cacheResult = ToKeyedSequence.prototype.cacheResult = ToSetSequence.prototype.cacheResult = FromEntriesSequence.prototype.cacheResult = cacheResultThrough;
+function flipFactory(collection) {
+  var flipSequence = makeSequence(collection);
+  flipSequence._iter = collection;
+  flipSequence.size = collection.size;
+  flipSequence.flip = function() {
+    return collection;
+  };
+  flipSequence.reverse = function() {
+    var reversedSequence = collection.reverse.apply(this);
+    reversedSequence.flip = function() {
+      return collection.reverse();
+    };
+    return reversedSequence;
+  };
+  flipSequence.has = function(key) {
+    return collection.includes(key);
+  };
+  flipSequence.includes = function(key) {
+    return collection.has(key);
+  };
+  flipSequence.cacheResult = cacheResultThrough;
+  flipSequence.__iterateUncached = function(fn, reverse3) {
+    var this$1$1 = this;
+    return collection.__iterate(function(v, k) {
+      return fn(k, v, this$1$1) !== false;
+    }, reverse3);
+  };
+  flipSequence.__iteratorUncached = function(type, reverse3) {
+    if (type === ITERATE_ENTRIES) {
+      var iterator = collection.__iterator(type, reverse3);
+      return new Iterator(function() {
+        var step = iterator.next();
+        if (!step.done) {
+          var k = step.value[0];
+          step.value[0] = step.value[1];
+          step.value[1] = k;
+        }
+        return step;
+      });
+    }
+    return collection.__iterator(
+      type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,
+      reverse3
+    );
+  };
+  return flipSequence;
+}
+function mapFactory(collection, mapper, context) {
+  var mappedSequence = makeSequence(collection);
+  mappedSequence.size = collection.size;
+  mappedSequence.has = function(key) {
+    return collection.has(key);
+  };
+  mappedSequence.get = function(key, notSetValue) {
+    var v = collection.get(key, NOT_SET);
+    return v === NOT_SET ? notSetValue : mapper.call(context, v, key, collection);
+  };
+  mappedSequence.__iterateUncached = function(fn, reverse3) {
+    var this$1$1 = this;
+    return collection.__iterate(
+      function(v, k, c) {
+        return fn(mapper.call(context, v, k, c), k, this$1$1) !== false;
+      },
+      reverse3
+    );
+  };
+  mappedSequence.__iteratorUncached = function(type, reverse3) {
+    var iterator = collection.__iterator(ITERATE_ENTRIES, reverse3);
+    return new Iterator(function() {
+      var step = iterator.next();
+      if (step.done) {
+        return step;
+      }
+      var entry = step.value;
+      var key = entry[0];
+      return iteratorValue(
+        type,
+        key,
+        mapper.call(context, entry[1], key, collection),
+        step
+      );
+    });
+  };
+  return mappedSequence;
+}
+function reverseFactory(collection, useKeys) {
+  var this$1$1 = this;
+  var reversedSequence = makeSequence(collection);
+  reversedSequence._iter = collection;
+  reversedSequence.size = collection.size;
+  reversedSequence.reverse = function() {
+    return collection;
+  };
+  if (collection.flip) {
+    reversedSequence.flip = function() {
+      var flipSequence = flipFactory(collection);
+      flipSequence.reverse = function() {
+        return collection.flip();
+      };
+      return flipSequence;
+    };
+  }
+  reversedSequence.get = function(key, notSetValue) {
+    return collection.get(useKeys ? key : -1 - key, notSetValue);
+  };
+  reversedSequence.has = function(key) {
+    return collection.has(useKeys ? key : -1 - key);
+  };
+  reversedSequence.includes = function(value) {
+    return collection.includes(value);
+  };
+  reversedSequence.cacheResult = cacheResultThrough;
+  reversedSequence.__iterate = function(fn, reverse3) {
+    var this$1$12 = this;
+    var i = 0;
+    reverse3 && ensureSize(collection);
+    return collection.__iterate(
+      function(v, k) {
+        return fn(v, useKeys ? k : reverse3 ? this$1$12.size - ++i : i++, this$1$12);
+      },
+      !reverse3
+    );
+  };
+  reversedSequence.__iterator = function(type, reverse3) {
+    var i = 0;
+    reverse3 && ensureSize(collection);
+    var iterator = collection.__iterator(ITERATE_ENTRIES, !reverse3);
+    return new Iterator(function() {
+      var step = iterator.next();
+      if (step.done) {
+        return step;
+      }
+      var entry = step.value;
+      return iteratorValue(
+        type,
+        useKeys ? entry[0] : reverse3 ? this$1$1.size - ++i : i++,
+        entry[1],
+        step
+      );
+    });
+  };
+  return reversedSequence;
+}
+function filterFactory(collection, predicate, context, useKeys) {
+  var filterSequence = makeSequence(collection);
+  if (useKeys) {
+    filterSequence.has = function(key) {
+      var v = collection.get(key, NOT_SET);
+      return v !== NOT_SET && !!predicate.call(context, v, key, collection);
+    };
+    filterSequence.get = function(key, notSetValue) {
+      var v = collection.get(key, NOT_SET);
+      return v !== NOT_SET && predicate.call(context, v, key, collection) ? v : notSetValue;
+    };
+  }
+  filterSequence.__iterateUncached = function(fn, reverse3) {
+    var this$1$1 = this;
+    var iterations = 0;
+    collection.__iterate(function(v, k, c) {
+      if (predicate.call(context, v, k, c)) {
+        iterations++;
+        return fn(v, useKeys ? k : iterations - 1, this$1$1);
+      }
+    }, reverse3);
+    return iterations;
+  };
+  filterSequence.__iteratorUncached = function(type, reverse3) {
+    var iterator = collection.__iterator(ITERATE_ENTRIES, reverse3);
+    var iterations = 0;
+    return new Iterator(function() {
+      while (true) {
+        var step = iterator.next();
+        if (step.done) {
+          return step;
+        }
+        var entry = step.value;
+        var key = entry[0];
+        var value = entry[1];
+        if (predicate.call(context, value, key, collection)) {
+          return iteratorValue(type, useKeys ? key : iterations++, value, step);
+        }
+      }
+    });
+  };
+  return filterSequence;
+}
+function countByFactory(collection, grouper, context) {
+  var groups = Map().asMutable();
+  collection.__iterate(function(v, k) {
+    groups.update(grouper.call(context, v, k, collection), 0, function(a) {
+      return a + 1;
+    });
+  });
+  return groups.asImmutable();
+}
+function groupByFactory(collection, grouper, context) {
+  var isKeyedIter = isKeyed(collection);
+  var groups = (isOrdered(collection) ? OrderedMap() : Map()).asMutable();
+  collection.__iterate(function(v, k) {
+    groups.update(
+      grouper.call(context, v, k, collection),
+      function(a) {
+        return a = a || [], a.push(isKeyedIter ? [k, v] : v), a;
+      }
+    );
+  });
+  var coerce = collectionClass(collection);
+  return groups.map(function(arr) {
+    return reify(collection, coerce(arr));
+  }).asImmutable();
+}
+function partitionFactory(collection, predicate, context) {
+  var isKeyedIter = isKeyed(collection);
+  var groups = [[], []];
+  collection.__iterate(function(v, k) {
+    groups[predicate.call(context, v, k, collection) ? 1 : 0].push(
+      isKeyedIter ? [k, v] : v
+    );
+  });
+  var coerce = collectionClass(collection);
+  return groups.map(function(arr) {
+    return reify(collection, coerce(arr));
+  });
+}
+function sliceFactory(collection, begin, end, useKeys) {
+  var originalSize = collection.size;
+  if (wholeSlice(begin, end, originalSize)) {
+    return collection;
+  }
+  if (typeof originalSize === "undefined" && (begin < 0 || end < 0)) {
+    return sliceFactory(collection.toSeq().cacheResult(), begin, end, useKeys);
+  }
+  var resolvedBegin = resolveBegin(begin, originalSize);
+  var resolvedEnd = resolveEnd(end, originalSize);
+  var resolvedSize = resolvedEnd - resolvedBegin;
+  var sliceSize;
+  if (resolvedSize === resolvedSize) {
+    sliceSize = resolvedSize < 0 ? 0 : resolvedSize;
+  }
+  var sliceSeq = makeSequence(collection);
+  sliceSeq.size = sliceSize === 0 ? sliceSize : collection.size && sliceSize || void 0;
+  if (!useKeys && isSeq(collection) && sliceSize >= 0) {
+    sliceSeq.get = function(index, notSetValue) {
+      index = wrapIndex(this, index);
+      return index >= 0 && index < sliceSize ? collection.get(index + resolvedBegin, notSetValue) : notSetValue;
+    };
+  }
+  sliceSeq.__iterateUncached = function(fn, reverse3) {
+    var this$1$1 = this;
+    if (sliceSize === 0) {
+      return 0;
+    }
+    if (reverse3) {
+      return this.cacheResult().__iterate(fn, reverse3);
+    }
+    var skipped = 0;
+    var isSkipping = true;
+    var iterations = 0;
+    collection.__iterate(function(v, k) {
+      if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {
+        iterations++;
+        return fn(v, useKeys ? k : iterations - 1, this$1$1) !== false && iterations !== sliceSize;
+      }
+    });
+    return iterations;
+  };
+  sliceSeq.__iteratorUncached = function(type, reverse3) {
+    if (sliceSize !== 0 && reverse3) {
+      return this.cacheResult().__iterator(type, reverse3);
+    }
+    if (sliceSize === 0) {
+      return new Iterator(iteratorDone);
+    }
+    var iterator = collection.__iterator(type, reverse3);
+    var skipped = 0;
+    var iterations = 0;
+    return new Iterator(function() {
+      while (skipped++ < resolvedBegin) {
+        iterator.next();
+      }
+      if (++iterations > sliceSize) {
+        return iteratorDone();
+      }
+      var step = iterator.next();
+      if (useKeys || type === ITERATE_VALUES || step.done) {
+        return step;
+      }
+      if (type === ITERATE_KEYS) {
+        return iteratorValue(type, iterations - 1, void 0, step);
+      }
+      return iteratorValue(type, iterations - 1, step.value[1], step);
+    });
+  };
+  return sliceSeq;
+}
+function takeWhileFactory(collection, predicate, context) {
+  var takeSequence = makeSequence(collection);
+  takeSequence.__iterateUncached = function(fn, reverse3) {
+    var this$1$1 = this;
+    if (reverse3) {
+      return this.cacheResult().__iterate(fn, reverse3);
+    }
+    var iterations = 0;
+    collection.__iterate(
+      function(v, k, c) {
+        return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$1$1);
+      }
+    );
+    return iterations;
+  };
+  takeSequence.__iteratorUncached = function(type, reverse3) {
+    var this$1$1 = this;
+    if (reverse3) {
+      return this.cacheResult().__iterator(type, reverse3);
+    }
+    var iterator = collection.__iterator(ITERATE_ENTRIES, reverse3);
+    var iterating = true;
+    return new Iterator(function() {
+      if (!iterating) {
+        return iteratorDone();
+      }
+      var step = iterator.next();
+      if (step.done) {
+        return step;
+      }
+      var entry = step.value;
+      var k = entry[0];
+      var v = entry[1];
+      if (!predicate.call(context, v, k, this$1$1)) {
+        iterating = false;
+        return iteratorDone();
+      }
+      return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step);
+    });
+  };
+  return takeSequence;
+}
+function skipWhileFactory(collection, predicate, context, useKeys) {
+  var skipSequence = makeSequence(collection);
+  skipSequence.__iterateUncached = function(fn, reverse3) {
+    var this$1$1 = this;
+    if (reverse3) {
+      return this.cacheResult().__iterate(fn, reverse3);
+    }
+    var isSkipping = true;
+    var iterations = 0;
+    collection.__iterate(function(v, k, c) {
+      if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) {
+        iterations++;
+        return fn(v, useKeys ? k : iterations - 1, this$1$1);
+      }
+    });
+    return iterations;
+  };
+  skipSequence.__iteratorUncached = function(type, reverse3) {
+    var this$1$1 = this;
+    if (reverse3) {
+      return this.cacheResult().__iterator(type, reverse3);
+    }
+    var iterator = collection.__iterator(ITERATE_ENTRIES, reverse3);
+    var skipping = true;
+    var iterations = 0;
+    return new Iterator(function() {
+      var step;
+      var k;
+      var v;
+      do {
+        step = iterator.next();
+        if (step.done) {
+          if (useKeys || type === ITERATE_VALUES) {
+            return step;
+          }
+          if (type === ITERATE_KEYS) {
+            return iteratorValue(type, iterations++, void 0, step);
+          }
+          return iteratorValue(type, iterations++, step.value[1], step);
+        }
+        var entry = step.value;
+        k = entry[0];
+        v = entry[1];
+        skipping && (skipping = predicate.call(context, v, k, this$1$1));
+      } while (skipping);
+      return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step);
+    });
+  };
+  return skipSequence;
+}
+var ConcatSeq = /* @__PURE__ */ function(Seq2) {
+  function ConcatSeq2(iterables) {
+    this._wrappedIterables = iterables.flatMap(function(iterable) {
+      if (iterable._wrappedIterables) {
+        return iterable._wrappedIterables;
+      }
+      return [iterable];
+    });
+    this.size = this._wrappedIterables.reduce(function(sum, iterable) {
+      if (sum !== void 0) {
+        var size = iterable.size;
+        if (size !== void 0) {
+          return sum + size;
+        }
+      }
+    }, 0);
+    this[IS_KEYED_SYMBOL] = this._wrappedIterables[0][IS_KEYED_SYMBOL];
+    this[IS_INDEXED_SYMBOL] = this._wrappedIterables[0][IS_INDEXED_SYMBOL];
+    this[IS_ORDERED_SYMBOL] = this._wrappedIterables[0][IS_ORDERED_SYMBOL];
+  }
+  if (Seq2) ConcatSeq2.__proto__ = Seq2;
+  ConcatSeq2.prototype = Object.create(Seq2 && Seq2.prototype);
+  ConcatSeq2.prototype.constructor = ConcatSeq2;
+  ConcatSeq2.prototype.__iterateUncached = function __iterateUncached(fn, reverse3) {
+    if (this._wrappedIterables.length === 0) {
+      return;
+    }
+    if (reverse3) {
+      return this.cacheResult().__iterate(fn, reverse3);
+    }
+    var iterableIndex = 0;
+    var useKeys = isKeyed(this);
+    var iteratorType = useKeys ? ITERATE_ENTRIES : ITERATE_VALUES;
+    var currentIterator = this._wrappedIterables[iterableIndex].__iterator(
+      iteratorType,
+      reverse3
+    );
+    var keepGoing = true;
+    var index = 0;
+    while (keepGoing) {
+      var next = currentIterator.next();
+      while (next.done) {
+        iterableIndex++;
+        if (iterableIndex === this._wrappedIterables.length) {
+          return index;
+        }
+        currentIterator = this._wrappedIterables[iterableIndex].__iterator(
+          iteratorType,
+          reverse3
+        );
+        next = currentIterator.next();
+      }
+      var fnResult = useKeys ? fn(next.value[1], next.value[0], this) : fn(next.value, index, this);
+      keepGoing = fnResult !== false;
+      index++;
+    }
+    return index;
+  };
+  ConcatSeq2.prototype.__iteratorUncached = function __iteratorUncached(type, reverse3) {
+    var this$1$1 = this;
+    if (this._wrappedIterables.length === 0) {
+      return new Iterator(iteratorDone);
+    }
+    if (reverse3) {
+      return this.cacheResult().__iterator(type, reverse3);
+    }
+    var iterableIndex = 0;
+    var currentIterator = this._wrappedIterables[iterableIndex].__iterator(
+      type,
+      reverse3
+    );
+    return new Iterator(function() {
+      var next = currentIterator.next();
+      while (next.done) {
+        iterableIndex++;
+        if (iterableIndex === this$1$1._wrappedIterables.length) {
+          return next;
+        }
+        currentIterator = this$1$1._wrappedIterables[iterableIndex].__iterator(
+          type,
+          reverse3
+        );
+        next = currentIterator.next();
+      }
+      return next;
+    });
+  };
+  return ConcatSeq2;
+}(Seq);
+function concatFactory(collection, values2) {
+  var isKeyedCollection = isKeyed(collection);
+  var iters = [collection].concat(values2).map(function(v) {
+    if (!isCollection(v)) {
+      v = isKeyedCollection ? keyedSeqFromValue(v) : indexedSeqFromValue(Array.isArray(v) ? v : [v]);
+    } else if (isKeyedCollection) {
+      v = KeyedCollection(v);
+    }
+    return v;
+  }).filter(function(v) {
+    return v.size !== 0;
+  });
+  if (iters.length === 0) {
+    return collection;
+  }
+  if (iters.length === 1) {
+    var singleton = iters[0];
+    if (singleton === collection || isKeyedCollection && isKeyed(singleton) || isIndexed(collection) && isIndexed(singleton)) {
+      return singleton;
+    }
+  }
+  return new ConcatSeq(iters);
+}
+function flattenFactory(collection, depth, useKeys) {
+  var flatSequence = makeSequence(collection);
+  flatSequence.__iterateUncached = function(fn, reverse3) {
+    if (reverse3) {
+      return this.cacheResult().__iterate(fn, reverse3);
+    }
+    var iterations = 0;
+    var stopped = false;
+    function flatDeep(iter, currentDepth) {
+      iter.__iterate(function(v, k) {
+        if ((!depth || currentDepth < depth) && isCollection(v)) {
+          flatDeep(v, currentDepth + 1);
+        } else {
+          iterations++;
+          if (fn(v, useKeys ? k : iterations - 1, flatSequence) === false) {
+            stopped = true;
+          }
+        }
+        return !stopped;
+      }, reverse3);
+    }
+    flatDeep(collection, 0);
+    return iterations;
+  };
+  flatSequence.__iteratorUncached = function(type, reverse3) {
+    if (reverse3) {
+      return this.cacheResult().__iterator(type, reverse3);
+    }
+    var iterator = collection.__iterator(type, reverse3);
+    var stack = [];
+    var iterations = 0;
+    return new Iterator(function() {
+      while (iterator) {
+        var step = iterator.next();
+        if (step.done !== false) {
+          iterator = stack.pop();
+          continue;
+        }
+        var v = step.value;
+        if (type === ITERATE_ENTRIES) {
+          v = v[1];
+        }
+        if ((!depth || stack.length < depth) && isCollection(v)) {
+          stack.push(iterator);
+          iterator = v.__iterator(type, reverse3);
+        } else {
+          return useKeys ? step : iteratorValue(type, iterations++, v, step);
+        }
+      }
+      return iteratorDone();
+    });
+  };
+  return flatSequence;
+}
+function flatMapFactory(collection, mapper, context) {
+  var coerce = collectionClass(collection);
+  return collection.toSeq().map(function(v, k) {
+    return coerce(mapper.call(context, v, k, collection));
+  }).flatten(true);
+}
+function interposeFactory(collection, separator) {
+  var interposedSequence = makeSequence(collection);
+  interposedSequence.size = collection.size && collection.size * 2 - 1;
+  interposedSequence.__iterateUncached = function(fn, reverse3) {
+    var this$1$1 = this;
+    var iterations = 0;
+    collection.__iterate(
+      function(v) {
+        return (!iterations || fn(separator, iterations++, this$1$1) !== false) && fn(v, iterations++, this$1$1) !== false;
+      },
+      reverse3
+    );
+    return iterations;
+  };
+  interposedSequence.__iteratorUncached = function(type, reverse3) {
+    var iterator = collection.__iterator(ITERATE_VALUES, reverse3);
+    var iterations = 0;
+    var step;
+    return new Iterator(function() {
+      if (!step || iterations % 2) {
+        step = iterator.next();
+        if (step.done) {
+          return step;
+        }
+      }
+      return iterations % 2 ? iteratorValue(type, iterations++, separator) : iteratorValue(type, iterations++, step.value, step);
+    });
+  };
+  return interposedSequence;
+}
+function sortFactory(collection, comparator, mapper) {
+  if (!comparator) {
+    comparator = defaultComparator;
+  }
+  var isKeyedCollection = isKeyed(collection);
+  var index = 0;
+  var entries3 = collection.toSeq().map(function(v, k) {
+    return [k, v, index++, mapper ? mapper(v, k, collection) : v];
+  }).valueSeq().toArray();
+  entries3.sort(function(a, b) {
+    return comparator(a[3], b[3]) || a[2] - b[2];
+  }).forEach(
+    isKeyedCollection ? function(v, i) {
+      entries3[i].length = 2;
+    } : function(v, i) {
+      entries3[i] = v[1];
+    }
+  );
+  return isKeyedCollection ? KeyedSeq(entries3) : isIndexed(collection) ? IndexedSeq(entries3) : SetSeq(entries3);
+}
+function maxFactory(collection, comparator, mapper) {
+  if (!comparator) {
+    comparator = defaultComparator;
+  }
+  if (mapper) {
+    var entry = collection.toSeq().map(function(v, k) {
+      return [v, mapper(v, k, collection)];
+    }).reduce(function(a, b) {
+      return maxCompare(comparator, a[1], b[1]) ? b : a;
+    });
+    return entry && entry[0];
+  }
+  return collection.reduce(function(a, b) {
+    return maxCompare(comparator, a, b) ? b : a;
+  });
+}
+function maxCompare(comparator, a, b) {
+  var comp = comparator(b, a);
+  return comp === 0 && b !== a && (b === void 0 || b === null || b !== b) || comp > 0;
+}
+function zipWithFactory(keyIter, zipper, iters, zipAll2) {
+  var zipSequence = makeSequence(keyIter);
+  var sizes = new ArraySeq(iters).map(function(i) {
+    return i.size;
+  });
+  zipSequence.size = zipAll2 ? sizes.max() : sizes.min();
+  zipSequence.__iterate = function(fn, reverse3) {
+    var iterator = this.__iterator(ITERATE_VALUES, reverse3);
+    var step;
+    var iterations = 0;
+    while (!(step = iterator.next()).done) {
+      if (fn(step.value, iterations++, this) === false) {
+        break;
+      }
+    }
+    return iterations;
+  };
+  zipSequence.__iteratorUncached = function(type, reverse3) {
+    var iterators = iters.map(
+      function(i) {
+        return i = Collection(i), getIterator(reverse3 ? i.reverse() : i);
+      }
+    );
+    var iterations = 0;
+    var isDone = false;
+    return new Iterator(function() {
+      var steps;
+      if (!isDone) {
+        steps = iterators.map(function(i) {
+          return i.next();
+        });
+        isDone = zipAll2 ? steps.every(function(s) {
+          return s.done;
+        }) : steps.some(function(s) {
+          return s.done;
+        });
+      }
+      if (isDone) {
+        return iteratorDone();
+      }
+      return iteratorValue(
+        type,
+        iterations++,
+        zipper.apply(
+          null,
+          steps.map(function(s) {
+            return s.value;
+          })
+        )
+      );
+    });
+  };
+  return zipSequence;
+}
+function reify(iter, seq) {
+  return iter === seq ? iter : isSeq(iter) ? seq : iter.constructor(seq);
+}
+function validateEntry(entry) {
+  if (entry !== Object(entry)) {
+    throw new TypeError("Expected [K, V] tuple: " + entry);
+  }
+}
+function collectionClass(collection) {
+  return isKeyed(collection) ? KeyedCollection : isIndexed(collection) ? IndexedCollection : SetCollection;
+}
+function makeSequence(collection) {
+  return Object.create(
+    (isKeyed(collection) ? KeyedSeq : isIndexed(collection) ? IndexedSeq : SetSeq).prototype
+  );
+}
+function cacheResultThrough() {
+  if (this._iter.cacheResult) {
+    this._iter.cacheResult();
+    this.size = this._iter.size;
+    return this;
+  }
+  return Seq.prototype.cacheResult.call(this);
+}
+function defaultComparator(a, b) {
+  if (a === void 0 && b === void 0) {
+    return 0;
+  }
+  if (a === void 0) {
+    return 1;
+  }
+  if (b === void 0) {
+    return -1;
+  }
+  return a > b ? 1 : a < b ? -1 : 0;
+}
+function arrCopy(arr, offset) {
+  offset = offset || 0;
+  var len = Math.max(0, arr.length - offset);
+  var newArr = new Array(len);
+  for (var ii = 0; ii < len; ii++) {
+    newArr[ii] = arr[ii + offset];
+  }
+  return newArr;
+}
+function invariant(condition, error) {
+  if (!condition) {
+    throw new Error(error);
+  }
+}
+function assertNotInfinite(size) {
+  invariant(size !== Infinity, "Cannot perform this action with an infinite size.");
+}
+function coerceKeyPath(keyPath) {
+  if (isArrayLike(keyPath) && typeof keyPath !== "string") {
+    return keyPath;
+  }
+  if (isOrdered(keyPath)) {
+    return keyPath.toArray();
+  }
+  throw new TypeError("Invalid keyPath: expected Ordered Collection or Array: " + keyPath);
+}
+var toString2 = Object.prototype.toString;
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || toString2.call(value) !== "[object Object]") {
+    return false;
+  }
+  var proto = Object.getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  var parentProto = proto;
+  var nextProto = Object.getPrototypeOf(proto);
+  while (nextProto !== null) {
+    parentProto = nextProto;
+    nextProto = Object.getPrototypeOf(parentProto);
+  }
+  return parentProto === proto;
+}
+function isDataStructure(value) {
+  return typeof value === "object" && (isImmutable(value) || Array.isArray(value) || isPlainObject(value));
+}
+function quoteString(value) {
+  try {
+    return typeof value === "string" ? JSON.stringify(value) : String(value);
+  } catch (_ignoreError) {
+    return JSON.stringify(value);
+  }
+}
+function has(collection, key) {
+  return isImmutable(collection) ? (
+    // @ts-expect-error key might be a number or symbol, which is not handled be Record key type
+    collection.has(key)
+  ) : (
+    // @ts-expect-error key might be anything else than PropertyKey, and will return false in that case but runtime is OK
+    isDataStructure(collection) && hasOwnProperty.call(collection, key)
+  );
+}
+function get(collection, key, notSetValue) {
+  return isImmutable(collection) ? collection.get(key, notSetValue) : !has(collection, key) ? notSetValue : (
+    // @ts-expect-error weird "get" here,
+    typeof collection.get === "function" ? (
+      // @ts-expect-error weird "get" here,
+      collection.get(key)
+    ) : (
+      // @ts-expect-error key is unknown here,
+      collection[key]
+    )
+  );
+}
+function shallowCopy(from) {
+  if (Array.isArray(from)) {
+    return arrCopy(from);
+  }
+  var to = {};
+  for (var key in from) {
+    if (hasOwnProperty.call(from, key)) {
+      to[key] = from[key];
+    }
+  }
+  return to;
+}
+function remove(collection, key) {
+  if (!isDataStructure(collection)) {
+    throw new TypeError("Cannot update non-data-structure value: " + collection);
+  }
+  if (isImmutable(collection)) {
+    if (!collection.remove) {
+      throw new TypeError("Cannot update immutable value without .remove() method: " + collection);
+    }
+    return collection.remove(key);
+  }
+  if (!hasOwnProperty.call(collection, key)) {
+    return collection;
+  }
+  var collectionCopy = shallowCopy(collection);
+  if (Array.isArray(collectionCopy)) {
+    collectionCopy.splice(key, 1);
+  } else {
+    delete collectionCopy[key];
+  }
+  return collectionCopy;
+}
+function set(collection, key, value) {
+  if (!isDataStructure(collection)) {
+    throw new TypeError("Cannot update non-data-structure value: " + collection);
+  }
+  if (isImmutable(collection)) {
+    if (!collection.set) {
+      throw new TypeError("Cannot update immutable value without .set() method: " + collection);
+    }
+    return collection.set(key, value);
+  }
+  if (hasOwnProperty.call(collection, key) && value === collection[key]) {
+    return collection;
+  }
+  var collectionCopy = shallowCopy(collection);
+  collectionCopy[key] = value;
+  return collectionCopy;
+}
+function updateIn$1(collection, keyPath, notSetValue, updater) {
+  if (!updater) {
+    updater = notSetValue;
+    notSetValue = void 0;
+  }
+  var updatedValue = updateInDeeply(
+    isImmutable(collection),
+    // @ts-expect-error type issues with Record and mixed types
+    collection,
+    coerceKeyPath(keyPath),
+    0,
+    notSetValue,
+    updater
+  );
+  return updatedValue === NOT_SET ? notSetValue : updatedValue;
+}
+function updateInDeeply(inImmutable, existing, keyPath, i, notSetValue, updater) {
+  var wasNotSet = existing === NOT_SET;
+  if (i === keyPath.length) {
+    var existingValue = wasNotSet ? notSetValue : existing;
+    var newValue = updater(existingValue);
+    return newValue === existingValue ? existing : newValue;
+  }
+  if (!wasNotSet && !isDataStructure(existing)) {
+    throw new TypeError("Cannot update within non-data-structure value in path [" + Array.from(keyPath).slice(0, i).map(quoteString) + "]: " + existing);
+  }
+  var key = keyPath[i];
+  if (typeof key === "undefined") {
+    throw new TypeError("Index can not be undefined in updateIn(). This should not happen");
+  }
+  var nextExisting = wasNotSet ? NOT_SET : get(existing, key, NOT_SET);
+  var nextUpdated = updateInDeeply(
+    nextExisting === NOT_SET ? inImmutable : isImmutable(nextExisting),
+    // @ts-expect-error mixed type
+    nextExisting,
+    keyPath,
+    i + 1,
+    notSetValue,
+    updater
+  );
+  return nextUpdated === nextExisting ? existing : nextUpdated === NOT_SET ? remove(existing, key) : set(wasNotSet ? inImmutable ? emptyMap() : {} : existing, key, nextUpdated);
+}
+function setIn$1(collection, keyPath, value) {
+  return updateIn$1(collection, keyPath, NOT_SET, function() {
+    return value;
+  });
+}
+function setIn(keyPath, v) {
+  return setIn$1(this, keyPath, v);
+}
+function removeIn(collection, keyPath) {
+  return updateIn$1(collection, keyPath, function() {
+    return NOT_SET;
+  });
+}
+function deleteIn(keyPath) {
+  return removeIn(this, keyPath);
+}
+function update$1(collection, key, notSetValue, updater) {
+  return updateIn$1(
+    // @ts-expect-error Index signature for type string is missing in type V[]
+    collection,
+    [key],
+    notSetValue,
+    updater
+  );
+}
+function update(key, notSetValue, updater) {
+  return arguments.length === 1 ? key(this) : update$1(this, key, notSetValue, updater);
+}
+function updateIn(keyPath, notSetValue, updater) {
+  return updateIn$1(this, keyPath, notSetValue, updater);
+}
+function merge$1() {
+  var iters = [], len = arguments.length;
+  while (len--) iters[len] = arguments[len];
+  return mergeIntoKeyedWith(this, iters);
+}
+function mergeWith$1(merger) {
+  var iters = [], len = arguments.length - 1;
+  while (len-- > 0) iters[len] = arguments[len + 1];
+  if (typeof merger !== "function") {
+    throw new TypeError("Invalid merger function: " + merger);
+  }
+  return mergeIntoKeyedWith(this, iters, merger);
+}
+function mergeIntoKeyedWith(collection, collections, merger) {
+  var iters = [];
+  for (var ii = 0; ii < collections.length; ii++) {
+    var collection$1 = KeyedCollection(collections[ii]);
+    if (collection$1.size !== 0) {
+      iters.push(collection$1);
+    }
+  }
+  if (iters.length === 0) {
+    return collection;
+  }
+  if (collection.toSeq().size === 0 && !collection.__ownerID && iters.length === 1) {
+    return collection.constructor(iters[0]);
+  }
+  return collection.withMutations(function(collection2) {
+    var mergeIntoCollection = merger ? function(value, key) {
+      update$1(
+        collection2,
+        key,
+        NOT_SET,
+        function(oldVal) {
+          return oldVal === NOT_SET ? value : merger(oldVal, value, key);
+        }
+      );
+    } : function(value, key) {
+      collection2.set(key, value);
+    };
+    for (var ii2 = 0; ii2 < iters.length; ii2++) {
+      iters[ii2].forEach(mergeIntoCollection);
+    }
+  });
+}
+function mergeDeepWithSources(collection, sources, merger) {
+  return mergeWithSources(collection, sources, deepMergerWith(merger));
+}
+function mergeWithSources(collection, sources, merger) {
+  if (!isDataStructure(collection)) {
+    throw new TypeError(
+      "Cannot merge into non-data-structure value: " + collection
+    );
+  }
+  if (isImmutable(collection)) {
+    return typeof merger === "function" && collection.mergeWith ? collection.mergeWith.apply(collection, [merger].concat(sources)) : collection.merge ? collection.merge.apply(collection, sources) : collection.concat.apply(collection, sources);
+  }
+  var isArray = Array.isArray(collection);
+  var merged = collection;
+  var Collection3 = isArray ? IndexedCollection : KeyedCollection;
+  var mergeItem = isArray ? function(value) {
+    if (merged === collection) {
+      merged = shallowCopy(merged);
+    }
+    merged.push(value);
+  } : function(value, key) {
+    var hasVal = hasOwnProperty.call(merged, key);
+    var nextVal = hasVal && merger ? merger(merged[key], value, key) : value;
+    if (!hasVal || nextVal !== merged[key]) {
+      if (merged === collection) {
+        merged = shallowCopy(merged);
+      }
+      merged[key] = nextVal;
+    }
+  };
+  for (var i = 0; i < sources.length; i++) {
+    Collection3(sources[i]).forEach(mergeItem);
+  }
+  return merged;
+}
+function deepMergerWith(merger) {
+  function deepMerger(oldValue, newValue, key) {
+    return isDataStructure(oldValue) && isDataStructure(newValue) && areMergeable(oldValue, newValue) ? mergeWithSources(oldValue, [newValue], deepMerger) : merger ? merger(oldValue, newValue, key) : newValue;
+  }
+  return deepMerger;
+}
+function areMergeable(oldDataStructure, newDataStructure) {
+  var oldSeq = Seq(oldDataStructure);
+  var newSeq = Seq(newDataStructure);
+  return isIndexed(oldSeq) === isIndexed(newSeq) && isKeyed(oldSeq) === isKeyed(newSeq);
+}
+function mergeDeep() {
+  var iters = [], len = arguments.length;
+  while (len--) iters[len] = arguments[len];
+  return mergeDeepWithSources(this, iters);
+}
+function mergeDeepWith(merger) {
+  var iters = [], len = arguments.length - 1;
+  while (len-- > 0) iters[len] = arguments[len + 1];
+  return mergeDeepWithSources(this, iters, merger);
+}
+function mergeIn(keyPath) {
+  var iters = [], len = arguments.length - 1;
+  while (len-- > 0) iters[len] = arguments[len + 1];
+  return updateIn$1(this, keyPath, emptyMap(), function(m) {
+    return mergeWithSources(m, iters);
+  });
+}
+function mergeDeepIn(keyPath) {
+  var iters = [], len = arguments.length - 1;
+  while (len-- > 0) iters[len] = arguments[len + 1];
+  return updateIn$1(
+    this,
+    keyPath,
+    emptyMap(),
+    function(m) {
+      return mergeDeepWithSources(m, iters);
+    }
+  );
+}
+function withMutations(fn) {
+  var mutable = this.asMutable();
+  fn(mutable);
+  return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;
+}
+function asMutable() {
+  return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
+}
+function asImmutable() {
+  return this.__ensureOwner();
+}
+function wasAltered() {
+  return this.__altered;
+}
+var Map = /* @__PURE__ */ function(KeyedCollection2) {
+  function Map2(value) {
+    return value === void 0 || value === null ? emptyMap() : isMap(value) && !isOrdered(value) ? value : emptyMap().withMutations(function(map5) {
+      var iter = KeyedCollection2(value);
+      assertNotInfinite(iter.size);
+      iter.forEach(function(v, k) {
+        return map5.set(k, v);
+      });
+    });
+  }
+  if (KeyedCollection2) Map2.__proto__ = KeyedCollection2;
+  Map2.prototype = Object.create(KeyedCollection2 && KeyedCollection2.prototype);
+  Map2.prototype.constructor = Map2;
+  Map2.prototype.toString = function toString5() {
+    return this.__toString("Map {", "}");
+  };
+  Map2.prototype.get = function get11(k, notSetValue) {
+    return this._root ? this._root.get(0, void 0, k, notSetValue) : notSetValue;
+  };
+  Map2.prototype.set = function set3(k, v) {
+    return updateMap(this, k, v);
+  };
+  Map2.prototype.remove = function remove3(k) {
+    return updateMap(this, k, NOT_SET);
+  };
+  Map2.prototype.deleteAll = function deleteAll(keys2) {
+    var collection = Collection(keys2);
+    if (collection.size === 0) {
+      return this;
+    }
+    return this.withMutations(function(map5) {
+      collection.forEach(function(key) {
+        return map5.remove(key);
+      });
+    });
+  };
+  Map2.prototype.clear = function clear2() {
+    if (this.size === 0) {
+      return this;
+    }
+    if (this.__ownerID) {
+      this.size = 0;
+      this._root = null;
+      this.__hash = void 0;
+      this.__altered = true;
+      return this;
+    }
+    return emptyMap();
+  };
+  Map2.prototype.sort = function sort2(comparator) {
+    return OrderedMap(sortFactory(this, comparator));
+  };
+  Map2.prototype.sortBy = function sortBy2(mapper, comparator) {
+    return OrderedMap(sortFactory(this, comparator, mapper));
+  };
+  Map2.prototype.map = function map5(mapper, context) {
+    var this$1$1 = this;
+    return this.withMutations(function(map6) {
+      map6.forEach(function(value, key) {
+        map6.set(key, mapper.call(context, value, key, this$1$1));
+      });
+    });
+  };
+  Map2.prototype.__iterator = function __iterator2(type, reverse3) {
+    return new MapIterator(this, type, reverse3);
+  };
+  Map2.prototype.__iterate = function __iterate2(fn, reverse3) {
+    var this$1$1 = this;
+    var iterations = 0;
+    this._root && this._root.iterate(function(entry) {
+      iterations++;
+      return fn(entry[1], entry[0], this$1$1);
+    }, reverse3);
+    return iterations;
+  };
+  Map2.prototype.__ensureOwner = function __ensureOwner2(ownerID) {
+    if (ownerID === this.__ownerID) {
+      return this;
+    }
+    if (!ownerID) {
+      if (this.size === 0) {
+        return emptyMap();
+      }
+      this.__ownerID = ownerID;
+      this.__altered = false;
+      return this;
+    }
+    return makeMap(this.size, this._root, ownerID, this.__hash);
+  };
+  return Map2;
+}(KeyedCollection);
+Map.isMap = isMap;
+var MapPrototype = Map.prototype;
+MapPrototype[IS_MAP_SYMBOL] = true;
+MapPrototype[DELETE] = MapPrototype.remove;
+MapPrototype.removeAll = MapPrototype.deleteAll;
+MapPrototype.setIn = setIn;
+MapPrototype.removeIn = MapPrototype.deleteIn = deleteIn;
+MapPrototype.update = update;
+MapPrototype.updateIn = updateIn;
+MapPrototype.merge = MapPrototype.concat = merge$1;
+MapPrototype.mergeWith = mergeWith$1;
+MapPrototype.mergeDeep = mergeDeep;
+MapPrototype.mergeDeepWith = mergeDeepWith;
+MapPrototype.mergeIn = mergeIn;
+MapPrototype.mergeDeepIn = mergeDeepIn;
+MapPrototype.withMutations = withMutations;
+MapPrototype.wasAltered = wasAltered;
+MapPrototype.asImmutable = asImmutable;
+MapPrototype["@@transducer/init"] = MapPrototype.asMutable = asMutable;
+MapPrototype["@@transducer/step"] = function(result, arr) {
+  return result.set(arr[0], arr[1]);
+};
+MapPrototype["@@transducer/result"] = function(obj) {
+  return obj.asImmutable();
+};
+var ArrayMapNode = function ArrayMapNode2(ownerID, entries3) {
+  this.ownerID = ownerID;
+  this.entries = entries3;
+};
+ArrayMapNode.prototype.get = function get2(shift, keyHash, key, notSetValue) {
+  var entries3 = this.entries;
+  for (var ii = 0, len = entries3.length; ii < len; ii++) {
+    if (is(key, entries3[ii][0])) {
+      return entries3[ii][1];
+    }
+  }
+  return notSetValue;
+};
+ArrayMapNode.prototype.update = function update2(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
+  var removed = value === NOT_SET;
+  var entries3 = this.entries;
+  var idx = 0;
+  var len = entries3.length;
+  for (; idx < len; idx++) {
+    if (is(key, entries3[idx][0])) {
+      break;
+    }
+  }
+  var exists = idx < len;
+  if (exists ? entries3[idx][1] === value : removed) {
+    return this;
+  }
+  SetRef(didAlter);
+  (removed || !exists) && SetRef(didChangeSize);
+  if (removed && entries3.length === 1) {
+    return;
+  }
+  if (!exists && !removed && entries3.length >= MAX_ARRAY_MAP_SIZE) {
+    return createNodes(ownerID, entries3, key, value);
+  }
+  var isEditable = ownerID && ownerID === this.ownerID;
+  var newEntries = isEditable ? entries3 : arrCopy(entries3);
+  if (exists) {
+    if (removed) {
+      idx === len - 1 ? newEntries.pop() : newEntries[idx] = newEntries.pop();
+    } else {
+      newEntries[idx] = [key, value];
+    }
+  } else {
+    newEntries.push([key, value]);
+  }
+  if (isEditable) {
+    this.entries = newEntries;
+    return this;
+  }
+  return new ArrayMapNode(ownerID, newEntries);
+};
+var BitmapIndexedNode = function BitmapIndexedNode2(ownerID, bitmap, nodes) {
+  this.ownerID = ownerID;
+  this.bitmap = bitmap;
+  this.nodes = nodes;
+};
+BitmapIndexedNode.prototype.get = function get3(shift, keyHash, key, notSetValue) {
+  if (keyHash === void 0) {
+    keyHash = hash(key);
+  }
+  var bit = 1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK);
+  var bitmap = this.bitmap;
+  return (bitmap & bit) === 0 ? notSetValue : this.nodes[popCount(bitmap & bit - 1)].get(
+    shift + SHIFT,
+    keyHash,
+    key,
+    notSetValue
+  );
+};
+BitmapIndexedNode.prototype.update = function update3(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
+  if (keyHash === void 0) {
+    keyHash = hash(key);
+  }
+  var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
+  var bit = 1 << keyHashFrag;
+  var bitmap = this.bitmap;
+  var exists = (bitmap & bit) !== 0;
+  if (!exists && value === NOT_SET) {
+    return this;
+  }
+  var idx = popCount(bitmap & bit - 1);
+  var nodes = this.nodes;
+  var node = exists ? nodes[idx] : void 0;
+  var newNode = updateNode(
+    node,
+    ownerID,
+    shift + SHIFT,
+    keyHash,
+    key,
+    value,
+    didChangeSize,
+    didAlter
+  );
+  if (newNode === node) {
+    return this;
+  }
+  if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {
+    return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);
+  }
+  if (exists && !newNode && nodes.length === 2 && isLeafNode(nodes[idx ^ 1])) {
+    return nodes[idx ^ 1];
+  }
+  if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {
+    return newNode;
+  }
+  var isEditable = ownerID && ownerID === this.ownerID;
+  var newBitmap = exists ? newNode ? bitmap : bitmap ^ bit : bitmap | bit;
+  var newNodes = exists ? newNode ? setAt(nodes, idx, newNode, isEditable) : spliceOut(nodes, idx, isEditable) : spliceIn(nodes, idx, newNode, isEditable);
+  if (isEditable) {
+    this.bitmap = newBitmap;
+    this.nodes = newNodes;
+    return this;
+  }
+  return new BitmapIndexedNode(ownerID, newBitmap, newNodes);
+};
+var HashArrayMapNode = function HashArrayMapNode2(ownerID, count2, nodes) {
+  this.ownerID = ownerID;
+  this.count = count2;
+  this.nodes = nodes;
+};
+HashArrayMapNode.prototype.get = function get4(shift, keyHash, key, notSetValue) {
+  if (keyHash === void 0) {
+    keyHash = hash(key);
+  }
+  var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
+  var node = this.nodes[idx];
+  return node ? node.get(shift + SHIFT, keyHash, key, notSetValue) : notSetValue;
+};
+HashArrayMapNode.prototype.update = function update4(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
+  if (keyHash === void 0) {
+    keyHash = hash(key);
+  }
+  var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
+  var removed = value === NOT_SET;
+  var nodes = this.nodes;
+  var node = nodes[idx];
+  if (removed && !node) {
+    return this;
+  }
+  var newNode = updateNode(
+    node,
+    ownerID,
+    shift + SHIFT,
+    keyHash,
+    key,
+    value,
+    didChangeSize,
+    didAlter
+  );
+  if (newNode === node) {
+    return this;
+  }
+  var newCount = this.count;
+  if (!node) {
+    newCount++;
+  } else if (!newNode) {
+    newCount--;
+    if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {
+      return packNodes(ownerID, nodes, newCount, idx);
+    }
+  }
+  var isEditable = ownerID && ownerID === this.ownerID;
+  var newNodes = setAt(nodes, idx, newNode, isEditable);
+  if (isEditable) {
+    this.count = newCount;
+    this.nodes = newNodes;
+    return this;
+  }
+  return new HashArrayMapNode(ownerID, newCount, newNodes);
+};
+var HashCollisionNode = function HashCollisionNode2(ownerID, keyHash, entries3) {
+  this.ownerID = ownerID;
+  this.keyHash = keyHash;
+  this.entries = entries3;
+};
+HashCollisionNode.prototype.get = function get5(shift, keyHash, key, notSetValue) {
+  var entries3 = this.entries;
+  for (var ii = 0, len = entries3.length; ii < len; ii++) {
+    if (is(key, entries3[ii][0])) {
+      return entries3[ii][1];
+    }
+  }
+  return notSetValue;
+};
+HashCollisionNode.prototype.update = function update5(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
+  if (keyHash === void 0) {
+    keyHash = hash(key);
+  }
+  var removed = value === NOT_SET;
+  if (keyHash !== this.keyHash) {
+    if (removed) {
+      return this;
+    }
+    SetRef(didAlter);
+    SetRef(didChangeSize);
+    return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);
+  }
+  var entries3 = this.entries;
+  var idx = 0;
+  var len = entries3.length;
+  for (; idx < len; idx++) {
+    if (is(key, entries3[idx][0])) {
+      break;
+    }
+  }
+  var exists = idx < len;
+  if (exists ? entries3[idx][1] === value : removed) {
+    return this;
+  }
+  SetRef(didAlter);
+  (removed || !exists) && SetRef(didChangeSize);
+  if (removed && len === 2) {
+    return new ValueNode(ownerID, this.keyHash, entries3[idx ^ 1]);
+  }
+  var isEditable = ownerID && ownerID === this.ownerID;
+  var newEntries = isEditable ? entries3 : arrCopy(entries3);
+  if (exists) {
+    if (removed) {
+      idx === len - 1 ? newEntries.pop() : newEntries[idx] = newEntries.pop();
+    } else {
+      newEntries[idx] = [key, value];
+    }
+  } else {
+    newEntries.push([key, value]);
+  }
+  if (isEditable) {
+    this.entries = newEntries;
+    return this;
+  }
+  return new HashCollisionNode(ownerID, this.keyHash, newEntries);
+};
+var ValueNode = function ValueNode2(ownerID, keyHash, entry) {
+  this.ownerID = ownerID;
+  this.keyHash = keyHash;
+  this.entry = entry;
+};
+ValueNode.prototype.get = function get6(shift, keyHash, key, notSetValue) {
+  return is(key, this.entry[0]) ? this.entry[1] : notSetValue;
+};
+ValueNode.prototype.update = function update6(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
+  var removed = value === NOT_SET;
+  var keyMatch = is(key, this.entry[0]);
+  if (keyMatch ? value === this.entry[1] : removed) {
+    return this;
+  }
+  SetRef(didAlter);
+  if (removed) {
+    SetRef(didChangeSize);
+    return;
+  }
+  if (keyMatch) {
+    if (ownerID && ownerID === this.ownerID) {
+      this.entry[1] = value;
+      return this;
+    }
+    return new ValueNode(ownerID, this.keyHash, [key, value]);
+  }
+  SetRef(didChangeSize);
+  return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);
+};
+ArrayMapNode.prototype.iterate = HashCollisionNode.prototype.iterate = function(fn, reverse3) {
+  var entries3 = this.entries;
+  for (var ii = 0, maxIndex = entries3.length - 1; ii <= maxIndex; ii++) {
+    if (fn(entries3[reverse3 ? maxIndex - ii : ii]) === false) {
+      return false;
+    }
+  }
+};
+BitmapIndexedNode.prototype.iterate = HashArrayMapNode.prototype.iterate = function(fn, reverse3) {
+  var nodes = this.nodes;
+  for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {
+    var node = nodes[reverse3 ? maxIndex - ii : ii];
+    if (node && node.iterate(fn, reverse3) === false) {
+      return false;
+    }
+  }
+};
+ValueNode.prototype.iterate = function(fn, reverse3) {
+  return fn(this.entry);
+};
+var MapIterator = /* @__PURE__ */ function(Iterator3) {
+  function MapIterator2(map5, type, reverse3) {
+    this._type = type;
+    this._reverse = reverse3;
+    this._stack = map5._root && mapIteratorFrame(map5._root);
+  }
+  if (Iterator3) MapIterator2.__proto__ = Iterator3;
+  MapIterator2.prototype = Object.create(Iterator3 && Iterator3.prototype);
+  MapIterator2.prototype.constructor = MapIterator2;
+  MapIterator2.prototype.next = function next() {
+    var type = this._type;
+    var stack = this._stack;
+    while (stack) {
+      var node = stack.node;
+      var index = stack.index++;
+      var maxIndex = void 0;
+      if (node.entry) {
+        if (index === 0) {
+          return mapIteratorValue(type, node.entry);
+        }
+      } else if (node.entries) {
+        maxIndex = node.entries.length - 1;
+        if (index <= maxIndex) {
+          return mapIteratorValue(
+            type,
+            node.entries[this._reverse ? maxIndex - index : index]
+          );
+        }
+      } else {
+        maxIndex = node.nodes.length - 1;
+        if (index <= maxIndex) {
+          var subNode = node.nodes[this._reverse ? maxIndex - index : index];
+          if (subNode) {
+            if (subNode.entry) {
+              return mapIteratorValue(type, subNode.entry);
+            }
+            stack = this._stack = mapIteratorFrame(subNode, stack);
+          }
+          continue;
+        }
+      }
+      stack = this._stack = this._stack.__prev;
+    }
+    return iteratorDone();
+  };
+  return MapIterator2;
+}(Iterator);
+function mapIteratorValue(type, entry) {
+  return iteratorValue(type, entry[0], entry[1]);
+}
+function mapIteratorFrame(node, prev) {
+  return {
+    node,
+    index: 0,
+    __prev: prev
+  };
+}
+function makeMap(size, root, ownerID, hash2) {
+  var map5 = Object.create(MapPrototype);
+  map5.size = size;
+  map5._root = root;
+  map5.__ownerID = ownerID;
+  map5.__hash = hash2;
+  map5.__altered = false;
+  return map5;
+}
+var EMPTY_MAP;
+function emptyMap() {
+  return EMPTY_MAP || (EMPTY_MAP = makeMap(0));
+}
+function updateMap(map5, k, v) {
+  var newRoot;
+  var newSize;
+  if (!map5._root) {
+    if (v === NOT_SET) {
+      return map5;
+    }
+    newSize = 1;
+    newRoot = new ArrayMapNode(map5.__ownerID, [[k, v]]);
+  } else {
+    var didChangeSize = MakeRef();
+    var didAlter = MakeRef();
+    newRoot = updateNode(
+      map5._root,
+      map5.__ownerID,
+      0,
+      void 0,
+      k,
+      v,
+      didChangeSize,
+      didAlter
+    );
+    if (!didAlter.value) {
+      return map5;
+    }
+    newSize = map5.size + (didChangeSize.value ? v === NOT_SET ? -1 : 1 : 0);
+  }
+  if (map5.__ownerID) {
+    map5.size = newSize;
+    map5._root = newRoot;
+    map5.__hash = void 0;
+    map5.__altered = true;
+    return map5;
+  }
+  return newRoot ? makeMap(newSize, newRoot) : emptyMap();
+}
+function updateNode(node, ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
+  if (!node) {
+    if (value === NOT_SET) {
+      return node;
+    }
+    SetRef(didAlter);
+    SetRef(didChangeSize);
+    return new ValueNode(ownerID, keyHash, [key, value]);
+  }
+  return node.update(
+    ownerID,
+    shift,
+    keyHash,
+    key,
+    value,
+    didChangeSize,
+    didAlter
+  );
+}
+function isLeafNode(node) {
+  return node.constructor === ValueNode || node.constructor === HashCollisionNode;
+}
+function mergeIntoNode(node, ownerID, shift, keyHash, entry) {
+  if (node.keyHash === keyHash) {
+    return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);
+  }
+  var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;
+  var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
+  var newNode;
+  var nodes = idx1 === idx2 ? [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)] : (newNode = new ValueNode(ownerID, keyHash, entry), idx1 < idx2 ? [node, newNode] : [newNode, node]);
+  return new BitmapIndexedNode(ownerID, 1 << idx1 | 1 << idx2, nodes);
+}
+function createNodes(ownerID, entries3, key, value) {
+  if (!ownerID) {
+    ownerID = new OwnerID();
+  }
+  var node = new ValueNode(ownerID, hash(key), [key, value]);
+  for (var ii = 0; ii < entries3.length; ii++) {
+    var entry = entries3[ii];
+    node = node.update(ownerID, 0, void 0, entry[0], entry[1]);
+  }
+  return node;
+}
+function packNodes(ownerID, nodes, count2, excluding) {
+  var bitmap = 0;
+  var packedII = 0;
+  var packedNodes = new Array(count2);
+  for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {
+    var node = nodes[ii];
+    if (node !== void 0 && ii !== excluding) {
+      bitmap |= bit;
+      packedNodes[packedII++] = node;
+    }
+  }
+  return new BitmapIndexedNode(ownerID, bitmap, packedNodes);
+}
+function expandNodes(ownerID, nodes, bitmap, including, node) {
+  var count2 = 0;
+  var expandedNodes = new Array(SIZE);
+  for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {
+    expandedNodes[ii] = bitmap & 1 ? nodes[count2++] : void 0;
+  }
+  expandedNodes[including] = node;
+  return new HashArrayMapNode(ownerID, count2 + 1, expandedNodes);
+}
+function popCount(x) {
+  x -= x >> 1 & 1431655765;
+  x = (x & 858993459) + (x >> 2 & 858993459);
+  x = x + (x >> 4) & 252645135;
+  x += x >> 8;
+  x += x >> 16;
+  return x & 127;
+}
+function setAt(array, idx, val, canEdit) {
+  var newArray = canEdit ? array : arrCopy(array);
+  newArray[idx] = val;
+  return newArray;
+}
+function spliceIn(array, idx, val, canEdit) {
+  var newLen = array.length + 1;
+  if (canEdit && idx + 1 === newLen) {
+    array[idx] = val;
+    return array;
+  }
+  var newArray = new Array(newLen);
+  var after = 0;
+  for (var ii = 0; ii < newLen; ii++) {
+    if (ii === idx) {
+      newArray[ii] = val;
+      after = -1;
+    } else {
+      newArray[ii] = array[ii + after];
+    }
+  }
+  return newArray;
+}
+function spliceOut(array, idx, canEdit) {
+  var newLen = array.length - 1;
+  if (canEdit && idx === newLen) {
+    array.pop();
+    return array;
+  }
+  var newArray = new Array(newLen);
+  var after = 0;
+  for (var ii = 0; ii < newLen; ii++) {
+    if (ii === idx) {
+      after = 1;
+    }
+    newArray[ii] = array[ii + after];
+  }
+  return newArray;
+}
+var MAX_ARRAY_MAP_SIZE = SIZE / 4;
+var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
+var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;
+var IS_LIST_SYMBOL = "@@__IMMUTABLE_LIST__@@";
+function isList(maybeList) {
+  return Boolean(maybeList && // @ts-expect-error: maybeList is typed as `{}`, need to change in 6.0 to `maybeList && typeof maybeList === 'object' && IS_LIST_SYMBOL in maybeList`
+  maybeList[IS_LIST_SYMBOL]);
+}
+var List = /* @__PURE__ */ function(IndexedCollection2) {
+  function List2(value) {
+    var empty = emptyList();
+    if (value === void 0 || value === null) {
+      return empty;
+    }
+    if (isList(value)) {
+      return value;
+    }
+    var iter = IndexedCollection2(value);
+    var size = iter.size;
+    if (size === 0) {
+      return empty;
+    }
+    assertNotInfinite(size);
+    if (size > 0 && size < SIZE) {
+      return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));
+    }
+    return empty.withMutations(function(list) {
+      list.setSize(size);
+      iter.forEach(function(v, i) {
+        return list.set(i, v);
+      });
+    });
+  }
+  if (IndexedCollection2) List2.__proto__ = IndexedCollection2;
+  List2.prototype = Object.create(IndexedCollection2 && IndexedCollection2.prototype);
+  List2.prototype.constructor = List2;
+  List2.of = function of3() {
+    return this(arguments);
+  };
+  List2.prototype.toString = function toString5() {
+    return this.__toString("List [", "]");
+  };
+  List2.prototype.get = function get11(index, notSetValue) {
+    index = wrapIndex(this, index);
+    if (index >= 0 && index < this.size) {
+      index += this._origin;
+      var node = listNodeFor(this, index);
+      return node && node.array[index & MASK];
+    }
+    return notSetValue;
+  };
+  List2.prototype.set = function set3(index, value) {
+    return updateList(this, index, value);
+  };
+  List2.prototype.remove = function remove3(index) {
+    return !this.has(index) ? this : index === 0 ? this.shift() : index === this.size - 1 ? this.pop() : this.splice(index, 1);
+  };
+  List2.prototype.insert = function insert(index, value) {
+    return this.splice(index, 0, value);
+  };
+  List2.prototype.clear = function clear2() {
+    if (this.size === 0) {
+      return this;
+    }
+    if (this.__ownerID) {
+      this.size = this._origin = this._capacity = 0;
+      this._level = SHIFT;
+      this._root = this._tail = this.__hash = void 0;
+      this.__altered = true;
+      return this;
+    }
+    return emptyList();
+  };
+  List2.prototype.push = function push() {
+    var values2 = arguments;
+    var oldSize = this.size;
+    return this.withMutations(function(list) {
+      setListBounds(list, 0, oldSize + values2.length);
+      for (var ii = 0; ii < values2.length; ii++) {
+        list.set(oldSize + ii, values2[ii]);
+      }
+    });
+  };
+  List2.prototype.pop = function pop() {
+    return setListBounds(this, 0, -1);
+  };
+  List2.prototype.unshift = function unshift() {
+    var values2 = arguments;
+    return this.withMutations(function(list) {
+      setListBounds(list, -values2.length);
+      for (var ii = 0; ii < values2.length; ii++) {
+        list.set(ii, values2[ii]);
+      }
+    });
+  };
+  List2.prototype.shift = function shift() {
+    return setListBounds(this, 1);
+  };
+  List2.prototype.shuffle = function shuffle(random) {
+    if (random === void 0) random = Math.random;
+    return this.withMutations(function(mutable) {
+      var current = mutable.size;
+      var destination;
+      var tmp;
+      while (current) {
+        destination = Math.floor(random() * current--);
+        tmp = mutable.get(destination);
+        mutable.set(destination, mutable.get(current));
+        mutable.set(current, tmp);
+      }
+    });
+  };
+  List2.prototype.concat = function concat2() {
+    var arguments$1 = arguments;
+    var seqs = [];
+    for (var i = 0; i < arguments.length; i++) {
+      var argument = arguments$1[i];
+      var seq = IndexedCollection2(
+        typeof argument !== "string" && hasIterator(argument) ? argument : [argument]
+      );
+      if (seq.size !== 0) {
+        seqs.push(seq);
+      }
+    }
+    if (seqs.length === 0) {
+      return this;
+    }
+    if (this.size === 0 && !this.__ownerID && seqs.length === 1) {
+      return this.constructor(seqs[0]);
+    }
+    return this.withMutations(function(list) {
+      seqs.forEach(function(seq2) {
+        return seq2.forEach(function(value) {
+          return list.push(value);
+        });
+      });
+    });
+  };
+  List2.prototype.setSize = function setSize(size) {
+    return setListBounds(this, 0, size);
+  };
+  List2.prototype.map = function map5(mapper, context) {
+    var this$1$1 = this;
+    return this.withMutations(function(list) {
+      for (var i = 0; i < this$1$1.size; i++) {
+        list.set(i, mapper.call(context, list.get(i), i, this$1$1));
+      }
+    });
+  };
+  List2.prototype.slice = function slice3(begin, end) {
+    var size = this.size;
+    if (wholeSlice(begin, end, size)) {
+      return this;
+    }
+    return setListBounds(
+      this,
+      resolveBegin(begin, size),
+      resolveEnd(end, size)
+    );
+  };
+  List2.prototype.__iterator = function __iterator2(type, reverse3) {
+    var index = reverse3 ? this.size : 0;
+    var values2 = iterateList(this, reverse3);
+    return new Iterator(function() {
+      var value = values2();
+      return value === DONE ? iteratorDone() : iteratorValue(type, reverse3 ? --index : index++, value);
+    });
+  };
+  List2.prototype.__iterate = function __iterate2(fn, reverse3) {
+    var index = reverse3 ? this.size : 0;
+    var values2 = iterateList(this, reverse3);
+    var value;
+    while ((value = values2()) !== DONE) {
+      if (fn(value, reverse3 ? --index : index++, this) === false) {
+        break;
+      }
+    }
+    return index;
+  };
+  List2.prototype.__ensureOwner = function __ensureOwner2(ownerID) {
+    if (ownerID === this.__ownerID) {
+      return this;
+    }
+    if (!ownerID) {
+      if (this.size === 0) {
+        return emptyList();
+      }
+      this.__ownerID = ownerID;
+      this.__altered = false;
+      return this;
+    }
+    return makeList(
+      this._origin,
+      this._capacity,
+      this._level,
+      this._root,
+      this._tail,
+      ownerID,
+      this.__hash
+    );
+  };
+  return List2;
+}(IndexedCollection);
+List.isList = isList;
+var ListPrototype = List.prototype;
+ListPrototype[IS_LIST_SYMBOL] = true;
+ListPrototype[DELETE] = ListPrototype.remove;
+ListPrototype.merge = ListPrototype.concat;
+ListPrototype.setIn = setIn;
+ListPrototype.deleteIn = ListPrototype.removeIn = deleteIn;
+ListPrototype.update = update;
+ListPrototype.updateIn = updateIn;
+ListPrototype.mergeIn = mergeIn;
+ListPrototype.mergeDeepIn = mergeDeepIn;
+ListPrototype.withMutations = withMutations;
+ListPrototype.wasAltered = wasAltered;
+ListPrototype.asImmutable = asImmutable;
+ListPrototype["@@transducer/init"] = ListPrototype.asMutable = asMutable;
+ListPrototype["@@transducer/step"] = function(result, arr) {
+  return result.push(arr);
+};
+ListPrototype["@@transducer/result"] = function(obj) {
+  return obj.asImmutable();
+};
+var VNode = function VNode2(array, ownerID) {
+  this.array = array;
+  this.ownerID = ownerID;
+};
+VNode.prototype.removeBefore = function removeBefore(ownerID, level, index) {
+  if ((index & (1 << level + SHIFT) - 1) === 0 || this.array.length === 0) {
+    return this;
+  }
+  var originIndex = index >>> level & MASK;
+  if (originIndex >= this.array.length) {
+    return new VNode([], ownerID);
+  }
+  var removingFirst = originIndex === 0;
+  var newChild;
+  if (level > 0) {
+    var oldChild = this.array[originIndex];
+    newChild = oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);
+    if (newChild === oldChild && removingFirst) {
+      return this;
+    }
+  }
+  if (removingFirst && !newChild) {
+    return this;
+  }
+  var editable = editableVNode(this, ownerID);
+  if (!removingFirst) {
+    for (var ii = 0; ii < originIndex; ii++) {
+      editable.array[ii] = void 0;
+    }
+  }
+  if (newChild) {
+    editable.array[originIndex] = newChild;
+  }
+  return editable;
+};
+VNode.prototype.removeAfter = function removeAfter(ownerID, level, index) {
+  if (index === (level ? 1 << level + SHIFT : SIZE) || this.array.length === 0) {
+    return this;
+  }
+  var sizeIndex = index - 1 >>> level & MASK;
+  if (sizeIndex >= this.array.length) {
+    return this;
+  }
+  var newChild;
+  if (level > 0) {
+    var oldChild = this.array[sizeIndex];
+    newChild = oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);
+    if (newChild === oldChild && sizeIndex === this.array.length - 1) {
+      return this;
+    }
+  }
+  var editable = editableVNode(this, ownerID);
+  editable.array.splice(sizeIndex + 1);
+  if (newChild) {
+    editable.array[sizeIndex] = newChild;
+  }
+  return editable;
+};
+var DONE = {};
+function iterateList(list, reverse3) {
+  var left = list._origin;
+  var right = list._capacity;
+  var tailPos = getTailOffset(right);
+  var tail = list._tail;
+  return iterateNodeOrLeaf(list._root, list._level, 0);
+  function iterateNodeOrLeaf(node, level, offset) {
+    return level === 0 ? iterateLeaf(node, offset) : iterateNode(node, level, offset);
+  }
+  function iterateLeaf(node, offset) {
+    var array = offset === tailPos ? tail && tail.array : node && node.array;
+    var from = offset > left ? 0 : left - offset;
+    var to = right - offset;
+    if (to > SIZE) {
+      to = SIZE;
+    }
+    return function() {
+      if (from === to) {
+        return DONE;
+      }
+      var idx = reverse3 ? --to : from++;
+      return array && array[idx];
+    };
+  }
+  function iterateNode(node, level, offset) {
+    var values2;
+    var array = node && node.array;
+    var from = offset > left ? 0 : left - offset >> level;
+    var to = (right - offset >> level) + 1;
+    if (to > SIZE) {
+      to = SIZE;
+    }
+    return function() {
+      while (true) {
+        if (values2) {
+          var value = values2();
+          if (value !== DONE) {
+            return value;
+          }
+          values2 = null;
+        }
+        if (from === to) {
+          return DONE;
+        }
+        var idx = reverse3 ? --to : from++;
+        values2 = iterateNodeOrLeaf(
+          array && array[idx],
+          level - SHIFT,
+          offset + (idx << level)
+        );
+      }
+    };
+  }
+}
+function makeList(origin, capacity, level, root, tail, ownerID, hash2) {
+  var list = Object.create(ListPrototype);
+  list.size = capacity - origin;
+  list._origin = origin;
+  list._capacity = capacity;
+  list._level = level;
+  list._root = root;
+  list._tail = tail;
+  list.__ownerID = ownerID;
+  list.__hash = hash2;
+  list.__altered = false;
+  return list;
+}
+function emptyList() {
+  return makeList(0, 0, SHIFT);
+}
+function updateList(list, index, value) {
+  index = wrapIndex(list, index);
+  if (index !== index) {
+    return list;
+  }
+  if (index >= list.size || index < 0) {
+    return list.withMutations(function(list2) {
+      index < 0 ? setListBounds(list2, index).set(0, value) : setListBounds(list2, 0, index + 1).set(index, value);
+    });
+  }
+  index += list._origin;
+  var newTail = list._tail;
+  var newRoot = list._root;
+  var didAlter = MakeRef();
+  if (index >= getTailOffset(list._capacity)) {
+    newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);
+  } else {
+    newRoot = updateVNode(
+      newRoot,
+      list.__ownerID,
+      list._level,
+      index,
+      value,
+      didAlter
+    );
+  }
+  if (!didAlter.value) {
+    return list;
+  }
+  if (list.__ownerID) {
+    list._root = newRoot;
+    list._tail = newTail;
+    list.__hash = void 0;
+    list.__altered = true;
+    return list;
+  }
+  return makeList(list._origin, list._capacity, list._level, newRoot, newTail);
+}
+function updateVNode(node, ownerID, level, index, value, didAlter) {
+  var idx = index >>> level & MASK;
+  var nodeHas = node && idx < node.array.length;
+  if (!nodeHas && value === void 0) {
+    return node;
+  }
+  var newNode;
+  if (level > 0) {
+    var lowerNode = node && node.array[idx];
+    var newLowerNode = updateVNode(
+      lowerNode,
+      ownerID,
+      level - SHIFT,
+      index,
+      value,
+      didAlter
+    );
+    if (newLowerNode === lowerNode) {
+      return node;
+    }
+    newNode = editableVNode(node, ownerID);
+    newNode.array[idx] = newLowerNode;
+    return newNode;
+  }
+  if (nodeHas && node.array[idx] === value) {
+    return node;
+  }
+  if (didAlter) {
+    SetRef(didAlter);
+  }
+  newNode = editableVNode(node, ownerID);
+  if (value === void 0 && idx === newNode.array.length - 1) {
+    newNode.array.pop();
+  } else {
+    newNode.array[idx] = value;
+  }
+  return newNode;
+}
+function editableVNode(node, ownerID) {
+  if (ownerID && node && ownerID === node.ownerID) {
+    return node;
+  }
+  return new VNode(node ? node.array.slice() : [], ownerID);
+}
+function listNodeFor(list, rawIndex) {
+  if (rawIndex >= getTailOffset(list._capacity)) {
+    return list._tail;
+  }
+  if (rawIndex < 1 << list._level + SHIFT) {
+    var node = list._root;
+    var level = list._level;
+    while (node && level > 0) {
+      node = node.array[rawIndex >>> level & MASK];
+      level -= SHIFT;
+    }
+    return node;
+  }
+}
+function setListBounds(list, begin, end) {
+  if (begin !== void 0) {
+    begin |= 0;
+  }
+  if (end !== void 0) {
+    end |= 0;
+  }
+  var owner = list.__ownerID || new OwnerID();
+  var oldOrigin = list._origin;
+  var oldCapacity = list._capacity;
+  var newOrigin = oldOrigin + begin;
+  var newCapacity = end === void 0 ? oldCapacity : end < 0 ? oldCapacity + end : oldOrigin + end;
+  if (newOrigin === oldOrigin && newCapacity === oldCapacity) {
+    return list;
+  }
+  if (newOrigin >= newCapacity) {
+    return list.clear();
+  }
+  var newLevel = list._level;
+  var newRoot = list._root;
+  var offsetShift = 0;
+  while (newOrigin + offsetShift < 0) {
+    newRoot = new VNode(
+      newRoot && newRoot.array.length ? [void 0, newRoot] : [],
+      owner
+    );
+    newLevel += SHIFT;
+    offsetShift += 1 << newLevel;
+  }
+  if (offsetShift) {
+    newOrigin += offsetShift;
+    oldOrigin += offsetShift;
+    newCapacity += offsetShift;
+    oldCapacity += offsetShift;
+  }
+  var oldTailOffset = getTailOffset(oldCapacity);
+  var newTailOffset = getTailOffset(newCapacity);
+  while (newTailOffset >= 1 << newLevel + SHIFT) {
+    newRoot = new VNode(
+      newRoot && newRoot.array.length ? [newRoot] : [],
+      owner
+    );
+    newLevel += SHIFT;
+  }
+  var oldTail = list._tail;
+  var newTail = newTailOffset < oldTailOffset ? listNodeFor(list, newCapacity - 1) : newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail;
+  if (oldTail && newTailOffset > oldTailOffset && newOrigin < oldCapacity && oldTail.array.length) {
+    newRoot = editableVNode(newRoot, owner);
+    var node = newRoot;
+    for (var level = newLevel; level > SHIFT; level -= SHIFT) {
+      var idx = oldTailOffset >>> level & MASK;
+      node = node.array[idx] = editableVNode(node.array[idx], owner);
+    }
+    node.array[oldTailOffset >>> SHIFT & MASK] = oldTail;
+  }
+  if (newCapacity < oldCapacity) {
+    newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);
+  }
+  if (newOrigin >= newTailOffset) {
+    newOrigin -= newTailOffset;
+    newCapacity -= newTailOffset;
+    newLevel = SHIFT;
+    newRoot = null;
+    newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);
+  } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {
+    offsetShift = 0;
+    while (newRoot) {
+      var beginIndex = newOrigin >>> newLevel & MASK;
+      if (beginIndex !== newTailOffset >>> newLevel & MASK) {
+        break;
+      }
+      if (beginIndex) {
+        offsetShift += (1 << newLevel) * beginIndex;
+      }
+      newLevel -= SHIFT;
+      newRoot = newRoot.array[beginIndex];
+    }
+    if (newRoot && newOrigin > oldOrigin) {
+      newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);
+    }
+    if (newRoot && newTailOffset < oldTailOffset) {
+      newRoot = newRoot.removeAfter(
+        owner,
+        newLevel,
+        newTailOffset - offsetShift
+      );
+    }
+    if (offsetShift) {
+      newOrigin -= offsetShift;
+      newCapacity -= offsetShift;
+    }
+  }
+  if (list.__ownerID) {
+    list.size = newCapacity - newOrigin;
+    list._origin = newOrigin;
+    list._capacity = newCapacity;
+    list._level = newLevel;
+    list._root = newRoot;
+    list._tail = newTail;
+    list.__hash = void 0;
+    list.__altered = true;
+    return list;
+  }
+  return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);
+}
+function getTailOffset(size) {
+  return size < SIZE ? 0 : size - 1 >>> SHIFT << SHIFT;
+}
+var OrderedMap = /* @__PURE__ */ function(Map2) {
+  function OrderedMap2(value) {
+    return value === void 0 || value === null ? emptyOrderedMap() : isOrderedMap(value) ? value : emptyOrderedMap().withMutations(function(map5) {
+      var iter = KeyedCollection(value);
+      assertNotInfinite(iter.size);
+      iter.forEach(function(v, k) {
+        return map5.set(k, v);
+      });
+    });
+  }
+  if (Map2) OrderedMap2.__proto__ = Map2;
+  OrderedMap2.prototype = Object.create(Map2 && Map2.prototype);
+  OrderedMap2.prototype.constructor = OrderedMap2;
+  OrderedMap2.of = function of3() {
+    return this(arguments);
+  };
+  OrderedMap2.prototype.toString = function toString5() {
+    return this.__toString("OrderedMap {", "}");
+  };
+  OrderedMap2.prototype.get = function get11(k, notSetValue) {
+    var index = this._map.get(k);
+    return index !== void 0 ? this._list.get(index)[1] : notSetValue;
+  };
+  OrderedMap2.prototype.clear = function clear2() {
+    if (this.size === 0) {
+      return this;
+    }
+    if (this.__ownerID) {
+      this.size = 0;
+      this._map.clear();
+      this._list.clear();
+      this.__altered = true;
+      return this;
+    }
+    return emptyOrderedMap();
+  };
+  OrderedMap2.prototype.set = function set3(k, v) {
+    return updateOrderedMap(this, k, v);
+  };
+  OrderedMap2.prototype.remove = function remove3(k) {
+    return updateOrderedMap(this, k, NOT_SET);
+  };
+  OrderedMap2.prototype.__iterate = function __iterate2(fn, reverse3) {
+    var this$1$1 = this;
+    return this._list.__iterate(
+      function(entry) {
+        return entry && fn(entry[1], entry[0], this$1$1);
+      },
+      reverse3
+    );
+  };
+  OrderedMap2.prototype.__iterator = function __iterator2(type, reverse3) {
+    return this._list.fromEntrySeq().__iterator(type, reverse3);
+  };
+  OrderedMap2.prototype.__ensureOwner = function __ensureOwner2(ownerID) {
+    if (ownerID === this.__ownerID) {
+      return this;
+    }
+    var newMap = this._map.__ensureOwner(ownerID);
+    var newList = this._list.__ensureOwner(ownerID);
+    if (!ownerID) {
+      if (this.size === 0) {
+        return emptyOrderedMap();
+      }
+      this.__ownerID = ownerID;
+      this.__altered = false;
+      this._map = newMap;
+      this._list = newList;
+      return this;
+    }
+    return makeOrderedMap(newMap, newList, ownerID, this.__hash);
+  };
+  return OrderedMap2;
+}(Map);
+OrderedMap.isOrderedMap = isOrderedMap;
+OrderedMap.prototype[IS_ORDERED_SYMBOL] = true;
+OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;
+function makeOrderedMap(map5, list, ownerID, hash2) {
+  var omap = Object.create(OrderedMap.prototype);
+  omap.size = map5 ? map5.size : 0;
+  omap._map = map5;
+  omap._list = list;
+  omap.__ownerID = ownerID;
+  omap.__hash = hash2;
+  omap.__altered = false;
+  return omap;
+}
+var EMPTY_ORDERED_MAP;
+function emptyOrderedMap() {
+  return EMPTY_ORDERED_MAP || (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()));
+}
+function updateOrderedMap(omap, k, v) {
+  var map5 = omap._map;
+  var list = omap._list;
+  var i = map5.get(k);
+  var has5 = i !== void 0;
+  var newMap;
+  var newList;
+  if (v === NOT_SET) {
+    if (!has5) {
+      return omap;
+    }
+    if (list.size >= SIZE && list.size >= map5.size * 2) {
+      newList = list.filter(function(entry, idx) {
+        return entry !== void 0 && i !== idx;
+      });
+      newMap = newList.toKeyedSeq().map(function(entry) {
+        return entry[0];
+      }).flip().toMap();
+      if (omap.__ownerID) {
+        newMap.__ownerID = newList.__ownerID = omap.__ownerID;
+      }
+    } else {
+      newMap = map5.remove(k);
+      newList = i === list.size - 1 ? list.pop() : list.set(i, void 0);
+    }
+  } else if (has5) {
+    if (v === list.get(i)[1]) {
+      return omap;
+    }
+    newMap = map5;
+    newList = list.set(i, [k, v]);
+  } else {
+    newMap = map5.set(k, list.size);
+    newList = list.set(list.size, [k, v]);
+  }
+  if (omap.__ownerID) {
+    omap.size = newMap.size;
+    omap._map = newMap;
+    omap._list = newList;
+    omap.__hash = void 0;
+    omap.__altered = true;
+    return omap;
+  }
+  return makeOrderedMap(newMap, newList);
+}
+var IS_STACK_SYMBOL = "@@__IMMUTABLE_STACK__@@";
+function isStack(maybeStack) {
+  return Boolean(maybeStack && // @ts-expect-error: maybeStack is typed as `{}`, need to change in 6.0 to `maybeStack && typeof maybeStack === 'object' && MAYBE_STACK_SYMBOL in maybeStack`
+  maybeStack[IS_STACK_SYMBOL]);
+}
+var Stack = /* @__PURE__ */ function(IndexedCollection2) {
+  function Stack2(value) {
+    return value === void 0 || value === null ? emptyStack() : isStack(value) ? value : emptyStack().pushAll(value);
+  }
+  if (IndexedCollection2) Stack2.__proto__ = IndexedCollection2;
+  Stack2.prototype = Object.create(IndexedCollection2 && IndexedCollection2.prototype);
+  Stack2.prototype.constructor = Stack2;
+  Stack2.of = function of3() {
+    return this(arguments);
+  };
+  Stack2.prototype.toString = function toString5() {
+    return this.__toString("Stack [", "]");
+  };
+  Stack2.prototype.get = function get11(index, notSetValue) {
+    var head = this._head;
+    index = wrapIndex(this, index);
+    while (head && index--) {
+      head = head.next;
+    }
+    return head ? head.value : notSetValue;
+  };
+  Stack2.prototype.peek = function peek() {
+    return this._head && this._head.value;
+  };
+  Stack2.prototype.push = function push() {
+    var arguments$1 = arguments;
+    if (arguments.length === 0) {
+      return this;
+    }
+    var newSize = this.size + arguments.length;
+    var head = this._head;
+    for (var ii = arguments.length - 1; ii >= 0; ii--) {
+      head = {
+        value: arguments$1[ii],
+        next: head
+      };
+    }
+    if (this.__ownerID) {
+      this.size = newSize;
+      this._head = head;
+      this.__hash = void 0;
+      this.__altered = true;
+      return this;
+    }
+    return makeStack(newSize, head);
+  };
+  Stack2.prototype.pushAll = function pushAll(iter) {
+    iter = IndexedCollection2(iter);
+    if (iter.size === 0) {
+      return this;
+    }
+    if (this.size === 0 && isStack(iter)) {
+      return iter;
+    }
+    assertNotInfinite(iter.size);
+    var newSize = this.size;
+    var head = this._head;
+    iter.__iterate(
+      function(value) {
+        newSize++;
+        head = {
+          value,
+          next: head
+        };
+      },
+      /* reverse */
+      true
+    );
+    if (this.__ownerID) {
+      this.size = newSize;
+      this._head = head;
+      this.__hash = void 0;
+      this.__altered = true;
+      return this;
+    }
+    return makeStack(newSize, head);
+  };
+  Stack2.prototype.pop = function pop() {
+    return this.slice(1);
+  };
+  Stack2.prototype.clear = function clear2() {
+    if (this.size === 0) {
+      return this;
+    }
+    if (this.__ownerID) {
+      this.size = 0;
+      this._head = void 0;
+      this.__hash = void 0;
+      this.__altered = true;
+      return this;
+    }
+    return emptyStack();
+  };
+  Stack2.prototype.slice = function slice3(begin, end) {
+    if (wholeSlice(begin, end, this.size)) {
+      return this;
+    }
+    var resolvedBegin = resolveBegin(begin, this.size);
+    var resolvedEnd = resolveEnd(end, this.size);
+    if (resolvedEnd !== this.size) {
+      return IndexedCollection2.prototype.slice.call(this, begin, end);
+    }
+    var newSize = this.size - resolvedBegin;
+    var head = this._head;
+    while (resolvedBegin--) {
+      head = head.next;
+    }
+    if (this.__ownerID) {
+      this.size = newSize;
+      this._head = head;
+      this.__hash = void 0;
+      this.__altered = true;
+      return this;
+    }
+    return makeStack(newSize, head);
+  };
+  Stack2.prototype.__ensureOwner = function __ensureOwner2(ownerID) {
+    if (ownerID === this.__ownerID) {
+      return this;
+    }
+    if (!ownerID) {
+      if (this.size === 0) {
+        return emptyStack();
+      }
+      this.__ownerID = ownerID;
+      this.__altered = false;
+      return this;
+    }
+    return makeStack(this.size, this._head, ownerID, this.__hash);
+  };
+  Stack2.prototype.__iterate = function __iterate2(fn, reverse3) {
+    var this$1$1 = this;
+    if (reverse3) {
+      return new ArraySeq(this.toArray()).__iterate(
+        function(v, k) {
+          return fn(v, k, this$1$1);
+        },
+        reverse3
+      );
+    }
+    var iterations = 0;
+    var node = this._head;
+    while (node) {
+      if (fn(node.value, iterations++, this) === false) {
+        break;
+      }
+      node = node.next;
+    }
+    return iterations;
+  };
+  Stack2.prototype.__iterator = function __iterator2(type, reverse3) {
+    if (reverse3) {
+      return new ArraySeq(this.toArray()).__iterator(type, reverse3);
+    }
+    var iterations = 0;
+    var node = this._head;
+    return new Iterator(function() {
+      if (node) {
+        var value = node.value;
+        node = node.next;
+        return iteratorValue(type, iterations++, value);
+      }
+      return iteratorDone();
+    });
+  };
+  return Stack2;
+}(IndexedCollection);
+Stack.isStack = isStack;
+var StackPrototype = Stack.prototype;
+StackPrototype[IS_STACK_SYMBOL] = true;
+StackPrototype.shift = StackPrototype.pop;
+StackPrototype.unshift = StackPrototype.push;
+StackPrototype.unshiftAll = StackPrototype.pushAll;
+StackPrototype.withMutations = withMutations;
+StackPrototype.wasAltered = wasAltered;
+StackPrototype.asImmutable = asImmutable;
+StackPrototype["@@transducer/init"] = StackPrototype.asMutable = asMutable;
+StackPrototype["@@transducer/step"] = function(result, arr) {
+  return result.unshift(arr);
+};
+StackPrototype["@@transducer/result"] = function(obj) {
+  return obj.asImmutable();
+};
+function makeStack(size, head, ownerID, hash2) {
+  var map5 = Object.create(StackPrototype);
+  map5.size = size;
+  map5._head = head;
+  map5.__ownerID = ownerID;
+  map5.__hash = hash2;
+  map5.__altered = false;
+  return map5;
+}
+var EMPTY_STACK;
+function emptyStack() {
+  return EMPTY_STACK || (EMPTY_STACK = makeStack(0));
+}
+var IS_SET_SYMBOL = "@@__IMMUTABLE_SET__@@";
+function isSet(maybeSet) {
+  return Boolean(maybeSet && // @ts-expect-error: maybeSet is typed as `{}`,  need to change in 6.0 to `maybeSeq && typeof maybeSet === 'object' && MAYBE_SET_SYMBOL in maybeSet`
+  maybeSet[IS_SET_SYMBOL]);
+}
+function isOrderedSet(maybeOrderedSet) {
+  return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (!isCollection(b) || // @ts-expect-error size should exists on Collection
+  a.size !== void 0 && b.size !== void 0 && a.size !== b.size || // @ts-expect-error __hash exists on Collection
+  a.__hash !== void 0 && // @ts-expect-error __hash exists on Collection
+  b.__hash !== void 0 && // @ts-expect-error __hash exists on Collection
+  a.__hash !== b.__hash || isKeyed(a) !== isKeyed(b) || isIndexed(a) !== isIndexed(b) || // @ts-expect-error Range extends Collection, which implements [Symbol.iterator], so it is valid
+  isOrdered(a) !== isOrdered(b)) {
+    return false;
+  }
+  if (a.size === 0 && b.size === 0) {
+    return true;
+  }
+  var notAssociative = !isAssociative(a);
+  if (isOrdered(a)) {
+    var entries3 = a.entries();
+    return b.every(function(v, k) {
+      var entry = entries3.next().value;
+      return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));
+    }) && entries3.next().done;
+  }
+  var flipped = false;
+  if (a.size === void 0) {
+    if (b.size === void 0) {
+      if (typeof a.cacheResult === "function") {
+        a.cacheResult();
+      }
+    } else {
+      flipped = true;
+      var _ = a;
+      a = b;
+      b = _;
+    }
+  }
+  var allEqual = true;
+  var bSize = (
+    // @ts-expect-error b is Range | Repeat | Collection<unknown, unknown> as it may have been flipped, and __iterate is valid
+    b.__iterate(function(v, k) {
+      if (notAssociative ? (
+        // @ts-expect-error has exists on Collection
+        !a.has(v)
+      ) : flipped ? (
+        // @ts-expect-error type of `get` does not "catch" the version with `notSetValue`
+        !is(v, a.get(k, NOT_SET))
+      ) : (
+        // @ts-expect-error type of `get` does not "catch" the version with `notSetValue`
+        !is(a.get(k, NOT_SET), v)
+      )) {
+        allEqual = false;
+        return false;
+      }
+    })
+  );
+  return allEqual && // @ts-expect-error size should exists on Collection
+  a.size === bSize;
+}
+function mixin(ctor, methods) {
+  var keyCopier = function(key) {
+    ctor.prototype[key] = methods[key];
+  };
+  Object.keys(methods).forEach(keyCopier);
+  Object.getOwnPropertySymbols && Object.getOwnPropertySymbols(methods).forEach(keyCopier);
+  return ctor;
+}
+function toJS(value) {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  if (!isCollection(value)) {
+    if (!isDataStructure(value)) {
+      return value;
+    }
+    value = Seq(value);
+  }
+  if (isKeyed(value)) {
+    var result$1 = {};
+    value.__iterate(function(v, k) {
+      result$1[k] = toJS(v);
+    });
+    return result$1;
+  }
+  var result = [];
+  value.__iterate(function(v) {
+    result.push(toJS(v));
+  });
+  return result;
+}
+var Set = /* @__PURE__ */ function(SetCollection2) {
+  function Set2(value) {
+    return value === void 0 || value === null ? emptySet() : isSet(value) && !isOrdered(value) ? value : emptySet().withMutations(function(set3) {
+      var iter = SetCollection2(value);
+      assertNotInfinite(iter.size);
+      iter.forEach(function(v) {
+        return set3.add(v);
+      });
+    });
+  }
+  if (SetCollection2) Set2.__proto__ = SetCollection2;
+  Set2.prototype = Object.create(SetCollection2 && SetCollection2.prototype);
+  Set2.prototype.constructor = Set2;
+  Set2.of = function of3() {
+    return this(arguments);
+  };
+  Set2.fromKeys = function fromKeys(value) {
+    return this(KeyedCollection(value).keySeq());
+  };
+  Set2.intersect = function intersect(sets) {
+    sets = Collection(sets).toArray();
+    return sets.length ? SetPrototype.intersect.apply(Set2(sets.pop()), sets) : emptySet();
+  };
+  Set2.union = function union(sets) {
+    sets = Collection(sets).toArray();
+    return sets.length ? SetPrototype.union.apply(Set2(sets.pop()), sets) : emptySet();
+  };
+  Set2.prototype.toString = function toString5() {
+    return this.__toString("Set {", "}");
+  };
+  Set2.prototype.has = function has5(value) {
+    return this._map.has(value);
+  };
+  Set2.prototype.add = function add(value) {
+    return updateSet(this, this._map.set(value, value));
+  };
+  Set2.prototype.remove = function remove3(value) {
+    return updateSet(this, this._map.remove(value));
+  };
+  Set2.prototype.clear = function clear2() {
+    return updateSet(this, this._map.clear());
+  };
+  Set2.prototype.map = function map5(mapper, context) {
+    var this$1$1 = this;
+    var didChanges = false;
+    var newMap = updateSet(
+      this,
+      this._map.mapEntries(function(ref) {
+        var v = ref[1];
+        var mapped = mapper.call(context, v, v, this$1$1);
+        if (mapped !== v) {
+          didChanges = true;
+        }
+        return [mapped, mapped];
+      }, context)
+    );
+    return didChanges ? newMap : this;
+  };
+  Set2.prototype.union = function union() {
+    var iters = [], len = arguments.length;
+    while (len--) iters[len] = arguments[len];
+    iters = iters.filter(function(x) {
+      return x.size !== 0;
+    });
+    if (iters.length === 0) {
+      return this;
+    }
+    if (this.size === 0 && !this.__ownerID && iters.length === 1) {
+      return this.constructor(iters[0]);
+    }
+    return this.withMutations(function(set3) {
+      for (var ii = 0; ii < iters.length; ii++) {
+        if (typeof iters[ii] === "string") {
+          set3.add(iters[ii]);
+        } else {
+          SetCollection2(iters[ii]).forEach(function(value) {
+            return set3.add(value);
+          });
+        }
+      }
+    });
+  };
+  Set2.prototype.intersect = function intersect() {
+    var iters = [], len = arguments.length;
+    while (len--) iters[len] = arguments[len];
+    if (iters.length === 0) {
+      return this;
+    }
+    iters = iters.map(function(iter) {
+      return SetCollection2(iter);
+    });
+    var toRemove = [];
+    this.forEach(function(value) {
+      if (!iters.every(function(iter) {
+        return iter.includes(value);
+      })) {
+        toRemove.push(value);
+      }
+    });
+    return this.withMutations(function(set3) {
+      toRemove.forEach(function(value) {
+        set3.remove(value);
+      });
+    });
+  };
+  Set2.prototype.subtract = function subtract() {
+    var iters = [], len = arguments.length;
+    while (len--) iters[len] = arguments[len];
+    if (iters.length === 0) {
+      return this;
+    }
+    iters = iters.map(function(iter) {
+      return SetCollection2(iter);
+    });
+    var toRemove = [];
+    this.forEach(function(value) {
+      if (iters.some(function(iter) {
+        return iter.includes(value);
+      })) {
+        toRemove.push(value);
+      }
+    });
+    return this.withMutations(function(set3) {
+      toRemove.forEach(function(value) {
+        set3.remove(value);
+      });
+    });
+  };
+  Set2.prototype.sort = function sort2(comparator) {
+    return OrderedSet(sortFactory(this, comparator));
+  };
+  Set2.prototype.sortBy = function sortBy2(mapper, comparator) {
+    return OrderedSet(sortFactory(this, comparator, mapper));
+  };
+  Set2.prototype.wasAltered = function wasAltered3() {
+    return this._map.wasAltered();
+  };
+  Set2.prototype.__iterate = function __iterate2(fn, reverse3) {
+    var this$1$1 = this;
+    return this._map.__iterate(function(k) {
+      return fn(k, k, this$1$1);
+    }, reverse3);
+  };
+  Set2.prototype.__iterator = function __iterator2(type, reverse3) {
+    return this._map.__iterator(type, reverse3);
+  };
+  Set2.prototype.__ensureOwner = function __ensureOwner2(ownerID) {
+    if (ownerID === this.__ownerID) {
+      return this;
+    }
+    var newMap = this._map.__ensureOwner(ownerID);
+    if (!ownerID) {
+      if (this.size === 0) {
+        return this.__empty();
+      }
+      this.__ownerID = ownerID;
+      this._map = newMap;
+      return this;
+    }
+    return this.__make(newMap, ownerID);
+  };
+  return Set2;
+}(SetCollection);
+Set.isSet = isSet;
+var SetPrototype = Set.prototype;
+SetPrototype[IS_SET_SYMBOL] = true;
+SetPrototype[DELETE] = SetPrototype.remove;
+SetPrototype.merge = SetPrototype.concat = SetPrototype.union;
+SetPrototype.withMutations = withMutations;
+SetPrototype.asImmutable = asImmutable;
+SetPrototype["@@transducer/init"] = SetPrototype.asMutable = asMutable;
+SetPrototype["@@transducer/step"] = function(result, arr) {
+  return result.add(arr);
+};
+SetPrototype["@@transducer/result"] = function(obj) {
+  return obj.asImmutable();
+};
+SetPrototype.__empty = emptySet;
+SetPrototype.__make = makeSet;
+function updateSet(set3, newMap) {
+  if (set3.__ownerID) {
+    set3.size = newMap.size;
+    set3._map = newMap;
+    return set3;
+  }
+  return newMap === set3._map ? set3 : newMap.size === 0 ? set3.__empty() : set3.__make(newMap);
+}
+function makeSet(map5, ownerID) {
+  var set3 = Object.create(SetPrototype);
+  set3.size = map5 ? map5.size : 0;
+  set3._map = map5;
+  set3.__ownerID = ownerID;
+  return set3;
+}
+var EMPTY_SET;
+function emptySet() {
+  return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));
+}
+var Range = /* @__PURE__ */ function(IndexedSeq2) {
+  function Range2(start, end, step) {
+    if (step === void 0) step = 1;
+    if (!(this instanceof Range2)) {
+      return new Range2(start, end, step);
+    }
+    invariant(step !== 0, "Cannot step a Range by 0");
+    invariant(
+      start !== void 0,
+      "You must define a start value when using Range"
+    );
+    invariant(
+      end !== void 0,
+      "You must define an end value when using Range"
+    );
+    step = Math.abs(step);
+    if (end < start) {
+      step = -step;
+    }
+    this._start = start;
+    this._end = end;
+    this._step = step;
+    this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);
+    if (this.size === 0) {
+      if (EMPTY_RANGE) {
+        return EMPTY_RANGE;
+      }
+      EMPTY_RANGE = this;
+    }
+  }
+  if (IndexedSeq2) Range2.__proto__ = IndexedSeq2;
+  Range2.prototype = Object.create(IndexedSeq2 && IndexedSeq2.prototype);
+  Range2.prototype.constructor = Range2;
+  Range2.prototype.toString = function toString5() {
+    return this.size === 0 ? "Range []" : "Range [ " + this._start + "..." + this._end + (this._step !== 1 ? " by " + this._step : "") + " ]";
+  };
+  Range2.prototype.get = function get11(index, notSetValue) {
+    return this.has(index) ? this._start + wrapIndex(this, index) * this._step : notSetValue;
+  };
+  Range2.prototype.includes = function includes3(searchValue) {
+    var possibleIndex = (searchValue - this._start) / this._step;
+    return possibleIndex >= 0 && possibleIndex < this.size && possibleIndex === Math.floor(possibleIndex);
+  };
+  Range2.prototype.slice = function slice3(begin, end) {
+    if (wholeSlice(begin, end, this.size)) {
+      return this;
+    }
+    begin = resolveBegin(begin, this.size);
+    end = resolveEnd(end, this.size);
+    if (end <= begin) {
+      return new Range2(0, 0);
+    }
+    return new Range2(
+      this.get(begin, this._end),
+      this.get(end, this._end),
+      this._step
+    );
+  };
+  Range2.prototype.indexOf = function indexOf2(searchValue) {
+    var offsetValue = searchValue - this._start;
+    if (offsetValue % this._step === 0) {
+      var index = offsetValue / this._step;
+      if (index >= 0 && index < this.size) {
+        return index;
+      }
+    }
+    return -1;
+  };
+  Range2.prototype.lastIndexOf = function lastIndexOf2(searchValue) {
+    return this.indexOf(searchValue);
+  };
+  Range2.prototype.__iterate = function __iterate2(fn, reverse3) {
+    var size = this.size;
+    var step = this._step;
+    var value = reverse3 ? this._start + (size - 1) * step : this._start;
+    var i = 0;
+    while (i !== size) {
+      if (fn(value, reverse3 ? size - ++i : i++, this) === false) {
+        break;
+      }
+      value += reverse3 ? -step : step;
+    }
+    return i;
+  };
+  Range2.prototype.__iterator = function __iterator2(type, reverse3) {
+    var size = this.size;
+    var step = this._step;
+    var value = reverse3 ? this._start + (size - 1) * step : this._start;
+    var i = 0;
+    return new Iterator(function() {
+      if (i === size) {
+        return iteratorDone();
+      }
+      var v = value;
+      value += reverse3 ? -step : step;
+      return iteratorValue(type, reverse3 ? size - ++i : i++, v);
+    });
+  };
+  Range2.prototype.equals = function equals3(other) {
+    return other instanceof Range2 ? this._start === other._start && this._end === other._end && this._step === other._step : deepEqual(this, other);
+  };
+  return Range2;
+}(IndexedSeq);
+var EMPTY_RANGE;
+function getIn$1(collection, searchKeyPath, notSetValue) {
+  var keyPath = coerceKeyPath(searchKeyPath);
+  var i = 0;
+  while (i !== keyPath.length) {
+    collection = get(collection, keyPath[i++], NOT_SET);
+    if (collection === NOT_SET) {
+      return notSetValue;
+    }
+  }
+  return collection;
+}
+function getIn(searchKeyPath, notSetValue) {
+  return getIn$1(this, searchKeyPath, notSetValue);
+}
+function hasIn$1(collection, keyPath) {
+  return getIn$1(collection, keyPath, NOT_SET) !== NOT_SET;
+}
+function hasIn(searchKeyPath) {
+  return hasIn$1(this, searchKeyPath);
+}
+function toObject() {
+  assertNotInfinite(this.size);
+  var object = {};
+  this.__iterate(function(v, k) {
+    object[k] = v;
+  });
+  return object;
+}
+Collection.Iterator = Iterator;
+mixin(Collection, {
+  // ### Conversion to other types
+  toArray: function toArray() {
+    assertNotInfinite(this.size);
+    var array = new Array(this.size || 0);
+    var useTuples = isKeyed(this);
+    var i = 0;
+    this.__iterate(function(v, k) {
+      array[i++] = useTuples ? [k, v] : v;
+    });
+    return array;
+  },
+  toIndexedSeq: function toIndexedSeq() {
+    return new ToIndexedSequence(this);
+  },
+  toJS: function toJS$1() {
+    return toJS(this);
+  },
+  toKeyedSeq: function toKeyedSeq() {
+    return new ToKeyedSequence(this, true);
+  },
+  toMap: function toMap() {
+    return Map(this.toKeyedSeq());
+  },
+  toObject,
+  toOrderedMap: function toOrderedMap() {
+    return OrderedMap(this.toKeyedSeq());
+  },
+  toOrderedSet: function toOrderedSet() {
+    return OrderedSet(isKeyed(this) ? this.valueSeq() : this);
+  },
+  toSet: function toSet() {
+    return Set(isKeyed(this) ? this.valueSeq() : this);
+  },
+  toSetSeq: function toSetSeq() {
+    return new ToSetSequence(this);
+  },
+  toSeq: function toSeq() {
+    return isIndexed(this) ? this.toIndexedSeq() : isKeyed(this) ? this.toKeyedSeq() : this.toSetSeq();
+  },
+  toStack: function toStack() {
+    return Stack(isKeyed(this) ? this.valueSeq() : this);
+  },
+  toList: function toList() {
+    return List(isKeyed(this) ? this.valueSeq() : this);
+  },
+  // ### Common JavaScript methods and properties
+  toString: function toString3() {
+    return "[Collection]";
+  },
+  __toString: function __toString(head, tail) {
+    if (this.size === 0) {
+      return head + tail;
+    }
+    return head + " " + this.toSeq().map(this.__toStringMapper).join(", ") + " " + tail;
+  },
+  // ### ES6 Collection methods (ES6 Array and Map)
+  concat: function concat() {
+    var values2 = [], len = arguments.length;
+    while (len--) values2[len] = arguments[len];
+    return reify(this, concatFactory(this, values2));
+  },
+  includes: function includes(searchValue) {
+    return this.some(function(value) {
+      return is(value, searchValue);
+    });
+  },
+  entries: function entries() {
+    return this.__iterator(ITERATE_ENTRIES);
+  },
+  every: function every(predicate, context) {
+    assertNotInfinite(this.size);
+    var returnValue = true;
+    this.__iterate(function(v, k, c) {
+      if (!predicate.call(context, v, k, c)) {
+        returnValue = false;
+        return false;
+      }
+    });
+    return returnValue;
+  },
+  filter: function filter(predicate, context) {
+    return reify(this, filterFactory(this, predicate, context, true));
+  },
+  partition: function partition(predicate, context) {
+    return partitionFactory(this, predicate, context);
+  },
+  find: function find(predicate, context, notSetValue) {
+    var entry = this.findEntry(predicate, context);
+    return entry ? entry[1] : notSetValue;
+  },
+  forEach: function forEach(sideEffect, context) {
+    assertNotInfinite(this.size);
+    return this.__iterate(context ? sideEffect.bind(context) : sideEffect);
+  },
+  join: function join(separator) {
+    assertNotInfinite(this.size);
+    separator = separator !== void 0 ? "" + separator : ",";
+    var joined = "";
+    var isFirst = true;
+    this.__iterate(function(v) {
+      isFirst ? isFirst = false : joined += separator;
+      joined += v !== null && v !== void 0 ? v.toString() : "";
+    });
+    return joined;
+  },
+  keys: function keys() {
+    return this.__iterator(ITERATE_KEYS);
+  },
+  map: function map2(mapper, context) {
+    return reify(this, mapFactory(this, mapper, context));
+  },
+  reduce: function reduce$1(reducer, initialReduction, context) {
+    return reduce(
+      this,
+      reducer,
+      initialReduction,
+      context,
+      arguments.length < 2,
+      false
+    );
+  },
+  reduceRight: function reduceRight(reducer, initialReduction, context) {
+    return reduce(
+      this,
+      reducer,
+      initialReduction,
+      context,
+      arguments.length < 2,
+      true
+    );
+  },
+  reverse: function reverse() {
+    return reify(this, reverseFactory(this, true));
+  },
+  slice: function slice(begin, end) {
+    return reify(this, sliceFactory(this, begin, end, true));
+  },
+  some: function some(predicate, context) {
+    assertNotInfinite(this.size);
+    var returnValue = false;
+    this.__iterate(function(v, k, c) {
+      if (predicate.call(context, v, k, c)) {
+        returnValue = true;
+        return false;
+      }
+    });
+    return returnValue;
+  },
+  sort: function sort(comparator) {
+    return reify(this, sortFactory(this, comparator));
+  },
+  values: function values() {
+    return this.__iterator(ITERATE_VALUES);
+  },
+  // ### More sequential methods
+  butLast: function butLast() {
+    return this.slice(0, -1);
+  },
+  isEmpty: function isEmpty() {
+    return this.size !== void 0 ? this.size === 0 : !this.some(function() {
+      return true;
+    });
+  },
+  count: function count(predicate, context) {
+    return ensureSize(
+      predicate ? this.toSeq().filter(predicate, context) : this
+    );
+  },
+  countBy: function countBy(grouper, context) {
+    return countByFactory(this, grouper, context);
+  },
+  equals: function equals(other) {
+    return deepEqual(this, other);
+  },
+  entrySeq: function entrySeq() {
+    var collection = this;
+    if (collection._cache) {
+      return new ArraySeq(collection._cache);
+    }
+    var entriesSequence = collection.toSeq().map(entryMapper).toIndexedSeq();
+    entriesSequence.fromEntrySeq = function() {
+      return collection.toSeq();
+    };
+    return entriesSequence;
+  },
+  filterNot: function filterNot(predicate, context) {
+    return this.filter(not(predicate), context);
+  },
+  findEntry: function findEntry(predicate, context, notSetValue) {
+    var found = notSetValue;
+    this.__iterate(function(v, k, c) {
+      if (predicate.call(context, v, k, c)) {
+        found = [k, v];
+        return false;
+      }
+    });
+    return found;
+  },
+  findKey: function findKey(predicate, context) {
+    var entry = this.findEntry(predicate, context);
+    return entry && entry[0];
+  },
+  findLast: function findLast(predicate, context, notSetValue) {
+    return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);
+  },
+  findLastEntry: function findLastEntry(predicate, context, notSetValue) {
+    return this.toKeyedSeq().reverse().findEntry(predicate, context, notSetValue);
+  },
+  findLastKey: function findLastKey(predicate, context) {
+    return this.toKeyedSeq().reverse().findKey(predicate, context);
+  },
+  first: function first(notSetValue) {
+    return this.find(returnTrue, null, notSetValue);
+  },
+  flatMap: function flatMap(mapper, context) {
+    return reify(this, flatMapFactory(this, mapper, context));
+  },
+  flatten: function flatten(depth) {
+    return reify(this, flattenFactory(this, depth, true));
+  },
+  fromEntrySeq: function fromEntrySeq() {
+    return new FromEntriesSequence(this);
+  },
+  get: function get7(searchKey, notSetValue) {
+    return this.find(function(_, key) {
+      return is(key, searchKey);
+    }, void 0, notSetValue);
+  },
+  getIn,
+  groupBy: function groupBy(grouper, context) {
+    return groupByFactory(this, grouper, context);
+  },
+  has: function has2(searchKey) {
+    return this.get(searchKey, NOT_SET) !== NOT_SET;
+  },
+  hasIn,
+  isSubset: function isSubset(iter) {
+    iter = typeof iter.includes === "function" ? iter : Collection(iter);
+    return this.every(function(value) {
+      return iter.includes(value);
+    });
+  },
+  isSuperset: function isSuperset(iter) {
+    iter = typeof iter.isSubset === "function" ? iter : Collection(iter);
+    return iter.isSubset(this);
+  },
+  keyOf: function keyOf(searchValue) {
+    return this.findKey(function(value) {
+      return is(value, searchValue);
+    });
+  },
+  keySeq: function keySeq() {
+    return this.toSeq().map(keyMapper).toIndexedSeq();
+  },
+  last: function last(notSetValue) {
+    return this.toSeq().reverse().first(notSetValue);
+  },
+  lastKeyOf: function lastKeyOf(searchValue) {
+    return this.toKeyedSeq().reverse().keyOf(searchValue);
+  },
+  max: function max(comparator) {
+    return maxFactory(this, comparator);
+  },
+  maxBy: function maxBy(mapper, comparator) {
+    return maxFactory(this, comparator, mapper);
+  },
+  min: function min(comparator) {
+    return maxFactory(
+      this,
+      comparator ? neg(comparator) : defaultNegComparator
+    );
+  },
+  minBy: function minBy(mapper, comparator) {
+    return maxFactory(
+      this,
+      comparator ? neg(comparator) : defaultNegComparator,
+      mapper
+    );
+  },
+  rest: function rest() {
+    return this.slice(1);
+  },
+  skip: function skip(amount) {
+    return amount === 0 ? this : this.slice(Math.max(0, amount));
+  },
+  skipLast: function skipLast(amount) {
+    return amount === 0 ? this : this.slice(0, -Math.max(0, amount));
+  },
+  skipWhile: function skipWhile(predicate, context) {
+    return reify(this, skipWhileFactory(this, predicate, context, true));
+  },
+  skipUntil: function skipUntil(predicate, context) {
+    return this.skipWhile(not(predicate), context);
+  },
+  sortBy: function sortBy(mapper, comparator) {
+    return reify(this, sortFactory(this, comparator, mapper));
+  },
+  take: function take2(amount) {
+    return this.slice(0, Math.max(0, amount));
+  },
+  takeLast: function takeLast(amount) {
+    return this.slice(-Math.max(0, amount));
+  },
+  takeWhile: function takeWhile(predicate, context) {
+    return reify(this, takeWhileFactory(this, predicate, context));
+  },
+  takeUntil: function takeUntil(predicate, context) {
+    return this.takeWhile(not(predicate), context);
+  },
+  update: function update7(fn) {
+    return fn(this);
+  },
+  valueSeq: function valueSeq() {
+    return this.toIndexedSeq();
+  },
+  // ### Hashable Object
+  hashCode: function hashCode() {
+    return this.__hash || (this.__hash = hashCollection(this));
+  }
+  // ### Internal
+  // abstract __iterate(fn, reverse)
+  // abstract __iterator(type, reverse)
+});
+var CollectionPrototype = Collection.prototype;
+CollectionPrototype[IS_COLLECTION_SYMBOL] = true;
+CollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.values;
+CollectionPrototype.toJSON = CollectionPrototype.toArray;
+CollectionPrototype.__toStringMapper = quoteString;
+CollectionPrototype.inspect = CollectionPrototype.toSource = function() {
+  return this.toString();
+};
+CollectionPrototype.chain = CollectionPrototype.flatMap;
+CollectionPrototype.contains = CollectionPrototype.includes;
+mixin(KeyedCollection, {
+  // ### More sequential methods
+  flip: function flip() {
+    return reify(this, flipFactory(this));
+  },
+  mapEntries: function mapEntries(mapper, context) {
+    var this$1$1 = this;
+    var iterations = 0;
+    return reify(
+      this,
+      this.toSeq().map(function(v, k) {
+        return mapper.call(context, [k, v], iterations++, this$1$1);
+      }).fromEntrySeq()
+    );
+  },
+  mapKeys: function mapKeys(mapper, context) {
+    var this$1$1 = this;
+    return reify(
+      this,
+      this.toSeq().flip().map(function(k, v) {
+        return mapper.call(context, k, v, this$1$1);
+      }).flip()
+    );
+  }
+});
+var KeyedCollectionPrototype = KeyedCollection.prototype;
+KeyedCollectionPrototype[IS_KEYED_SYMBOL] = true;
+KeyedCollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.entries;
+KeyedCollectionPrototype.toJSON = toObject;
+KeyedCollectionPrototype.__toStringMapper = function(v, k) {
+  return quoteString(k) + ": " + quoteString(v);
+};
+mixin(IndexedCollection, {
+  // ### Conversion to other types
+  toKeyedSeq: function toKeyedSeq2() {
+    return new ToKeyedSequence(this, false);
+  },
+  // ### ES6 Collection methods (ES6 Array and Map)
+  filter: function filter2(predicate, context) {
+    return reify(this, filterFactory(this, predicate, context, false));
+  },
+  findIndex: function findIndex(predicate, context) {
+    var entry = this.findEntry(predicate, context);
+    return entry ? entry[0] : -1;
+  },
+  indexOf: function indexOf(searchValue) {
+    var key = this.keyOf(searchValue);
+    return key === void 0 ? -1 : key;
+  },
+  lastIndexOf: function lastIndexOf(searchValue) {
+    var key = this.lastKeyOf(searchValue);
+    return key === void 0 ? -1 : key;
+  },
+  reverse: function reverse2() {
+    return reify(this, reverseFactory(this, false));
+  },
+  slice: function slice2(begin, end) {
+    return reify(this, sliceFactory(this, begin, end, false));
+  },
+  splice: function splice(index, removeNum) {
+    var numArgs = arguments.length;
+    removeNum = Math.max(removeNum || 0, 0);
+    if (numArgs === 0 || numArgs === 2 && !removeNum) {
+      return this;
+    }
+    index = resolveBegin(index, index < 0 ? this.count() : this.size);
+    var spliced = this.slice(0, index);
+    return reify(
+      this,
+      numArgs === 1 ? spliced : spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))
+    );
+  },
+  // ### More collection methods
+  findLastIndex: function findLastIndex(predicate, context) {
+    var entry = this.findLastEntry(predicate, context);
+    return entry ? entry[0] : -1;
+  },
+  first: function first2(notSetValue) {
+    return this.get(0, notSetValue);
+  },
+  flatten: function flatten2(depth) {
+    return reify(this, flattenFactory(this, depth, false));
+  },
+  get: function get8(index, notSetValue) {
+    index = wrapIndex(this, index);
+    return index < 0 || this.size === Infinity || this.size !== void 0 && index > this.size ? notSetValue : this.find(function(_, key) {
+      return key === index;
+    }, void 0, notSetValue);
+  },
+  has: function has3(index) {
+    index = wrapIndex(this, index);
+    return index >= 0 && (this.size !== void 0 ? this.size === Infinity || index < this.size : this.indexOf(index) !== -1);
+  },
+  interpose: function interpose(separator) {
+    return reify(this, interposeFactory(this, separator));
+  },
+  interleave: function interleave() {
+    var collections = [this].concat(arrCopy(arguments));
+    var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, collections);
+    var interleaved = zipped.flatten(true);
+    if (zipped.size) {
+      interleaved.size = zipped.size * collections.length;
+    }
+    return reify(this, interleaved);
+  },
+  keySeq: function keySeq2() {
+    return Range(0, this.size);
+  },
+  last: function last2(notSetValue) {
+    return this.get(-1, notSetValue);
+  },
+  skipWhile: function skipWhile2(predicate, context) {
+    return reify(this, skipWhileFactory(this, predicate, context, false));
+  },
+  zip: function zip() {
+    var collections = [this].concat(arrCopy(arguments));
+    return reify(this, zipWithFactory(this, defaultZipper, collections));
+  },
+  zipAll: function zipAll() {
+    var collections = [this].concat(arrCopy(arguments));
+    return reify(this, zipWithFactory(this, defaultZipper, collections, true));
+  },
+  zipWith: function zipWith(zipper) {
+    var collections = arrCopy(arguments);
+    collections[0] = this;
+    return reify(this, zipWithFactory(this, zipper, collections));
+  }
+});
+var IndexedCollectionPrototype = IndexedCollection.prototype;
+IndexedCollectionPrototype[IS_INDEXED_SYMBOL] = true;
+IndexedCollectionPrototype[IS_ORDERED_SYMBOL] = true;
+mixin(SetCollection, {
+  // ### ES6 Collection methods (ES6 Array and Map)
+  get: function get9(value, notSetValue) {
+    return this.has(value) ? value : notSetValue;
+  },
+  includes: function includes2(value) {
+    return this.has(value);
+  },
+  // ### More sequential methods
+  keySeq: function keySeq3() {
+    return this.valueSeq();
+  }
+});
+var SetCollectionPrototype = SetCollection.prototype;
+SetCollectionPrototype.has = CollectionPrototype.includes;
+SetCollectionPrototype.contains = SetCollectionPrototype.includes;
+SetCollectionPrototype.keys = SetCollectionPrototype.values;
+mixin(KeyedSeq, KeyedCollectionPrototype);
+mixin(IndexedSeq, IndexedCollectionPrototype);
+mixin(SetSeq, SetCollectionPrototype);
+function reduce(collection, reducer, reduction, context, useFirst, reverse3) {
+  assertNotInfinite(collection.size);
+  collection.__iterate(function(v, k, c) {
+    if (useFirst) {
+      useFirst = false;
+      reduction = v;
+    } else {
+      reduction = reducer.call(context, reduction, v, k, c);
+    }
+  }, reverse3);
+  return reduction;
+}
+function keyMapper(v, k) {
+  return k;
+}
+function entryMapper(v, k) {
+  return [k, v];
+}
+function not(predicate) {
+  return function() {
+    return !predicate.apply(this, arguments);
+  };
+}
+function neg(predicate) {
+  return function() {
+    return -predicate.apply(this, arguments);
+  };
+}
+function defaultZipper() {
+  return arrCopy(arguments);
+}
+function defaultNegComparator(a, b) {
+  return a < b ? 1 : a > b ? -1 : 0;
+}
+function hashCollection(collection) {
+  if (collection.size === Infinity) {
+    return 0;
+  }
+  var ordered = isOrdered(collection);
+  var keyed = isKeyed(collection);
+  var h = ordered ? 1 : 0;
+  collection.__iterate(
+    keyed ? ordered ? function(v, k) {
+      h = 31 * h + hashMerge(hash(v), hash(k)) | 0;
+    } : function(v, k) {
+      h = h + hashMerge(hash(v), hash(k)) | 0;
+    } : ordered ? function(v) {
+      h = 31 * h + hash(v) | 0;
+    } : function(v) {
+      h = h + hash(v) | 0;
+    }
+  );
+  return murmurHashOfSize(collection.size, h);
+}
+function murmurHashOfSize(size, h) {
+  h = imul(h, 3432918353);
+  h = imul(h << 15 | h >>> -15, 461845907);
+  h = imul(h << 13 | h >>> -13, 5);
+  h = (h + 3864292196 | 0) ^ size;
+  h = imul(h ^ h >>> 16, 2246822507);
+  h = imul(h ^ h >>> 13, 3266489909);
+  h = smi(h ^ h >>> 16);
+  return h;
+}
+function hashMerge(a, b) {
+  return a ^ b + 2654435769 + (a << 6) + (a >> 2) | 0;
+}
+var OrderedSet = /* @__PURE__ */ function(Set2) {
+  function OrderedSet2(value) {
+    return value === void 0 || value === null ? emptyOrderedSet() : isOrderedSet(value) ? value : emptyOrderedSet().withMutations(function(set3) {
+      var iter = SetCollection(value);
+      assertNotInfinite(iter.size);
+      iter.forEach(function(v) {
+        return set3.add(v);
+      });
+    });
+  }
+  if (Set2) OrderedSet2.__proto__ = Set2;
+  OrderedSet2.prototype = Object.create(Set2 && Set2.prototype);
+  OrderedSet2.prototype.constructor = OrderedSet2;
+  OrderedSet2.of = function of3() {
+    return this(arguments);
+  };
+  OrderedSet2.fromKeys = function fromKeys(value) {
+    return this(KeyedCollection(value).keySeq());
+  };
+  OrderedSet2.prototype.toString = function toString5() {
+    return this.__toString("OrderedSet {", "}");
+  };
+  return OrderedSet2;
+}(Set);
+OrderedSet.isOrderedSet = isOrderedSet;
+var OrderedSetPrototype = OrderedSet.prototype;
+OrderedSetPrototype[IS_ORDERED_SYMBOL] = true;
+OrderedSetPrototype.zip = IndexedCollectionPrototype.zip;
+OrderedSetPrototype.zipWith = IndexedCollectionPrototype.zipWith;
+OrderedSetPrototype.zipAll = IndexedCollectionPrototype.zipAll;
+OrderedSetPrototype.__empty = emptyOrderedSet;
+OrderedSetPrototype.__make = makeOrderedSet;
+function makeOrderedSet(map5, ownerID) {
+  var set3 = Object.create(OrderedSetPrototype);
+  set3.size = map5 ? map5.size : 0;
+  set3._map = map5;
+  set3.__ownerID = ownerID;
+  return set3;
+}
+var EMPTY_ORDERED_SET;
+function emptyOrderedSet() {
+  return EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()));
+}
+function throwOnInvalidDefaultValues(defaultValues) {
+  if (isRecord(defaultValues)) {
+    throw new Error(
+      "Can not call `Record` with an immutable Record as default values. Use a plain javascript object instead."
+    );
+  }
+  if (isImmutable(defaultValues)) {
+    throw new Error(
+      "Can not call `Record` with an immutable Collection as default values. Use a plain javascript object instead."
+    );
+  }
+  if (defaultValues === null || typeof defaultValues !== "object") {
+    throw new Error(
+      "Can not call `Record` with a non-object as default values. Use a plain javascript object instead."
+    );
+  }
+}
+var Record = function Record2(defaultValues, name) {
+  var hasInitialized;
+  throwOnInvalidDefaultValues(defaultValues);
+  var RecordType = function Record3(values2) {
+    var this$1$1 = this;
+    if (values2 instanceof RecordType) {
+      return values2;
+    }
+    if (!(this instanceof RecordType)) {
+      return new RecordType(values2);
+    }
+    if (!hasInitialized) {
+      hasInitialized = true;
+      var keys2 = Object.keys(defaultValues);
+      var indices = RecordTypePrototype._indices = {};
+      RecordTypePrototype._name = name;
+      RecordTypePrototype._keys = keys2;
+      RecordTypePrototype._defaultValues = defaultValues;
+      for (var i = 0; i < keys2.length; i++) {
+        var propName = keys2[i];
+        indices[propName] = i;
+        if (RecordTypePrototype[propName]) {
+          typeof console === "object" && console.warn && console.warn(
+            "Cannot define " + recordName(this) + ' with property "' + propName + '" since that property name is part of the Record API.'
+          );
+        } else {
+          setProp(RecordTypePrototype, propName);
+        }
+      }
+    }
+    this.__ownerID = void 0;
+    this._values = List().withMutations(function(l) {
+      l.setSize(this$1$1._keys.length);
+      KeyedCollection(values2).forEach(function(v, k) {
+        l.set(this$1$1._indices[k], v === this$1$1._defaultValues[k] ? void 0 : v);
+      });
+    });
+    return this;
+  };
+  var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype);
+  RecordTypePrototype.constructor = RecordType;
+  if (name) {
+    RecordType.displayName = name;
+  }
+  return RecordType;
+};
+Record.prototype.toString = function toString4() {
+  var str = recordName(this) + " { ";
+  var keys2 = this._keys;
+  var k;
+  for (var i = 0, l = keys2.length; i !== l; i++) {
+    k = keys2[i];
+    str += (i ? ", " : "") + k + ": " + quoteString(this.get(k));
+  }
+  return str + " }";
+};
+Record.prototype.equals = function equals2(other) {
+  return this === other || isRecord(other) && recordSeq(this).equals(recordSeq(other));
+};
+Record.prototype.hashCode = function hashCode2() {
+  return recordSeq(this).hashCode();
+};
+Record.prototype.has = function has4(k) {
+  return this._indices.hasOwnProperty(k);
+};
+Record.prototype.get = function get10(k, notSetValue) {
+  if (!this.has(k)) {
+    return notSetValue;
+  }
+  var index = this._indices[k];
+  var value = this._values.get(index);
+  return value === void 0 ? this._defaultValues[k] : value;
+};
+Record.prototype.set = function set2(k, v) {
+  if (this.has(k)) {
+    var newValues = this._values.set(
+      this._indices[k],
+      v === this._defaultValues[k] ? void 0 : v
+    );
+    if (newValues !== this._values && !this.__ownerID) {
+      return makeRecord(this, newValues);
+    }
+  }
+  return this;
+};
+Record.prototype.remove = function remove2(k) {
+  return this.set(k);
+};
+Record.prototype.clear = function clear() {
+  var newValues = this._values.clear().setSize(this._keys.length);
+  return this.__ownerID ? this : makeRecord(this, newValues);
+};
+Record.prototype.wasAltered = function wasAltered2() {
+  return this._values.wasAltered();
+};
+Record.prototype.toSeq = function toSeq2() {
+  return recordSeq(this);
+};
+Record.prototype.toJS = function toJS$12() {
+  return toJS(this);
+};
+Record.prototype.entries = function entries2() {
+  return this.__iterator(ITERATE_ENTRIES);
+};
+Record.prototype.__iterator = function __iterator(type, reverse3) {
+  return recordSeq(this).__iterator(type, reverse3);
+};
+Record.prototype.__iterate = function __iterate(fn, reverse3) {
+  return recordSeq(this).__iterate(fn, reverse3);
+};
+Record.prototype.__ensureOwner = function __ensureOwner(ownerID) {
+  if (ownerID === this.__ownerID) {
+    return this;
+  }
+  var newValues = this._values.__ensureOwner(ownerID);
+  if (!ownerID) {
+    this.__ownerID = ownerID;
+    this._values = newValues;
+    return this;
+  }
+  return makeRecord(this, newValues, ownerID);
+};
+Record.isRecord = isRecord;
+Record.getDescriptiveName = recordName;
+var RecordPrototype = Record.prototype;
+RecordPrototype[IS_RECORD_SYMBOL] = true;
+RecordPrototype[DELETE] = RecordPrototype.remove;
+RecordPrototype.deleteIn = RecordPrototype.removeIn = deleteIn;
+RecordPrototype.getIn = getIn;
+RecordPrototype.hasIn = CollectionPrototype.hasIn;
+RecordPrototype.merge = merge$1;
+RecordPrototype.mergeWith = mergeWith$1;
+RecordPrototype.mergeIn = mergeIn;
+RecordPrototype.mergeDeep = mergeDeep;
+RecordPrototype.mergeDeepWith = mergeDeepWith;
+RecordPrototype.mergeDeepIn = mergeDeepIn;
+RecordPrototype.setIn = setIn;
+RecordPrototype.update = update;
+RecordPrototype.updateIn = updateIn;
+RecordPrototype.withMutations = withMutations;
+RecordPrototype.asMutable = asMutable;
+RecordPrototype.asImmutable = asImmutable;
+RecordPrototype[ITERATOR_SYMBOL] = RecordPrototype.entries;
+RecordPrototype.toJSON = RecordPrototype.toObject = CollectionPrototype.toObject;
+RecordPrototype.inspect = RecordPrototype.toSource = function() {
+  return this.toString();
+};
+function makeRecord(likeRecord, values2, ownerID) {
+  var record = Object.create(Object.getPrototypeOf(likeRecord));
+  record._values = values2;
+  record.__ownerID = ownerID;
+  return record;
+}
+function recordName(record) {
+  return record.constructor.displayName || record.constructor.name || "Record";
+}
+function recordSeq(record) {
+  return keyedSeqFromValue(record._keys.map(function(k) {
+    return [k, record.get(k)];
+  }));
+}
+function setProp(prototype, name) {
+  try {
+    Object.defineProperty(prototype, name, {
+      get: function() {
+        return this.get(name);
+      },
+      set: function(value) {
+        invariant(this.__ownerID, "Cannot set on an immutable record.");
+        this.set(name, value);
+      }
+    });
+  } catch (error) {
+  }
+}
+
+// src/store/store.ts
+import { EMPTY as EMPTY2, map as map4, of as of2, scan, shareReplay, Subject, switchMap as switchMap2 } from "rxjs";
+
+// src/batcher/index.ts
+import { Observable as Observable3 } from "rxjs";
+function batcher(waitTime) {
+  return (source$) => new Observable3((observer) => {
+    let buffer = [];
+    const loaded = [];
+    let timerId = null;
+    const emitBuffer = () => {
+      if (buffer.length > 0) {
+        observer.next({
+          next: [...buffer],
+          loaded: [...loaded]
+        });
+        loaded.push(...buffer);
+        buffer = [];
+      }
+      clearTimeout(timerId);
+      timerId = null;
+    };
+    const sub = source$.subscribe({
+      next: (value) => {
+        buffer.push(value);
+        if (!timerId) {
+          timerId = setTimeout(() => {
+            emitBuffer();
+          }, waitTime);
+        }
+      },
+      error: (err) => observer.error(err),
+      complete: () => {
+        emitBuffer();
+        observer.complete();
+      }
+    });
+    return () => {
+      clearTimeout(timerId);
+      sub.unsubscribe();
+    };
+  });
+}
+
+// src/lens/lens.ts
+import { Observable as Observable4, BehaviorSubject as BehaviorSubject2, Subscription } from "rxjs";
+import { distinctUntilChanged, map as map3, tap as tap2 } from "rxjs/operators";
+import { isEqual } from "lodash";
+var Lens = class extends Observable4 {
+  constructor(source$, lens) {
+    const initialValue = lens.get(source$.get());
+    const subject$ = new BehaviorSubject2(initialValue);
+    super((subscriber) => {
+      const localSub = subject$.subscribe(subscriber);
+      if (this.subCount++ === 0) {
+        this.sub = new Subscription();
+        this.sub.add(
+          source$.pipe(
+            map3((x) => lens.get(x)),
+            distinctUntilChanged(isEqual),
+            tap2((x) => {
+              const prev = subject$.getValue();
+              if (!isEqual(prev, x)) {
+                subject$.next(x);
+              }
+            })
+          ).subscribe()
+        );
+        this.sub.add(
+          subject$.pipe(
+            distinctUntilChanged(isEqual),
+            tap2((next) => {
+              const value = source$.get();
+              const updated = lens.set(next, value);
+              if (!isEqual(updated, value)) {
+                source$.set(updated);
+              }
+            })
+          ).subscribe()
+        );
+        return () => {
+          localSub.unsubscribe();
+          if (--this.subCount === 0) {
+            this.sub?.unsubscribe();
+            this.sub = void 0;
+          }
+        };
+      }
+    });
+    this.subCount = 0;
+    this.set = (value) => this.subject$.next(value);
+    this.get = () => this.subject$.getValue();
+    this.modify = (fn) => this.set(fn(this.get()));
+    this.subject$ = subject$;
+  }
+};
+function createLens(source$, lens) {
+  return new Lens(source$, lens);
+}
+function keyLens(key) {
+  return {
+    get: (source) => source[key],
+    set: (current, source) => ({
+      ...source,
+      [key]: current
+    })
+  };
+}
+
+// src/store/store.ts
+function createState(val) {
+  return toBranded("store", val);
+}
+function createStore(queue, state$) {
+  return {
+    state$,
+    collect: () => queue.start().onIdle(),
+    node: (name) => {
+      const lens = createLens(state$, {
+        get: (x) => x.value[name] ?? toBranded("store", {}),
+        set: (x, xs) => ({
+          ...xs,
+          value: { ...xs.value, [name]: x }
+        })
+      });
+      return createStore(queue, lens);
+    },
+    factoryBatch: (name, batch) => {
+      const lens = createLens(state$, {
+        get: (x) => x.value[name] ?? toBranded("map", {}),
+        set: (x, xs) => ({
+          ...xs,
+          value: { ...xs.value, [name]: x }
+        })
+      });
+      return createFactory(batch, queue, lens);
+    }
+  };
+}
+function createFactory(batch, queue, state$) {
+  const cache = Map().asMutable();
+  const keys$ = new Subject();
+  const map$ = keys$.pipe(
+    batcher(250),
+    switchMap2(({ next, loaded }) => batch(subtractArrays(next, loaded))),
+    scan((acc, val) => ({ ...acc, ...val }), {}),
+    shareReplay(1)
+  );
+  map$.subscribe();
+  return {
+    get: (key) => {
+      if (!cache.has(key)) {
+        keys$.next(key);
+        const lens = createLens(
+          createLens(state$, {
+            get: (x) => {
+              const value = x.value[key];
+              return value ?? toBranded("edge", createIdle());
+            },
+            set: (x, xs) => ({
+              ...xs,
+              value: { ...xs.value, [key]: x }
+            })
+          }),
+          keyLens("value")
+        );
+        const edge = createEdge(
+          lens,
+          queue,
+          () => map$.pipe(
+            map4((x) => x[key]),
+            switchMap2((x) => x ? of2(x) : EMPTY2)
+          )
+        );
+        cache.set(key, edge);
+      }
+      return cache.get(key);
+    }
+  };
+}
+function subtractArrays(arrayA, arrayB) {
+  return arrayA.filter((item) => !arrayB.includes(item));
+}
+export {
+  Atom,
+  Lens,
+  StatusEnum,
+  createAtom,
+  createEdge,
+  createFulfilled,
+  createIdle,
+  createLens,
+  createPending,
+  createRejected,
+  createState,
+  createStore,
+  isBranded,
+  keyLens,
+  toBranded
+};
+/*! Bundled license information:
+
+immutable/dist/immutable.es.js:
+  (**
+   * @license
+   * MIT License
+   * 
+   * Copyright (c) 2014-present, Lee Byron and other contributors.
+   * 
+   * Permission is hereby granted, free of charge, to any person obtaining a copy
+   * of this software and associated documentation files (the "Software"), to deal
+   * in the Software without restriction, including without limitation the rights
+   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   * copies of the Software, and to permit persons to whom the Software is
+   * furnished to do so, subject to the following conditions:
+   * 
+   * The above copyright notice and this permission notice shall be included in all
+   * copies or substantial portions of the Software.
+   * 
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   * SOFTWARE.
+   *)
+*/