@tedi-design-system/react 14.0.0-rc.1

package/external/immutable/dist/immutable.es.js

@@ -0,0 +1,2634 @@
+import { commonjsGlobal as Ln } from "../../../_virtual/_commonjsHelpers.es.js";
+import { __module as Ze } from "../../../_virtual/immutable.es.js";
+(function(Qe, Nn) {
+  (function(H, m) {
+    Qe.exports = m();
+  })(Ln, function() {
+    var H = Array.prototype.slice;
+    function m(t, r) {
+      r && (t.prototype = Object.create(r.prototype)), t.prototype.constructor = t;
+    }
+    function q(t) {
+      return F(t) ? t : N(t);
+    }
+    m(C, q);
+    function C(t) {
+      return R(t) ? t : Z(t);
+    }
+    m(tt, q);
+    function tt(t) {
+      return b(t) ? t : O(t);
+    }
+    m(V, q);
+    function V(t) {
+      return F(t) && !ir(t) ? t : it(t);
+    }
+    function F(t) {
+      return !!(t && t[jr]);
+    }
+    function R(t) {
+      return !!(t && t[Yr]);
+    }
+    function b(t) {
+      return !!(t && t[Jr]);
+    }
+    function ir(t) {
+      return R(t) || b(t);
+    }
+    function et(t) {
+      return !!(t && t[mt]);
+    }
+    q.isIterable = F, q.isKeyed = R, q.isIndexed = b, q.isAssociative = ir, q.isOrdered = et, q.Keyed = C, q.Indexed = tt, q.Set = V;
+    var jr = "@@__IMMUTABLE_ITERABLE__@@", Yr = "@@__IMMUTABLE_KEYED__@@", Jr = "@@__IMMUTABLE_INDEXED__@@", mt = "@@__IMMUTABLE_ORDERED__@@", Rt = "delete", E = 5, x = 1 << E, P = x - 1, l = {}, tn = { value: !1 }, Hr = { value: !1 };
+    function ur(t) {
+      return t.value = !1, t;
+    }
+    function G(t) {
+      t && (t.value = !0);
+    }
+    function or() {
+    }
+    function _t(t, r) {
+      r = r || 0;
+      for (var e = Math.max(0, t.length - r), n = new Array(e), i = 0; i < e; i++)
+        n[i] = t[i + r];
+      return n;
+    }
+    function sr(t) {
+      return t.size === void 0 && (t.size = t.__iterate(Vr)), t.size;
+    }
+    function pt(t, r) {
+      if (typeof r != "number") {
+        var e = r >>> 0;
+        if ("" + e !== r || e === 4294967295)
+          return NaN;
+        r = e;
+      }
+      return r < 0 ? sr(t) + r : r;
+    }
+    function Vr() {
+      return !0;
+    }
+    function Lt(t, r, e) {
+      return (t === 0 || e !== void 0 && t <= -e) && (r === void 0 || e !== void 0 && r >= e);
+    }
+    function gt(t, r) {
+      return br(t, r, 0);
+    }
+    function Nt(t, r) {
+      return br(t, r, r);
+    }
+    function br(t, r, e) {
+      return t === void 0 ? e : t < 0 ? Math.max(0, r + t) : r === void 0 ? t : Math.min(r, t);
+    }
+    var Ft = 0, X = 1, nt = 2, ar = typeof Symbol == "function" && Symbol.iterator, xr = "@@iterator", fr = ar || xr;
+    function S(t) {
+      this.next = t;
+    }
+    S.prototype.toString = function() {
+      return "[Iterator]";
+    }, S.KEYS = Ft, S.VALUES = X, S.ENTRIES = nt, S.prototype.inspect = S.prototype.toSource = function() {
+      return this.toString();
+    }, S.prototype[fr] = function() {
+      return this;
+    };
+    function w(t, r, e, n) {
+      var i = t === 0 ? r : t === 1 ? e : [r, e];
+      return n ? n.value = i : n = {
+        value: i,
+        done: !1
+      }, n;
+    }
+    function B() {
+      return { value: void 0, done: !0 };
+    }
+    function Gr(t) {
+      return !!Xr(t);
+    }
+    function Jt(t) {
+      return t && typeof t.next == "function";
+    }
+    function Dt(t) {
+      var r = Xr(t);
+      return r && r.call(t);
+    }
+    function Xr(t) {
+      var r = t && (ar && t[ar] || t[xr]);
+      if (typeof r == "function")
+        return r;
+    }
+    function Zr(t) {
+      return t && typeof t.length == "number";
+    }
+    m(N, q);
+    function N(t) {
+      return t == null ? Ht() : F(t) ? t.toSeq() : rn(t);
+    }
+    N.of = function() {
+      return N(arguments);
+    }, N.prototype.toSeq = function() {
+      return this;
+    }, N.prototype.toString = function() {
+      return this.__toString("Seq {", "}");
+    }, N.prototype.cacheResult = function() {
+      return !this._cache && this.__iterateUncached && (this._cache = this.entrySeq().toArray(), this.size = this._cache.length), this;
+    }, N.prototype.__iterate = function(t, r) {
+      return ne(this, t, r, !0);
+    }, N.prototype.__iterator = function(t, r) {
+      return ie(this, t, r, !0);
+    }, m(Z, N);
+    function Z(t) {
+      return t == null ? Ht().toKeyedSeq() : F(t) ? R(t) ? t.toSeq() : t.fromEntrySeq() : re(t);
+    }
+    Z.prototype.toKeyedSeq = function() {
+      return this;
+    }, m(O, N);
+    function O(t) {
+      return t == null ? Ht() : F(t) ? R(t) ? t.entrySeq() : t.toIndexedSeq() : cr(t);
+    }
+    O.of = function() {
+      return O(arguments);
+    }, O.prototype.toIndexedSeq = function() {
+      return this;
+    }, O.prototype.toString = function() {
+      return this.__toString("Seq [", "]");
+    }, O.prototype.__iterate = function(t, r) {
+      return ne(this, t, r, !1);
+    }, O.prototype.__iterator = function(t, r) {
+      return ie(this, t, r, !1);
+    }, m(it, N);
+    function it(t) {
+      return (t == null ? Ht() : F(t) ? R(t) ? t.entrySeq() : t : cr(t)).toSetSeq();
+    }
+    it.of = function() {
+      return it(arguments);
+    }, it.prototype.toSetSeq = function() {
+      return this;
+    }, N.isSeq = hr, N.Keyed = Z, N.Set = it, N.Indexed = O;
+    var Qr = "@@__IMMUTABLE_SEQ__@@";
+    N.prototype[Qr] = !0, m(ut, O);
+    function ut(t) {
+      this._array = t, this.size = t.length;
+    }
+    ut.prototype.get = function(t, r) {
+      return this.has(t) ? this._array[pt(this, t)] : r;
+    }, ut.prototype.__iterate = function(t, r) {
+      for (var e = this._array, n = e.length - 1, i = 0; i <= n; i++)
+        if (t(e[r ? n - i : i], i, this) === !1)
+          return i + 1;
+      return i;
+    }, ut.prototype.__iterator = function(t, r) {
+      var e = this._array, n = e.length - 1, i = 0;
+      return new S(
+        function() {
+          return i > n ? B() : w(t, i, e[r ? n - i++ : i++]);
+        }
+      );
+    }, m(vt, Z);
+    function vt(t) {
+      var r = Object.keys(t);
+      this._object = t, this._keys = r, this.size = r.length;
+    }
+    vt.prototype.get = function(t, r) {
+      return r !== void 0 && !this.has(t) ? r : this._object[t];
+    }, vt.prototype.has = function(t) {
+      return this._object.hasOwnProperty(t);
+    }, vt.prototype.__iterate = function(t, r) {
+      for (var e = this._object, n = this._keys, i = n.length - 1, u = 0; u <= i; u++) {
+        var o = n[r ? i - u : u];
+        if (t(e[o], o, this) === !1)
+          return u + 1;
+      }
+      return u;
+    }, vt.prototype.__iterator = function(t, r) {
+      var e = this._object, n = this._keys, i = n.length - 1, u = 0;
+      return new S(function() {
+        var o = n[r ? i - u : u];
+        return u++ > i ? B() : w(t, o, e[o]);
+      });
+    }, vt.prototype[mt] = !0, m(kt, O);
+    function kt(t) {
+      this._iterable = t, this.size = t.length || t.size;
+    }
+    kt.prototype.__iterateUncached = function(t, r) {
+      if (r)
+        return this.cacheResult().__iterate(t, r);
+      var e = this._iterable, n = Dt(e), i = 0;
+      if (Jt(n))
+        for (var u; !(u = n.next()).done && t(u.value, i++, this) !== !1; )
+          ;
+      return i;
+    }, kt.prototype.__iteratorUncached = function(t, r) {
+      if (r)
+        return this.cacheResult().__iterator(t, r);
+      var e = this._iterable, n = Dt(e);
+      if (!Jt(n))
+        return new S(B);
+      var i = 0;
+      return new S(function() {
+        var u = n.next();
+        return u.done ? u : w(t, i++, u.value);
+      });
+    }, m(Kt, O);
+    function Kt(t) {
+      this._iterator = t, this._iteratorCache = [];
+    }
+    Kt.prototype.__iterateUncached = function(t, r) {
+      if (r)
+        return this.cacheResult().__iterate(t, r);
+      for (var e = this._iterator, n = this._iteratorCache, i = 0; i < n.length; )
+        if (t(n[i], i++, this) === !1)
+          return i;
+      for (var u; !(u = e.next()).done; ) {
+        var o = u.value;
+        if (n[i] = o, t(o, i++, this) === !1)
+          break;
+      }
+      return i;
+    }, Kt.prototype.__iteratorUncached = function(t, r) {
+      if (r)
+        return this.cacheResult().__iterator(t, r);
+      var e = this._iterator, n = this._iteratorCache, i = 0;
+      return new S(function() {
+        if (i >= n.length) {
+          var u = e.next();
+          if (u.done)
+            return u;
+          n[i] = u.value;
+        }
+        return w(t, i, n[i++]);
+      });
+    };
+    function hr(t) {
+      return !!(t && t[Qr]);
+    }
+    var te;
+    function Ht() {
+      return te || (te = new ut([]));
+    }
+    function re(t) {
+      var r = Array.isArray(t) ? new ut(t).fromEntrySeq() : Jt(t) ? new Kt(t).fromEntrySeq() : Gr(t) ? new kt(t).fromEntrySeq() : typeof t == "object" ? new vt(t) : void 0;
+      if (!r)
+        throw new TypeError(
+          "Expected Array or iterable object of [k, v] entries, or keyed object: " + t
+        );
+      return r;
+    }
+    function cr(t) {
+      var r = ee(t);
+      if (!r)
+        throw new TypeError(
+          "Expected Array or iterable object of values: " + t
+        );
+      return r;
+    }
+    function rn(t) {
+      var r = ee(t) || typeof t == "object" && new vt(t);
+      if (!r)
+        throw new TypeError(
+          "Expected Array or iterable object of values, or keyed object: " + t
+        );
+      return r;
+    }
+    function ee(t) {
+      return Zr(t) ? new ut(t) : Jt(t) ? new Kt(t) : Gr(t) ? new kt(t) : void 0;
+    }
+    function ne(t, r, e, n) {
+      var i = t._cache;
+      if (i) {
+        for (var u = i.length - 1, o = 0; o <= u; o++) {
+          var s = i[e ? u - o : o];
+          if (r(s[1], n ? s[0] : o, t) === !1)
+            return o + 1;
+        }
+        return o;
+      }
+      return t.__iterateUncached(r, e);
+    }
+    function ie(t, r, e, n) {
+      var i = t._cache;
+      if (i) {
+        var u = i.length - 1, o = 0;
+        return new S(function() {
+          var s = i[e ? u - o : o];
+          return o++ > u ? B() : w(r, n ? s[0] : o - 1, s[1]);
+        });
+      }
+      return t.__iteratorUncached(r, e);
+    }
+    function _r(t, r) {
+      return r ? pr(r, t, "", { "": t }) : vr(t);
+    }
+    function pr(t, r, e, n) {
+      return Array.isArray(r) ? t.call(n, e, O(r).map(function(i, u) {
+        return pr(t, i, u, r);
+      })) : ue(r) ? t.call(n, e, Z(r).map(function(i, u) {
+        return pr(t, i, u, r);
+      })) : r;
+    }
+    function vr(t) {
+      return Array.isArray(t) ? O(t).map(vr).toList() : ue(t) ? Z(t).map(vr).toMap() : t;
+    }
+    function ue(t) {
+      return t && (t.constructor === Object || t.constructor === void 0);
+    }
+    function A(t, r) {
+      if (t === r || t !== t && r !== r)
+        return !0;
+      if (!t || !r)
+        return !1;
+      if (typeof t.valueOf == "function" && typeof r.valueOf == "function") {
+        if (t = t.valueOf(), r = r.valueOf(), t === r || t !== t && r !== r)
+          return !0;
+        if (!t || !r)
+          return !1;
+      }
+      return !!(typeof t.equals == "function" && typeof r.equals == "function" && t.equals(r));
+    }
+    function dr(t, r) {
+      if (t === r)
+        return !0;
+      if (!F(r) || t.size !== void 0 && r.size !== void 0 && t.size !== r.size || t.__hash !== void 0 && r.__hash !== void 0 && t.__hash !== r.__hash || R(t) !== R(r) || b(t) !== b(r) || et(t) !== et(r))
+        return !1;
+      if (t.size === 0 && r.size === 0)
+        return !0;
+      var e = !ir(t);
+      if (et(t)) {
+        var n = t.entries();
+        return r.every(function(a, f) {
+          var h = n.next().value;
+          return h && A(h[1], a) && (e || A(h[0], f));
+        }) && n.next().done;
+      }
+      var i = !1;
+      if (t.size === void 0)
+        if (r.size === void 0)
+          typeof t.cacheResult == "function" && t.cacheResult();
+        else {
+          i = !0;
+          var u = t;
+          t = r, r = u;
+        }
+      var o = !0, s = r.__iterate(function(a, f) {
+        if (e ? !t.has(a) : i ? !A(a, t.get(f, l)) : !A(t.get(f, l), a))
+          return o = !1, !1;
+      });
+      return o && t.size === s;
+    }
+    m(k, O);
+    function k(t, r) {
+      if (!(this instanceof k))
+        return new k(t, r);
+      if (this._value = t, this.size = r === void 0 ? 1 / 0 : Math.max(0, r), this.size === 0) {
+        if (lr)
+          return lr;
+        lr = this;
+      }
+    }
+    k.prototype.toString = function() {
+      return this.size === 0 ? "Repeat []" : "Repeat [ " + this._value + " " + this.size + " times ]";
+    }, k.prototype.get = function(t, r) {
+      return this.has(t) ? this._value : r;
+    }, k.prototype.includes = function(t) {
+      return A(this._value, t);
+    }, k.prototype.slice = function(t, r) {
+      var e = this.size;
+      return Lt(t, r, e) ? this : new k(this._value, Nt(r, e) - gt(t, e));
+    }, k.prototype.reverse = function() {
+      return this;
+    }, k.prototype.indexOf = function(t) {
+      return A(this._value, t) ? 0 : -1;
+    }, k.prototype.lastIndexOf = function(t) {
+      return A(this._value, t) ? this.size : -1;
+    }, k.prototype.__iterate = function(t, r) {
+      for (var e = 0; e < this.size; e++)
+        if (t(this._value, e, this) === !1)
+          return e + 1;
+      return e;
+    }, k.prototype.__iterator = function(t, r) {
+      var e = this, n = 0;
+      return new S(
+        function() {
+          return n < e.size ? w(t, n++, e._value) : B();
+        }
+      );
+    }, k.prototype.equals = function(t) {
+      return t instanceof k ? A(this._value, t._value) : dr(t);
+    };
+    var lr;
+    function Vt(t, r) {
+      if (!t) throw new Error(r);
+    }
+    m(K, O);
+    function K(t, r, e) {
+      if (!(this instanceof K))
+        return new K(t, r, e);
+      if (Vt(e !== 0, "Cannot step a Range by 0"), t = t || 0, r === void 0 && (r = 1 / 0), e = e === void 0 ? 1 : Math.abs(e), r < t && (e = -e), this._start = t, this._end = r, this._step = e, this.size = Math.max(0, Math.ceil((r - t) / e - 1) + 1), this.size === 0) {
+        if (yr)
+          return yr;
+        yr = this;
+      }
+    }
+    K.prototype.toString = function() {
+      return this.size === 0 ? "Range []" : "Range [ " + this._start + "..." + this._end + (this._step > 1 ? " by " + this._step : "") + " ]";
+    }, K.prototype.get = function(t, r) {
+      return this.has(t) ? this._start + pt(this, t) * this._step : r;
+    }, K.prototype.includes = function(t) {
+      var r = (t - this._start) / this._step;
+      return r >= 0 && r < this.size && r === Math.floor(r);
+    }, K.prototype.slice = function(t, r) {
+      return Lt(t, r, this.size) ? this : (t = gt(t, this.size), r = Nt(r, this.size), r <= t ? new K(0, 0) : new K(this.get(t, this._end), this.get(r, this._end), this._step));
+    }, K.prototype.indexOf = function(t) {
+      var r = t - this._start;
+      if (r % this._step === 0) {
+        var e = r / this._step;
+        if (e >= 0 && e < this.size)
+          return e;
+      }
+      return -1;
+    }, K.prototype.lastIndexOf = function(t) {
+      return this.indexOf(t);
+    }, K.prototype.__iterate = function(t, r) {
+      for (var e = this.size - 1, n = this._step, i = r ? this._start + e * n : this._start, u = 0; u <= e; u++) {
+        if (t(i, u, this) === !1)
+          return u + 1;
+        i += r ? -n : n;
+      }
+      return u;
+    }, K.prototype.__iterator = function(t, r) {
+      var e = this.size - 1, n = this._step, i = r ? this._start + e * n : this._start, u = 0;
+      return new S(function() {
+        var o = i;
+        return i += r ? -n : n, u > e ? B() : w(t, u++, o);
+      });
+    }, K.prototype.equals = function(t) {
+      return t instanceof K ? this._start === t._start && this._end === t._end && this._step === t._step : dr(this, t);
+    };
+    var yr;
+    m(dt, q);
+    function dt() {
+      throw TypeError("Abstract");
+    }
+    m(Ut, dt);
+    function Ut() {
+    }
+    m(wt, dt);
+    function wt() {
+    }
+    m(bt, dt);
+    function bt() {
+    }
+    dt.Keyed = Ut, dt.Indexed = wt, dt.Set = bt;
+    var Ct = typeof Math.imul == "function" && Math.imul(4294967295, 2) === -2 ? Math.imul : function(r, e) {
+      r = r | 0, e = e | 0;
+      var n = r & 65535, i = e & 65535;
+      return n * i + ((r >>> 16) * i + n * (e >>> 16) << 16 >>> 0) | 0;
+    };
+    function Sr(t) {
+      return t >>> 1 & 1073741824 | t & 3221225471;
+    }
+    function $(t) {
+      if (t === !1 || t === null || t === void 0 || typeof t.valueOf == "function" && (t = t.valueOf(), t === !1 || t === null || t === void 0))
+        return 0;
+      if (t === !0)
+        return 1;
+      var r = typeof t;
+      if (r === "number") {
+        var e = t | 0;
+        for (e !== t && (e ^= t * 4294967295); t > 4294967295; )
+          t /= 4294967295, e ^= t;
+        return Sr(e);
+      }
+      if (r === "string")
+        return t.length > on ? en(t) : mr(t);
+      if (typeof t.hashCode == "function")
+        return t.hashCode();
+      if (r === "object")
+        return nn(t);
+      if (typeof t.toString == "function")
+        return mr(t.toString());
+      throw new Error("Value type " + r + " cannot be hashed.");
+    }
+    function en(t) {
+      var r = zr[t];
+      return r === void 0 && (r = mr(t), Ir === sn && (Ir = 0, zr = {}), Ir++, zr[t] = r), r;
+    }
+    function mr(t) {
+      for (var r = 0, e = 0; e < t.length; e++)
+        r = 31 * r + t.charCodeAt(e) | 0;
+      return Sr(r);
+    }
+    function nn(t) {
+      var r;
+      if (gr && (r = wr.get(t), r !== void 0) || (r = t[St], r !== void 0) || !se && (r = t.propertyIsEnumerable && t.propertyIsEnumerable[St], r !== void 0 || (r = un(t), r !== void 0)))
+        return r;
+      if (r = ++Er, Er & 1073741824 && (Er = 0), gr)
+        wr.set(t, r);
+      else {
+        if (oe !== void 0 && oe(t) === !1)
+          throw new Error("Non-extensible objects are not allowed as keys.");
+        if (se)
+          Object.defineProperty(t, St, {
+            enumerable: !1,
+            configurable: !1,
+            writable: !1,
+            value: r
+          });
+        else if (t.propertyIsEnumerable !== void 0 && t.propertyIsEnumerable === t.constructor.prototype.propertyIsEnumerable)
+          t.propertyIsEnumerable = function() {
+            return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments);
+          }, t.propertyIsEnumerable[St] = r;
+        else if (t.nodeType !== void 0)
+          t[St] = r;
+        else
+          throw new Error("Unable to set a non-enumerable property on object.");
+      }
+      return r;
+    }
+    var oe = Object.isExtensible, se = function() {
+      try {
+        return Object.defineProperty({}, "@", {}), !0;
+      } catch {
+        return !1;
+      }
+    }();
+    function un(t) {
+      if (t && t.nodeType > 0)
+        switch (t.nodeType) {
+          case 1:
+            return t.uniqueID;
+          case 9:
+            return t.documentElement && t.documentElement.uniqueID;
+        }
+    }
+    var gr = typeof WeakMap == "function", wr;
+    gr && (wr = /* @__PURE__ */ new WeakMap());
+    var Er = 0, St = "__immutablehash__";
+    typeof Symbol == "function" && (St = Symbol(St));
+    var on = 16, sn = 255, Ir = 0, zr = {};
+    function j(t) {
+      Vt(
+        t !== 1 / 0,
+        "Cannot perform this action with an infinite size."
+      );
+    }
+    m(y, Ut);
+    function y(t) {
+      return t == null ? ot() : Mr(t) && !et(t) ? t : ot().withMutations(function(r) {
+        var e = C(t);
+        j(e.size), e.forEach(function(n, i) {
+          return r.set(i, n);
+        });
+      });
+    }
+    y.prototype.toString = function() {
+      return this.__toString("Map {", "}");
+    }, y.prototype.get = function(t, r) {
+      return this._root ? this._root.get(0, void 0, t, r) : r;
+    }, y.prototype.set = function(t, r) {
+      return ce(this, t, r);
+    }, y.prototype.setIn = function(t, r) {
+      return this.updateIn(t, l, function() {
+        return r;
+      });
+    }, y.prototype.remove = function(t) {
+      return ce(this, t, l);
+    }, y.prototype.deleteIn = function(t) {
+      return this.updateIn(t, function() {
+        return l;
+      });
+    }, y.prototype.update = function(t, r, e) {
+      return arguments.length === 1 ? t(this) : this.updateIn([t], r, e);
+    }, y.prototype.updateIn = function(t, r, e) {
+      e || (e = r, r = void 0);
+      var n = le(
+        this,
+        Ue(t),
+        r,
+        e
+      );
+      return n === l ? void 0 : n;
+    }, y.prototype.clear = function() {
+      return this.size === 0 ? this : this.__ownerID ? (this.size = 0, this._root = null, this.__hash = void 0, this.__altered = !0, this) : ot();
+    }, y.prototype.merge = function() {
+      return xt(this, void 0, arguments);
+    }, y.prototype.mergeWith = function(t) {
+      var r = H.call(arguments, 1);
+      return xt(this, t, r);
+    }, y.prototype.mergeIn = function(t) {
+      var r = H.call(arguments, 1);
+      return this.updateIn(
+        t,
+        ot(),
+        function(e) {
+          return typeof e.merge == "function" ? e.merge.apply(e, r) : r[r.length - 1];
+        }
+      );
+    }, y.prototype.mergeDeep = function() {
+      return xt(this, pe, arguments);
+    }, y.prototype.mergeDeepWith = function(t) {
+      var r = H.call(arguments, 1);
+      return xt(this, ve(t), r);
+    }, y.prototype.mergeDeepIn = function(t) {
+      var r = H.call(arguments, 1);
+      return this.updateIn(
+        t,
+        ot(),
+        function(e) {
+          return typeof e.mergeDeep == "function" ? e.mergeDeep.apply(e, r) : r[r.length - 1];
+        }
+      );
+    }, y.prototype.sort = function(t) {
+      return T(At(this, t));
+    }, y.prototype.sortBy = function(t, r) {
+      return T(At(this, r, t));
+    }, y.prototype.withMutations = function(t) {
+      var r = this.asMutable();
+      return t(r), r.wasAltered() ? r.__ensureOwner(this.__ownerID) : this;
+    }, y.prototype.asMutable = function() {
+      return this.__ownerID ? this : this.__ensureOwner(new or());
+    }, y.prototype.asImmutable = function() {
+      return this.__ensureOwner();
+    }, y.prototype.wasAltered = function() {
+      return this.__altered;
+    }, y.prototype.__iterator = function(t, r) {
+      return new qr(this, t, r);
+    }, y.prototype.__iterate = function(t, r) {
+      var e = this, n = 0;
+      return this._root && this._root.iterate(function(i) {
+        return n++, t(i[1], i[0], e);
+      }, r), n;
+    }, y.prototype.__ensureOwner = function(t) {
+      return t === this.__ownerID ? this : t ? Ar(this.size, this._root, t, this.__hash) : (this.__ownerID = t, this.__altered = !1, this);
+    };
+    function Mr(t) {
+      return !!(t && t[ae]);
+    }
+    y.isMap = Mr;
+    var ae = "@@__IMMUTABLE_MAP__@@", d = y.prototype;
+    d[ae] = !0, d[Rt] = d.remove, d.removeIn = d.deleteIn;
+    function Pt(t, r) {
+      this.ownerID = t, this.entries = r;
+    }
+    Pt.prototype.get = function(t, r, e, n) {
+      for (var i = this.entries, u = 0, o = i.length; u < o; u++)
+        if (A(e, i[u][0]))
+          return i[u][1];
+      return n;
+    }, Pt.prototype.update = function(t, r, e, n, i, u, o) {
+      for (var s = i === l, a = this.entries, f = 0, h = a.length; f < h && !A(n, a[f][0]); f++)
+        ;
+      var c = f < h;
+      if (c ? a[f][1] === i : s)
+        return this;
+      if (G(o), (s || !c) && G(u), !(s && a.length === 1)) {
+        if (!c && !s && a.length >= pn)
+          return an(t, a, n, i);
+        var _ = t && t === this.ownerID, p = _ ? a : _t(a);
+        return c ? s ? f === h - 1 ? p.pop() : p[f] = p.pop() : p[f] = [n, i] : p.push([n, i]), _ ? (this.entries = p, this) : new Pt(t, p);
+      }
+    };
+    function Et(t, r, e) {
+      this.ownerID = t, this.bitmap = r, this.nodes = e;
+    }
+    Et.prototype.get = function(t, r, e, n) {
+      r === void 0 && (r = $(e));
+      var i = 1 << ((t === 0 ? r : r >>> t) & P), u = this.bitmap;
+      return u & i ? this.nodes[ye(u & i - 1)].get(t + E, r, e, n) : n;
+    }, Et.prototype.update = function(t, r, e, n, i, u, o) {
+      e === void 0 && (e = $(n));
+      var s = (r === 0 ? e : e >>> r) & P, a = 1 << s, f = this.bitmap, h = (f & a) !== 0;
+      if (!h && i === l)
+        return this;
+      var c = ye(f & a - 1), _ = this.nodes, p = h ? _[c] : void 0, v = Tr(p, t, r + E, e, n, i, u, o);
+      if (v === p)
+        return this;
+      if (!h && v && _.length >= vn)
+        return hn(t, _, f, s, v);
+      if (h && !v && _.length === 2 && _e(_[c ^ 1]))
+        return _[c ^ 1];
+      if (h && v && _.length === 1 && _e(v))
+        return v;
+      var M = t && t === this.ownerID, rt = h ? v ? f : f ^ a : f | a, ht = h ? v ? Se(_, c, v, M) : _n(_, c, M) : cn(_, c, v, M);
+      return M ? (this.bitmap = rt, this.nodes = ht, this) : new Et(t, rt, ht);
+    };
+    function Wt(t, r, e) {
+      this.ownerID = t, this.count = r, this.nodes = e;
+    }
+    Wt.prototype.get = function(t, r, e, n) {
+      r === void 0 && (r = $(e));
+      var i = (t === 0 ? r : r >>> t) & P, u = this.nodes[i];
+      return u ? u.get(t + E, r, e, n) : n;
+    }, Wt.prototype.update = function(t, r, e, n, i, u, o) {
+      e === void 0 && (e = $(n));
+      var s = (r === 0 ? e : e >>> r) & P, a = i === l, f = this.nodes, h = f[s];
+      if (a && !h)
+        return this;
+      var c = Tr(h, t, r + E, e, n, i, u, o);
+      if (c === h)
+        return this;
+      var _ = this.count;
+      if (!h)
+        _++;
+      else if (!c && (_--, _ < dn))
+        return fn(t, f, _, s);
+      var p = t && t === this.ownerID, v = Se(f, s, c, p);
+      return p ? (this.count = _, this.nodes = v, this) : new Wt(t, _, v);
+    };
+    function It(t, r, e) {
+      this.ownerID = t, this.keyHash = r, this.entries = e;
+    }
+    It.prototype.get = function(t, r, e, n) {
+      for (var i = this.entries, u = 0, o = i.length; u < o; u++)
+        if (A(e, i[u][0]))
+          return i[u][1];
+      return n;
+    }, It.prototype.update = function(t, r, e, n, i, u, o) {
+      e === void 0 && (e = $(n));
+      var s = i === l;
+      if (e !== this.keyHash)
+        return s ? this : (G(o), G(u), Rr(this, t, r, e, [n, i]));
+      for (var a = this.entries, f = 0, h = a.length; f < h && !A(n, a[f][0]); f++)
+        ;
+      var c = f < h;
+      if (c ? a[f][1] === i : s)
+        return this;
+      if (G(o), (s || !c) && G(u), s && h === 2)
+        return new ct(t, this.keyHash, a[f ^ 1]);
+      var _ = t && t === this.ownerID, p = _ ? a : _t(a);
+      return c ? s ? f === h - 1 ? p.pop() : p[f] = p.pop() : p[f] = [n, i] : p.push([n, i]), _ ? (this.entries = p, this) : new It(t, this.keyHash, p);
+    };
+    function ct(t, r, e) {
+      this.ownerID = t, this.keyHash = r, this.entry = e;
+    }
+    ct.prototype.get = function(t, r, e, n) {
+      return A(e, this.entry[0]) ? this.entry[1] : n;
+    }, ct.prototype.update = function(t, r, e, n, i, u, o) {
+      var s = i === l, a = A(n, this.entry[0]);
+      if (a ? i === this.entry[1] : s)
+        return this;
+      if (G(o), s) {
+        G(u);
+        return;
+      }
+      return a ? t && t === this.ownerID ? (this.entry[1] = i, this) : new ct(t, this.keyHash, [n, i]) : (G(u), Rr(this, t, r, $(n), [n, i]));
+    }, Pt.prototype.iterate = It.prototype.iterate = function(t, r) {
+      for (var e = this.entries, n = 0, i = e.length - 1; n <= i; n++)
+        if (t(e[r ? i - n : n]) === !1)
+          return !1;
+    }, Et.prototype.iterate = Wt.prototype.iterate = function(t, r) {
+      for (var e = this.nodes, n = 0, i = e.length - 1; n <= i; n++) {
+        var u = e[r ? i - n : n];
+        if (u && u.iterate(t, r) === !1)
+          return !1;
+      }
+    }, ct.prototype.iterate = function(t, r) {
+      return t(this.entry);
+    }, m(qr, S);
+    function qr(t, r, e) {
+      this._type = r, this._reverse = e, this._stack = t._root && fe(t._root);
+    }
+    qr.prototype.next = function() {
+      for (var t = this._type, r = this._stack; r; ) {
+        var e = r.node, n = r.index++, i;
+        if (e.entry) {
+          if (n === 0)
+            return Or(t, e.entry);
+        } else if (e.entries) {
+          if (i = e.entries.length - 1, n <= i)
+            return Or(t, e.entries[this._reverse ? i - n : n]);
+        } else if (i = e.nodes.length - 1, n <= i) {
+          var u = e.nodes[this._reverse ? i - n : n];
+          if (u) {
+            if (u.entry)
+              return Or(t, u.entry);
+            r = this._stack = fe(u, r);
+          }
+          continue;
+        }
+        r = this._stack = this._stack.__prev;
+      }
+      return B();
+    };
+    function Or(t, r) {
+      return w(t, r[0], r[1]);
+    }
+    function fe(t, r) {
+      return {
+        node: t,
+        index: 0,
+        __prev: r
+      };
+    }
+    function Ar(t, r, e, n) {
+      var i = Object.create(d);
+      return i.size = t, i._root = r, i.__ownerID = e, i.__hash = n, i.__altered = !1, i;
+    }
+    var he;
+    function ot() {
+      return he || (he = Ar(0));
+    }
+    function ce(t, r, e) {
+      var n, i;
+      if (t._root) {
+        var u = ur(tn), o = ur(Hr);
+        if (n = Tr(t._root, t.__ownerID, 0, void 0, r, e, u, o), !o.value)
+          return t;
+        i = t.size + (u.value ? e === l ? -1 : 1 : 0);
+      } else {
+        if (e === l)
+          return t;
+        i = 1, n = new Pt(t.__ownerID, [[r, e]]);
+      }
+      return t.__ownerID ? (t.size = i, t._root = n, t.__hash = void 0, t.__altered = !0, t) : n ? Ar(i, n) : ot();
+    }
+    function Tr(t, r, e, n, i, u, o, s) {
+      return t ? t.update(r, e, n, i, u, o, s) : u === l ? t : (G(s), G(o), new ct(r, n, [i, u]));
+    }
+    function _e(t) {
+      return t.constructor === ct || t.constructor === It;
+    }
+    function Rr(t, r, e, n, i) {
+      if (t.keyHash === n)
+        return new It(r, n, [t.entry, i]);
+      var u = (e === 0 ? t.keyHash : t.keyHash >>> e) & P, o = (e === 0 ? n : n >>> e) & P, s, a = u === o ? [Rr(t, r, e + E, n, i)] : (s = new ct(r, n, i), u < o ? [t, s] : [s, t]);
+      return new Et(r, 1 << u | 1 << o, a);
+    }
+    function an(t, r, e, n) {
+      t || (t = new or());
+      for (var i = new ct(t, $(e), [e, n]), u = 0; u < r.length; u++) {
+        var o = r[u];
+        i = i.update(t, 0, void 0, o[0], o[1]);
+      }
+      return i;
+    }
+    function fn(t, r, e, n) {
+      for (var i = 0, u = 0, o = new Array(e), s = 0, a = 1, f = r.length; s < f; s++, a <<= 1) {
+        var h = r[s];
+        h !== void 0 && s !== n && (i |= a, o[u++] = h);
+      }
+      return new Et(t, i, o);
+    }
+    function hn(t, r, e, n, i) {
+      for (var u = 0, o = new Array(x), s = 0; e !== 0; s++, e >>>= 1)
+        o[s] = e & 1 ? r[u++] : void 0;
+      return o[n] = i, new Wt(t, u + 1, o);
+    }
+    function xt(t, r, e) {
+      for (var n = [], i = 0; i < e.length; i++) {
+        var u = e[i], o = C(u);
+        F(u) || (o = o.map(function(s) {
+          return _r(s);
+        })), n.push(o);
+      }
+      return de(t, r, n);
+    }
+    function pe(t, r, e) {
+      return t && t.mergeDeep && F(r) ? t.mergeDeep(r) : A(t, r) ? t : r;
+    }
+    function ve(t) {
+      return function(r, e, n) {
+        if (r && r.mergeDeepWith && F(e))
+          return r.mergeDeepWith(t, e);
+        var i = t(r, e, n);
+        return A(r, i) ? r : i;
+      };
+    }
+    function de(t, r, e) {
+      return e = e.filter(function(n) {
+        return n.size !== 0;
+      }), e.length === 0 ? t : t.size === 0 && !t.__ownerID && e.length === 1 ? t.constructor(e[0]) : t.withMutations(function(n) {
+        for (var i = r ? function(o, s) {
+          n.update(
+            s,
+            l,
+            function(a) {
+              return a === l ? o : r(a, o, s);
+            }
+          );
+        } : function(o, s) {
+          n.set(s, o);
+        }, u = 0; u < e.length; u++)
+          e[u].forEach(i);
+      });
+    }
+    function le(t, r, e, n) {
+      var i = t === l, u = r.next();
+      if (u.done) {
+        var o = i ? e : t, s = n(o);
+        return s === o ? t : s;
+      }
+      Vt(
+        i || t && t.set,
+        "invalid keyPath"
+      );
+      var a = u.value, f = i ? l : t.get(a, l), h = le(
+        f,
+        r,
+        e,
+        n
+      );
+      return h === f ? t : h === l ? t.remove(a) : (i ? ot() : t).set(a, h);
+    }
+    function ye(t) {
+      return t = t - (t >> 1 & 1431655765), t = (t & 858993459) + (t >> 2 & 858993459), t = t + (t >> 4) & 252645135, t = t + (t >> 8), t = t + (t >> 16), t & 127;
+    }
+    function Se(t, r, e, n) {
+      var i = n ? t : _t(t);
+      return i[r] = e, i;
+    }
+    function cn(t, r, e, n) {
+      var i = t.length + 1;
+      if (n && r + 1 === i)
+        return t[r] = e, t;
+      for (var u = new Array(i), o = 0, s = 0; s < i; s++)
+        s === r ? (u[s] = e, o = -1) : u[s] = t[s + o];
+      return u;
+    }
+    function _n(t, r, e) {
+      var n = t.length - 1;
+      if (e && r === n)
+        return t.pop(), t;
+      for (var i = new Array(n), u = 0, o = 0; o < n; o++)
+        o === r && (u = 1), i[o] = t[o + u];
+      return i;
+    }
+    var pn = x / 4, vn = x / 2, dn = x / 4;
+    m(I, wt);
+    function I(t) {
+      var r = Lr();
+      if (t == null)
+        return r;
+      if (me(t))
+        return t;
+      var e = tt(t), n = e.size;
+      return n === 0 ? r : (j(n), n > 0 && n < x ? $t(0, n, E, null, new lt(e.toArray())) : r.withMutations(function(i) {
+        i.setSize(n), e.forEach(function(u, o) {
+          return i.set(o, u);
+        });
+      }));
+    }
+    I.of = function() {
+      return this(arguments);
+    }, I.prototype.toString = function() {
+      return this.__toString("List [", "]");
+    }, I.prototype.get = function(t, r) {
+      if (t = pt(this, t), t >= 0 && t < this.size) {
+        t += this._origin;
+        var e = Ie(this, t);
+        return e && e.array[t & P];
+      }
+      return r;
+    }, I.prototype.set = function(t, r) {
+      return ln(this, t, r);
+    }, I.prototype.remove = function(t) {
+      return this.has(t) ? t === 0 ? this.shift() : t === this.size - 1 ? this.pop() : this.splice(t, 1) : this;
+    }, I.prototype.insert = function(t, r) {
+      return this.splice(t, 0, r);
+    }, I.prototype.clear = function() {
+      return this.size === 0 ? this : this.__ownerID ? (this.size = this._origin = this._capacity = 0, this._level = E, this._root = this._tail = null, this.__hash = void 0, this.__altered = !0, this) : Lr();
+    }, I.prototype.push = function() {
+      var t = arguments, r = this.size;
+      return this.withMutations(function(e) {
+        yt(e, 0, r + t.length);
+        for (var n = 0; n < t.length; n++)
+          e.set(r + n, t[n]);
+      });
+    }, I.prototype.pop = function() {
+      return yt(this, 0, -1);
+    }, I.prototype.unshift = function() {
+      var t = arguments;
+      return this.withMutations(function(r) {
+        yt(r, -t.length);
+        for (var e = 0; e < t.length; e++)
+          r.set(e, t[e]);
+      });
+    }, I.prototype.shift = function() {
+      return yt(this, 1);
+    }, I.prototype.merge = function() {
+      return Gt(this, void 0, arguments);
+    }, I.prototype.mergeWith = function(t) {
+      var r = H.call(arguments, 1);
+      return Gt(this, t, r);
+    }, I.prototype.mergeDeep = function() {
+      return Gt(this, pe, arguments);
+    }, I.prototype.mergeDeepWith = function(t) {
+      var r = H.call(arguments, 1);
+      return Gt(this, ve(t), r);
+    }, I.prototype.setSize = function(t) {
+      return yt(this, 0, t);
+    }, I.prototype.slice = function(t, r) {
+      var e = this.size;
+      return Lt(t, r, e) ? this : yt(
+        this,
+        gt(t, e),
+        Nt(r, e)
+      );
+    }, I.prototype.__iterator = function(t, r) {
+      var e = 0, n = we(this, r);
+      return new S(function() {
+        var i = n();
+        return i === Bt ? B() : w(t, e++, i);
+      });
+    }, I.prototype.__iterate = function(t, r) {
+      for (var e = 0, n = we(this, r), i; (i = n()) !== Bt && t(i, e++, this) !== !1; )
+        ;
+      return e;
+    }, I.prototype.__ensureOwner = function(t) {
+      return t === this.__ownerID ? this : t ? $t(this._origin, this._capacity, this._level, this._root, this._tail, t, this.__hash) : (this.__ownerID = t, this);
+    };
+    function me(t) {
+      return !!(t && t[ge]);
+    }
+    I.isList = me;
+    var ge = "@@__IMMUTABLE_LIST__@@", W = I.prototype;
+    W[ge] = !0, W[Rt] = W.remove, W.setIn = d.setIn, W.deleteIn = W.removeIn = d.removeIn, W.update = d.update, W.updateIn = d.updateIn, W.mergeIn = d.mergeIn, W.mergeDeepIn = d.mergeDeepIn, W.withMutations = d.withMutations, W.asMutable = d.asMutable, W.asImmutable = d.asImmutable, W.wasAltered = d.wasAltered;
+    function lt(t, r) {
+      this.array = t, this.ownerID = r;
+    }
+    lt.prototype.removeBefore = function(t, r, e) {
+      if (e === r ? 1 << r : this.array.length === 0)
+        return this;
+      var n = e >>> r & P;
+      if (n >= this.array.length)
+        return new lt([], t);
+      var i = n === 0, u;
+      if (r > 0) {
+        var o = this.array[n];
+        if (u = o && o.removeBefore(t, r - E, e), u === o && i)
+          return this;
+      }
+      if (i && !u)
+        return this;
+      var s = zt(this, t);
+      if (!i)
+        for (var a = 0; a < n; a++)
+          s.array[a] = void 0;
+      return u && (s.array[n] = u), s;
+    }, lt.prototype.removeAfter = function(t, r, e) {
+      if (e === (r ? 1 << r : 0) || this.array.length === 0)
+        return this;
+      var n = e - 1 >>> r & P;
+      if (n >= this.array.length)
+        return this;
+      var i;
+      if (r > 0) {
+        var u = this.array[n];
+        if (i = u && u.removeAfter(t, r - E, e), i === u && n === this.array.length - 1)
+          return this;
+      }
+      var o = zt(this, t);
+      return o.array.splice(n + 1), i && (o.array[n] = i), o;
+    };
+    var Bt = {};
+    function we(t, r) {
+      var e = t._origin, n = t._capacity, i = jt(n), u = t._tail;
+      return o(t._root, t._level, 0);
+      function o(f, h, c) {
+        return h === 0 ? s(f, c) : a(f, h, c);
+      }
+      function s(f, h) {
+        var c = h === i ? u && u.array : f && f.array, _ = h > e ? 0 : e - h, p = n - h;
+        return p > x && (p = x), function() {
+          if (_ === p)
+            return Bt;
+          var v = r ? --p : _++;
+          return c && c[v];
+        };
+      }
+      function a(f, h, c) {
+        var _, p = f && f.array, v = c > e ? 0 : e - c >> h, M = (n - c >> h) + 1;
+        return M > x && (M = x), function() {
+          do {
+            if (_) {
+              var rt = _();
+              if (rt !== Bt)
+                return rt;
+              _ = null;
+            }
+            if (v === M)
+              return Bt;
+            var ht = r ? --M : v++;
+            _ = o(
+              p && p[ht],
+              h - E,
+              c + (ht << h)
+            );
+          } while (!0);
+        };
+      }
+    }
+    function $t(t, r, e, n, i, u, o) {
+      var s = Object.create(W);
+      return s.size = r - t, s._origin = t, s._capacity = r, s._level = e, s._root = n, s._tail = i, s.__ownerID = u, s.__hash = o, s.__altered = !1, s;
+    }
+    var Ee;
+    function Lr() {
+      return Ee || (Ee = $t(0, 0, E));
+    }
+    function ln(t, r, e) {
+      if (r = pt(t, r), r !== r)
+        return t;
+      if (r >= t.size || r < 0)
+        return t.withMutations(function(o) {
+          r < 0 ? yt(o, r).set(0, e) : yt(o, 0, r + 1).set(r, e);
+        });
+      r += t._origin;
+      var n = t._tail, i = t._root, u = ur(Hr);
+      return r >= jt(t._capacity) ? n = Nr(n, t.__ownerID, 0, r, e, u) : i = Nr(i, t.__ownerID, t._level, r, e, u), u.value ? t.__ownerID ? (t._root = i, t._tail = n, t.__hash = void 0, t.__altered = !0, t) : $t(t._origin, t._capacity, t._level, i, n) : t;
+    }
+    function Nr(t, r, e, n, i, u) {
+      var o = n >>> e & P, s = t && o < t.array.length;
+      if (!s && i === void 0)
+        return t;
+      var a;
+      if (e > 0) {
+        var f = t && t.array[o], h = Nr(f, r, e - E, n, i, u);
+        return h === f ? t : (a = zt(t, r), a.array[o] = h, a);
+      }
+      return s && t.array[o] === i ? t : (G(u), a = zt(t, r), i === void 0 && o === a.array.length - 1 ? a.array.pop() : a.array[o] = i, a);
+    }
+    function zt(t, r) {
+      return r && t && r === t.ownerID ? t : new lt(t ? t.array.slice() : [], r);
+    }
+    function Ie(t, r) {
+      if (r >= jt(t._capacity))
+        return t._tail;
+      if (r < 1 << t._level + E) {
+        for (var e = t._root, n = t._level; e && n > 0; )
+          e = e.array[r >>> n & P], n -= E;
+        return e;
+      }
+    }
+    function yt(t, r, e) {
+      r !== void 0 && (r = r | 0), e !== void 0 && (e = e | 0);
+      var n = t.__ownerID || new or(), i = t._origin, u = t._capacity, o = i + r, s = e === void 0 ? u : e < 0 ? u + e : i + e;
+      if (o === i && s === u)
+        return t;
+      if (o >= s)
+        return t.clear();
+      for (var a = t._level, f = t._root, h = 0; o + h < 0; )
+        f = new lt(f && f.array.length ? [void 0, f] : [], n), a += E, h += 1 << a;
+      h && (o += h, i += h, s += h, u += h);
+      for (var c = jt(u), _ = jt(s); _ >= 1 << a + E; )
+        f = new lt(f && f.array.length ? [f] : [], n), a += E;
+      var p = t._tail, v = _ < c ? Ie(t, s - 1) : _ > c ? new lt([], n) : p;
+      if (p && _ > c && o < u && p.array.length) {
+        f = zt(f, n);
+        for (var M = f, rt = a; rt > E; rt -= E) {
+          var ht = c >>> rt & P;
+          M = M.array[ht] = zt(M.array[ht], n);
+        }
+        M.array[c >>> E & P] = p;
+      }
+      if (s < u && (v = v && v.removeAfter(n, 0, s)), o >= _)
+        o -= _, s -= _, a = E, f = null, v = v && v.removeBefore(n, 0, o);
+      else if (o > i || _ < c) {
+        for (h = 0; f; ) {
+          var nr = o >>> a & P;
+          if (nr !== _ >>> a & P)
+            break;
+          nr && (h += (1 << a) * nr), a -= E, f = f.array[nr];
+        }
+        f && o > i && (f = f.removeBefore(n, a, o - h)), f && _ < c && (f = f.removeAfter(n, a, _ - h)), h && (o -= h, s -= h);
+      }
+      return t.__ownerID ? (t.size = s - o, t._origin = o, t._capacity = s, t._level = a, t._root = f, t._tail = v, t.__hash = void 0, t.__altered = !0, t) : $t(o, s, a, f, v);
+    }
+    function Gt(t, r, e) {
+      for (var n = [], i = 0, u = 0; u < e.length; u++) {
+        var o = e[u], s = tt(o);
+        s.size > i && (i = s.size), F(o) || (s = s.map(function(a) {
+          return _r(a);
+        })), n.push(s);
+      }
+      return i > t.size && (t = t.setSize(i)), de(t, r, n);
+    }
+    function jt(t) {
+      return t < x ? 0 : t - 1 >>> E << E;
+    }
+    m(T, y);
+    function T(t) {
+      return t == null ? Xt() : ze(t) ? t : Xt().withMutations(function(r) {
+        var e = C(t);
+        j(e.size), e.forEach(function(n, i) {
+          return r.set(i, n);
+        });
+      });
+    }
+    T.of = function() {
+      return this(arguments);
+    }, T.prototype.toString = function() {
+      return this.__toString("OrderedMap {", "}");
+    }, T.prototype.get = function(t, r) {
+      var e = this._map.get(t);
+      return e !== void 0 ? this._list.get(e)[1] : r;
+    }, T.prototype.clear = function() {
+      return this.size === 0 ? this : this.__ownerID ? (this.size = 0, this._map.clear(), this._list.clear(), this) : Xt();
+    }, T.prototype.set = function(t, r) {
+      return qe(this, t, r);
+    }, T.prototype.remove = function(t) {
+      return qe(this, t, l);
+    }, T.prototype.wasAltered = function() {
+      return this._map.wasAltered() || this._list.wasAltered();
+    }, T.prototype.__iterate = function(t, r) {
+      var e = this;
+      return this._list.__iterate(
+        function(n) {
+          return n && t(n[1], n[0], e);
+        },
+        r
+      );
+    }, T.prototype.__iterator = function(t, r) {
+      return this._list.fromEntrySeq().__iterator(t, r);
+    }, T.prototype.__ensureOwner = function(t) {
+      if (t === this.__ownerID)
+        return this;
+      var r = this._map.__ensureOwner(t), e = this._list.__ensureOwner(t);
+      return t ? Fr(r, e, t, this.__hash) : (this.__ownerID = t, this._map = r, this._list = e, this);
+    };
+    function ze(t) {
+      return Mr(t) && et(t);
+    }
+    T.isOrderedMap = ze, T.prototype[mt] = !0, T.prototype[Rt] = T.prototype.remove;
+    function Fr(t, r, e, n) {
+      var i = Object.create(T.prototype);
+      return i.size = t ? t.size : 0, i._map = t, i._list = r, i.__ownerID = e, i.__hash = n, i;
+    }
+    var Me;
+    function Xt() {
+      return Me || (Me = Fr(ot(), Lr()));
+    }
+    function qe(t, r, e) {
+      var n = t._map, i = t._list, u = n.get(r), o = u !== void 0, s, a;
+      if (e === l) {
+        if (!o)
+          return t;
+        i.size >= x && i.size >= n.size * 2 ? (a = i.filter(function(f, h) {
+          return f !== void 0 && u !== h;
+        }), s = a.toKeyedSeq().map(function(f) {
+          return f[0];
+        }).flip().toMap(), t.__ownerID && (s.__ownerID = a.__ownerID = t.__ownerID)) : (s = n.remove(r), a = u === i.size - 1 ? i.pop() : i.set(u, void 0));
+      } else if (o) {
+        if (e === i.get(u)[1])
+          return t;
+        s = n, a = i.set(u, [r, e]);
+      } else
+        s = n.set(r, i.size), a = i.set(i.size, [r, e]);
+      return t.__ownerID ? (t.size = s.size, t._map = s, t._list = a, t.__hash = void 0, t) : Fr(s, a);
+    }
+    m(Q, Z);
+    function Q(t, r) {
+      this._iter = t, this._useKeys = r, this.size = t.size;
+    }
+    Q.prototype.get = function(t, r) {
+      return this._iter.get(t, r);
+    }, Q.prototype.has = function(t) {
+      return this._iter.has(t);
+    }, Q.prototype.valueSeq = function() {
+      return this._iter.valueSeq();
+    }, Q.prototype.reverse = function() {
+      var t = this, r = Dr(this, !0);
+      return this._useKeys || (r.valueSeq = function() {
+        return t._iter.toSeq().reverse();
+      }), r;
+    }, Q.prototype.map = function(t, r) {
+      var e = this, n = Ae(this, t, r);
+      return this._useKeys || (n.valueSeq = function() {
+        return e._iter.toSeq().map(t, r);
+      }), n;
+    }, Q.prototype.__iterate = function(t, r) {
+      var e = this, n;
+      return this._iter.__iterate(
+        this._useKeys ? function(i, u) {
+          return t(i, u, e);
+        } : (n = r ? De(this) : 0, function(i) {
+          return t(i, r ? --n : n++, e);
+        }),
+        r
+      );
+    }, Q.prototype.__iterator = function(t, r) {
+      if (this._useKeys)
+        return this._iter.__iterator(t, r);
+      var e = this._iter.__iterator(X, r), n = r ? De(this) : 0;
+      return new S(function() {
+        var i = e.next();
+        return i.done ? i : w(t, r ? --n : n++, i.value, i);
+      });
+    }, Q.prototype[mt] = !0, m(Mt, O);
+    function Mt(t) {
+      this._iter = t, this.size = t.size;
+    }
+    Mt.prototype.includes = function(t) {
+      return this._iter.includes(t);
+    }, Mt.prototype.__iterate = function(t, r) {
+      var e = this, n = 0;
+      return this._iter.__iterate(function(i) {
+        return t(i, n++, e);
+      }, r);
+    }, Mt.prototype.__iterator = function(t, r) {
+      var e = this._iter.__iterator(X, r), n = 0;
+      return new S(function() {
+        var i = e.next();
+        return i.done ? i : w(t, n++, i.value, i);
+      });
+    }, m(qt, it);
+    function qt(t) {
+      this._iter = t, this.size = t.size;
+    }
+    qt.prototype.has = function(t) {
+      return this._iter.includes(t);
+    }, qt.prototype.__iterate = function(t, r) {
+      var e = this;
+      return this._iter.__iterate(function(n) {
+        return t(n, n, e);
+      }, r);
+    }, qt.prototype.__iterator = function(t, r) {
+      var e = this._iter.__iterator(X, r);
+      return new S(function() {
+        var n = e.next();
+        return n.done ? n : w(t, n.value, n.value, n);
+      });
+    }, m(Ot, Z);
+    function Ot(t) {
+      this._iter = t, this.size = t.size;
+    }
+    Ot.prototype.entrySeq = function() {
+      return this._iter.toSeq();
+    }, Ot.prototype.__iterate = function(t, r) {
+      var e = this;
+      return this._iter.__iterate(function(n) {
+        if (n) {
+          Fe(n);
+          var i = F(n);
+          return t(
+            i ? n.get(1) : n[1],
+            i ? n.get(0) : n[0],
+            e
+          );
+        }
+      }, r);
+    }, Ot.prototype.__iterator = function(t, r) {
+      var e = this._iter.__iterator(X, r);
+      return new S(function() {
+        for (; ; ) {
+          var n = e.next();
+          if (n.done)
+            return n;
+          var i = n.value;
+          if (i) {
+            Fe(i);
+            var u = F(i);
+            return w(
+              t,
+              u ? i.get(0) : i[0],
+              u ? i.get(1) : i[1],
+              n
+            );
+          }
+        }
+      });
+    }, Mt.prototype.cacheResult = Q.prototype.cacheResult = qt.prototype.cacheResult = Ot.prototype.cacheResult = Ur;
+    function Oe(t) {
+      var r = st(t);
+      return r._iter = t, r.size = t.size, r.flip = function() {
+        return t;
+      }, r.reverse = function() {
+        var e = t.reverse.apply(this);
+        return e.flip = function() {
+          return t.reverse();
+        }, e;
+      }, r.has = function(e) {
+        return t.includes(e);
+      }, r.includes = function(e) {
+        return t.has(e);
+      }, r.cacheResult = Ur, r.__iterateUncached = function(e, n) {
+        var i = this;
+        return t.__iterate(function(u, o) {
+          return e(o, u, i) !== !1;
+        }, n);
+      }, r.__iteratorUncached = function(e, n) {
+        if (e === nt) {
+          var i = t.__iterator(e, n);
+          return new S(function() {
+            var u = i.next();
+            if (!u.done) {
+              var o = u.value[0];
+              u.value[0] = u.value[1], u.value[1] = o;
+            }
+            return u;
+          });
+        }
+        return t.__iterator(
+          e === X ? Ft : X,
+          n
+        );
+      }, r;
+    }
+    function Ae(t, r, e) {
+      var n = st(t);
+      return n.size = t.size, n.has = function(i) {
+        return t.has(i);
+      }, n.get = function(i, u) {
+        var o = t.get(i, l);
+        return o === l ? u : r.call(e, o, i, t);
+      }, n.__iterateUncached = function(i, u) {
+        var o = this;
+        return t.__iterate(
+          function(s, a, f) {
+            return i(r.call(e, s, a, f), a, o) !== !1;
+          },
+          u
+        );
+      }, n.__iteratorUncached = function(i, u) {
+        var o = t.__iterator(nt, u);
+        return new S(function() {
+          var s = o.next();
+          if (s.done)
+            return s;
+          var a = s.value, f = a[0];
+          return w(
+            i,
+            f,
+            r.call(e, a[1], f, t),
+            s
+          );
+        });
+      }, n;
+    }
+    function Dr(t, r) {
+      var e = st(t);
+      return e._iter = t, e.size = t.size, e.reverse = function() {
+        return t;
+      }, t.flip && (e.flip = function() {
+        var n = Oe(t);
+        return n.reverse = function() {
+          return t.flip();
+        }, n;
+      }), e.get = function(n, i) {
+        return t.get(r ? n : -1 - n, i);
+      }, e.has = function(n) {
+        return t.has(r ? n : -1 - n);
+      }, e.includes = function(n) {
+        return t.includes(n);
+      }, e.cacheResult = Ur, e.__iterate = function(n, i) {
+        var u = this;
+        return t.__iterate(function(o, s) {
+          return n(o, s, u);
+        }, !i);
+      }, e.__iterator = function(n, i) {
+        return t.__iterator(n, !i);
+      }, e;
+    }
+    function Te(t, r, e, n) {
+      var i = st(t);
+      return n && (i.has = function(u) {
+        var o = t.get(u, l);
+        return o !== l && !!r.call(e, o, u, t);
+      }, i.get = function(u, o) {
+        var s = t.get(u, l);
+        return s !== l && r.call(e, s, u, t) ? s : o;
+      }), i.__iterateUncached = function(u, o) {
+        var s = this, a = 0;
+        return t.__iterate(function(f, h, c) {
+          if (r.call(e, f, h, c))
+            return a++, u(f, n ? h : a - 1, s);
+        }, o), a;
+      }, i.__iteratorUncached = function(u, o) {
+        var s = t.__iterator(nt, o), a = 0;
+        return new S(function() {
+          for (; ; ) {
+            var f = s.next();
+            if (f.done)
+              return f;
+            var h = f.value, c = h[0], _ = h[1];
+            if (r.call(e, _, c, t))
+              return w(u, n ? c : a++, _, f);
+          }
+        });
+      }, i;
+    }
+    function yn(t, r, e) {
+      var n = y().asMutable();
+      return t.__iterate(function(i, u) {
+        n.update(
+          r.call(e, i, u, t),
+          0,
+          function(o) {
+            return o + 1;
+          }
+        );
+      }), n.asImmutable();
+    }
+    function Sn(t, r, e) {
+      var n = R(t), i = (et(t) ? T() : y()).asMutable();
+      t.__iterate(function(o, s) {
+        i.update(
+          r.call(e, o, s, t),
+          function(a) {
+            return a = a || [], a.push(n ? [s, o] : o), a;
+          }
+        );
+      });
+      var u = ke(t);
+      return i.map(function(o) {
+        return g(t, u(o));
+      });
+    }
+    function kr(t, r, e, n) {
+      var i = t.size;
+      if (r !== void 0 && (r = r | 0), e !== void 0 && (e = e | 0), Lt(r, e, i))
+        return t;
+      var u = gt(r, i), o = Nt(e, i);
+      if (u !== u || o !== o)
+        return kr(t.toSeq().cacheResult(), r, e, n);
+      var s = o - u, a;
+      s === s && (a = s < 0 ? 0 : s);
+      var f = st(t);
+      return f.size = a === 0 ? a : t.size && a || void 0, !n && hr(t) && a >= 0 && (f.get = function(h, c) {
+        return h = pt(this, h), h >= 0 && h < a ? t.get(h + u, c) : c;
+      }), f.__iterateUncached = function(h, c) {
+        var _ = this;
+        if (a === 0)
+          return 0;
+        if (c)
+          return this.cacheResult().__iterate(h, c);
+        var p = 0, v = !0, M = 0;
+        return t.__iterate(function(rt, ht) {
+          if (!(v && (v = p++ < u)))
+            return M++, h(rt, n ? ht : M - 1, _) !== !1 && M !== a;
+        }), M;
+      }, f.__iteratorUncached = function(h, c) {
+        if (a !== 0 && c)
+          return this.cacheResult().__iterator(h, c);
+        var _ = a !== 0 && t.__iterator(h, c), p = 0, v = 0;
+        return new S(function() {
+          for (; p++ < u; )
+            _.next();
+          if (++v > a)
+            return B();
+          var M = _.next();
+          return n || h === X ? M : h === Ft ? w(h, v - 1, void 0, M) : w(h, v - 1, M.value[1], M);
+        });
+      }, f;
+    }
+    function mn(t, r, e) {
+      var n = st(t);
+      return n.__iterateUncached = function(i, u) {
+        var o = this;
+        if (u)
+          return this.cacheResult().__iterate(i, u);
+        var s = 0;
+        return t.__iterate(
+          function(a, f, h) {
+            return r.call(e, a, f, h) && ++s && i(a, f, o);
+          }
+        ), s;
+      }, n.__iteratorUncached = function(i, u) {
+        var o = this;
+        if (u)
+          return this.cacheResult().__iterator(i, u);
+        var s = t.__iterator(nt, u), a = !0;
+        return new S(function() {
+          if (!a)
+            return B();
+          var f = s.next();
+          if (f.done)
+            return f;
+          var h = f.value, c = h[0], _ = h[1];
+          return r.call(e, _, c, o) ? i === nt ? f : w(i, c, _, f) : (a = !1, B());
+        });
+      }, n;
+    }
+    function Re(t, r, e, n) {
+      var i = st(t);
+      return i.__iterateUncached = function(u, o) {
+        var s = this;
+        if (o)
+          return this.cacheResult().__iterate(u, o);
+        var a = !0, f = 0;
+        return t.__iterate(function(h, c, _) {
+          if (!(a && (a = r.call(e, h, c, _))))
+            return f++, u(h, n ? c : f - 1, s);
+        }), f;
+      }, i.__iteratorUncached = function(u, o) {
+        var s = this;
+        if (o)
+          return this.cacheResult().__iterator(u, o);
+        var a = t.__iterator(nt, o), f = !0, h = 0;
+        return new S(function() {
+          var c, _, p;
+          do {
+            if (c = a.next(), c.done)
+              return n || u === X ? c : u === Ft ? w(u, h++, void 0, c) : w(u, h++, c.value[1], c);
+            var v = c.value;
+            _ = v[0], p = v[1], f && (f = r.call(e, p, _, s));
+          } while (f);
+          return u === nt ? c : w(u, _, p, c);
+        });
+      }, i;
+    }
+    function gn(t, r) {
+      var e = R(t), n = [t].concat(r).map(function(o) {
+        return F(o) ? e && (o = C(o)) : o = e ? re(o) : cr(Array.isArray(o) ? o : [o]), o;
+      }).filter(function(o) {
+        return o.size !== 0;
+      });
+      if (n.length === 0)
+        return t;
+      if (n.length === 1) {
+        var i = n[0];
+        if (i === t || e && R(i) || b(t) && b(i))
+          return i;
+      }
+      var u = new ut(n);
+      return e ? u = u.toKeyedSeq() : b(t) || (u = u.toSetSeq()), u = u.flatten(!0), u.size = n.reduce(
+        function(o, s) {
+          if (o !== void 0) {
+            var a = s.size;
+            if (a !== void 0)
+              return o + a;
+          }
+        },
+        0
+      ), u;
+    }
+    function Le(t, r, e) {
+      var n = st(t);
+      return n.__iterateUncached = function(i, u) {
+        var o = 0, s = !1;
+        function a(f, h) {
+          var c = this;
+          f.__iterate(function(_, p) {
+            return (!r || h < r) && F(_) ? a(_, h + 1) : i(_, e ? p : o++, c) === !1 && (s = !0), !s;
+          }, u);
+        }
+        return a(t, 0), o;
+      }, n.__iteratorUncached = function(i, u) {
+        var o = t.__iterator(i, u), s = [], a = 0;
+        return new S(function() {
+          for (; o; ) {
+            var f = o.next();
+            if (f.done !== !1) {
+              o = s.pop();
+              continue;
+            }
+            var h = f.value;
+            if (i === nt && (h = h[1]), (!r || s.length < r) && F(h))
+              s.push(o), o = h.__iterator(i, u);
+            else
+              return e ? f : w(i, a++, h, f);
+          }
+          return B();
+        });
+      }, n;
+    }
+    function wn(t, r, e) {
+      var n = ke(t);
+      return t.toSeq().map(
+        function(i, u) {
+          return n(r.call(e, i, u, t));
+        }
+      ).flatten(!0);
+    }
+    function En(t, r) {
+      var e = st(t);
+      return e.size = t.size && t.size * 2 - 1, e.__iterateUncached = function(n, i) {
+        var u = this, o = 0;
+        return t.__iterate(
+          function(s, a) {
+            return (!o || n(r, o++, u) !== !1) && n(s, o++, u) !== !1;
+          },
+          i
+        ), o;
+      }, e.__iteratorUncached = function(n, i) {
+        var u = t.__iterator(X, i), o = 0, s;
+        return new S(function() {
+          return (!s || o % 2) && (s = u.next(), s.done) ? s : o % 2 ? w(n, o++, r) : w(n, o++, s.value, s);
+        });
+      }, e;
+    }
+    function At(t, r, e) {
+      r || (r = Ke);
+      var n = R(t), i = 0, u = t.toSeq().map(
+        function(o, s) {
+          return [s, o, i++, e ? e(o, s, t) : o];
+        }
+      ).toArray();
+      return u.sort(function(o, s) {
+        return r(o[3], s[3]) || o[2] - s[2];
+      }).forEach(
+        n ? function(o, s) {
+          u[s].length = 2;
+        } : function(o, s) {
+          u[s] = o[1];
+        }
+      ), n ? Z(u) : b(t) ? O(u) : it(u);
+    }
+    function Zt(t, r, e) {
+      if (r || (r = Ke), e) {
+        var n = t.toSeq().map(function(i, u) {
+          return [i, e(i, u, t)];
+        }).reduce(function(i, u) {
+          return Ne(r, i[1], u[1]) ? u : i;
+        });
+        return n && n[0];
+      } else
+        return t.reduce(function(i, u) {
+          return Ne(r, i, u) ? u : i;
+        });
+    }
+    function Ne(t, r, e) {
+      var n = t(e, r);
+      return n === 0 && e !== r && (e == null || e !== e) || n > 0;
+    }
+    function Kr(t, r, e) {
+      var n = st(t);
+      return n.size = new ut(e).map(function(i) {
+        return i.size;
+      }).min(), n.__iterate = function(i, u) {
+        for (var o = this.__iterator(X, u), s, a = 0; !(s = o.next()).done && i(s.value, a++, this) !== !1; )
+          ;
+        return a;
+      }, n.__iteratorUncached = function(i, u) {
+        var o = e.map(
+          function(f) {
+            return f = q(f), Dt(u ? f.reverse() : f);
+          }
+        ), s = 0, a = !1;
+        return new S(function() {
+          var f;
+          return a || (f = o.map(function(h) {
+            return h.next();
+          }), a = f.some(function(h) {
+            return h.done;
+          })), a ? B() : w(
+            i,
+            s++,
+            r.apply(null, f.map(function(h) {
+              return h.value;
+            }))
+          );
+        });
+      }, n;
+    }
+    function g(t, r) {
+      return hr(t) ? r : t.constructor(r);
+    }
+    function Fe(t) {
+      if (t !== Object(t))
+        throw new TypeError("Expected [K, V] tuple: " + t);
+    }
+    function De(t) {
+      return j(t.size), sr(t);
+    }
+    function ke(t) {
+      return R(t) ? C : b(t) ? tt : V;
+    }
+    function st(t) {
+      return Object.create(
+        (R(t) ? Z : b(t) ? O : it).prototype
+      );
+    }
+    function Ur() {
+      return this._iter.cacheResult ? (this._iter.cacheResult(), this.size = this._iter.size, this) : N.prototype.cacheResult.call(this);
+    }
+    function Ke(t, r) {
+      return t > r ? 1 : t < r ? -1 : 0;
+    }
+    function Ue(t) {
+      var r = Dt(t);
+      if (!r) {
+        if (!Zr(t))
+          throw new TypeError("Expected iterable or array-like: " + t);
+        r = Dt(q(t));
+      }
+      return r;
+    }
+    m(Y, Ut);
+    function Y(t, r) {
+      var e, n = function(o) {
+        if (o instanceof n)
+          return o;
+        if (!(this instanceof n))
+          return new n(o);
+        if (!e) {
+          e = !0;
+          var s = Object.keys(t);
+          In(i, s), i.size = s.length, i._name = r, i._keys = s, i._defaultValues = t;
+        }
+        this._map = y(o);
+      }, i = n.prototype = Object.create(D);
+      return i.constructor = n, n;
+    }
+    Y.prototype.toString = function() {
+      return this.__toString(Ce(this) + " {", "}");
+    }, Y.prototype.has = function(t) {
+      return this._defaultValues.hasOwnProperty(t);
+    }, Y.prototype.get = function(t, r) {
+      if (!this.has(t))
+        return r;
+      var e = this._defaultValues[t];
+      return this._map ? this._map.get(t, e) : e;
+    }, Y.prototype.clear = function() {
+      if (this.__ownerID)
+        return this._map && this._map.clear(), this;
+      var t = this.constructor;
+      return t._empty || (t._empty = Qt(this, ot()));
+    }, Y.prototype.set = function(t, r) {
+      if (!this.has(t))
+        throw new Error('Cannot set unknown key "' + t + '" on ' + Ce(this));
+      var e = this._map && this._map.set(t, r);
+      return this.__ownerID || e === this._map ? this : Qt(this, e);
+    }, Y.prototype.remove = function(t) {
+      if (!this.has(t))
+        return this;
+      var r = this._map && this._map.remove(t);
+      return this.__ownerID || r === this._map ? this : Qt(this, r);
+    }, Y.prototype.wasAltered = function() {
+      return this._map.wasAltered();
+    }, Y.prototype.__iterator = function(t, r) {
+      var e = this;
+      return C(this._defaultValues).map(function(n, i) {
+        return e.get(i);
+      }).__iterator(t, r);
+    }, Y.prototype.__iterate = function(t, r) {
+      var e = this;
+      return C(this._defaultValues).map(function(n, i) {
+        return e.get(i);
+      }).__iterate(t, r);
+    }, Y.prototype.__ensureOwner = function(t) {
+      if (t === this.__ownerID)
+        return this;
+      var r = this._map && this._map.__ensureOwner(t);
+      return t ? Qt(this, r, t) : (this.__ownerID = t, this._map = r, this);
+    };
+    var D = Y.prototype;
+    D[Rt] = D.remove, D.deleteIn = D.removeIn = d.removeIn, D.merge = d.merge, D.mergeWith = d.mergeWith, D.mergeIn = d.mergeIn, D.mergeDeep = d.mergeDeep, D.mergeDeepWith = d.mergeDeepWith, D.mergeDeepIn = d.mergeDeepIn, D.setIn = d.setIn, D.update = d.update, D.updateIn = d.updateIn, D.withMutations = d.withMutations, D.asMutable = d.asMutable, D.asImmutable = d.asImmutable;
+    function Qt(t, r, e) {
+      var n = Object.create(Object.getPrototypeOf(t));
+      return n._map = r, n.__ownerID = e, n;
+    }
+    function Ce(t) {
+      return t._name || t.constructor.name || "Record";
+    }
+    function In(t, r) {
+      try {
+        r.forEach(zn.bind(void 0, t));
+      } catch {
+      }
+    }
+    function zn(t, r) {
+      Object.defineProperty(t, r, {
+        get: function() {
+          return this.get(r);
+        },
+        set: function(e) {
+          Vt(this.__ownerID, "Cannot set on an immutable record."), this.set(r, e);
+        }
+      });
+    }
+    m(z, bt);
+    function z(t) {
+      return t == null ? Wr() : Cr(t) && !et(t) ? t : Wr().withMutations(function(r) {
+        var e = V(t);
+        j(e.size), e.forEach(function(n) {
+          return r.add(n);
+        });
+      });
+    }
+    z.of = function() {
+      return this(arguments);
+    }, z.fromKeys = function(t) {
+      return this(C(t).keySeq());
+    }, z.prototype.toString = function() {
+      return this.__toString("Set {", "}");
+    }, z.prototype.has = function(t) {
+      return this._map.has(t);
+    }, z.prototype.add = function(t) {
+      return Pr(this, this._map.set(t, !0));
+    }, z.prototype.remove = function(t) {
+      return Pr(this, this._map.remove(t));
+    }, z.prototype.clear = function() {
+      return Pr(this, this._map.clear());
+    }, z.prototype.union = function() {
+      var t = H.call(arguments, 0);
+      return t = t.filter(function(r) {
+        return r.size !== 0;
+      }), t.length === 0 ? this : this.size === 0 && !this.__ownerID && t.length === 1 ? this.constructor(t[0]) : this.withMutations(function(r) {
+        for (var e = 0; e < t.length; e++)
+          V(t[e]).forEach(function(n) {
+            return r.add(n);
+          });
+      });
+    }, z.prototype.intersect = function() {
+      var t = H.call(arguments, 0);
+      if (t.length === 0)
+        return this;
+      t = t.map(function(e) {
+        return V(e);
+      });
+      var r = this;
+      return this.withMutations(function(e) {
+        r.forEach(function(n) {
+          t.every(function(i) {
+            return i.includes(n);
+          }) || e.remove(n);
+        });
+      });
+    }, z.prototype.subtract = function() {
+      var t = H.call(arguments, 0);
+      if (t.length === 0)
+        return this;
+      t = t.map(function(e) {
+        return V(e);
+      });
+      var r = this;
+      return this.withMutations(function(e) {
+        r.forEach(function(n) {
+          t.some(function(i) {
+            return i.includes(n);
+          }) && e.remove(n);
+        });
+      });
+    }, z.prototype.merge = function() {
+      return this.union.apply(this, arguments);
+    }, z.prototype.mergeWith = function(t) {
+      var r = H.call(arguments, 1);
+      return this.union.apply(this, r);
+    }, z.prototype.sort = function(t) {
+      return at(At(this, t));
+    }, z.prototype.sortBy = function(t, r) {
+      return at(At(this, r, t));
+    }, z.prototype.wasAltered = function() {
+      return this._map.wasAltered();
+    }, z.prototype.__iterate = function(t, r) {
+      var e = this;
+      return this._map.__iterate(function(n, i) {
+        return t(i, i, e);
+      }, r);
+    }, z.prototype.__iterator = function(t, r) {
+      return this._map.map(function(e, n) {
+        return n;
+      }).__iterator(t, r);
+    }, z.prototype.__ensureOwner = function(t) {
+      if (t === this.__ownerID)
+        return this;
+      var r = this._map.__ensureOwner(t);
+      return t ? this.__make(r, t) : (this.__ownerID = t, this._map = r, this);
+    };
+    function Cr(t) {
+      return !!(t && t[Pe]);
+    }
+    z.isSet = Cr;
+    var Pe = "@@__IMMUTABLE_SET__@@", J = z.prototype;
+    J[Pe] = !0, J[Rt] = J.remove, J.mergeDeep = J.merge, J.mergeDeepWith = J.mergeWith, J.withMutations = d.withMutations, J.asMutable = d.asMutable, J.asImmutable = d.asImmutable, J.__empty = Wr, J.__make = We;
+    function Pr(t, r) {
+      return t.__ownerID ? (t.size = r.size, t._map = r, t) : r === t._map ? t : r.size === 0 ? t.__empty() : t.__make(r);
+    }
+    function We(t, r) {
+      var e = Object.create(J);
+      return e.size = t ? t.size : 0, e._map = t, e.__ownerID = r, e;
+    }
+    var Be;
+    function Wr() {
+      return Be || (Be = We(ot()));
+    }
+    m(at, z);
+    function at(t) {
+      return t == null ? Br() : $e(t) ? t : Br().withMutations(function(r) {
+        var e = V(t);
+        j(e.size), e.forEach(function(n) {
+          return r.add(n);
+        });
+      });
+    }
+    at.of = function() {
+      return this(arguments);
+    }, at.fromKeys = function(t) {
+      return this(C(t).keySeq());
+    }, at.prototype.toString = function() {
+      return this.__toString("OrderedSet {", "}");
+    };
+    function $e(t) {
+      return Cr(t) && et(t);
+    }
+    at.isOrderedSet = $e;
+    var tr = at.prototype;
+    tr[mt] = !0, tr.__empty = Br, tr.__make = je;
+    function je(t, r) {
+      var e = Object.create(tr);
+      return e.size = t ? t.size : 0, e._map = t, e.__ownerID = r, e;
+    }
+    var Ye;
+    function Br() {
+      return Ye || (Ye = je(Xt()));
+    }
+    m(L, wt);
+    function L(t) {
+      return t == null ? $r() : Je(t) ? t : $r().unshiftAll(t);
+    }
+    L.of = function() {
+      return this(arguments);
+    }, L.prototype.toString = function() {
+      return this.__toString("Stack [", "]");
+    }, L.prototype.get = function(t, r) {
+      var e = this._head;
+      for (t = pt(this, t); e && t--; )
+        e = e.next;
+      return e ? e.value : r;
+    }, L.prototype.peek = function() {
+      return this._head && this._head.value;
+    }, L.prototype.push = function() {
+      if (arguments.length === 0)
+        return this;
+      for (var t = this.size + arguments.length, r = this._head, e = arguments.length - 1; e >= 0; e--)
+        r = {
+          value: arguments[e],
+          next: r
+        };
+      return this.__ownerID ? (this.size = t, this._head = r, this.__hash = void 0, this.__altered = !0, this) : Yt(t, r);
+    }, L.prototype.pushAll = function(t) {
+      if (t = tt(t), t.size === 0)
+        return this;
+      j(t.size);
+      var r = this.size, e = this._head;
+      return t.reverse().forEach(function(n) {
+        r++, e = {
+          value: n,
+          next: e
+        };
+      }), this.__ownerID ? (this.size = r, this._head = e, this.__hash = void 0, this.__altered = !0, this) : Yt(r, e);
+    }, L.prototype.pop = function() {
+      return this.slice(1);
+    }, L.prototype.unshift = function() {
+      return this.push.apply(this, arguments);
+    }, L.prototype.unshiftAll = function(t) {
+      return this.pushAll(t);
+    }, L.prototype.shift = function() {
+      return this.pop.apply(this, arguments);
+    }, L.prototype.clear = function() {
+      return this.size === 0 ? this : this.__ownerID ? (this.size = 0, this._head = void 0, this.__hash = void 0, this.__altered = !0, this) : $r();
+    }, L.prototype.slice = function(t, r) {
+      if (Lt(t, r, this.size))
+        return this;
+      var e = gt(t, this.size), n = Nt(r, this.size);
+      if (n !== this.size)
+        return wt.prototype.slice.call(this, t, r);
+      for (var i = this.size - e, u = this._head; e--; )
+        u = u.next;
+      return this.__ownerID ? (this.size = i, this._head = u, this.__hash = void 0, this.__altered = !0, this) : Yt(i, u);
+    }, L.prototype.__ensureOwner = function(t) {
+      return t === this.__ownerID ? this : t ? Yt(this.size, this._head, t, this.__hash) : (this.__ownerID = t, this.__altered = !1, this);
+    }, L.prototype.__iterate = function(t, r) {
+      if (r)
+        return this.reverse().__iterate(t);
+      for (var e = 0, n = this._head; n && t(n.value, e++, this) !== !1; )
+        n = n.next;
+      return e;
+    }, L.prototype.__iterator = function(t, r) {
+      if (r)
+        return this.reverse().__iterator(t);
+      var e = 0, n = this._head;
+      return new S(function() {
+        if (n) {
+          var i = n.value;
+          return n = n.next, w(t, e++, i);
+        }
+        return B();
+      });
+    };
+    function Je(t) {
+      return !!(t && t[He]);
+    }
+    L.isStack = Je;
+    var He = "@@__IMMUTABLE_STACK__@@", Tt = L.prototype;
+    Tt[He] = !0, Tt.withMutations = d.withMutations, Tt.asMutable = d.asMutable, Tt.asImmutable = d.asImmutable, Tt.wasAltered = d.wasAltered;
+    function Yt(t, r, e, n) {
+      var i = Object.create(Tt);
+      return i.size = t, i._head = r, i.__ownerID = e, i.__hash = n, i.__altered = !1, i;
+    }
+    var Ve;
+    function $r() {
+      return Ve || (Ve = Yt(0));
+    }
+    function ft(t, r) {
+      var e = function(n) {
+        t.prototype[n] = r[n];
+      };
+      return Object.keys(r).forEach(e), Object.getOwnPropertySymbols && Object.getOwnPropertySymbols(r).forEach(e), t;
+    }
+    q.Iterator = S, ft(q, {
+      // ### Conversion to other types
+      toArray: function() {
+        j(this.size);
+        var t = new Array(this.size || 0);
+        return this.valueSeq().__iterate(function(r, e) {
+          t[e] = r;
+        }), t;
+      },
+      toIndexedSeq: function() {
+        return new Mt(this);
+      },
+      toJS: function() {
+        return this.toSeq().map(
+          function(t) {
+            return t && typeof t.toJS == "function" ? t.toJS() : t;
+          }
+        ).__toJS();
+      },
+      toJSON: function() {
+        return this.toSeq().map(
+          function(t) {
+            return t && typeof t.toJSON == "function" ? t.toJSON() : t;
+          }
+        ).__toJS();
+      },
+      toKeyedSeq: function() {
+        return new Q(this, !0);
+      },
+      toMap: function() {
+        return y(this.toKeyedSeq());
+      },
+      toObject: function() {
+        j(this.size);
+        var t = {};
+        return this.__iterate(function(r, e) {
+          t[e] = r;
+        }), t;
+      },
+      toOrderedMap: function() {
+        return T(this.toKeyedSeq());
+      },
+      toOrderedSet: function() {
+        return at(R(this) ? this.valueSeq() : this);
+      },
+      toSet: function() {
+        return z(R(this) ? this.valueSeq() : this);
+      },
+      toSetSeq: function() {
+        return new qt(this);
+      },
+      toSeq: function() {
+        return b(this) ? this.toIndexedSeq() : R(this) ? this.toKeyedSeq() : this.toSetSeq();
+      },
+      toStack: function() {
+        return L(R(this) ? this.valueSeq() : this);
+      },
+      toList: function() {
+        return I(R(this) ? this.valueSeq() : this);
+      },
+      // ### Common JavaScript methods and properties
+      toString: function() {
+        return "[Iterable]";
+      },
+      __toString: function(t, r) {
+        return this.size === 0 ? t + r : t + " " + this.toSeq().map(this.__toStringMapper).join(", ") + " " + r;
+      },
+      // ### ES6 Collection methods (ES6 Array and Map)
+      concat: function() {
+        var t = H.call(arguments, 0);
+        return g(this, gn(this, t));
+      },
+      includes: function(t) {
+        return this.some(function(r) {
+          return A(r, t);
+        });
+      },
+      entries: function() {
+        return this.__iterator(nt);
+      },
+      every: function(t, r) {
+        j(this.size);
+        var e = !0;
+        return this.__iterate(function(n, i, u) {
+          if (!t.call(r, n, i, u))
+            return e = !1, !1;
+        }), e;
+      },
+      filter: function(t, r) {
+        return g(this, Te(this, t, r, !0));
+      },
+      find: function(t, r, e) {
+        var n = this.findEntry(t, r);
+        return n ? n[1] : e;
+      },
+      findEntry: function(t, r) {
+        var e;
+        return this.__iterate(function(n, i, u) {
+          if (t.call(r, n, i, u))
+            return e = [i, n], !1;
+        }), e;
+      },
+      findLastEntry: function(t, r) {
+        return this.toSeq().reverse().findEntry(t, r);
+      },
+      forEach: function(t, r) {
+        return j(this.size), this.__iterate(r ? t.bind(r) : t);
+      },
+      join: function(t) {
+        j(this.size), t = t !== void 0 ? "" + t : ",";
+        var r = "", e = !0;
+        return this.__iterate(function(n) {
+          e ? e = !1 : r += t, r += n != null ? n.toString() : "";
+        }), r;
+      },
+      keys: function() {
+        return this.__iterator(Ft);
+      },
+      map: function(t, r) {
+        return g(this, Ae(this, t, r));
+      },
+      reduce: function(t, r, e) {
+        j(this.size);
+        var n, i;
+        return arguments.length < 2 ? i = !0 : n = r, this.__iterate(function(u, o, s) {
+          i ? (i = !1, n = u) : n = t.call(e, n, u, o, s);
+        }), n;
+      },
+      reduceRight: function(t, r, e) {
+        var n = this.toKeyedSeq().reverse();
+        return n.reduce.apply(n, arguments);
+      },
+      reverse: function() {
+        return g(this, Dr(this, !0));
+      },
+      slice: function(t, r) {
+        return g(this, kr(this, t, r, !0));
+      },
+      some: function(t, r) {
+        return !this.every(er(t), r);
+      },
+      sort: function(t) {
+        return g(this, At(this, t));
+      },
+      values: function() {
+        return this.__iterator(X);
+      },
+      // ### More sequential methods
+      butLast: function() {
+        return this.slice(0, -1);
+      },
+      isEmpty: function() {
+        return this.size !== void 0 ? this.size === 0 : !this.some(function() {
+          return !0;
+        });
+      },
+      count: function(t, r) {
+        return sr(
+          t ? this.toSeq().filter(t, r) : this
+        );
+      },
+      countBy: function(t, r) {
+        return yn(this, t, r);
+      },
+      equals: function(t) {
+        return dr(this, t);
+      },
+      entrySeq: function() {
+        var t = this;
+        if (t._cache)
+          return new ut(t._cache);
+        var r = t.toSeq().map(qn).toIndexedSeq();
+        return r.fromEntrySeq = function() {
+          return t.toSeq();
+        }, r;
+      },
+      filterNot: function(t, r) {
+        return this.filter(er(t), r);
+      },
+      findLast: function(t, r, e) {
+        return this.toKeyedSeq().reverse().find(t, r, e);
+      },
+      first: function() {
+        return this.find(Vr);
+      },
+      flatMap: function(t, r) {
+        return g(this, wn(this, t, r));
+      },
+      flatten: function(t) {
+        return g(this, Le(this, t, !0));
+      },
+      fromEntrySeq: function() {
+        return new Ot(this);
+      },
+      get: function(t, r) {
+        return this.find(function(e, n) {
+          return A(n, t);
+        }, void 0, r);
+      },
+      getIn: function(t, r) {
+        for (var e = this, n = Ue(t), i; !(i = n.next()).done; ) {
+          var u = i.value;
+          if (e = e && e.get ? e.get(u, l) : l, e === l)
+            return r;
+        }
+        return e;
+      },
+      groupBy: function(t, r) {
+        return Sn(this, t, r);
+      },
+      has: function(t) {
+        return this.get(t, l) !== l;
+      },
+      hasIn: function(t) {
+        return this.getIn(t, l) !== l;
+      },
+      isSubset: function(t) {
+        return t = typeof t.includes == "function" ? t : q(t), this.every(function(r) {
+          return t.includes(r);
+        });
+      },
+      isSuperset: function(t) {
+        return t = typeof t.isSubset == "function" ? t : q(t), t.isSubset(this);
+      },
+      keySeq: function() {
+        return this.toSeq().map(Mn).toIndexedSeq();
+      },
+      last: function() {
+        return this.toSeq().reverse().first();
+      },
+      max: function(t) {
+        return Zt(this, t);
+      },
+      maxBy: function(t, r) {
+        return Zt(this, r, t);
+      },
+      min: function(t) {
+        return Zt(this, t ? be(t) : Ge);
+      },
+      minBy: function(t, r) {
+        return Zt(this, r ? be(r) : Ge, t);
+      },
+      rest: function() {
+        return this.slice(1);
+      },
+      skip: function(t) {
+        return this.slice(Math.max(0, t));
+      },
+      skipLast: function(t) {
+        return g(this, this.toSeq().reverse().skip(t).reverse());
+      },
+      skipWhile: function(t, r) {
+        return g(this, Re(this, t, r, !0));
+      },
+      skipUntil: function(t, r) {
+        return this.skipWhile(er(t), r);
+      },
+      sortBy: function(t, r) {
+        return g(this, At(this, r, t));
+      },
+      take: function(t) {
+        return this.slice(0, Math.max(0, t));
+      },
+      takeLast: function(t) {
+        return g(this, this.toSeq().reverse().take(t).reverse());
+      },
+      takeWhile: function(t, r) {
+        return g(this, mn(this, t, r));
+      },
+      takeUntil: function(t, r) {
+        return this.takeWhile(er(t), r);
+      },
+      valueSeq: function() {
+        return this.toIndexedSeq();
+      },
+      // ### Hashable Object
+      hashCode: function() {
+        return this.__hash || (this.__hash = An(this));
+      }
+      // ### Internal
+      // abstract __iterate(fn, reverse)
+      // abstract __iterator(type, reverse)
+    });
+    var U = q.prototype;
+    U[jr] = !0, U[fr] = U.values, U.__toJS = U.toArray, U.__toStringMapper = xe, U.inspect = U.toSource = function() {
+      return this.toString();
+    }, U.chain = U.flatMap, U.contains = U.includes, function() {
+      try {
+        Object.defineProperty(U, "length", {
+          get: function() {
+            if (!q.noLengthWarning) {
+              var t;
+              try {
+                throw new Error();
+              } catch (r) {
+                t = r.stack;
+              }
+              if (t.indexOf("_wrapObject") === -1)
+                return console && console.warn && console.warn(
+                  "iterable.length has been deprecated, use iterable.size or iterable.count(). This warning will become a silent error in a future version. " + t
+                ), this.size;
+            }
+          }
+        });
+      } catch {
+      }
+    }(), ft(C, {
+      // ### More sequential methods
+      flip: function() {
+        return g(this, Oe(this));
+      },
+      findKey: function(t, r) {
+        var e = this.findEntry(t, r);
+        return e && e[0];
+      },
+      findLastKey: function(t, r) {
+        return this.toSeq().reverse().findKey(t, r);
+      },
+      keyOf: function(t) {
+        return this.findKey(function(r) {
+          return A(r, t);
+        });
+      },
+      lastKeyOf: function(t) {
+        return this.findLastKey(function(r) {
+          return A(r, t);
+        });
+      },
+      mapEntries: function(t, r) {
+        var e = this, n = 0;
+        return g(
+          this,
+          this.toSeq().map(
+            function(i, u) {
+              return t.call(r, [u, i], n++, e);
+            }
+          ).fromEntrySeq()
+        );
+      },
+      mapKeys: function(t, r) {
+        var e = this;
+        return g(
+          this,
+          this.toSeq().flip().map(
+            function(n, i) {
+              return t.call(r, n, i, e);
+            }
+          ).flip()
+        );
+      }
+    });
+    var rr = C.prototype;
+    rr[Yr] = !0, rr[fr] = U.entries, rr.__toJS = U.toObject, rr.__toStringMapper = function(t, r) {
+      return JSON.stringify(r) + ": " + xe(t);
+    }, ft(tt, {
+      // ### Conversion to other types
+      toKeyedSeq: function() {
+        return new Q(this, !1);
+      },
+      // ### ES6 Collection methods (ES6 Array and Map)
+      filter: function(t, r) {
+        return g(this, Te(this, t, r, !1));
+      },
+      findIndex: function(t, r) {
+        var e = this.findEntry(t, r);
+        return e ? e[0] : -1;
+      },
+      indexOf: function(t) {
+        var r = this.toKeyedSeq().keyOf(t);
+        return r === void 0 ? -1 : r;
+      },
+      lastIndexOf: function(t) {
+        var r = this.toKeyedSeq().reverse().keyOf(t);
+        return r === void 0 ? -1 : r;
+      },
+      reverse: function() {
+        return g(this, Dr(this, !1));
+      },
+      slice: function(t, r) {
+        return g(this, kr(this, t, r, !1));
+      },
+      splice: function(t, r) {
+        var e = arguments.length;
+        if (r = Math.max(r | 0, 0), e === 0 || e === 2 && !r)
+          return this;
+        t = gt(t, t < 0 ? this.count() : this.size);
+        var n = this.slice(0, t);
+        return g(
+          this,
+          e === 1 ? n : n.concat(_t(arguments, 2), this.slice(t + r))
+        );
+      },
+      // ### More collection methods
+      findLastIndex: function(t, r) {
+        var e = this.toKeyedSeq().findLastKey(t, r);
+        return e === void 0 ? -1 : e;
+      },
+      first: function() {
+        return this.get(0);
+      },
+      flatten: function(t) {
+        return g(this, Le(this, t, !1));
+      },
+      get: function(t, r) {
+        return t = pt(this, t), t < 0 || this.size === 1 / 0 || this.size !== void 0 && t > this.size ? r : this.find(function(e, n) {
+          return n === t;
+        }, void 0, r);
+      },
+      has: function(t) {
+        return t = pt(this, t), t >= 0 && (this.size !== void 0 ? this.size === 1 / 0 || t < this.size : this.indexOf(t) !== -1);
+      },
+      interpose: function(t) {
+        return g(this, En(this, t));
+      },
+      interleave: function() {
+        var t = [this].concat(_t(arguments)), r = Kr(this.toSeq(), O.of, t), e = r.flatten(!0);
+        return r.size && (e.size = r.size * t.length), g(this, e);
+      },
+      last: function() {
+        return this.get(-1);
+      },
+      skipWhile: function(t, r) {
+        return g(this, Re(this, t, r, !1));
+      },
+      zip: function() {
+        var t = [this].concat(_t(arguments));
+        return g(this, Kr(this, On, t));
+      },
+      zipWith: function(t) {
+        var r = _t(arguments);
+        return r[0] = this, g(this, Kr(this, t, r));
+      }
+    }), tt.prototype[Jr] = !0, tt.prototype[mt] = !0, ft(V, {
+      // ### ES6 Collection methods (ES6 Array and Map)
+      get: function(t, r) {
+        return this.has(t) ? t : r;
+      },
+      includes: function(t) {
+        return this.has(t);
+      },
+      // ### More sequential methods
+      keySeq: function() {
+        return this.valueSeq();
+      }
+    }), V.prototype.has = U.includes, ft(Z, C.prototype), ft(O, tt.prototype), ft(it, V.prototype), ft(Ut, C.prototype), ft(wt, tt.prototype), ft(bt, V.prototype);
+    function Mn(t, r) {
+      return r;
+    }
+    function qn(t, r) {
+      return [r, t];
+    }
+    function er(t) {
+      return function() {
+        return !t.apply(this, arguments);
+      };
+    }
+    function be(t) {
+      return function() {
+        return -t.apply(this, arguments);
+      };
+    }
+    function xe(t) {
+      return typeof t == "string" ? JSON.stringify(t) : t;
+    }
+    function On() {
+      return _t(arguments);
+    }
+    function Ge(t, r) {
+      return t < r ? 1 : t > r ? -1 : 0;
+    }
+    function An(t) {
+      if (t.size === 1 / 0)
+        return 0;
+      var r = et(t), e = R(t), n = r ? 1 : 0, i = t.__iterate(
+        e ? r ? function(u, o) {
+          n = 31 * n + Xe($(u), $(o)) | 0;
+        } : function(u, o) {
+          n = n + Xe($(u), $(o)) | 0;
+        } : r ? function(u) {
+          n = 31 * n + $(u) | 0;
+        } : function(u) {
+          n = n + $(u) | 0;
+        }
+      );
+      return Tn(i, n);
+    }
+    function Tn(t, r) {
+      return r = Ct(r, 3432918353), r = Ct(r << 15 | r >>> -15, 461845907), r = Ct(r << 13 | r >>> -13, 5), r = (r + 3864292196 | 0) ^ t, r = Ct(r ^ r >>> 16, 2246822507), r = Ct(r ^ r >>> 13, 3266489909), r = Sr(r ^ r >>> 16), r;
+    }
+    function Xe(t, r) {
+      return t ^ r + 2654435769 + (t << 6) + (t >> 2) | 0;
+    }
+    var Rn = {
+      Iterable: q,
+      Seq: N,
+      Collection: dt,
+      Map: y,
+      OrderedMap: T,
+      List: I,
+      Stack: L,
+      Set: z,
+      OrderedSet: at,
+      Record: Y,
+      Range: K,
+      Repeat: k,
+      is: A,
+      fromJS: _r
+    };
+    return Rn;
+  });
+})(Ze);
+var kn = Ze.exports;
+export {
+  kn as i
+};