@dmsi/wedgekit-react 2.0.0 → 2.0.2

package/dist/node_modules/jsbi/dist/jsbi.js

@@ -0,0 +1,1040 @@
+class i extends Array {
+  constructor(t, e) {
+    if (super(t), this.sign = e, Object.setPrototypeOf(this, i.prototype), t > i.__kMaxLength) throw new RangeError("Maximum BigInt size exceeded");
+  }
+  static BigInt(t) {
+    var e = Math.floor, r = Number.isFinite;
+    if (typeof t == "number") {
+      if (t === 0) return i.__zero();
+      if (i.__isOneDigitInt(t)) return 0 > t ? i.__oneDigit(-t, !0) : i.__oneDigit(t, !1);
+      if (!r(t) || e(t) !== t) throw new RangeError("The number " + t + " cannot be converted to BigInt because it is not an integer");
+      return i.__fromDouble(t);
+    }
+    if (typeof t == "string") {
+      const o = i.__fromString(t);
+      if (o === null) throw new SyntaxError("Cannot convert " + t + " to a BigInt");
+      return o;
+    }
+    if (typeof t == "boolean") return t === !0 ? i.__oneDigit(1, !1) : i.__zero();
+    if (typeof t == "object") {
+      if (t.constructor === i) return t;
+      const o = i.__toPrimitive(t);
+      return i.BigInt(o);
+    }
+    throw new TypeError("Cannot convert " + t + " to a BigInt");
+  }
+  toDebugString() {
+    const t = ["BigInt["];
+    for (const e of this) t.push((e && (e >>> 0).toString(16)) + ", ");
+    return t.push("]"), t.join("");
+  }
+  toString(t = 10) {
+    if (2 > t || 36 < t) throw new RangeError("toString() radix argument must be between 2 and 36");
+    return this.length === 0 ? "0" : (t & t - 1) == 0 ? i.__toStringBasePowerOfTwo(this, t) : i.__toStringGeneric(this, t, !1);
+  }
+  valueOf() {
+    throw new Error("Convert JSBI instances to native numbers using `toNumber`.");
+  }
+  static toNumber(t) {
+    const e = t.length;
+    if (e === 0) return 0;
+    if (e === 1) {
+      const b = t.__unsignedDigit(0);
+      return t.sign ? -b : b;
+    }
+    const r = t.__digit(e - 1), o = i.__clz30(r), n = 30 * e - o;
+    if (1024 < n) return t.sign ? -1 / 0 : 1 / 0;
+    let s = n - 1, l = r, g = e - 1;
+    const a = o + 3;
+    let _ = a === 32 ? 0 : l << a;
+    _ >>>= 12;
+    const u = a - 12;
+    let f = 12 <= a ? 0 : l << 20 + a, h = 20 + a;
+    for (0 < u && 0 < g && (g--, l = t.__digit(g), _ |= l >>> 30 - u, f = l << u + 2, h = u + 2); 0 < h && 0 < g; ) g--, l = t.__digit(g), f |= 30 <= h ? l << h - 30 : l >>> 30 - h, h -= 30;
+    const d = i.__decideRounding(t, h, g, l);
+    if ((d === 1 || d === 0 && (1 & f) == 1) && (f = f + 1 >>> 0, f === 0 && (_++, _ >>> 20 != 0 && (_ = 0, s++, 1023 < s)))) return t.sign ? -1 / 0 : 1 / 0;
+    const c = t.sign ? -2147483648 : 0;
+    return s = s + 1023 << 20, i.__kBitConversionInts[i.__kBitConversionIntHigh] = c | s | _, i.__kBitConversionInts[i.__kBitConversionIntLow] = f, i.__kBitConversionDouble[0];
+  }
+  static unaryMinus(t) {
+    if (t.length === 0) return t;
+    const e = t.__copy();
+    return e.sign = !t.sign, e;
+  }
+  static bitwiseNot(t) {
+    return t.sign ? i.__absoluteSubOne(t).__trim() : i.__absoluteAddOne(t, !0);
+  }
+  static exponentiate(t, e) {
+    if (e.sign) throw new RangeError("Exponent must be positive");
+    if (e.length === 0) return i.__oneDigit(1, !1);
+    if (t.length === 0) return t;
+    if (t.length === 1 && t.__digit(0) === 1) return t.sign && (1 & e.__digit(0)) == 0 ? i.unaryMinus(t) : t;
+    if (1 < e.length) throw new RangeError("BigInt too big");
+    let r = e.__unsignedDigit(0);
+    if (r === 1) return t;
+    if (r >= i.__kMaxLengthBits) throw new RangeError("BigInt too big");
+    if (t.length === 1 && t.__digit(0) === 2) {
+      const s = 1 + (0 | r / 30), l = t.sign && (1 & r) != 0, g = new i(s, l);
+      g.__initializeDigits();
+      const a = 1 << r % 30;
+      return g.__setDigit(s - 1, a), g;
+    }
+    let o = null, n = t;
+    for ((1 & r) != 0 && (o = t), r >>= 1; r !== 0; r >>= 1) n = i.multiply(n, n), (1 & r) != 0 && (o === null ? o = n : o = i.multiply(o, n));
+    return o;
+  }
+  static multiply(t, e) {
+    if (t.length === 0) return t;
+    if (e.length === 0) return e;
+    let r = t.length + e.length;
+    30 <= t.__clzmsd() + e.__clzmsd() && r--;
+    const o = new i(r, t.sign !== e.sign);
+    o.__initializeDigits();
+    for (let n = 0; n < t.length; n++) i.__multiplyAccumulate(e, t.__digit(n), o, n);
+    return o.__trim();
+  }
+  static divide(t, e) {
+    if (e.length === 0) throw new RangeError("Division by zero");
+    if (0 > i.__absoluteCompare(t, e)) return i.__zero();
+    const r = t.sign !== e.sign, o = e.__unsignedDigit(0);
+    let n;
+    if (e.length === 1 && 32767 >= o) {
+      if (o === 1) return r === t.sign ? t : i.unaryMinus(t);
+      n = i.__absoluteDivSmall(t, o, null);
+    } else n = i.__absoluteDivLarge(t, e, !0, !1);
+    return n.sign = r, n.__trim();
+  }
+  static remainder(t, e) {
+    if (e.length === 0) throw new RangeError("Division by zero");
+    if (0 > i.__absoluteCompare(t, e)) return t;
+    const r = e.__unsignedDigit(0);
+    if (e.length === 1 && 32767 >= r) {
+      if (r === 1) return i.__zero();
+      const n = i.__absoluteModSmall(t, r);
+      return n === 0 ? i.__zero() : i.__oneDigit(n, t.sign);
+    }
+    const o = i.__absoluteDivLarge(t, e, !1, !0);
+    return o.sign = t.sign, o.__trim();
+  }
+  static add(t, e) {
+    const r = t.sign;
+    return r === e.sign ? i.__absoluteAdd(t, e, r) : 0 <= i.__absoluteCompare(t, e) ? i.__absoluteSub(t, e, r) : i.__absoluteSub(e, t, !r);
+  }
+  static subtract(t, e) {
+    const r = t.sign;
+    return r === e.sign ? 0 <= i.__absoluteCompare(t, e) ? i.__absoluteSub(t, e, r) : i.__absoluteSub(e, t, !r) : i.__absoluteAdd(t, e, r);
+  }
+  static leftShift(t, e) {
+    return e.length === 0 || t.length === 0 ? t : e.sign ? i.__rightShiftByAbsolute(t, e) : i.__leftShiftByAbsolute(t, e);
+  }
+  static signedRightShift(t, e) {
+    return e.length === 0 || t.length === 0 ? t : e.sign ? i.__leftShiftByAbsolute(t, e) : i.__rightShiftByAbsolute(t, e);
+  }
+  static unsignedRightShift() {
+    throw new TypeError("BigInts have no unsigned right shift; use >> instead");
+  }
+  static lessThan(t, e) {
+    return 0 > i.__compareToBigInt(t, e);
+  }
+  static lessThanOrEqual(t, e) {
+    return 0 >= i.__compareToBigInt(t, e);
+  }
+  static greaterThan(t, e) {
+    return 0 < i.__compareToBigInt(t, e);
+  }
+  static greaterThanOrEqual(t, e) {
+    return 0 <= i.__compareToBigInt(t, e);
+  }
+  static equal(t, e) {
+    if (t.sign !== e.sign || t.length !== e.length) return !1;
+    for (let r = 0; r < t.length; r++) if (t.__digit(r) !== e.__digit(r)) return !1;
+    return !0;
+  }
+  static notEqual(t, e) {
+    return !i.equal(t, e);
+  }
+  static bitwiseAnd(t, e) {
+    var r = Math.max;
+    if (!t.sign && !e.sign) return i.__absoluteAnd(t, e).__trim();
+    if (t.sign && e.sign) {
+      const o = r(t.length, e.length) + 1;
+      let n = i.__absoluteSubOne(t, o);
+      const s = i.__absoluteSubOne(e);
+      return n = i.__absoluteOr(n, s, n), i.__absoluteAddOne(n, !0, n).__trim();
+    }
+    return t.sign && ([t, e] = [e, t]), i.__absoluteAndNot(t, i.__absoluteSubOne(e)).__trim();
+  }
+  static bitwiseXor(t, e) {
+    var r = Math.max;
+    if (!t.sign && !e.sign) return i.__absoluteXor(t, e).__trim();
+    if (t.sign && e.sign) {
+      const s = r(t.length, e.length), l = i.__absoluteSubOne(t, s), g = i.__absoluteSubOne(e);
+      return i.__absoluteXor(l, g, l).__trim();
+    }
+    const o = r(t.length, e.length) + 1;
+    t.sign && ([t, e] = [e, t]);
+    let n = i.__absoluteSubOne(e, o);
+    return n = i.__absoluteXor(n, t, n), i.__absoluteAddOne(n, !0, n).__trim();
+  }
+  static bitwiseOr(t, e) {
+    var r = Math.max;
+    const o = r(t.length, e.length);
+    if (!t.sign && !e.sign) return i.__absoluteOr(t, e).__trim();
+    if (t.sign && e.sign) {
+      let s = i.__absoluteSubOne(t, o);
+      const l = i.__absoluteSubOne(e);
+      return s = i.__absoluteAnd(s, l, s), i.__absoluteAddOne(s, !0, s).__trim();
+    }
+    t.sign && ([t, e] = [e, t]);
+    let n = i.__absoluteSubOne(e, o);
+    return n = i.__absoluteAndNot(n, t, n), i.__absoluteAddOne(n, !0, n).__trim();
+  }
+  static asIntN(t, e) {
+    var r = Math.floor;
+    if (e.length === 0) return e;
+    if (t = r(t), 0 > t) throw new RangeError("Invalid value: not (convertible to) a safe integer");
+    if (t === 0) return i.__zero();
+    if (t >= i.__kMaxLengthBits) return e;
+    const o = 0 | (t + 29) / 30;
+    if (e.length < o) return e;
+    const n = e.__unsignedDigit(o - 1), s = 1 << (t - 1) % 30;
+    if (e.length === o && n < s) return e;
+    if ((n & s) !== s) return i.__truncateToNBits(t, e);
+    if (!e.sign) return i.__truncateAndSubFromPowerOfTwo(t, e, !0);
+    if ((n & s - 1) == 0) {
+      for (let l = o - 2; 0 <= l; l--) if (e.__digit(l) !== 0) return i.__truncateAndSubFromPowerOfTwo(t, e, !1);
+      return e.length === o && n === s ? e : i.__truncateToNBits(t, e);
+    }
+    return i.__truncateAndSubFromPowerOfTwo(t, e, !1);
+  }
+  static asUintN(t, e) {
+    var r = Math.floor;
+    if (e.length === 0) return e;
+    if (t = r(t), 0 > t) throw new RangeError("Invalid value: not (convertible to) a safe integer");
+    if (t === 0) return i.__zero();
+    if (e.sign) {
+      if (t > i.__kMaxLengthBits) throw new RangeError("BigInt too big");
+      return i.__truncateAndSubFromPowerOfTwo(t, e, !1);
+    }
+    if (t >= i.__kMaxLengthBits) return e;
+    const o = 0 | (t + 29) / 30;
+    if (e.length < o) return e;
+    const n = t % 30;
+    return e.length == o && (n === 0 || !(e.__digit(o - 1) >>> n)) ? e : i.__truncateToNBits(t, e);
+  }
+  static ADD(t, e) {
+    if (t = i.__toPrimitive(t), e = i.__toPrimitive(e), typeof t == "string") return typeof e != "string" && (e = e.toString()), t + e;
+    if (typeof e == "string") return t.toString() + e;
+    if (t = i.__toNumeric(t), e = i.__toNumeric(e), i.__isBigInt(t) && i.__isBigInt(e)) return i.add(t, e);
+    if (typeof t == "number" && typeof e == "number") return t + e;
+    throw new TypeError("Cannot mix BigInt and other types, use explicit conversions");
+  }
+  static LT(t, e) {
+    return i.__compare(t, e, 0);
+  }
+  static LE(t, e) {
+    return i.__compare(t, e, 1);
+  }
+  static GT(t, e) {
+    return i.__compare(t, e, 2);
+  }
+  static GE(t, e) {
+    return i.__compare(t, e, 3);
+  }
+  static EQ(t, e) {
+    for (; ; ) {
+      if (i.__isBigInt(t)) return i.__isBigInt(e) ? i.equal(t, e) : i.EQ(e, t);
+      if (typeof t == "number") {
+        if (i.__isBigInt(e)) return i.__equalToNumber(e, t);
+        if (typeof e != "object") return t == e;
+        e = i.__toPrimitive(e);
+      } else if (typeof t == "string") {
+        if (i.__isBigInt(e)) return t = i.__fromString(t), t !== null && i.equal(t, e);
+        if (typeof e != "object") return t == e;
+        e = i.__toPrimitive(e);
+      } else if (typeof t == "boolean") {
+        if (i.__isBigInt(e)) return i.__equalToNumber(e, +t);
+        if (typeof e != "object") return t == e;
+        e = i.__toPrimitive(e);
+      } else if (typeof t == "symbol") {
+        if (i.__isBigInt(e)) return !1;
+        if (typeof e != "object") return t == e;
+        e = i.__toPrimitive(e);
+      } else if (typeof t == "object") {
+        if (typeof e == "object" && e.constructor !== i) return t == e;
+        t = i.__toPrimitive(t);
+      } else return t == e;
+    }
+  }
+  static NE(t, e) {
+    return !i.EQ(t, e);
+  }
+  static DataViewGetBigInt64(t, e, r = !1) {
+    return i.asIntN(64, i.DataViewGetBigUint64(t, e, r));
+  }
+  static DataViewGetBigUint64(t, e, r = !1) {
+    const [o, n] = r ? [4, 0] : [0, 4], s = t.getUint32(e + o, r), l = t.getUint32(e + n, r), g = new i(3, !1);
+    return g.__setDigit(0, 1073741823 & l), g.__setDigit(1, (268435455 & s) << 2 | l >>> 30), g.__setDigit(2, s >>> 28), g.__trim();
+  }
+  static DataViewSetBigInt64(t, e, r, o = !1) {
+    i.DataViewSetBigUint64(t, e, r, o);
+  }
+  static DataViewSetBigUint64(t, e, r, o = !1) {
+    r = i.asUintN(64, r);
+    let n = 0, s = 0;
+    if (0 < r.length && (s = r.__digit(0), 1 < r.length)) {
+      const a = r.__digit(1);
+      s |= a << 30, n = a >>> 2, 2 < r.length && (n |= r.__digit(2) << 28);
+    }
+    const [l, g] = o ? [4, 0] : [0, 4];
+    t.setUint32(e + l, n, o), t.setUint32(e + g, s, o);
+  }
+  static __zero() {
+    return new i(0, !1);
+  }
+  static __oneDigit(t, e) {
+    const r = new i(1, e);
+    return r.__setDigit(0, t), r;
+  }
+  __copy() {
+    const t = new i(this.length, this.sign);
+    for (let e = 0; e < this.length; e++) t[e] = this[e];
+    return t;
+  }
+  __trim() {
+    let t = this.length, e = this[t - 1];
+    for (; e === 0; ) t--, e = this[t - 1], this.pop();
+    return t === 0 && (this.sign = !1), this;
+  }
+  __initializeDigits() {
+    for (let t = 0; t < this.length; t++) this[t] = 0;
+  }
+  static __decideRounding(t, e, r, o) {
+    if (0 < e) return -1;
+    let n;
+    if (0 > e) n = -e - 1;
+    else {
+      if (r === 0) return -1;
+      r--, o = t.__digit(r), n = 29;
+    }
+    let s = 1 << n;
+    if ((o & s) == 0) return -1;
+    if (s -= 1, (o & s) != 0) return 1;
+    for (; 0 < r; ) if (r--, t.__digit(r) !== 0) return 1;
+    return 0;
+  }
+  static __fromDouble(t) {
+    i.__kBitConversionDouble[0] = t;
+    const e = 2047 & i.__kBitConversionInts[i.__kBitConversionIntHigh] >>> 20, r = e - 1023, o = (0 | r / 30) + 1, n = new i(o, 0 > t);
+    let s = 1048575 & i.__kBitConversionInts[i.__kBitConversionIntHigh] | 1048576, l = i.__kBitConversionInts[i.__kBitConversionIntLow];
+    const g = 20, a = r % 30;
+    let _, u = 0;
+    if (a < 20) {
+      const f = g - a;
+      u = f + 32, _ = s >>> f, s = s << 32 - f | l >>> f, l <<= 32 - f;
+    } else if (a === 20) u = 32, _ = s, s = l, l = 0;
+    else {
+      const f = a - g;
+      u = 32 - f, _ = s << f | l >>> 32 - f, s = l << f, l = 0;
+    }
+    n.__setDigit(o - 1, _);
+    for (let f = o - 2; 0 <= f; f--) 0 < u ? (u -= 30, _ = s >>> 2, s = s << 30 | l >>> 2, l <<= 30) : _ = 0, n.__setDigit(f, _);
+    return n.__trim();
+  }
+  static __isWhitespace(t) {
+    return 13 >= t && 9 <= t || (159 >= t ? t == 32 : 131071 >= t ? t == 160 || t == 5760 : 196607 >= t ? (t &= 131071, 10 >= t || t == 40 || t == 41 || t == 47 || t == 95 || t == 4096) : t == 65279);
+  }
+  static __fromString(t, e = 0) {
+    let r = 0;
+    const o = t.length;
+    let n = 0;
+    if (n === o) return i.__zero();
+    let s = t.charCodeAt(n);
+    for (; i.__isWhitespace(s); ) {
+      if (++n === o) return i.__zero();
+      s = t.charCodeAt(n);
+    }
+    if (s === 43) {
+      if (++n === o) return null;
+      s = t.charCodeAt(n), r = 1;
+    } else if (s === 45) {
+      if (++n === o) return null;
+      s = t.charCodeAt(n), r = -1;
+    }
+    if (e === 0) {
+      if (e = 10, s === 48) {
+        if (++n === o) return i.__zero();
+        if (s = t.charCodeAt(n), s === 88 || s === 120) {
+          if (e = 16, ++n === o) return null;
+          s = t.charCodeAt(n);
+        } else if (s === 79 || s === 111) {
+          if (e = 8, ++n === o) return null;
+          s = t.charCodeAt(n);
+        } else if (s === 66 || s === 98) {
+          if (e = 2, ++n === o) return null;
+          s = t.charCodeAt(n);
+        }
+      }
+    } else if (e === 16 && s === 48) {
+      if (++n === o) return i.__zero();
+      if (s = t.charCodeAt(n), s === 88 || s === 120) {
+        if (++n === o) return null;
+        s = t.charCodeAt(n);
+      }
+    }
+    if (r != 0 && e !== 10) return null;
+    for (; s === 48; ) {
+      if (++n === o) return i.__zero();
+      s = t.charCodeAt(n);
+    }
+    const l = o - n;
+    let g = i.__kMaxBitsPerChar[e], a = i.__kBitsPerCharTableMultiplier - 1;
+    if (l > 1073741824 / g) return null;
+    const _ = g * l + a >>> i.__kBitsPerCharTableShift, u = new i(0 | (_ + 29) / 30, !1), f = 10 > e ? e : 10, h = 10 < e ? e - 10 : 0;
+    if ((e & e - 1) == 0) {
+      g >>= i.__kBitsPerCharTableShift;
+      const d = [], c = [];
+      let b = !1;
+      do {
+        let m = 0, D = 0;
+        for (; ; ) {
+          let w;
+          if (s - 48 >>> 0 < f) w = s - 48;
+          else if ((32 | s) - 97 >>> 0 < h) w = (32 | s) - 87;
+          else {
+            b = !0;
+            break;
+          }
+          if (D += g, m = m << g | w, ++n === o) {
+            b = !0;
+            break;
+          }
+          if (s = t.charCodeAt(n), 30 < D + g) break;
+        }
+        d.push(m), c.push(D);
+      } while (!b);
+      i.__fillFromParts(u, d, c);
+    } else {
+      u.__initializeDigits();
+      let d = !1, c = 0;
+      do {
+        let b = 0, m = 1;
+        for (; ; ) {
+          let w;
+          if (s - 48 >>> 0 < f) w = s - 48;
+          else if ((32 | s) - 97 >>> 0 < h) w = (32 | s) - 87;
+          else {
+            d = !0;
+            break;
+          }
+          const v = m * e;
+          if (1073741823 < v) break;
+          if (m = v, b = b * e + w, c++, ++n === o) {
+            d = !0;
+            break;
+          }
+          s = t.charCodeAt(n);
+        }
+        a = 30 * i.__kBitsPerCharTableMultiplier - 1;
+        const D = 0 | (g * c + a >>> i.__kBitsPerCharTableShift) / 30;
+        u.__inplaceMultiplyAdd(m, b, D);
+      } while (!d);
+    }
+    if (n !== o) {
+      if (!i.__isWhitespace(s)) return null;
+      for (n++; n < o; n++) if (s = t.charCodeAt(n), !i.__isWhitespace(s)) return null;
+    }
+    return u.sign = r == -1, u.__trim();
+  }
+  static __fillFromParts(t, e, r) {
+    let o = 0, n = 0, s = 0;
+    for (let l = e.length - 1; 0 <= l; l--) {
+      const g = e[l], a = r[l];
+      n |= g << s, s += a, s === 30 ? (t.__setDigit(o++, n), s = 0, n = 0) : 30 < s && (t.__setDigit(o++, 1073741823 & n), s -= 30, n = g >>> a - s);
+    }
+    if (n !== 0) {
+      if (o >= t.length) throw new Error("implementation bug");
+      t.__setDigit(o++, n);
+    }
+    for (; o < t.length; o++) t.__setDigit(o, 0);
+  }
+  static __toStringBasePowerOfTwo(t, e) {
+    const r = t.length;
+    let o = e - 1;
+    o = (85 & o >>> 1) + (85 & o), o = (51 & o >>> 2) + (51 & o), o = (15 & o >>> 4) + (15 & o);
+    const n = o, s = e - 1, l = t.__digit(r - 1), g = i.__clz30(l);
+    let a = 0 | (30 * r - g + n - 1) / n;
+    if (t.sign && a++, 268435456 < a) throw new Error("string too long");
+    const _ = Array(a);
+    let u = a - 1, f = 0, h = 0;
+    for (let c = 0; c < r - 1; c++) {
+      const b = t.__digit(c), m = (f | b << h) & s;
+      _[u--] = i.__kConversionChars[m];
+      const D = n - h;
+      for (f = b >>> D, h = 30 - D; h >= n; ) _[u--] = i.__kConversionChars[f & s], f >>>= n, h -= n;
+    }
+    const d = (f | l << h) & s;
+    for (_[u--] = i.__kConversionChars[d], f = l >>> n - h; f !== 0; ) _[u--] = i.__kConversionChars[f & s], f >>>= n;
+    if (t.sign && (_[u--] = "-"), u != -1) throw new Error("implementation bug");
+    return _.join("");
+  }
+  static __toStringGeneric(t, e, r) {
+    const o = t.length;
+    if (o === 0) return "";
+    if (o === 1) {
+      let c = t.__unsignedDigit(0).toString(e);
+      return r === !1 && t.sign && (c = "-" + c), c;
+    }
+    const n = 30 * o - i.__clz30(t.__digit(o - 1)), s = i.__kMaxBitsPerChar[e], l = s - 1;
+    let g = n * i.__kBitsPerCharTableMultiplier;
+    g += l - 1, g = 0 | g / l;
+    const a = g + 1 >> 1, _ = i.exponentiate(i.__oneDigit(e, !1), i.__oneDigit(a, !1));
+    let u, f;
+    const h = _.__unsignedDigit(0);
+    if (_.length === 1 && 32767 >= h) {
+      u = new i(t.length, !1), u.__initializeDigits();
+      let c = 0;
+      for (let b = 2 * t.length - 1; 0 <= b; b--) {
+        const m = c << 15 | t.__halfDigit(b);
+        u.__setHalfDigit(b, 0 | m / h), c = 0 | m % h;
+      }
+      f = c.toString(e);
+    } else {
+      const c = i.__absoluteDivLarge(t, _, !0, !0);
+      u = c.quotient;
+      const b = c.remainder.__trim();
+      f = i.__toStringGeneric(b, e, !0);
+    }
+    u.__trim();
+    let d = i.__toStringGeneric(u, e, !0);
+    for (; f.length < a; ) f = "0" + f;
+    return r === !1 && t.sign && (d = "-" + d), d + f;
+  }
+  static __unequalSign(t) {
+    return t ? -1 : 1;
+  }
+  static __absoluteGreater(t) {
+    return t ? -1 : 1;
+  }
+  static __absoluteLess(t) {
+    return t ? 1 : -1;
+  }
+  static __compareToBigInt(t, e) {
+    const r = t.sign;
+    if (r !== e.sign) return i.__unequalSign(r);
+    const o = i.__absoluteCompare(t, e);
+    return 0 < o ? i.__absoluteGreater(r) : 0 > o ? i.__absoluteLess(r) : 0;
+  }
+  static __compareToNumber(t, e) {
+    if (i.__isOneDigitInt(e)) {
+      const r = t.sign, o = 0 > e;
+      if (r !== o) return i.__unequalSign(r);
+      if (t.length === 0) {
+        if (o) throw new Error("implementation bug");
+        return e === 0 ? 0 : -1;
+      }
+      if (1 < t.length) return i.__absoluteGreater(r);
+      const n = Math.abs(e), s = t.__unsignedDigit(0);
+      return s > n ? i.__absoluteGreater(r) : s < n ? i.__absoluteLess(r) : 0;
+    }
+    return i.__compareToDouble(t, e);
+  }
+  static __compareToDouble(t, e) {
+    if (e !== e) return e;
+    if (e === 1 / 0) return -1;
+    if (e === -1 / 0) return 1;
+    const r = t.sign;
+    if (r !== 0 > e) return i.__unequalSign(r);
+    if (e === 0) throw new Error("implementation bug: should be handled elsewhere");
+    if (t.length === 0) return -1;
+    i.__kBitConversionDouble[0] = e;
+    const o = 2047 & i.__kBitConversionInts[i.__kBitConversionIntHigh] >>> 20;
+    if (o == 2047) throw new Error("implementation bug: handled elsewhere");
+    const n = o - 1023;
+    if (0 > n) return i.__absoluteGreater(r);
+    const s = t.length;
+    let l = t.__digit(s - 1);
+    const g = i.__clz30(l), a = 30 * s - g, _ = n + 1;
+    if (a < _) return i.__absoluteLess(r);
+    if (a > _) return i.__absoluteGreater(r);
+    let u = 1048576 | 1048575 & i.__kBitConversionInts[i.__kBitConversionIntHigh], f = i.__kBitConversionInts[i.__kBitConversionIntLow];
+    const h = 20, d = 29 - g;
+    if (d !== (0 | (a - 1) % 30)) throw new Error("implementation bug");
+    let c, b = 0;
+    if (20 > d) {
+      const m = h - d;
+      b = m + 32, c = u >>> m, u = u << 32 - m | f >>> m, f <<= 32 - m;
+    } else if (d === 20) b = 32, c = u, u = f, f = 0;
+    else {
+      const m = d - h;
+      b = 32 - m, c = u << m | f >>> 32 - m, u = f << m, f = 0;
+    }
+    if (l >>>= 0, c >>>= 0, l > c) return i.__absoluteGreater(r);
+    if (l < c) return i.__absoluteLess(r);
+    for (let m = s - 2; 0 <= m; m--) {
+      0 < b ? (b -= 30, c = u >>> 2, u = u << 30 | f >>> 2, f <<= 30) : c = 0;
+      const D = t.__unsignedDigit(m);
+      if (D > c) return i.__absoluteGreater(r);
+      if (D < c) return i.__absoluteLess(r);
+    }
+    if (u !== 0 || f !== 0) {
+      if (b === 0) throw new Error("implementation bug");
+      return i.__absoluteLess(r);
+    }
+    return 0;
+  }
+  static __equalToNumber(t, e) {
+    var r = Math.abs;
+    return i.__isOneDigitInt(e) ? e === 0 ? t.length === 0 : t.length === 1 && t.sign === 0 > e && t.__unsignedDigit(0) === r(e) : i.__compareToDouble(t, e) === 0;
+  }
+  static __comparisonResultToBool(t, e) {
+    return e === 0 ? 0 > t : e === 1 ? 0 >= t : e === 2 ? 0 < t : e === 3 ? 0 <= t : void 0;
+  }
+  static __compare(t, e, r) {
+    if (t = i.__toPrimitive(t), e = i.__toPrimitive(e), typeof t == "string" && typeof e == "string") switch (r) {
+      case 0:
+        return t < e;
+      case 1:
+        return t <= e;
+      case 2:
+        return t > e;
+      case 3:
+        return t >= e;
+    }
+    if (i.__isBigInt(t) && typeof e == "string") return e = i.__fromString(e), e !== null && i.__comparisonResultToBool(i.__compareToBigInt(t, e), r);
+    if (typeof t == "string" && i.__isBigInt(e)) return t = i.__fromString(t), t !== null && i.__comparisonResultToBool(i.__compareToBigInt(t, e), r);
+    if (t = i.__toNumeric(t), e = i.__toNumeric(e), i.__isBigInt(t)) {
+      if (i.__isBigInt(e)) return i.__comparisonResultToBool(i.__compareToBigInt(t, e), r);
+      if (typeof e != "number") throw new Error("implementation bug");
+      return i.__comparisonResultToBool(i.__compareToNumber(t, e), r);
+    }
+    if (typeof t != "number") throw new Error("implementation bug");
+    if (i.__isBigInt(e)) return i.__comparisonResultToBool(i.__compareToNumber(e, t), 2 ^ r);
+    if (typeof e != "number") throw new Error("implementation bug");
+    return r === 0 ? t < e : r === 1 ? t <= e : r === 2 ? t > e : r === 3 ? t >= e : void 0;
+  }
+  __clzmsd() {
+    return i.__clz30(this.__digit(this.length - 1));
+  }
+  static __absoluteAdd(t, e, r) {
+    if (t.length < e.length) return i.__absoluteAdd(e, t, r);
+    if (t.length === 0) return t;
+    if (e.length === 0) return t.sign === r ? t : i.unaryMinus(t);
+    let o = t.length;
+    (t.__clzmsd() === 0 || e.length === t.length && e.__clzmsd() === 0) && o++;
+    const n = new i(o, r);
+    let s = 0, l = 0;
+    for (; l < e.length; l++) {
+      const g = t.__digit(l) + e.__digit(l) + s;
+      s = g >>> 30, n.__setDigit(l, 1073741823 & g);
+    }
+    for (; l < t.length; l++) {
+      const g = t.__digit(l) + s;
+      s = g >>> 30, n.__setDigit(l, 1073741823 & g);
+    }
+    return l < n.length && n.__setDigit(l, s), n.__trim();
+  }
+  static __absoluteSub(t, e, r) {
+    if (t.length === 0) return t;
+    if (e.length === 0) return t.sign === r ? t : i.unaryMinus(t);
+    const o = new i(t.length, r);
+    let n = 0, s = 0;
+    for (; s < e.length; s++) {
+      const l = t.__digit(s) - e.__digit(s) - n;
+      n = 1 & l >>> 30, o.__setDigit(s, 1073741823 & l);
+    }
+    for (; s < t.length; s++) {
+      const l = t.__digit(s) - n;
+      n = 1 & l >>> 30, o.__setDigit(s, 1073741823 & l);
+    }
+    return o.__trim();
+  }
+  static __absoluteAddOne(t, e, r = null) {
+    const o = t.length;
+    r === null ? r = new i(o, e) : r.sign = e;
+    let n = 1;
+    for (let s = 0; s < o; s++) {
+      const l = t.__digit(s) + n;
+      n = l >>> 30, r.__setDigit(s, 1073741823 & l);
+    }
+    return n != 0 && r.__setDigitGrow(o, 1), r;
+  }
+  static __absoluteSubOne(t, e) {
+    const r = t.length;
+    e = e || r;
+    const o = new i(e, !1);
+    let n = 1;
+    for (let s = 0; s < r; s++) {
+      const l = t.__digit(s) - n;
+      n = 1 & l >>> 30, o.__setDigit(s, 1073741823 & l);
+    }
+    if (n != 0) throw new Error("implementation bug");
+    for (let s = r; s < e; s++) o.__setDigit(s, 0);
+    return o;
+  }
+  static __absoluteAnd(t, e, r = null) {
+    let o = t.length, n = e.length, s = n;
+    if (o < n) {
+      s = o;
+      const a = t, _ = o;
+      t = e, o = n, e = a, n = _;
+    }
+    let l = s;
+    r === null ? r = new i(l, !1) : l = r.length;
+    let g = 0;
+    for (; g < s; g++) r.__setDigit(g, t.__digit(g) & e.__digit(g));
+    for (; g < l; g++) r.__setDigit(g, 0);
+    return r;
+  }
+  static __absoluteAndNot(t, e, r = null) {
+    const o = t.length, n = e.length;
+    let s = n;
+    o < n && (s = o);
+    let l = o;
+    r === null ? r = new i(l, !1) : l = r.length;
+    let g = 0;
+    for (; g < s; g++) r.__setDigit(g, t.__digit(g) & ~e.__digit(g));
+    for (; g < o; g++) r.__setDigit(g, t.__digit(g));
+    for (; g < l; g++) r.__setDigit(g, 0);
+    return r;
+  }
+  static __absoluteOr(t, e, r = null) {
+    let o = t.length, n = e.length, s = n;
+    if (o < n) {
+      s = o;
+      const a = t, _ = o;
+      t = e, o = n, e = a, n = _;
+    }
+    let l = o;
+    r === null ? r = new i(l, !1) : l = r.length;
+    let g = 0;
+    for (; g < s; g++) r.__setDigit(g, t.__digit(g) | e.__digit(g));
+    for (; g < o; g++) r.__setDigit(g, t.__digit(g));
+    for (; g < l; g++) r.__setDigit(g, 0);
+    return r;
+  }
+  static __absoluteXor(t, e, r = null) {
+    let o = t.length, n = e.length, s = n;
+    if (o < n) {
+      s = o;
+      const a = t, _ = o;
+      t = e, o = n, e = a, n = _;
+    }
+    let l = o;
+    r === null ? r = new i(l, !1) : l = r.length;
+    let g = 0;
+    for (; g < s; g++) r.__setDigit(g, t.__digit(g) ^ e.__digit(g));
+    for (; g < o; g++) r.__setDigit(g, t.__digit(g));
+    for (; g < l; g++) r.__setDigit(g, 0);
+    return r;
+  }
+  static __absoluteCompare(t, e) {
+    const r = t.length - e.length;
+    if (r != 0) return r;
+    let o = t.length - 1;
+    for (; 0 <= o && t.__digit(o) === e.__digit(o); ) o--;
+    return 0 > o ? 0 : t.__unsignedDigit(o) > e.__unsignedDigit(o) ? 1 : -1;
+  }
+  static __multiplyAccumulate(t, e, r, o) {
+    if (e === 0) return;
+    const n = 32767 & e, s = e >>> 15;
+    let l = 0, g = 0;
+    for (let a, _ = 0; _ < t.length; _++, o++) {
+      a = r.__digit(o);
+      const u = t.__digit(_), f = 32767 & u, h = u >>> 15, d = i.__imul(f, n), c = i.__imul(f, s), b = i.__imul(h, n), m = i.__imul(h, s);
+      a += g + d + l, l = a >>> 30, a &= 1073741823, a += ((32767 & c) << 15) + ((32767 & b) << 15), l += a >>> 30, g = m + (c >>> 15) + (b >>> 15), r.__setDigit(o, 1073741823 & a);
+    }
+    for (; l != 0 || g !== 0; o++) {
+      let a = r.__digit(o);
+      a += l + g, g = 0, l = a >>> 30, r.__setDigit(o, 1073741823 & a);
+    }
+  }
+  static __internalMultiplyAdd(t, e, r, o, n) {
+    let s = r, l = 0;
+    for (let g = 0; g < o; g++) {
+      const a = t.__digit(g), _ = i.__imul(32767 & a, e), u = i.__imul(a >>> 15, e), f = _ + ((32767 & u) << 15) + l + s;
+      s = f >>> 30, l = u >>> 15, n.__setDigit(g, 1073741823 & f);
+    }
+    if (n.length > o) for (n.__setDigit(o++, s + l); o < n.length; ) n.__setDigit(o++, 0);
+    else if (s + l !== 0) throw new Error("implementation bug");
+  }
+  __inplaceMultiplyAdd(t, e, r) {
+    r > this.length && (r = this.length);
+    const o = 32767 & t, n = t >>> 15;
+    let s = 0, l = e;
+    for (let g = 0; g < r; g++) {
+      const a = this.__digit(g), _ = 32767 & a, u = a >>> 15, f = i.__imul(_, o), h = i.__imul(_, n), d = i.__imul(u, o), c = i.__imul(u, n);
+      let b = l + f + s;
+      s = b >>> 30, b &= 1073741823, b += ((32767 & h) << 15) + ((32767 & d) << 15), s += b >>> 30, l = c + (h >>> 15) + (d >>> 15), this.__setDigit(g, 1073741823 & b);
+    }
+    if (s != 0 || l !== 0) throw new Error("implementation bug");
+  }
+  static __absoluteDivSmall(t, e, r = null) {
+    r === null && (r = new i(t.length, !1));
+    let o = 0;
+    for (let n, s = 2 * t.length - 1; 0 <= s; s -= 2) {
+      n = (o << 15 | t.__halfDigit(s)) >>> 0;
+      const l = 0 | n / e;
+      o = 0 | n % e, n = (o << 15 | t.__halfDigit(s - 1)) >>> 0;
+      const g = 0 | n / e;
+      o = 0 | n % e, r.__setDigit(s >>> 1, l << 15 | g);
+    }
+    return r;
+  }
+  static __absoluteModSmall(t, e) {
+    let r = 0;
+    for (let o = 2 * t.length - 1; 0 <= o; o--)
+      r = 0 | ((r << 15 | t.__halfDigit(o)) >>> 0) % e;
+    return r;
+  }
+  static __absoluteDivLarge(t, e, r, o) {
+    const n = e.__halfDigitLength(), s = e.length, l = t.__halfDigitLength() - n;
+    let g = null;
+    r && (g = new i(l + 2 >>> 1, !1), g.__initializeDigits());
+    const a = new i(n + 2 >>> 1, !1);
+    a.__initializeDigits();
+    const _ = i.__clz15(e.__halfDigit(n - 1));
+    0 < _ && (e = i.__specialLeftShift(e, _, 0));
+    const u = i.__specialLeftShift(t, _, 1), f = e.__halfDigit(n - 1);
+    let h = 0;
+    for (let d, c = l; 0 <= c; c--) {
+      d = 32767;
+      const b = u.__halfDigit(c + n);
+      if (b !== f) {
+        const D = (b << 15 | u.__halfDigit(c + n - 1)) >>> 0;
+        d = 0 | D / f;
+        let w = 0 | D % f;
+        const v = e.__halfDigit(n - 2), y = u.__halfDigit(c + n - 2);
+        for (; i.__imul(d, v) >>> 0 > (w << 16 | y) >>> 0 && (d--, w += f, !(32767 < w)); ) ;
+      }
+      i.__internalMultiplyAdd(e, d, 0, s, a);
+      let m = u.__inplaceSub(a, c, n + 1);
+      m !== 0 && (m = u.__inplaceAdd(e, c, n), u.__setHalfDigit(c + n, 32767 & u.__halfDigit(c + n) + m), d--), r && (1 & c ? h = d << 15 : g.__setDigit(c >>> 1, h | d));
+    }
+    if (o) return u.__inplaceRightShift(_), r ? { quotient: g, remainder: u } : u;
+    if (r) return g;
+    throw new Error("unreachable");
+  }
+  static __clz15(t) {
+    return i.__clz30(t) - 15;
+  }
+  __inplaceAdd(t, e, r) {
+    let o = 0;
+    for (let n = 0; n < r; n++) {
+      const s = this.__halfDigit(e + n) + t.__halfDigit(n) + o;
+      o = s >>> 15, this.__setHalfDigit(e + n, 32767 & s);
+    }
+    return o;
+  }
+  __inplaceSub(t, e, r) {
+    let o = 0;
+    if (1 & e) {
+      e >>= 1;
+      let n = this.__digit(e), s = 32767 & n, l = 0;
+      for (; l < r - 1 >>> 1; l++) {
+        const _ = t.__digit(l), u = (n >>> 15) - (32767 & _) - o;
+        o = 1 & u >>> 15, this.__setDigit(e + l, (32767 & u) << 15 | 32767 & s), n = this.__digit(e + l + 1), s = (32767 & n) - (_ >>> 15) - o, o = 1 & s >>> 15;
+      }
+      const g = t.__digit(l), a = (n >>> 15) - (32767 & g) - o;
+      if (o = 1 & a >>> 15, this.__setDigit(e + l, (32767 & a) << 15 | 32767 & s), e + l + 1 >= this.length) throw new RangeError("out of bounds");
+      (1 & r) == 0 && (n = this.__digit(e + l + 1), s = (32767 & n) - (g >>> 15) - o, o = 1 & s >>> 15, this.__setDigit(e + t.length, 1073709056 & n | 32767 & s));
+    } else {
+      e >>= 1;
+      let n = 0;
+      for (; n < t.length - 1; n++) {
+        const _ = this.__digit(e + n), u = t.__digit(n), f = (32767 & _) - (32767 & u) - o;
+        o = 1 & f >>> 15;
+        const h = (_ >>> 15) - (u >>> 15) - o;
+        o = 1 & h >>> 15, this.__setDigit(e + n, (32767 & h) << 15 | 32767 & f);
+      }
+      const s = this.__digit(e + n), l = t.__digit(n), g = (32767 & s) - (32767 & l) - o;
+      o = 1 & g >>> 15;
+      let a = 0;
+      (1 & r) == 0 && (a = (s >>> 15) - (l >>> 15) - o, o = 1 & a >>> 15), this.__setDigit(e + n, (32767 & a) << 15 | 32767 & g);
+    }
+    return o;
+  }
+  __inplaceRightShift(t) {
+    if (t === 0) return;
+    let e = this.__digit(0) >>> t;
+    const r = this.length - 1;
+    for (let o = 0; o < r; o++) {
+      const n = this.__digit(o + 1);
+      this.__setDigit(o, 1073741823 & n << 30 - t | e), e = n >>> t;
+    }
+    this.__setDigit(r, e);
+  }
+  static __specialLeftShift(t, e, r) {
+    const o = t.length, n = new i(o + r, !1);
+    if (e === 0) {
+      for (let l = 0; l < o; l++) n.__setDigit(l, t.__digit(l));
+      return 0 < r && n.__setDigit(o, 0), n;
+    }
+    let s = 0;
+    for (let l = 0; l < o; l++) {
+      const g = t.__digit(l);
+      n.__setDigit(l, 1073741823 & g << e | s), s = g >>> 30 - e;
+    }
+    return 0 < r && n.__setDigit(o, s), n;
+  }
+  static __leftShiftByAbsolute(t, e) {
+    const r = i.__toShiftAmount(e);
+    if (0 > r) throw new RangeError("BigInt too big");
+    const o = 0 | r / 30, n = r % 30, s = t.length, l = n !== 0 && t.__digit(s - 1) >>> 30 - n != 0, g = s + o + (l ? 1 : 0), a = new i(g, t.sign);
+    if (n === 0) {
+      let _ = 0;
+      for (; _ < o; _++) a.__setDigit(_, 0);
+      for (; _ < g; _++) a.__setDigit(_, t.__digit(_ - o));
+    } else {
+      let _ = 0;
+      for (let u = 0; u < o; u++) a.__setDigit(u, 0);
+      for (let u = 0; u < s; u++) {
+        const f = t.__digit(u);
+        a.__setDigit(u + o, 1073741823 & f << n | _), _ = f >>> 30 - n;
+      }
+      if (l) a.__setDigit(s + o, _);
+      else if (_ !== 0) throw new Error("implementation bug");
+    }
+    return a.__trim();
+  }
+  static __rightShiftByAbsolute(t, e) {
+    const r = t.length, o = t.sign, n = i.__toShiftAmount(e);
+    if (0 > n) return i.__rightShiftByMaximum(o);
+    const s = 0 | n / 30, l = n % 30;
+    let g = r - s;
+    if (0 >= g) return i.__rightShiftByMaximum(o);
+    let a = !1;
+    if (o) {
+      if ((t.__digit(s) & (1 << l) - 1) != 0) a = !0;
+      else for (let u = 0; u < s; u++) if (t.__digit(u) !== 0) {
+        a = !0;
+        break;
+      }
+    }
+    a && l === 0 && ~t.__digit(r - 1) == 0 && g++;
+    let _ = new i(g, o);
+    if (l === 0) {
+      _.__setDigit(g - 1, 0);
+      for (let u = s; u < r; u++) _.__setDigit(u - s, t.__digit(u));
+    } else {
+      let u = t.__digit(s) >>> l;
+      const f = r - s - 1;
+      for (let h = 0; h < f; h++) {
+        const d = t.__digit(h + s + 1);
+        _.__setDigit(h, 1073741823 & d << 30 - l | u), u = d >>> l;
+      }
+      _.__setDigit(f, u);
+    }
+    return a && (_ = i.__absoluteAddOne(_, !0, _)), _.__trim();
+  }
+  static __rightShiftByMaximum(t) {
+    return t ? i.__oneDigit(1, !0) : i.__zero();
+  }
+  static __toShiftAmount(t) {
+    if (1 < t.length) return -1;
+    const e = t.__unsignedDigit(0);
+    return e > i.__kMaxLengthBits ? -1 : e;
+  }
+  static __toPrimitive(t, e = "default") {
+    if (typeof t != "object" || t.constructor === i) return t;
+    if (typeof Symbol < "u" && typeof Symbol.toPrimitive == "symbol" && t[Symbol.toPrimitive]) {
+      const n = t[Symbol.toPrimitive](e);
+      if (typeof n != "object") return n;
+      throw new TypeError("Cannot convert object to primitive value");
+    }
+    const r = t.valueOf;
+    if (r) {
+      const n = r.call(t);
+      if (typeof n != "object") return n;
+    }
+    const o = t.toString;
+    if (o) {
+      const n = o.call(t);
+      if (typeof n != "object") return n;
+    }
+    throw new TypeError("Cannot convert object to primitive value");
+  }
+  static __toNumeric(t) {
+    return i.__isBigInt(t) ? t : +t;
+  }
+  static __isBigInt(t) {
+    return typeof t == "object" && t !== null && t.constructor === i;
+  }
+  static __truncateToNBits(t, e) {
+    const r = 0 | (t + 29) / 30, o = new i(r, e.sign), n = r - 1;
+    for (let l = 0; l < n; l++) o.__setDigit(l, e.__digit(l));
+    let s = e.__digit(n);
+    if (t % 30 != 0) {
+      const l = 32 - t % 30;
+      s = s << l >>> l;
+    }
+    return o.__setDigit(n, s), o.__trim();
+  }
+  static __truncateAndSubFromPowerOfTwo(t, e, r) {
+    var o = Math.min;
+    const n = 0 | (t + 29) / 30, s = new i(n, r);
+    let l = 0;
+    const g = n - 1;
+    let a = 0;
+    for (const h = o(g, e.length); l < h; l++) {
+      const d = 0 - e.__digit(l) - a;
+      a = 1 & d >>> 30, s.__setDigit(l, 1073741823 & d);
+    }
+    for (; l < g; l++) s.__setDigit(l, 0 | 1073741823 & -a);
+    let _ = g < e.length ? e.__digit(g) : 0;
+    const u = t % 30;
+    let f;
+    if (u == 0) f = 0 - _ - a, f &= 1073741823;
+    else {
+      const h = 32 - u;
+      _ = _ << h >>> h;
+      const d = 1 << 32 - h;
+      f = d - _ - a, f &= d - 1;
+    }
+    return s.__setDigit(g, f), s.__trim();
+  }
+  __digit(t) {
+    return this[t];
+  }
+  __unsignedDigit(t) {
+    return this[t] >>> 0;
+  }
+  __setDigit(t, e) {
+    this[t] = 0 | e;
+  }
+  __setDigitGrow(t, e) {
+    this[t] = 0 | e;
+  }
+  __halfDigitLength() {
+    const t = this.length;
+    return 32767 >= this.__unsignedDigit(t - 1) ? 2 * t - 1 : 2 * t;
+  }
+  __halfDigit(t) {
+    return 32767 & this[t >>> 1] >>> 15 * (1 & t);
+  }
+  __setHalfDigit(t, e) {
+    const r = t >>> 1, o = this.__digit(r), n = 1 & t ? 32767 & o | e << 15 : 1073709056 & o | 32767 & e;
+    this.__setDigit(r, n);
+  }
+  static __digitPow(t, e) {
+    let r = 1;
+    for (; 0 < e; ) 1 & e && (r *= t), e >>>= 1, t *= t;
+    return r;
+  }
+  static __detectBigEndian() {
+    return i.__kBitConversionDouble[0] = -0, i.__kBitConversionInts[0] !== 0;
+  }
+  static __isOneDigitInt(t) {
+    return (1073741823 & t) === t;
+  }
+}
+i.__kMaxLength = 33554432, i.__kMaxLengthBits = i.__kMaxLength << 5, i.__kMaxBitsPerChar = [0, 0, 32, 51, 64, 75, 83, 90, 96, 102, 107, 111, 115, 119, 122, 126, 128, 131, 134, 136, 139, 141, 143, 145, 147, 149, 151, 153, 154, 156, 158, 159, 160, 162, 163, 165, 166], i.__kBitsPerCharTableShift = 5, i.__kBitsPerCharTableMultiplier = 1 << i.__kBitsPerCharTableShift, i.__kConversionChars = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"], i.__kBitConversionBuffer = new ArrayBuffer(8), i.__kBitConversionDouble = new Float64Array(i.__kBitConversionBuffer), i.__kBitConversionInts = new Int32Array(i.__kBitConversionBuffer), i.__kBitConversionIntHigh = i.__detectBigEndian() ? 0 : 1, i.__kBitConversionIntLow = i.__detectBigEndian() ? 1 : 0, i.__clz30 = Math.clz32 ? function(p) {
+  return Math.clz32(p) - 2;
+} : function(p) {
+  return p === 0 ? 30 : 0 | 29 - (0 | Math.log(p >>> 0) / Math.LN2);
+}, i.__imul = Math.imul || function(p, t) {
+  return 0 | p * t;
+};
+export {
+  i as default
+};