@hinkal/common 0.0.116 → 0.0.118

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@iden3/binfileutils/node_modules/ffjavascript/build/browser.esm.mjs

@@ -0,0 +1,389 @@
+const A = [0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4];
+function b(t, n) {
+  if (!n || n == 10)
+    return BigInt(t);
+  if (n == 16)
+    return t.slice(0, 2) == "0x" ? BigInt(t) : BigInt("0x" + t);
+}
+const l = b;
+function E(t, n) {
+  let e = BigInt(0);
+  n = BigInt(n);
+  for (let r = 0; r < t.length; r++)
+    e = e * n + BigInt(t[r]);
+  return e;
+}
+function m(t) {
+  const n = t.toString(16);
+  return (n.length - 1) * 4 + A[parseInt(n[0], 16)];
+}
+function v(t) {
+  return BigInt(t) < BigInt(0);
+}
+function L(t) {
+  return !t;
+}
+function d(t, n) {
+  return BigInt(t) << BigInt(n);
+}
+function I(t, n) {
+  return BigInt(t) >> BigInt(n);
+}
+const M = d, k = I;
+function S(t) {
+  return (BigInt(t) & BigInt(1)) == BigInt(1);
+}
+function U(t) {
+  let n = BigInt(t);
+  const e = [];
+  for (; n; ) {
+    if (n & BigInt(1)) {
+      const r = 2 - Number(n % BigInt(4));
+      e.push(r), n = n - BigInt(r);
+    } else
+      e.push(0);
+    n = n >> BigInt(1);
+  }
+  return e;
+}
+function T(t) {
+  let n = BigInt(t);
+  const e = [];
+  for (; n; )
+    n & BigInt(1) ? e.push(1) : e.push(0), n = n >> BigInt(1);
+  return e;
+}
+function y(t) {
+  if (t > BigInt(Number.MAX_SAFE_INTEGER))
+    throw new Error("Number too big");
+  return Number(t);
+}
+function q(t, n) {
+  const e = [];
+  let r = BigInt(t);
+  for (n = BigInt(n); r; )
+    e.unshift(Number(r % n)), r = r / n;
+  return e;
+}
+function x(t, n) {
+  return BigInt(t) + BigInt(n);
+}
+function N(t, n) {
+  return BigInt(t) - BigInt(n);
+}
+function R(t) {
+  return -BigInt(t);
+}
+function O(t, n) {
+  return BigInt(t) * BigInt(n);
+}
+function P(t) {
+  return BigInt(t) * BigInt(t);
+}
+function _(t, n) {
+  return BigInt(t) ** BigInt(n);
+}
+function $(t, n) {
+  return BigInt(t) ** BigInt(n);
+}
+function j(t) {
+  return BigInt(t) >= 0 ? BigInt(t) : -BigInt(t);
+}
+function V(t, n) {
+  return BigInt(t) / BigInt(n);
+}
+function X(t, n) {
+  return BigInt(t) % BigInt(n);
+}
+function C(t, n) {
+  return BigInt(t) == BigInt(n);
+}
+function F(t, n) {
+  return BigInt(t) != BigInt(n);
+}
+function G(t, n) {
+  return BigInt(t) < BigInt(n);
+}
+function W(t, n) {
+  return BigInt(t) > BigInt(n);
+}
+function Z(t, n) {
+  return BigInt(t) <= BigInt(n);
+}
+function z(t, n) {
+  return BigInt(t) >= BigInt(n);
+}
+function p(t, n) {
+  return BigInt(t) & BigInt(n);
+}
+function D(t, n) {
+  return BigInt(t) | BigInt(n);
+}
+function H(t, n) {
+  return BigInt(t) ^ BigInt(n);
+}
+function J(t, n) {
+  return BigInt(t) && BigInt(n);
+}
+function K(t, n) {
+  return BigInt(t) || BigInt(n);
+}
+function Q(t) {
+  return !BigInt(t);
+}
+function w(t, n, e, r) {
+  const s = "0000000" + e.toString(16), o = new Uint32Array(t.buffer, t.byteOffset + n, r / 4), f = ((s.length - 7) * 4 - 1 >> 5) + 1;
+  for (let i = 0; i < f; i++)
+    o[i] = parseInt(s.substring(s.length - 8 * i - 8, s.length - 8 * i), 16);
+  for (let i = f; i < o.length; i++)
+    o[i] = 0;
+  for (let i = o.length * 4; i < r; i++)
+    t[i] = y(p(I(e, i * 8), 255));
+}
+function Y(t, n, e, r) {
+  const s = "0000000" + e.toString(16), o = new DataView(t.buffer, t.byteOffset + n, r), f = ((s.length - 7) * 4 - 1 >> 5) + 1;
+  for (let i = 0; i < f; i++)
+    o.setUint32(r - i * 4 - 4, parseInt(s.substring(s.length - 8 * i - 8, s.length - 8 * i), 16), !1);
+  for (let i = 0; i < r / 4 - f; i++)
+    o[i] = 0;
+}
+function nn(t, n, e) {
+  e = e || t.byteLength, n = n || 0;
+  const r = new Uint32Array(t.buffer, t.byteOffset + n, e / 4), s = new Array(e / 4);
+  return r.forEach((o, f) => s[s.length - f - 1] = o.toString(16).padStart(8, "0")), b(s.join(""), 16);
+}
+function tn(t, n, e) {
+  e = e || t.byteLength, n = n || 0;
+  const r = new DataView(t.buffer, t.byteOffset + n, e), s = new Array(e / 4);
+  for (let o = 0; o < e / 4; o++)
+    s[o] = r.getUint32(o * 4, !1).toString(16).padStart(8, "0");
+  return b(s.join(""), 16);
+}
+function en(t, n) {
+  return t.toString(n);
+}
+function rn(t) {
+  const n = new Uint8Array(Math.floor((m(t) - 1) / 8) + 1);
+  return w(n, 0, t, n.byteLength), n;
+}
+const sn = l(0), on = l(1);
+var fn = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  abs: j,
+  add: x,
+  band: p,
+  bitLength: m,
+  bits: T,
+  bor: D,
+  bxor: H,
+  div: V,
+  e: l,
+  eq: C,
+  exp: $,
+  fromArray: E,
+  fromRprBE: tn,
+  fromRprLE: nn,
+  fromString: b,
+  geq: z,
+  gt: W,
+  isNegative: v,
+  isOdd: S,
+  isZero: L,
+  land: J,
+  leq: Z,
+  lnot: Q,
+  lor: K,
+  lt: G,
+  mod: X,
+  mul: O,
+  naf: U,
+  neg: R,
+  neq: F,
+  one: on,
+  pow: _,
+  shiftLeft: d,
+  shiftRight: I,
+  shl: M,
+  shr: k,
+  square: P,
+  sub: N,
+  toArray: q,
+  toLEBuff: rn,
+  toNumber: y,
+  toRprBE: Y,
+  toRprLE: w,
+  toString: en,
+  zero: sn
+});
+const u = 1 << 30;
+class B {
+  constructor(n) {
+    this.buffers = [], this.byteLength = n;
+    for (let e = 0; e < n; e += u) {
+      const r = Math.min(n - e, u);
+      this.buffers.push(new Uint8Array(r));
+    }
+  }
+  slice(n, e) {
+    e === void 0 && (e = this.byteLength), n === void 0 && (n = 0);
+    const r = e - n, s = Math.floor(n / u), o = Math.floor((n + r - 1) / u);
+    if (s == o || r == 0)
+      return this.buffers[s].slice(n % u, n % u + r);
+    let f, i = s, a = n % u, c = r;
+    for (; c > 0; ) {
+      const g = a + c > u ? u - a : c, h = new Uint8Array(this.buffers[i].buffer, this.buffers[i].byteOffset + a, g);
+      if (g == r)
+        return h.slice();
+      f || (r <= u ? f = new Uint8Array(r) : f = new B(r)), f.set(h, r - c), c = c - g, i++, a = 0;
+    }
+    return f;
+  }
+  set(n, e) {
+    e === void 0 && (e = 0);
+    const r = n.byteLength;
+    if (r == 0)
+      return;
+    const s = Math.floor(e / u), o = Math.floor((e + r - 1) / u);
+    if (s == o)
+      return n instanceof B && n.buffers.length == 1 ? this.buffers[s].set(n.buffers[0], e % u) : this.buffers[s].set(n, e % u);
+    let f = s, i = e % u, a = r;
+    for (; a > 0; ) {
+      const c = i + a > u ? u - i : a, g = n.slice(r - a, r - a + c);
+      new Uint8Array(this.buffers[f].buffer, this.buffers[f].byteOffset + i, c).set(g), a = a - c, f++, i = 0;
+    }
+  }
+}
+function un(t) {
+  return globalThis.btoa(t);
+}
+un(`(function thread(self) {
+    const MAXMEM = 32767;
+    let instance;
+    let memory;
+
+    if (self) {
+        self.onmessage = function(e) {
+            let data;
+            if (e.data) {
+                data = e.data;
+            } else {
+                data = e;
+            }
+
+            if (data[0].cmd == "INIT") {
+                init(data[0]).then(function() {
+                    self.postMessage(data.result);
+                });
+            } else if (data[0].cmd == "TERMINATE") {
+                self.close();
+            } else {
+                const res = runTask(data);
+                self.postMessage(res);
+            }
+        };
+    }
+
+    async function init(data) {
+        const code = new Uint8Array(data.code);
+        const wasmModule = await WebAssembly.compile(code);
+        memory = new WebAssembly.Memory({initial:data.init, maximum: MAXMEM});
+
+        instance = await WebAssembly.instantiate(wasmModule, {
+            env: {
+                "memory": memory
+            }
+        });
+    }
+
+
+
+    function alloc(length) {
+        const u32 = new Uint32Array(memory.buffer, 0, 1);
+        while (u32[0] & 3) u32[0]++;  // Return always aligned pointers
+        const res = u32[0];
+        u32[0] += length;
+        if (u32[0] + length > memory.buffer.byteLength) {
+            const currentPages = memory.buffer.byteLength / 0x10000;
+            let requiredPages = Math.floor((u32[0] + length) / 0x10000)+1;
+            if (requiredPages>MAXMEM) requiredPages=MAXMEM;
+            memory.grow(requiredPages-currentPages);
+        }
+        return res;
+    }
+
+    function allocBuffer(buffer) {
+        const p = alloc(buffer.byteLength);
+        setBuffer(p, buffer);
+        return p;
+    }
+
+    function getBuffer(pointer, length) {
+        const u8 = new Uint8Array(memory.buffer);
+        return new Uint8Array(u8.buffer, u8.byteOffset + pointer, length);
+    }
+
+    function setBuffer(pointer, buffer) {
+        const u8 = new Uint8Array(memory.buffer);
+        u8.set(new Uint8Array(buffer), pointer);
+    }
+
+    function runTask(task) {
+        if (task[0].cmd == "INIT") {
+            return init(task[0]);
+        }
+        const ctx = {
+            vars: [],
+            out: []
+        };
+        const u32a = new Uint32Array(memory.buffer, 0, 1);
+        const oldAlloc = u32a[0];
+        for (let i=0; i<task.length; i++) {
+            switch (task[i].cmd) {
+            case "ALLOCSET":
+                ctx.vars[task[i].var] = allocBuffer(task[i].buff);
+                break;
+            case "ALLOC":
+                ctx.vars[task[i].var] = alloc(task[i].len);
+                break;
+            case "SET":
+                setBuffer(ctx.vars[task[i].var], task[i].buff);
+                break;
+            case "CALL": {
+                const params = [];
+                for (let j=0; j<task[i].params.length; j++) {
+                    const p = task[i].params[j];
+                    if (typeof p.var !== "undefined") {
+                        params.push(ctx.vars[p.var] + (p.offset || 0));
+                    } else if (typeof p.val != "undefined") {
+                        params.push(p.val);
+                    }
+                }
+                instance.exports[task[i].fnName](...params);
+                break;
+            }
+            case "GET":
+                ctx.out[task[i].out] = getBuffer(ctx.vars[task[i].var], task[i].len).slice();
+                break;
+            default:
+                throw new Error("Invalid cmd");
+            }
+        }
+        const u32b = new Uint32Array(memory.buffer, 0, 1);
+        u32b[0] = oldAlloc;
+        return ctx.out;
+    }
+
+
+    return runTask;
+})(self)`);
+globalThis.curve_bn128 = null;
+globalThis.curve_bls12381 = null;
+l("73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001", 16);
+l("21888242871839275222246405745257275088548364400416034343698204186575808495617");
+l("1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab", 16);
+l("21888242871839275222246405745257275088696311157297823662689037894645226208583");
+const an = fn;
+export {
+  B as BigBuffer,
+  an as Scalar
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@iden3/binfileutils/src/binfileutils.mjs

@@ -0,0 +1,82 @@
+import { BigBuffer as E, Scalar as d } from "../node_modules/ffjavascript/build/browser.esm.mjs";
+import { readExisting as S, createOverride as g } from "../../../fastfile/src/fastfile.mjs";
+async function h(e, i, r, o, t) {
+  const n = await S(e, o, t), a = await n.read(4);
+  let c = "";
+  for (let w = 0; w < 4; w++)
+    c += String.fromCharCode(a[w]);
+  if (c != i)
+    throw new Error(e + ": Invalid File format");
+  if (await n.readULE32() > r)
+    throw new Error("Version not supported");
+  const y = await n.readULE32();
+  let p = [];
+  for (let w = 0; w < y; w++) {
+    let f = await n.readULE32(), u = await n.readULE64();
+    typeof p[f] > "u" && (p[f] = []), p[f].push({
+      p: n.pos,
+      size: u
+    }), n.pos += u;
+  }
+  return { fd: n, sections: p };
+}
+async function L(e, i, r, o, t, n) {
+  const a = await g(e, t, n), c = new Uint8Array(4);
+  for (let s = 0; s < 4; s++)
+    c[s] = i.charCodeAt(s);
+  return await a.write(c, 0), await a.writeULE32(r), await a.writeULE32(o), a;
+}
+async function z(e, i) {
+  if (typeof e.writingSection < "u")
+    throw new Error("Already writing a section");
+  await e.writeULE32(i), e.writingSection = {
+    pSectionSize: e.pos
+  }, await e.writeULE64(0);
+}
+async function m(e) {
+  if (typeof e.writingSection > "u")
+    throw new Error("Not writing a section");
+  const i = e.pos - e.writingSection.pSectionSize - 8, r = e.pos;
+  e.pos = e.writingSection.pSectionSize, await e.writeULE64(i), e.pos = r, delete e.writingSection;
+}
+async function B(e, i, r) {
+  if (typeof e.readingSection < "u")
+    throw new Error("Already reading a section");
+  if (!i[r])
+    throw new Error(e.fileName + ": Missing section " + r);
+  if (i[r].length > 1)
+    throw new Error(e.fileName + ": Section Duplicated " + r);
+  e.pos = i[r][0].p, e.readingSection = i[r][0];
+}
+async function A(e, i) {
+  if (typeof e.readingSection > "u")
+    throw new Error("Not reading a section");
+  if (!i && e.pos - e.readingSection.p != e.readingSection.size)
+    throw new Error("Invalid section size reading");
+  delete e.readingSection;
+}
+async function b(e, i, r, o) {
+  const t = new Uint8Array(r);
+  d.toRprLE(t, 0, i, r), await e.write(t, o);
+}
+async function v(e, i, r) {
+  const o = await e.read(i, r);
+  return d.fromRprLE(o, 0, i);
+}
+async function R(e, i, r, o, t) {
+  if (o = typeof o > "u" ? 0 : o, t = typeof t > "u" ? i[r][0].size - o : t, o + t > i[r][0].size)
+    throw new Error("Reading out of the range of the section");
+  let n;
+  return t < 1 << 30 ? n = new Uint8Array(t) : n = new E(t), await e.readToBuffer(n, 0, t, i[r][0].p + o), n;
+}
+export {
+  L as createBinFile,
+  A as endReadSection,
+  m as endWriteSection,
+  v as readBigInt,
+  h as readBinFile,
+  R as readSection,
+  B as startReadUniqueSection,
+  z as startWriteSection,
+  b as writeBigInt
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@protobufjs/aspromise/index.mjs

@@ -0,0 +1,25 @@
+var f = m;
+function m(g, c) {
+  for (var n = new Array(arguments.length - 1), l = 0, t = 2, e = !0; t < arguments.length; )
+    n[l++] = arguments[t++];
+  return new Promise(function(h, i) {
+    n[l] = function(s) {
+      if (e)
+        if (e = !1, s)
+          i(s);
+        else {
+          for (var a = new Array(arguments.length - 1), r = 0; r < a.length; )
+            a[r++] = arguments[r];
+          h.apply(null, a);
+        }
+    };
+    try {
+      g.apply(c || null, n);
+    } catch (u) {
+      e && (e = !1, i(u));
+    }
+  });
+}
+export {
+  f as a
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@protobufjs/base64/index.mjs

@@ -0,0 +1,61 @@
+import { __exports as f } from "../../../../../../../../_virtual/index76.mjs";
+(function(g) {
+  var v = g;
+  v.length = function(t) {
+    var i = t.length;
+    if (!i)
+      return 0;
+    for (var o = 0; --i % 4 > 1 && t.charAt(i) === "="; )
+      ++o;
+    return Math.ceil(t.length * 3) / 4 - o;
+  };
+  for (var l = new Array(64), u = new Array(123), n = 0; n < 64; )
+    u[l[n] = n < 26 ? n + 65 : n < 52 ? n + 71 : n < 62 ? n - 4 : n - 59 | 43] = n++;
+  v.encode = function(t, i, o) {
+    for (var c = null, a = [], r = 0, h = 0, e; i < o; ) {
+      var d = t[i++];
+      switch (h) {
+        case 0:
+          a[r++] = l[d >> 2], e = (d & 3) << 4, h = 1;
+          break;
+        case 1:
+          a[r++] = l[e | d >> 4], e = (d & 15) << 2, h = 2;
+          break;
+        case 2:
+          a[r++] = l[e | d >> 6], a[r++] = l[d & 63], h = 0;
+          break;
+      }
+      r > 8191 && ((c || (c = [])).push(String.fromCharCode.apply(String, a)), r = 0);
+    }
+    return h && (a[r++] = l[e], a[r++] = 61, h === 1 && (a[r++] = 61)), c ? (r && c.push(String.fromCharCode.apply(String, a.slice(0, r))), c.join("")) : String.fromCharCode.apply(String, a.slice(0, r));
+  };
+  var p = "invalid encoding";
+  v.decode = function(t, i, o) {
+    for (var c = o, a = 0, r, h = 0; h < t.length; ) {
+      var e = t.charCodeAt(h++);
+      if (e === 61 && a > 1)
+        break;
+      if ((e = u[e]) === void 0)
+        throw Error(p);
+      switch (a) {
+        case 0:
+          r = e, a = 1;
+          break;
+        case 1:
+          i[o++] = r << 2 | (e & 48) >> 4, r = e, a = 2;
+          break;
+        case 2:
+          i[o++] = (r & 15) << 4 | (e & 60) >> 2, r = e, a = 3;
+          break;
+        case 3:
+          i[o++] = (r & 3) << 6 | e, a = 0;
+          break;
+      }
+    }
+    if (a === 1)
+      throw Error(p);
+    return o - c;
+  }, v.test = function(t) {
+    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(t);
+  };
+})(f);

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@protobufjs/eventemitter/index.mjs

@@ -0,0 +1,33 @@
+var f = r;
+function r() {
+  this._listeners = {};
+}
+r.prototype.on = function(n, e, s) {
+  return (this._listeners[n] || (this._listeners[n] = [])).push({
+    fn: e,
+    ctx: s || this
+  }), this;
+};
+r.prototype.off = function(n, e) {
+  if (n === void 0)
+    this._listeners = {};
+  else if (e === void 0)
+    this._listeners[n] = [];
+  else
+    for (var s = this._listeners[n], t = 0; t < s.length; )
+      s[t].fn === e ? s.splice(t, 1) : ++t;
+  return this;
+};
+r.prototype.emit = function(n) {
+  var e = this._listeners[n];
+  if (e) {
+    for (var s = [], t = 1; t < arguments.length; )
+      s.push(arguments[t++]);
+    for (t = 0; t < e.length; )
+      e[t].fn.apply(e[t++].ctx, s);
+  }
+  return this;
+};
+export {
+  f as e
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@protobufjs/float/index.mjs

@@ -0,0 +1,110 @@
+var B = D(D);
+function D(t) {
+  return typeof Float32Array < "u" ? function() {
+    var l = new Float32Array([-0]), n = new Uint8Array(l.buffer), a = n[3] === 128;
+    function E(r, e, i) {
+      l[0] = r, e[i] = n[0], e[i + 1] = n[1], e[i + 2] = n[2], e[i + 3] = n[3];
+    }
+    function _(r, e, i) {
+      l[0] = r, e[i] = n[3], e[i + 1] = n[2], e[i + 2] = n[1], e[i + 3] = n[0];
+    }
+    t.writeFloatLE = a ? E : _, t.writeFloatBE = a ? _ : E;
+    function d(r, e) {
+      return n[0] = r[e], n[1] = r[e + 1], n[2] = r[e + 2], n[3] = r[e + 3], l[0];
+    }
+    function c(r, e) {
+      return n[3] = r[e], n[2] = r[e + 1], n[1] = r[e + 2], n[0] = r[e + 3], l[0];
+    }
+    t.readFloatLE = a ? d : c, t.readFloatBE = a ? c : d;
+  }() : function() {
+    function l(a, E, _, d) {
+      var c = E < 0 ? 1 : 0;
+      if (c && (E = -E), E === 0)
+        a(1 / E > 0 ? (
+          /* positive */
+          0
+        ) : (
+          /* negative 0 */
+          2147483648
+        ), _, d);
+      else if (isNaN(E))
+        a(2143289344, _, d);
+      else if (E > 34028234663852886e22)
+        a((c << 31 | 2139095040) >>> 0, _, d);
+      else if (E < 11754943508222875e-54)
+        a((c << 31 | Math.round(E / 1401298464324817e-60)) >>> 0, _, d);
+      else {
+        var r = Math.floor(Math.log(E) / Math.LN2), e = Math.round(E * Math.pow(2, -r) * 8388608) & 8388607;
+        a((c << 31 | r + 127 << 23 | e) >>> 0, _, d);
+      }
+    }
+    t.writeFloatLE = l.bind(null, h), t.writeFloatBE = l.bind(null, L);
+    function n(a, E, _) {
+      var d = a(E, _), c = (d >> 31) * 2 + 1, r = d >>> 23 & 255, e = d & 8388607;
+      return r === 255 ? e ? NaN : c * (1 / 0) : r === 0 ? c * 1401298464324817e-60 * e : c * Math.pow(2, r - 150) * (e + 8388608);
+    }
+    t.readFloatLE = n.bind(null, M), t.readFloatBE = n.bind(null, w);
+  }(), typeof Float64Array < "u" ? function() {
+    var l = new Float64Array([-0]), n = new Uint8Array(l.buffer), a = n[7] === 128;
+    function E(r, e, i) {
+      l[0] = r, e[i] = n[0], e[i + 1] = n[1], e[i + 2] = n[2], e[i + 3] = n[3], e[i + 4] = n[4], e[i + 5] = n[5], e[i + 6] = n[6], e[i + 7] = n[7];
+    }
+    function _(r, e, i) {
+      l[0] = r, e[i] = n[7], e[i + 1] = n[6], e[i + 2] = n[5], e[i + 3] = n[4], e[i + 4] = n[3], e[i + 5] = n[2], e[i + 6] = n[1], e[i + 7] = n[0];
+    }
+    t.writeDoubleLE = a ? E : _, t.writeDoubleBE = a ? _ : E;
+    function d(r, e) {
+      return n[0] = r[e], n[1] = r[e + 1], n[2] = r[e + 2], n[3] = r[e + 3], n[4] = r[e + 4], n[5] = r[e + 5], n[6] = r[e + 6], n[7] = r[e + 7], l[0];
+    }
+    function c(r, e) {
+      return n[7] = r[e], n[6] = r[e + 1], n[5] = r[e + 2], n[4] = r[e + 3], n[3] = r[e + 4], n[2] = r[e + 5], n[1] = r[e + 6], n[0] = r[e + 7], l[0];
+    }
+    t.readDoubleLE = a ? d : c, t.readDoubleBE = a ? c : d;
+  }() : function() {
+    function l(a, E, _, d, c, r) {
+      var e = d < 0 ? 1 : 0;
+      if (e && (d = -d), d === 0)
+        a(0, c, r + E), a(1 / d > 0 ? (
+          /* positive */
+          0
+        ) : (
+          /* negative 0 */
+          2147483648
+        ), c, r + _);
+      else if (isNaN(d))
+        a(0, c, r + E), a(2146959360, c, r + _);
+      else if (d > 17976931348623157e292)
+        a(0, c, r + E), a((e << 31 | 2146435072) >>> 0, c, r + _);
+      else {
+        var i;
+        if (d < 22250738585072014e-324)
+          i = d / 5e-324, a(i >>> 0, c, r + E), a((e << 31 | i / 4294967296) >>> 0, c, r + _);
+        else {
+          var F = Math.floor(Math.log(d) / Math.LN2);
+          F === 1024 && (F = 1023), i = d * Math.pow(2, -F), a(i * 4503599627370496 >>> 0, c, r + E), a((e << 31 | F + 1023 << 20 | i * 1048576 & 1048575) >>> 0, c, r + _);
+        }
+      }
+    }
+    t.writeDoubleLE = l.bind(null, h, 0, 4), t.writeDoubleBE = l.bind(null, L, 4, 0);
+    function n(a, E, _, d, c) {
+      var r = a(d, c + E), e = a(d, c + _), i = (e >> 31) * 2 + 1, F = e >>> 20 & 2047, y = 4294967296 * (e & 1048575) + r;
+      return F === 2047 ? y ? NaN : i * (1 / 0) : F === 0 ? i * 5e-324 * y : i * Math.pow(2, F - 1075) * (y + 4503599627370496);
+    }
+    t.readDoubleLE = n.bind(null, M, 0, 4), t.readDoubleBE = n.bind(null, w, 4, 0);
+  }(), t;
+}
+function h(t, l, n) {
+  l[n] = t & 255, l[n + 1] = t >>> 8 & 255, l[n + 2] = t >>> 16 & 255, l[n + 3] = t >>> 24;
+}
+function L(t, l, n) {
+  l[n] = t >>> 24, l[n + 1] = t >>> 16 & 255, l[n + 2] = t >>> 8 & 255, l[n + 3] = t & 255;
+}
+function M(t, l) {
+  return (t[l] | t[l + 1] << 8 | t[l + 2] << 16 | t[l + 3] << 24) >>> 0;
+}
+function w(t, l) {
+  return (t[l] << 24 | t[l + 1] << 16 | t[l + 2] << 8 | t[l + 3]) >>> 0;
+}
+export {
+  B as f
+};