@gsknnft/bigint-buffer 1.4.4 → 1.4.6

package/dist/index.js

@@ -1,91 +1,167 @@
-import { Buffer as o } from "buffer";
-import c from "path";
-import S from "fs";
-let l = !1, f, B;
-const u = typeof globalThis < "u" && typeof globalThis.document < "u", x = [
+import { Buffer as v } from "buffer";
+import l from "path";
+import F from "fs";
+let T = !1, B, b;
+const u = typeof globalThis < "u" && typeof globalThis.document < "u", y = [
   // when running from dist/
-  c.resolve(__dirname, ".."),
+  l.resolve(__dirname, "../"),
   // when running from build/conversion/src/ts
-  c.resolve(__dirname, "../../.."),
+  l.resolve(__dirname, "../.."),
   // when running from src/conversion/src/ts
-  c.resolve(__dirname, "../../../../")
+  l.resolve(__dirname, "../../../")
 ], $ = () => {
-  for (const e of x) {
-    const t = c.join(e, "build", "Release", "bigint_buffer.node");
-    if (S.existsSync(t)) return e;
+  for (const t of y) {
+    const e = l.join(t, "build", "Release", "bigint_buffer.node");
+    if (F.existsSync(e)) return t;
   }
-  return x[0];
+  return y[0];
 };
-function _() {
+function O() {
   try {
-    const e = require("bindings"), t = $();
-    return e({
+    const t = require("bindings"), e = $();
+    return t({
       bindings: "bigint_buffer",
-      module_root: t
+      module_root: e
     });
-  } catch (e) {
-    B = e;
+  } catch (t) {
+    b = t;
     return;
   }
 }
-u || (f = _(), l = f !== void 0, !l && B !== void 0 && process.env?.BIGINT_BUFFER_SILENT_NATIVE_FAIL !== "1" && console.warn(
+u || (B = O(), T = B !== void 0, !T && b !== void 0 && process.env?.BIGINT_BUFFER_SILENT_NATIVE_FAIL !== "1" && console.warn(
   "bigint-buffer: Failed to load native bindings; using pure JS fallback. Run npm run rebuild to restore native.",
-  B
+  b
+));
+B === void 0 && (B = {
+  toBigInt: (t, e = !0) => {
+    const n = v.from(t);
+    e || n.reverse();
+    const r = n.toString("hex");
+    return r.length === 0 ? 0n : BigInt(`0x${r}`);
+  },
+  fromBigInt: (t, e, n = !0) => {
+    const r = t.toString(16), i = e.length, o = r.padStart(i * 2, "0").slice(0, i * 2), c = v.from(o, "hex");
+    return n || c.reverse(), c.copy(e), e;
+  }
+});
+const x = 9, d = "0x0", P = (t) => t.startsWith("0x") || t.startsWith("0X") ? t : `0x${t}`, h = (t) => {
+  if (t === 0n)
+    return d;
+  const e = t < 0n, n = e ? -t : t, r = p(n);
+  return `${e ? "-" : ""}0x${r}`;
+}, s = (t) => {
+  if (!t)
+    return 0n;
+  const e = t.trim();
+  if (e.length === 0)
+    return 0n;
+  const n = e.startsWith("-"), r = n ? e.slice(1) : e, i = P(r), o = E(i);
+  return n ? -o : o;
+};
+function V(t, e = x) {
+  if (!Number.isFinite(t))
+    return d;
+  const n = Math.pow(10, e), r = BigInt(Math.round(t * n));
+  return h(r);
+}
+function M(t, e = x) {
+  const n = s(t);
+  if (n === 0n)
+    return 0;
+  const r = Math.pow(10, e);
+  return Number(n) / r;
+}
+function H(t, e) {
+  return h(s(t) + s(e));
+}
+function W(t, e) {
+  return h(s(t) - s(e));
+}
+function k(t) {
+  if (t.length === 0)
+    return d;
+  const e = t.reduce((n, r) => n + s(r), 0n);
+  return h(e / BigInt(t.length));
+}
+function z(t, e) {
+  const n = s(t) - s(e);
+  return n === 0n ? 0 : n > 0n ? 1 : -1;
+}
+function j(t) {
+  return s(t);
+}
+let f, m;
+function D() {
+  try {
+    const t = require("bindings"), e = $();
+    return t({
+      bindings: "bigint_buffer",
+      module_root: e
+    });
+  } catch (t) {
+    m = t;
+    return;
+  }
+}
+let S = !1;
+u || (f = D(), S = f !== void 0, !S && m !== void 0 && process.env?.BIGINT_BUFFER_SILENT_NATIVE_FAIL !== "1" && console.warn(
+  "bigint-buffer: Failed to load native bindings; using pure JS fallback. Run npm run rebuild to restore native.",
+  m
 ));
 f === void 0 && (f = {
-  toBigInt: (e, t = !0) => {
-    const n = o.from(e);
-    t || n.reverse();
+  toBigInt: (t, e = !0) => {
+    const n = Buffer.from(t);
+    e || n.reverse();
     const r = n.toString("hex");
     return r.length === 0 ? 0n : BigInt(`0x${r}`);
   },
-  fromBigInt: (e, t, n = !0) => {
-    const r = e.toString(16), i = t.length, g = r.padStart(i * 2, "0").slice(0, i * 2), b = o.from(g, "hex");
-    return n || b.reverse(), b.copy(t), t;
+  fromBigInt: (t, e, n = !0) => {
+    const r = t.toString(16), i = e.length, o = r.padStart(i * 2, "0").slice(0, i * 2), c = Buffer.from(o, "hex");
+    return n || c.reverse(), c.copy(e), e;
   }
 });
-function v(e) {
+function _(t) {
   if (u || f === void 0) {
-    const t = o.from(e);
-    t.reverse();
-    const n = t.toString("hex");
+    const e = Buffer.from(t);
+    e.reverse();
+    const n = e.toString("hex");
     return n.length === 0 ? BigInt(0) : BigInt(`0x${n}`);
   }
-  return f.toBigInt(e, !1);
+  return f.toBigInt(t, !1);
 }
-function A() {
+function q() {
   try {
-    return v(o.from([1, 0])) === BigInt(1);
+    return _(Buffer.from([1, 0])) === BigInt(1);
   } catch {
     return !1;
   }
 }
-function R(e) {
+function C(t) {
   if (u || f === void 0) {
-    const t = e.toString("hex");
-    return t.length === 0 ? BigInt(0) : BigInt(`0x${t}`);
+    const e = t.toString("hex");
+    return e.length === 0 ? BigInt(0) : BigInt(`0x${e}`);
   }
-  return f.toBigInt(e, !0);
+  return f.toBigInt(t, !0);
 }
-function U(e, t) {
+function J(t, e) {
   if (u || f === void 0) {
-    const n = e.toString(16), r = o.from(
-      n.padStart(t * 2, "0").slice(0, t * 2),
+    const n = t.toString(16), r = Buffer.from(
+      n.padStart(e * 2, "0").slice(0, e * 2),
       "hex"
     );
     return r.reverse(), r;
   }
-  return f.fromBigInt(e, o.allocUnsafe(t), !1);
+  return f.fromBigInt(t, Buffer.allocUnsafe(e), !1);
 }
-function N(e, t) {
+function X(t, e) {
   if (u || f === void 0) {
-    const n = e.toString(16);
-    return o.from(n.padStart(t * 2, "0").slice(0, t * 2), "hex");
+    const n = t.toString(16);
+    return Buffer.from(n.padStart(e * 2, "0").slice(0, e * 2), "hex");
   }
-  return f.fromBigInt(e, o.allocUnsafe(t), !0);
+  return f.fromBigInt(t, Buffer.allocUnsafe(e), !0);
 }
-function a(e, t = !1, n) {
-  const r = e.match(/^(0x)?([\da-fA-F]+)$/);
+function a(t, e = !1, n) {
+  const r = t.match(/^(0x)?([\da-fA-F]+)$/);
   if (r == null)
     throw new RangeError(
       "input must be a hexadecimal string, e.g. '0x124fe3a' or '0214f1b2'"
@@ -100,249 +176,315 @@ function a(e, t = !1, n) {
       );
     i = i.padStart(n * 2, "0");
   }
-  return t ? "0x" + i : i;
+  return e ? "0x" + i : i;
 }
-function p(e, t = !1) {
-  if (e < 0)
+function L(t, e = !1) {
+  if (t < 0)
     throw RangeError(
       "a should be a non-negative integer. Negative values are not supported"
     );
-  return h(m(e), t);
+  return w(p(t), e);
 }
-function T(e) {
-  let t = 8n;
-  ArrayBuffer.isView(e) ? t = BigInt(e.BYTES_PER_ELEMENT * 8) : e = new Uint8Array(e);
+function N(t) {
+  let e = 8n;
+  ArrayBuffer.isView(t) ? e = BigInt(t.BYTES_PER_ELEMENT * 8) : t = new Uint8Array(t);
   let n = 0n;
-  for (const r of e.values()) {
+  for (const r of t.values()) {
     const i = BigInt(r);
-    n = (n << t) + i;
+    n = (n << e) + i;
   }
   return n;
 }
-function m(e, t = !1, n) {
-  if (e < 0)
+function p(t, e = !1, n) {
+  if (t < 0)
     throw RangeError(
       "a should be a non-negative integer. Negative values are not supported"
     );
-  return a(e.toString(16), t, n);
+  return a(t.toString(16), e, n);
 }
-function w(e) {
-  return BigInt(a(e, !0));
+function E(t) {
+  return BigInt(a(t, !0));
 }
-function L(e) {
-  if (e < 0)
+function Z(t) {
+  if (t < 0)
     throw RangeError(
       "a should be a non-negative integer. Negative values are not supported"
     );
-  return I(h(e.toString(16)));
-}
-function O(e) {
-  return w(E(y(e)));
-}
-function d(e) {
-  if (o.isBuffer(e))
-    return e;
-  if (ArrayBuffer.isView(e))
-    return o.from(e.buffer, e.byteOffset, e.byteLength);
-  if (e instanceof ArrayBuffer)
-    return o.from(new Uint8Array(e));
+  return R(w(t.toString(16)));
+}
+function G(t) {
+  return E(A(U(t)));
+}
+function I(t) {
+  if (Buffer.isBuffer(t))
+    return t;
+  if (ArrayBuffer.isView(t))
+    return Buffer.from(t.buffer, t.byteOffset, t.byteLength);
+  if (t instanceof ArrayBuffer)
+    return Buffer.from(new Uint8Array(t));
   throw new TypeError("Unsupported input type for Buffer.from");
 }
-function I(e) {
-  const t = d(e);
-  return u ? new TextDecoder().decode(new Uint8Array(t)) : o.from(t).toString();
+function R(t) {
+  const e = I(t);
+  return u ? new TextDecoder().decode(new Uint8Array(e)) : Buffer.from(e).toString();
 }
-function y(e, t = !1) {
-  return !u && !t ? o.from(new TextEncoder().encode(e).buffer) : new TextEncoder().encode(e).buffer;
+function U(t, e = !1) {
+  return !u && !e ? Buffer.from(new TextEncoder().encode(t).buffer) : new TextEncoder().encode(t).buffer;
 }
-function E(e, t = !1, n) {
+function A(t, e = !1, n) {
   if (u) {
     let r = "";
     const i = "0123456789abcdef";
-    return ArrayBuffer.isView(e) ? e = new Uint8Array(
-      e.buffer.slice(e.byteOffset, e.byteOffset + e.byteLength)
-    ) : e = new Uint8Array(e), e.forEach((g) => {
-      r += i[g >> 4] + i[g & 15];
-    }), a(r, t, n);
+    return ArrayBuffer.isView(t) ? t = new Uint8Array(
+      t.buffer.slice(t.byteOffset, t.byteOffset + t.byteLength)
+    ) : t = new Uint8Array(t), t.forEach((o) => {
+      r += i[o >> 4] + i[o & 15];
+    }), a(r, e, n);
   } else {
-    const r = d(e);
-    return ArrayBuffer.isView(r) && (e = new Uint8Array(
+    const r = I(t);
+    return ArrayBuffer.isView(r) && (t = new Uint8Array(
       r.buffer.slice(
         r.byteOffset,
         r.byteOffset + r.byteLength
       )
     )), a(
-      o.from(d(e)).toString("hex"),
-      t,
+      Buffer.from(I(t)).toString("hex"),
+      e,
       n
     );
   }
 }
-function h(e, t = !1) {
-  let n = a(e);
-  if (n = a(e, !1, Math.ceil(n.length / 2)), u)
+function w(t, e = !1) {
+  let n = a(t);
+  if (n = a(t, !1, Math.ceil(n.length / 2)), u)
     return Uint8Array.from(
       n.match(/[\da-fA-F]{2}/g).map((r) => +("0x" + r))
     ).buffer;
   {
-    const r = o.from(n, "hex");
-    return t ? r.buffer.slice(r.byteOffset, r.byteOffset + r.byteLength) : r;
+    const r = Buffer.from(n, "hex");
+    return e ? r.buffer.slice(r.byteOffset, r.byteOffset + r.byteLength) : r;
   }
 }
-function F(e, t = !1, n = !0) {
-  if (e < 0n)
+function Y(t, e = !1, n = !0) {
+  if (t < 0n)
     throw new RangeError("negative bigint");
-  const r = p(e);
-  let i = o.isBuffer(r) ? r.toString("base64") : o.from(r).toString("base64");
-  return t && (i = i.replace(/\+/g, "-").replace(/\//g, "_")), n || (i = i.replace(/=+$/, "")), i;
+  const r = L(t);
+  let i = Buffer.isBuffer(r) ? r.toString("base64") : Buffer.from(r).toString("base64");
+  return e && (i = i.replace(/\+/g, "-").replace(/\//g, "_")), n || (i = i.replace(/=+$/, "")), i;
 }
-function H(e) {
-  if (!e || e.trim() === "")
+function K(t) {
+  if (!t || t.trim() === "")
     return 0n;
-  const t = e.trim();
-  if (!/^[A-Za-z0-9+/=_-]*$/.test(t))
+  const e = t.trim();
+  if (!/^[A-Za-z0-9+/=_-]*$/.test(e))
     throw new RangeError("invalid base64");
-  let n = t.replace(/-/g, "+").replace(/_/g, "/");
+  let n = e.replace(/-/g, "+").replace(/_/g, "/");
   for (; n.length % 4 !== 0; )
     n += "=";
-  const r = o.from(n, "base64");
-  return T(r);
+  const r = Buffer.from(n, "base64");
+  return N(r);
 }
-const k = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const wt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  base64ToBigint: H,
-  bigintToBase64: F,
-  bigintToBuf: p,
-  bigintToHex: m,
-  bigintToText: L,
-  bufToBigint: T,
-  bufToHex: E,
-  bufToText: I,
-  hexToBigint: w,
-  hexToBuf: h,
-  get isNative() {
-    return l;
-  },
+  FIXED_POINT_DECIMALS: x,
+  ZERO_FIXED_POINT: d,
+  addFixedPoint: H,
+  averageFixedPoint: k,
+  base64ToBigint: K,
+  bigintToBase64: Y,
+  bigintToBuf: L,
+  bigintToHex: p,
+  bigintToText: Z,
+  bufToBigint: N,
+  bufToHex: A,
+  bufToText: R,
+  compareFixedPoint: z,
+  fixedPointToBigInt: j,
+  fromFixedPoint: M,
+  hexToBigint: E,
+  hexToBuf: w,
   parseHex: a,
-  textToBigint: O,
-  textToBuf: y,
-  toBigIntBE: R,
-  toBigIntLE: v,
-  toBufferBE: N,
-  toBufferLE: U,
-  validateBigIntBuffer: A
-}, Symbol.toStringTag, { value: "Module" }));
-let s, M = !1;
+  subtractFixedPoint: W,
+  textToBigint: G,
+  textToBuf: U,
+  toBigIntBE: C,
+  toBigIntLE: _,
+  toBigIntValue: s,
+  toBufferBE: X,
+  toBufferLE: J,
+  toFixedPoint: V,
+  validateBigIntBuffer: q
+}, Symbol.toStringTag, { value: "Module" })), Q = typeof Buffer.prototype.readBigUInt64LE == "function", tt = typeof Buffer.prototype.readBigUInt64BE == "function", et = typeof Buffer.prototype.writeBigUInt64LE == "function", nt = typeof Buffer.prototype.writeBigUInt64BE == "function", rt = Q ? (t, e) => t.readBigUInt64LE(e) : (t, e) => {
+  let n = 0n;
+  for (let r = 7; r >= 0; r--)
+    n = (n << 8n) + BigInt(t[e + r]);
+  return n;
+}, it = tt ? (t, e) => t.readBigUInt64BE(e) : (t, e) => {
+  let n = 0n;
+  for (let r = 0; r < 8; r++)
+    n = (n << 8n) + BigInt(t[e + r]);
+  return n;
+}, ot = et ? (t, e, n) => {
+  t.writeBigUInt64LE(n, e);
+} : (t, e, n) => {
+  let r = n;
+  for (let i = 0; i < 8; i++)
+    t[e + i] = Number(r & 0xffn), r >>= 8n;
+}, ft = nt ? (t, e, n) => {
+  t.writeBigUInt64BE(n, e);
+} : (t, e, n) => {
+  let r = n;
+  for (let i = 7; i >= 0; i--)
+    t[e + i] = Number(r & 0xffn), r >>= 8n;
+}, st = (t) => {
+  let e = 0n, n = 1n;
+  const r = t.length, i = r & 7;
+  for (let o = 0; o < i; o++)
+    e += BigInt(t[o]) * n, n <<= 8n;
+  for (let o = i; o < r; o += 8) {
+    const c = rt(t, o);
+    e += c * n, n <<= 64n;
+  }
+  return e;
+}, ut = (t) => {
+  const e = t.length;
+  if (e === 0) return 0n;
+  let n = 0n;
+  const r = e & 7;
+  let i = 0;
+  if (r !== 0)
+    for (; i < r; i++)
+      n = (n << 8n) + BigInt(t[i]);
+  for (; i < e; i += 8) {
+    const o = it(t, i);
+    n = (n << 64n) + o;
+  }
+  return n;
+}, ct = (t, e) => {
+  const n = e.length;
+  let r = t, i = 0;
+  const o = n - n % 8;
+  for (; i < o; i += 8)
+    ot(e, i, r & 0xffffffffffffffffn), r >>= 64n;
+  for (; i < n; i++)
+    e[i] = Number(r & 0xffn), r >>= 8n;
+  return e;
+}, at = (t, e) => {
+  const n = e.length;
+  let r = t, i = n;
+  const o = n & -8;
+  for (; i > o; )
+    i--, e[i] = Number(r & 0xffn), r >>= 8n;
+  for (; i > 0; i -= 8) {
+    const c = r & 0xffffffffffffffffn;
+    ft(e, i - 8, c), r >>= 64n;
+  }
+  return e;
+}, gt = (t) => {
+  if (t === 0n) return 1;
+  let e = t, n = 0;
+  for (; e > 0n; )
+    n++, e >>= 8n;
+  return n;
+}, lt = {
+  toBigInt: (t, e = !0) => e ? ut(t) : st(t),
+  fromBigInt: (t, e, n = !0) => n ? at(t, e) : ct(t, e)
+};
+let g = lt, Bt = !1;
 if (typeof window > "u")
   try {
-    s = require("bindings")("bigint_buffer"), M = s !== void 0;
-  } catch (e) {
+    const t = require("bindings")("bigint_buffer");
+    t !== void 0 && (g = t, Bt = !0);
+  } catch (t) {
     console.warn(
       "bigint: Failed to load bindings, pure JS will be used (try npm run rebuild?)",
-      e
+      t
     );
   }
-function V(e) {
-  if (typeof window < "u" || s === void 0) {
-    const t = Buffer.from(e);
-    t.reverse();
-    const n = t.toString("hex");
-    return n.length === 0 ? BigInt(0) : BigInt(`0x${n}`);
-  }
-  return s.toBigInt(e, !1);
+function dt(t) {
+  return g.toBigInt(t, !1);
 }
-function D() {
+function vt() {
   try {
-    return V(Buffer.from([1, 0])) === BigInt(1);
+    return dt(Buffer.from([1, 0])) === BigInt(1);
   } catch {
     return !1;
   }
 }
-function j(e) {
-  if (typeof window < "u" || s === void 0) {
-    const t = e.toString("hex");
-    return t.length === 0 ? BigInt(0) : BigInt(`0x${t}`);
-  }
-  return s.toBigInt(e, !0);
+function ht(t) {
+  return g.toBigInt(t, !0);
 }
-function G(e, t) {
-  if (typeof window < "u" || s === void 0) {
-    const n = e.toString(16), r = Buffer.from(
-      n.padStart(t * 2, "0").slice(0, t * 2),
-      "hex"
-    );
-    return r.reverse(), r;
-  }
-  return s.fromBigInt(e, Buffer.allocUnsafe(t), !1);
+function Tt(t, e) {
+  if (e < 0)
+    throw new RangeError("toBufferLE width must be non-negative");
+  const n = e === 0 ? Buffer.alloc(0) : Buffer.allocUnsafe(e);
+  return g.fromBigInt(t, n, !1);
 }
-function z(e, t) {
-  if (typeof window < "u" || s === void 0) {
-    const n = e.toString(16);
-    return Buffer.from(n.padStart(t * 2, "0").slice(0, t * 2), "hex");
-  }
-  return s.fromBigInt(e, Buffer.allocUnsafe(t), !0);
+function bt(t, e) {
+  if (e < 0)
+    throw new RangeError("toBufferBE width must be non-negative");
+  const n = e === 0 ? Buffer.alloc(0) : Buffer.allocUnsafe(e);
+  return g.fromBigInt(t, n, !0);
 }
-function q(e) {
-  if (e < BigInt(0))
+function mt(t) {
+  if (t < BigInt(0))
     throw new Error("bigintToBuf: negative bigint values are not supported");
-  if (e === BigInt(0))
-    return Buffer.from([0]);
-  const t = e.toString(16), n = Math.ceil(t.length / 2);
-  return z(e, n);
+  const e = gt(t);
+  return bt(t, e);
 }
-function J(e) {
-  return j(e);
+function It(t) {
+  return ht(t);
 }
-function Y(e) {
-  if (e < BigInt(0))
+function yt(t) {
+  if (t < BigInt(0))
     throw new Error("bigintToHex: negative bigint values are not supported");
-  const t = e.toString(16);
-  return t.length % 2 === 0 ? t : "0" + t;
+  const e = t.toString(16);
+  return e.length % 2 === 0 ? e : "0" + e;
 }
-function C(e) {
-  const t = e.startsWith("0x") ? e.slice(2) : e;
-  return t.length === 0 ? BigInt(0) : BigInt(`0x${t}`);
+function St(t) {
+  const e = t.startsWith("0x") ? t.slice(2) : t;
+  return e.length === 0 ? BigInt(0) : BigInt(`0x${e}`);
 }
-function K(e) {
-  return e.toString(10);
+function $t(t) {
+  return t.toString(10);
 }
-function Q(e) {
-  if (!e?.trim())
+function _t(t) {
+  if (!t?.trim())
     throw new Error("textToBigint: input string cannot be empty");
   try {
-    return BigInt(e);
-  } catch (t) {
-    throw new Error(`textToBigint: invalid decimal string "${e}" ${t instanceof Error ? t.message : String(t)}`);
+    return BigInt(t);
+  } catch (e) {
+    throw new Error(`textToBigint: invalid decimal string "${t}" ${e instanceof Error ? e.message : String(e)}`);
   }
 }
-function X(e) {
-  if (e < BigInt(0))
+function Lt(t) {
+  if (t < BigInt(0))
     throw new Error("bigintToBase64: negative bigint values are not supported");
-  return q(e).toString("base64");
+  return mt(t).toString("base64");
 }
-function ee(e) {
-  if (!e?.trim())
+function Nt(t) {
+  if (!t?.trim())
     throw new Error("base64ToBigint: input string cannot be empty");
-  const t = e.trim();
-  if (!/^[A-Za-z0-9+/]+=*$/.test(t))
+  const e = t.trim();
+  if (!/^[A-Za-z0-9+/]+=*$/.test(e))
     throw new Error("base64ToBigint: invalid base64 string format");
-  const n = Buffer.from(t, "base64");
-  return J(n);
+  const n = Buffer.from(e, "base64");
+  return It(n);
 }
 export {
-  ee as base64ToBigint,
-  X as bigintToBase64,
-  q as bigintToBuf,
-  Y as bigintToHex,
-  K as bigintToText,
-  J as bufToBigint,
-  k as conversionUtils,
-  C as hexToBigint,
-  M as isNative,
-  Q as textToBigint,
-  j as toBigIntBE,
-  V as toBigIntLE,
-  z as toBufferBE,
-  G as toBufferLE,
-  D as validateBigIntBuffer
+  Nt as base64ToBigint,
+  Lt as bigintToBase64,
+  mt as bigintToBuf,
+  yt as bigintToHex,
+  $t as bigintToText,
+  It as bufToBigint,
+  wt as conversionUtils,
+  St as hexToBigint,
+  Bt as isNative,
+  _t as textToBigint,
+  ht as toBigIntBE,
+  dt as toBigIntLE,
+  bt as toBufferBE,
+  Tt as toBufferLE,
+  vt as validateBigIntBuffer
 };