@hinkal/common 0.0.116 → 0.0.118

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/ethers/lib.esm/index.mjs

@@ -0,0 +1,40 @@
+import * as o from "./ethers.mjs";
+import { logger as i } from "./ethers.mjs";
+import { Signer as x, VoidSigner as f } from "../../@ethersproject/abstract-signer/lib.esm/index.mjs";
+import { Wallet as l } from "../../@ethersproject/wallet/lib.esm/index.mjs";
+import * as t from "../../@ethersproject/providers/lib.esm/index.mjs";
+import { getDefaultProvider as c } from "../../@ethersproject/providers/lib.esm/index.mjs";
+import { BaseContract as u, Contract as h, ContractFactory as C } from "../../@ethersproject/contracts/lib.esm/index.mjs";
+import { BigNumber as v } from "../../@ethersproject/bignumber/lib.esm/bignumber.mjs";
+import { FixedNumber as y } from "../../@ethersproject/bignumber/lib.esm/fixednumber.mjs";
+import * as e from "../../@ethersproject/constants/lib.esm/index.mjs";
+import { ErrorCode as F } from "../../@ethersproject/logger/lib.esm/index.mjs";
+import * as m from "./utils.mjs";
+import { wordlists as S } from "../../@ethersproject/wordlists/lib.esm/wordlists.mjs";
+import { version as _ } from "./_version.mjs";
+import { Wordlist as E } from "../../@ethersproject/wordlists/lib.esm/wordlist.mjs";
+try {
+  const r = window;
+  r._ethers == null && (r._ethers = o);
+} catch {
+}
+export {
+  u as BaseContract,
+  v as BigNumber,
+  h as Contract,
+  C as ContractFactory,
+  y as FixedNumber,
+  x as Signer,
+  f as VoidSigner,
+  l as Wallet,
+  E as Wordlist,
+  e as constants,
+  F as errors,
+  o as ethers,
+  c as getDefaultProvider,
+  i as logger,
+  t as providers,
+  m as utils,
+  _ as version,
+  S as wordlists
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/ethers/lib.esm/utils.mjs

@@ -0,0 +1,132 @@
+import { ConstructorFragment as a, ErrorFragment as s, EventFragment as i, FormatTypes as p, Fragment as n, FunctionFragment as m, ParamType as f } from "../../@ethersproject/abi/lib.esm/fragments.mjs";
+import { AbiCoder as d, defaultAbiCoder as x } from "../../@ethersproject/abi/lib.esm/abi-coder.mjs";
+import { Indexed as g, Interface as h, LogDescription as l, TransactionDescription as u } from "../../@ethersproject/abi/lib.esm/interface.mjs";
+import { getAddress as T, getContractAddress as A, getCreate2Address as E, getIcapAddress as P, isAddress as k } from "../../@ethersproject/address/lib.esm/index.mjs";
+import * as e from "../../@ethersproject/base64/lib.esm/index.mjs";
+import { Base58 as D } from "../../@ethersproject/basex/lib.esm/index.mjs";
+import { arrayify as U, concat as B, hexConcat as b, hexDataLength as v, hexDataSlice as L, hexStripZeros as z, hexValue as K, hexZeroPad as M, hexlify as R, isBytes as H, isBytesLike as I, isHexString as N, joinSignature as V, splitSignature as Z, stripZeros as _, zeroPad as J } from "../../@ethersproject/bytes/lib.esm/index.mjs";
+import { id as w } from "../../@ethersproject/hash/lib.esm/id.mjs";
+import { dnsEncode as W, isValidName as $, namehash as q } from "../../@ethersproject/hash/lib.esm/namehash.mjs";
+import { hashMessage as Q } from "../../@ethersproject/hash/lib.esm/message.mjs";
+import { TypedDataEncoder as Y } from "../../@ethersproject/hash/lib.esm/typed-data.mjs";
+import { HDNode as re, defaultPath as oe, entropyToMnemonic as te, getAccountPath as ae, isValidMnemonic as se, mnemonicToEntropy as ie, mnemonicToSeed as pe } from "../../@ethersproject/hdnode/lib.esm/index.mjs";
+import { getJsonWalletAddress as me } from "../../@ethersproject/json-wallets/lib.esm/inspect.mjs";
+import { keccak256 as ce } from "../../@ethersproject/keccak256/lib.esm/index.mjs";
+import { Logger as xe } from "../../@ethersproject/logger/lib.esm/index.mjs";
+import { computeHmac as ge, ripemd160 as he, sha256 as le, sha512 as ue } from "../../@ethersproject/sha2/lib.esm/sha2.mjs";
+import { SupportedAlgorithm as Te } from "../../@ethersproject/sha2/lib.esm/types.mjs";
+import { keccak256 as Ee, pack as Pe, sha256 as ke } from "../../@ethersproject/solidity/lib.esm/index.mjs";
+import { checkProperties as De, deepCopy as Fe, defineReadOnly as Ue, getStatic as Be, resolveProperties as be, shallowCopy as ve } from "../../@ethersproject/properties/lib.esm/index.mjs";
+import * as r from "../../@ethersproject/rlp/lib.esm/index.mjs";
+import { SigningKey as ze, computePublicKey as Ke, recoverPublicKey as Me } from "../../@ethersproject/signing-key/lib.esm/index.mjs";
+import { formatBytes32String as He, parseBytes32String as Ie } from "../../@ethersproject/strings/lib.esm/bytes32.mjs";
+import { nameprep as Ve } from "../../@ethersproject/strings/lib.esm/idna.mjs";
+import { UnicodeNormalizationForm as _e, Utf8ErrorFuncs as Je, Utf8ErrorReason as je, _toEscapedUtf8String as we, toUtf8Bytes as Oe, toUtf8CodePoints as We, toUtf8String as $e } from "../../@ethersproject/strings/lib.esm/utf8.mjs";
+import { TransactionTypes as Ge, accessListify as Qe, computeAddress as Xe, parse as Ye, recoverAddress as er, serialize as rr } from "../../@ethersproject/transactions/lib.esm/index.mjs";
+import { commify as tr, formatEther as ar, formatUnits as sr, parseEther as ir, parseUnits as pr } from "../../@ethersproject/units/lib.esm/index.mjs";
+import { verifyMessage as mr, verifyTypedData as fr } from "../../@ethersproject/wallet/lib.esm/index.mjs";
+import { _fetchData as dr, fetchJson as xr, poll as yr } from "../../@ethersproject/web/lib.esm/index.mjs";
+import { checkResultErrors as hr } from "../../@ethersproject/abi/lib.esm/coders/abstract-coder.mjs";
+import { randomBytes as ur } from "../../@ethersproject/random/lib.esm/random.mjs";
+import { shuffled as Tr } from "../../@ethersproject/random/lib.esm/shuffle.mjs";
+export {
+  d as AbiCoder,
+  a as ConstructorFragment,
+  s as ErrorFragment,
+  i as EventFragment,
+  p as FormatTypes,
+  n as Fragment,
+  m as FunctionFragment,
+  re as HDNode,
+  g as Indexed,
+  h as Interface,
+  l as LogDescription,
+  xe as Logger,
+  f as ParamType,
+  r as RLP,
+  ze as SigningKey,
+  Te as SupportedAlgorithm,
+  u as TransactionDescription,
+  Ge as TransactionTypes,
+  _e as UnicodeNormalizationForm,
+  Je as Utf8ErrorFuncs,
+  je as Utf8ErrorReason,
+  Y as _TypedDataEncoder,
+  dr as _fetchData,
+  we as _toEscapedUtf8String,
+  Qe as accessListify,
+  U as arrayify,
+  D as base58,
+  e as base64,
+  De as checkProperties,
+  hr as checkResultErrors,
+  tr as commify,
+  Xe as computeAddress,
+  ge as computeHmac,
+  Ke as computePublicKey,
+  B as concat,
+  Fe as deepCopy,
+  x as defaultAbiCoder,
+  oe as defaultPath,
+  Ue as defineReadOnly,
+  W as dnsEncode,
+  te as entropyToMnemonic,
+  xr as fetchJson,
+  He as formatBytes32String,
+  ar as formatEther,
+  sr as formatUnits,
+  ae as getAccountPath,
+  T as getAddress,
+  A as getContractAddress,
+  E as getCreate2Address,
+  P as getIcapAddress,
+  me as getJsonWalletAddress,
+  Be as getStatic,
+  Q as hashMessage,
+  b as hexConcat,
+  v as hexDataLength,
+  L as hexDataSlice,
+  z as hexStripZeros,
+  K as hexValue,
+  M as hexZeroPad,
+  R as hexlify,
+  w as id,
+  k as isAddress,
+  H as isBytes,
+  I as isBytesLike,
+  N as isHexString,
+  se as isValidMnemonic,
+  $ as isValidName,
+  V as joinSignature,
+  ce as keccak256,
+  ie as mnemonicToEntropy,
+  pe as mnemonicToSeed,
+  q as namehash,
+  Ve as nameprep,
+  Ie as parseBytes32String,
+  ir as parseEther,
+  Ye as parseTransaction,
+  pr as parseUnits,
+  yr as poll,
+  ur as randomBytes,
+  er as recoverAddress,
+  Me as recoverPublicKey,
+  be as resolveProperties,
+  he as ripemd160,
+  rr as serializeTransaction,
+  le as sha256,
+  ue as sha512,
+  ve as shallowCopy,
+  Tr as shuffled,
+  Ee as solidityKeccak256,
+  Pe as solidityPack,
+  ke as soliditySha256,
+  Z as splitSignature,
+  _ as stripZeros,
+  Oe as toUtf8Bytes,
+  We as toUtf8CodePoints,
+  $e as toUtf8String,
+  mr as verifyMessage,
+  fr as verifyTypedData,
+  J as zeroPad
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/events/events.mjs

@@ -0,0 +1,229 @@
+import { __module as p } from "../../../../../../../_virtual/events2.mjs";
+var a = typeof Reflect == "object" ? Reflect : null, h = a && typeof a.apply == "function" ? a.apply : function(e, n, r) {
+  return Function.prototype.apply.call(e, n, r);
+}, l;
+a && typeof a.ownKeys == "function" ? l = a.ownKeys : Object.getOwnPropertySymbols ? l = function(e) {
+  return Object.getOwnPropertyNames(e).concat(Object.getOwnPropertySymbols(e));
+} : l = function(e) {
+  return Object.getOwnPropertyNames(e);
+};
+function C(t) {
+  console && console.warn && console.warn(t);
+}
+var L = Number.isNaN || function(e) {
+  return e !== e;
+};
+function o() {
+  o.init.call(this);
+}
+p.exports = o;
+p.exports.once = M;
+o.EventEmitter = o;
+o.prototype._events = void 0;
+o.prototype._eventsCount = 0;
+o.prototype._maxListeners = void 0;
+var m = 10;
+function v(t) {
+  if (typeof t != "function")
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof t);
+}
+Object.defineProperty(o, "defaultMaxListeners", {
+  enumerable: !0,
+  get: function() {
+    return m;
+  },
+  set: function(t) {
+    if (typeof t != "number" || t < 0 || L(t))
+      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + t + ".");
+    m = t;
+  }
+});
+o.init = function() {
+  (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
+};
+o.prototype.setMaxListeners = function(e) {
+  if (typeof e != "number" || e < 0 || L(e))
+    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + e + ".");
+  return this._maxListeners = e, this;
+};
+function y(t) {
+  return t._maxListeners === void 0 ? o.defaultMaxListeners : t._maxListeners;
+}
+o.prototype.getMaxListeners = function() {
+  return y(this);
+};
+o.prototype.emit = function(e) {
+  for (var n = [], r = 1; r < arguments.length; r++)
+    n.push(arguments[r]);
+  var i = e === "error", f = this._events;
+  if (f !== void 0)
+    i = i && f.error === void 0;
+  else if (!i)
+    return !1;
+  if (i) {
+    var s;
+    if (n.length > 0 && (s = n[0]), s instanceof Error)
+      throw s;
+    var u = new Error("Unhandled error." + (s ? " (" + s.message + ")" : ""));
+    throw u.context = s, u;
+  }
+  var c = f[e];
+  if (c === void 0)
+    return !1;
+  if (typeof c == "function")
+    h(c, this, n);
+  else
+    for (var d = c.length, x = E(c, d), r = 0; r < d; ++r)
+      h(x[r], this, n);
+  return !0;
+};
+function g(t, e, n, r) {
+  var i, f, s;
+  if (v(n), f = t._events, f === void 0 ? (f = t._events = /* @__PURE__ */ Object.create(null), t._eventsCount = 0) : (f.newListener !== void 0 && (t.emit(
+    "newListener",
+    e,
+    n.listener ? n.listener : n
+  ), f = t._events), s = f[e]), s === void 0)
+    s = f[e] = n, ++t._eventsCount;
+  else if (typeof s == "function" ? s = f[e] = r ? [n, s] : [s, n] : r ? s.unshift(n) : s.push(n), i = y(t), i > 0 && s.length > i && !s.warned) {
+    s.warned = !0;
+    var u = new Error("Possible EventEmitter memory leak detected. " + s.length + " " + String(e) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+    u.name = "MaxListenersExceededWarning", u.emitter = t, u.type = e, u.count = s.length, C(u);
+  }
+  return t;
+}
+o.prototype.addListener = function(e, n) {
+  return g(this, e, n, !1);
+};
+o.prototype.on = o.prototype.addListener;
+o.prototype.prependListener = function(e, n) {
+  return g(this, e, n, !0);
+};
+function j() {
+  if (!this.fired)
+    return this.target.removeListener(this.type, this.wrapFn), this.fired = !0, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);
+}
+function _(t, e, n) {
+  var r = { fired: !1, wrapFn: void 0, target: t, type: e, listener: n }, i = j.bind(r);
+  return i.listener = n, r.wrapFn = i, i;
+}
+o.prototype.once = function(e, n) {
+  return v(n), this.on(e, _(this, e, n)), this;
+};
+o.prototype.prependOnceListener = function(e, n) {
+  return v(n), this.prependListener(e, _(this, e, n)), this;
+};
+o.prototype.removeListener = function(e, n) {
+  var r, i, f, s, u;
+  if (v(n), i = this._events, i === void 0)
+    return this;
+  if (r = i[e], r === void 0)
+    return this;
+  if (r === n || r.listener === n)
+    --this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : (delete i[e], i.removeListener && this.emit("removeListener", e, r.listener || n));
+  else if (typeof r != "function") {
+    for (f = -1, s = r.length - 1; s >= 0; s--)
+      if (r[s] === n || r[s].listener === n) {
+        u = r[s].listener, f = s;
+        break;
+      }
+    if (f < 0)
+      return this;
+    f === 0 ? r.shift() : R(r, f), r.length === 1 && (i[e] = r[0]), i.removeListener !== void 0 && this.emit("removeListener", e, u || n);
+  }
+  return this;
+};
+o.prototype.off = o.prototype.removeListener;
+o.prototype.removeAllListeners = function(e) {
+  var n, r, i;
+  if (r = this._events, r === void 0)
+    return this;
+  if (r.removeListener === void 0)
+    return arguments.length === 0 ? (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0) : r[e] !== void 0 && (--this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : delete r[e]), this;
+  if (arguments.length === 0) {
+    var f = Object.keys(r), s;
+    for (i = 0; i < f.length; ++i)
+      s = f[i], s !== "removeListener" && this.removeAllListeners(s);
+    return this.removeAllListeners("removeListener"), this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0, this;
+  }
+  if (n = r[e], typeof n == "function")
+    this.removeListener(e, n);
+  else if (n !== void 0)
+    for (i = n.length - 1; i >= 0; i--)
+      this.removeListener(e, n[i]);
+  return this;
+};
+function w(t, e, n) {
+  var r = t._events;
+  if (r === void 0)
+    return [];
+  var i = r[e];
+  return i === void 0 ? [] : typeof i == "function" ? n ? [i.listener || i] : [i] : n ? N(i) : E(i, i.length);
+}
+o.prototype.listeners = function(e) {
+  return w(this, e, !0);
+};
+o.prototype.rawListeners = function(e) {
+  return w(this, e, !1);
+};
+o.listenerCount = function(t, e) {
+  return typeof t.listenerCount == "function" ? t.listenerCount(e) : b.call(t, e);
+};
+o.prototype.listenerCount = b;
+function b(t) {
+  var e = this._events;
+  if (e !== void 0) {
+    var n = e[t];
+    if (typeof n == "function")
+      return 1;
+    if (n !== void 0)
+      return n.length;
+  }
+  return 0;
+}
+o.prototype.eventNames = function() {
+  return this._eventsCount > 0 ? l(this._events) : [];
+};
+function E(t, e) {
+  for (var n = new Array(e), r = 0; r < e; ++r)
+    n[r] = t[r];
+  return n;
+}
+function R(t, e) {
+  for (; e + 1 < t.length; e++)
+    t[e] = t[e + 1];
+  t.pop();
+}
+function N(t) {
+  for (var e = new Array(t.length), n = 0; n < e.length; ++n)
+    e[n] = t[n].listener || t[n];
+  return e;
+}
+function M(t, e) {
+  return new Promise(function(n, r) {
+    function i(s) {
+      t.removeListener(e, f), r(s);
+    }
+    function f() {
+      typeof t.removeListener == "function" && t.removeListener("error", i), n([].slice.call(arguments));
+    }
+    O(t, e, f, { once: !0 }), e !== "error" && A(t, i, { once: !0 });
+  });
+}
+function A(t, e, n) {
+  typeof t.on == "function" && O(t, "error", e, n);
+}
+function O(t, e, n, r) {
+  if (typeof t.on == "function")
+    r.once ? t.once(e, n) : t.on(e, n);
+  else if (typeof t.addEventListener == "function")
+    t.addEventListener(e, function i(f) {
+      r.once && t.removeEventListener(e, i), n(f);
+    });
+  else
+    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof t);
+}
+var T = p.exports;
+export {
+  T as e
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/fastfile/src/bigmemfile.mjs

@@ -0,0 +1,111 @@
+function g(d) {
+  const t = d.initialSize || 0, e = new y();
+  e.o = d;
+  const n = t ? Math.floor((t - 1) / 4194304) + 1 : 0;
+  e.o.data = [];
+  for (let i = 0; i < n - 1; i++)
+    e.o.data.push(new Uint8Array(4194304));
+  return n && e.o.data.push(new Uint8Array(t - 4194304 * (n - 1))), e.totalSize = 0, e.readOnly = !1, e.pos = 0, e;
+}
+function A(d) {
+  const t = new y();
+  return t.o = d, t.totalSize = (d.data.length - 1) * 4194304 + d.data[d.data.length - 1].byteLength, t.readOnly = !0, t.pos = 0, t;
+}
+const h = new Uint8Array(4), w = new DataView(h.buffer), u = new Uint8Array(8), E = new DataView(u.buffer);
+class y {
+  constructor() {
+    this.pageSize = 16384;
+  }
+  _resizeIfNeeded(t) {
+    if (t <= this.totalSize)
+      return;
+    if (this.readOnly)
+      throw new Error("Reading out of file bounds");
+    const e = Math.floor((t - 1) / 4194304) + 1;
+    for (let n = Math.max(this.o.data.length - 1, 0); n < e; n++) {
+      const i = n < e - 1 ? 4194304 : t - (e - 1) * 4194304, s = new Uint8Array(i);
+      n == this.o.data.length - 1 && s.set(this.o.data[n]), this.o.data[n] = s;
+    }
+    this.totalSize = t;
+  }
+  async write(t, e) {
+    const n = this;
+    if (typeof e > "u" && (e = n.pos), this.readOnly)
+      throw new Error("Writing a read only file");
+    this._resizeIfNeeded(e + t.byteLength);
+    let s = Math.floor(e / 4194304), f = e % 4194304, r = t.byteLength;
+    for (; r > 0; ) {
+      const a = f + r > 4194304 ? 4194304 - f : r, o = t.slice(t.byteLength - r, t.byteLength - r + a);
+      new Uint8Array(n.o.data[s].buffer, f, a).set(o), r = r - a, s++, f = 0;
+    }
+    this.pos = e + t.byteLength;
+  }
+  async readToBuffer(t, e, n, i) {
+    const s = this;
+    if (typeof i > "u" && (i = s.pos), this.readOnly && i + n > this.totalSize)
+      throw new Error("Reading out of bounds");
+    this._resizeIfNeeded(i + n);
+    let r = Math.floor(i / 4194304), a = i % 4194304, o = n;
+    for (; o > 0; ) {
+      const c = a + o > 4194304 ? 4194304 - a : o, l = new Uint8Array(s.o.data[r].buffer, a, c);
+      t.set(l, e + n - o), o = o - c, r++, a = 0;
+    }
+    this.pos = i + n;
+  }
+  async read(t, e) {
+    const n = this, i = new Uint8Array(t);
+    return await n.readToBuffer(i, 0, t, e), i;
+  }
+  close() {
+  }
+  async discard() {
+  }
+  async writeULE32(t, e) {
+    const n = this;
+    w.setUint32(0, t, !0), await n.write(h, e);
+  }
+  async writeUBE32(t, e) {
+    const n = this;
+    w.setUint32(0, t, !1), await n.write(h, e);
+  }
+  async writeULE64(t, e) {
+    const n = this;
+    E.setUint32(0, t & 4294967295, !0), E.setUint32(4, Math.floor(t / 4294967296), !0), await n.write(u, e);
+  }
+  async readULE32(t) {
+    const n = await this.read(4, t);
+    return new Uint32Array(n.buffer)[0];
+  }
+  async readUBE32(t) {
+    const n = await this.read(4, t);
+    return new DataView(n.buffer).getUint32(0, !1);
+  }
+  async readULE64(t) {
+    const n = await this.read(8, t), i = new Uint32Array(n.buffer);
+    return i[1] * 4294967296 + i[0];
+  }
+  async readString(t) {
+    const e = this, n = 2048;
+    let i = typeof t > "u" ? e.pos : t;
+    if (i > this.totalSize) {
+      if (this.readOnly)
+        throw new Error("Reading out of bounds");
+      this._resizeIfNeeded(t);
+    }
+    let s = !1, f = "";
+    for (; !s; ) {
+      let r = Math.floor(i / 4194304), a = i % 4194304;
+      if (e.o.data[r] === void 0)
+        throw new Error("ERROR");
+      let o = Math.min(n, e.o.data[r].length - a);
+      const c = new Uint8Array(e.o.data[r].buffer, a, o);
+      let l = c.findIndex((S) => S === 0);
+      s = l !== -1, s ? (f += new TextDecoder().decode(c.slice(0, l)), e.pos = r * 4194304 + a + l + 1) : (f += new TextDecoder().decode(c), e.pos = r * 4194304 + a + c.length), i = e.pos;
+    }
+    return f;
+  }
+}
+export {
+  g as createNew,
+  A as readExisting
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/fastfile/src/fastfile.mjs

@@ -0,0 +1,47 @@
+import { open as a } from "./osfile.mjs";
+import { createNew as s, readExisting as p } from "./memfile.mjs";
+import { createNew as c, readExisting as m } from "./bigmemfile.mjs";
+import { O_TRUNC as y, O_CREAT as l, O_RDWR as u, O_RDONLY as g } from "../../../../../../../../@virtual_vite-plugin-virtual/constants.mjs";
+const n = 65536, f = 8192;
+async function N(e, t, i) {
+  if (typeof e == "string" && (e = {
+    type: "file",
+    fileName: e,
+    cacheSize: t || n,
+    pageSize: i || f
+  }), e.type == "file")
+    return await a(e.fileName, y | l | u, e.cacheSize, e.pageSize);
+  if (e.type == "mem")
+    return s(e);
+  if (e.type == "bigMem")
+    return c(e);
+  throw new Error("Invalid FastFile type: " + e.type);
+}
+async function z(e, t, i) {
+  if (e instanceof Uint8Array && (e = {
+    type: "mem",
+    data: e
+  }), process.browser ? typeof e == "string" && (e = {
+    type: "mem",
+    data: await fetch(e).then(function(r) {
+      return r.arrayBuffer();
+    }).then(function(r) {
+      return new Uint8Array(r);
+    })
+  }) : typeof e == "string" && (e = {
+    type: "file",
+    fileName: e,
+    cacheSize: t || n,
+    pageSize: i || f
+  }), e.type == "file")
+    return await a(e.fileName, g, e.cacheSize, e.pageSize);
+  if (e.type == "mem")
+    return await p(e);
+  if (e.type == "bigMem")
+    return await m(e);
+  throw new Error("Invalid FastFile type: " + e.type);
+}
+export {
+  N as createOverride,
+  z as readExisting
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/fastfile/src/memfile.mjs

@@ -0,0 +1,89 @@
+function y(n) {
+  const t = n.initialSize || 1048576, e = new h();
+  return e.o = n, e.o.data = new Uint8Array(t), e.allocSize = t, e.totalSize = 0, e.readOnly = !1, e.pos = 0, e;
+}
+function u(n) {
+  const t = new h();
+  return t.o = n, t.allocSize = n.data.byteLength, t.totalSize = n.data.byteLength, t.readOnly = !0, t.pos = 0, t;
+}
+const o = new Uint8Array(4), c = new DataView(o.buffer), l = new Uint8Array(8), d = new DataView(l.buffer);
+class h {
+  constructor() {
+    this.pageSize = 16384;
+  }
+  _resizeIfNeeded(t) {
+    if (t > this.allocSize) {
+      const e = Math.max(
+        this.allocSize + 1048576,
+        Math.floor(this.allocSize * 1.1),
+        t
+      ), i = new Uint8Array(e);
+      i.set(this.o.data), this.o.data = i, this.allocSize = e;
+    }
+  }
+  async write(t, e) {
+    if (typeof e > "u" && (e = this.pos), this.readOnly)
+      throw new Error("Writing a read only file");
+    this._resizeIfNeeded(e + t.byteLength), this.o.data.set(t.slice(), e), e + t.byteLength > this.totalSize && (this.totalSize = e + t.byteLength), this.pos = e + t.byteLength;
+  }
+  async readToBuffer(t, e, i, a) {
+    if (typeof a > "u" && (a = this.pos), this.readOnly && a + i > this.totalSize)
+      throw new Error("Reading out of bounds");
+    this._resizeIfNeeded(a + i);
+    const r = new Uint8Array(this.o.data.buffer, this.o.data.byteOffset + a, i);
+    t.set(r, e), this.pos = a + i;
+  }
+  async read(t, e) {
+    const i = this, a = new Uint8Array(t);
+    return await i.readToBuffer(a, 0, t, e), a;
+  }
+  close() {
+    this.o.data.byteLength != this.totalSize && (this.o.data = this.o.data.slice(0, this.totalSize));
+  }
+  async discard() {
+  }
+  async writeULE32(t, e) {
+    const i = this;
+    c.setUint32(0, t, !0), await i.write(o, e);
+  }
+  async writeUBE32(t, e) {
+    const i = this;
+    c.setUint32(0, t, !1), await i.write(o, e);
+  }
+  async writeULE64(t, e) {
+    const i = this;
+    d.setUint32(0, t & 4294967295, !0), d.setUint32(4, Math.floor(t / 4294967296), !0), await i.write(l, e);
+  }
+  async readULE32(t) {
+    const i = await this.read(4, t);
+    return new Uint32Array(i.buffer)[0];
+  }
+  async readUBE32(t) {
+    const i = await this.read(4, t);
+    return new DataView(i.buffer).getUint32(0, !1);
+  }
+  async readULE64(t) {
+    const i = await this.read(8, t), a = new Uint32Array(i.buffer);
+    return a[1] * 4294967296 + a[0];
+  }
+  async readString(t) {
+    const e = this;
+    let i = typeof t > "u" ? e.pos : t;
+    if (i > this.totalSize) {
+      if (this.readOnly)
+        throw new Error("Reading out of bounds");
+      this._resizeIfNeeded(t);
+    }
+    const a = new Uint8Array(
+      e.o.data.buffer,
+      i,
+      this.totalSize - i
+    );
+    let s = a.findIndex((w) => w === 0), r = s !== -1, f = "";
+    return r ? (f = new TextDecoder().decode(a.slice(0, s)), e.pos = i + s + 1) : e.pos = i, f;
+  }
+}
+export {
+  y as createNew,
+  u as readExisting
+};