@hinkal/common 0.0.116 → 0.0.118

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/util/support/isBufferBrowser.mjs

@@ -0,0 +1,6 @@
+var t = function(f) {
+  return f && typeof f == "object" && typeof f.copy == "function" && typeof f.fill == "function" && typeof f.readUInt8 == "function";
+};
+export {
+  t as i
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/util/support/types.mjs

@@ -0,0 +1,189 @@
+import { __exports as ir } from "../../../../../../../../_virtual/types5.mjs";
+import { i as tr } from "../../is-arguments/index.mjs";
+import { i as ar } from "../../is-generator-function/index.mjs";
+import { w as fr } from "../../which-typed-array/index.mjs";
+import { i as or } from "../../is-typed-array/index.mjs";
+(function(n) {
+  var M = tr, O = ar, i = fr, b = or;
+  function t(r) {
+    return r.call.bind(r);
+  }
+  var S = typeof BigInt < "u", p = typeof Symbol < "u", e = t(Object.prototype.toString), h = t(Number.prototype.valueOf), W = t(String.prototype.valueOf), U = t(Boolean.prototype.valueOf);
+  if (S)
+    var V = t(BigInt.prototype.valueOf);
+  if (p)
+    var T = t(Symbol.prototype.valueOf);
+  function a(r, er) {
+    if (typeof r != "object")
+      return !1;
+    try {
+      return er(r), !0;
+    } catch {
+      return !1;
+    }
+  }
+  n.isArgumentsObject = M, n.isGeneratorFunction = O, n.isTypedArray = b;
+  function F(r) {
+    return typeof Promise < "u" && r instanceof Promise || r !== null && typeof r == "object" && typeof r.then == "function" && typeof r.catch == "function";
+  }
+  n.isPromise = F;
+  function P(r) {
+    return typeof ArrayBuffer < "u" && ArrayBuffer.isView ? ArrayBuffer.isView(r) : b(r) || B(r);
+  }
+  n.isArrayBufferView = P;
+  function v(r) {
+    return i(r) === "Uint8Array";
+  }
+  n.isUint8Array = v;
+  function D(r) {
+    return i(r) === "Uint8ClampedArray";
+  }
+  n.isUint8ClampedArray = D;
+  function C(r) {
+    return i(r) === "Uint16Array";
+  }
+  n.isUint16Array = C;
+  function G(r) {
+    return i(r) === "Uint32Array";
+  }
+  n.isUint32Array = G;
+  function N(r) {
+    return i(r) === "Int8Array";
+  }
+  n.isInt8Array = N;
+  function E(r) {
+    return i(r) === "Int16Array";
+  }
+  n.isInt16Array = E;
+  function $(r) {
+    return i(r) === "Int32Array";
+  }
+  n.isInt32Array = $;
+  function _(r) {
+    return i(r) === "Float32Array";
+  }
+  n.isFloat32Array = _;
+  function q(r) {
+    return i(r) === "Float64Array";
+  }
+  n.isFloat64Array = q;
+  function z(r) {
+    return i(r) === "BigInt64Array";
+  }
+  n.isBigInt64Array = z;
+  function H(r) {
+    return i(r) === "BigUint64Array";
+  }
+  n.isBigUint64Array = H;
+  function o(r) {
+    return e(r) === "[object Map]";
+  }
+  o.working = typeof Map < "u" && o(/* @__PURE__ */ new Map());
+  function J(r) {
+    return typeof Map > "u" ? !1 : o.working ? o(r) : r instanceof Map;
+  }
+  n.isMap = J;
+  function u(r) {
+    return e(r) === "[object Set]";
+  }
+  u.working = typeof Set < "u" && u(/* @__PURE__ */ new Set());
+  function K(r) {
+    return typeof Set > "u" ? !1 : u.working ? u(r) : r instanceof Set;
+  }
+  n.isSet = K;
+  function y(r) {
+    return e(r) === "[object WeakMap]";
+  }
+  y.working = typeof WeakMap < "u" && y(/* @__PURE__ */ new WeakMap());
+  function L(r) {
+    return typeof WeakMap > "u" ? !1 : y.working ? y(r) : r instanceof WeakMap;
+  }
+  n.isWeakMap = L;
+  function A(r) {
+    return e(r) === "[object WeakSet]";
+  }
+  A.working = typeof WeakSet < "u" && A(/* @__PURE__ */ new WeakSet());
+  function Q(r) {
+    return A(r);
+  }
+  n.isWeakSet = Q;
+  function c(r) {
+    return e(r) === "[object ArrayBuffer]";
+  }
+  c.working = typeof ArrayBuffer < "u" && c(new ArrayBuffer());
+  function g(r) {
+    return typeof ArrayBuffer > "u" ? !1 : c.working ? c(r) : r instanceof ArrayBuffer;
+  }
+  n.isArrayBuffer = g;
+  function s(r) {
+    return e(r) === "[object DataView]";
+  }
+  s.working = typeof ArrayBuffer < "u" && typeof DataView < "u" && s(new DataView(new ArrayBuffer(1), 0, 1));
+  function B(r) {
+    return typeof DataView > "u" ? !1 : s.working ? s(r) : r instanceof DataView;
+  }
+  n.isDataView = B;
+  var d = typeof SharedArrayBuffer < "u" ? SharedArrayBuffer : void 0;
+  function f(r) {
+    return e(r) === "[object SharedArrayBuffer]";
+  }
+  function w(r) {
+    return typeof d > "u" ? !1 : (typeof f.working > "u" && (f.working = f(new d())), f.working ? f(r) : r instanceof d);
+  }
+  n.isSharedArrayBuffer = w;
+  function R(r) {
+    return e(r) === "[object AsyncFunction]";
+  }
+  n.isAsyncFunction = R;
+  function X(r) {
+    return e(r) === "[object Map Iterator]";
+  }
+  n.isMapIterator = X;
+  function Y(r) {
+    return e(r) === "[object Set Iterator]";
+  }
+  n.isSetIterator = Y;
+  function Z(r) {
+    return e(r) === "[object Generator]";
+  }
+  n.isGeneratorObject = Z;
+  function x(r) {
+    return e(r) === "[object WebAssembly.Module]";
+  }
+  n.isWebAssemblyCompiledModule = x;
+  function l(r) {
+    return a(r, h);
+  }
+  n.isNumberObject = l;
+  function m(r) {
+    return a(r, W);
+  }
+  n.isStringObject = m;
+  function j(r) {
+    return a(r, U);
+  }
+  n.isBooleanObject = j;
+  function k(r) {
+    return S && a(r, V);
+  }
+  n.isBigIntObject = k;
+  function I(r) {
+    return p && a(r, T);
+  }
+  n.isSymbolObject = I;
+  function rr(r) {
+    return l(r) || m(r) || j(r) || k(r) || I(r);
+  }
+  n.isBoxedPrimitive = rr;
+  function nr(r) {
+    return typeof Uint8Array < "u" && (g(r) || w(r));
+  }
+  n.isAnyArrayBuffer = nr, ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(function(r) {
+    Object.defineProperty(n, r, {
+      enumerable: !1,
+      value: function() {
+        throw new Error(r + " is not supported in userland");
+      }
+    });
+  });
+})(ir);

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

@@ -0,0 +1,399 @@
+import { __exports as Y } from "../../../../../../../_virtual/util.mjs";
+import "./support/types.mjs";
+import { i as x } from "./support/isBufferBrowser.mjs";
+import { i as ee } from "../inherits/inherits_browser.mjs";
+import { __exports as re } from "../../../../../../../_virtual/types5.mjs";
+(function(n) {
+  var $ = Object.getOwnPropertyDescriptors || function(r) {
+    for (var t = Object.keys(r), i = {}, s = 0; s < t.length; s++)
+      i[t[s]] = Object.getOwnPropertyDescriptor(r, t[s]);
+    return i;
+  }, U = /%[sdj%]/g;
+  n.format = function(e) {
+    if (!w(e)) {
+      for (var r = [], t = 0; t < arguments.length; t++)
+        r.push(l(arguments[t]));
+      return r.join(" ");
+    }
+    for (var t = 1, i = arguments, s = i.length, u = String(e).replace(U, function(f) {
+      if (f === "%%")
+        return "%";
+      if (t >= s)
+        return f;
+      switch (f) {
+        case "%s":
+          return String(i[t++]);
+        case "%d":
+          return Number(i[t++]);
+        case "%j":
+          try {
+            return JSON.stringify(i[t++]);
+          } catch {
+            return "[Circular]";
+          }
+        default:
+          return f;
+      }
+    }), o = i[t]; t < s; o = i[++t])
+      O(o) || !g(o) ? u += " " + o : u += " " + l(o);
+    return u;
+  }, n.deprecate = function(e, r) {
+    if (typeof process < "u" && process.noDeprecation === !0)
+      return e;
+    if (typeof process > "u")
+      return function() {
+        return n.deprecate(e, r).apply(this, arguments);
+      };
+    var t = !1;
+    function i() {
+      if (!t) {
+        if (process.throwDeprecation)
+          throw new Error(r);
+        process.traceDeprecation ? console.trace(r) : console.error(r), t = !0;
+      }
+      return e.apply(this, arguments);
+    }
+    return i;
+  };
+  var b = {}, A = /^$/;
+  if (process.env.NODE_DEBUG) {
+    var P = process.env.NODE_DEBUG;
+    P = P.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase(), A = new RegExp("^" + P + "$", "i");
+  }
+  n.debuglog = function(e) {
+    if (e = e.toUpperCase(), !b[e])
+      if (A.test(e)) {
+        var r = process.pid;
+        b[e] = function() {
+          var t = n.format.apply(n, arguments);
+          console.error("%s %d: %s", e, r, t);
+        };
+      } else
+        b[e] = function() {
+        };
+    return b[e];
+  };
+  function l(e, r) {
+    var t = {
+      seen: [],
+      stylize: B
+    };
+    return arguments.length >= 3 && (t.depth = arguments[2]), arguments.length >= 4 && (t.colors = arguments[3]), D(r) ? t.showHidden = r : r && n._extend(t, r), p(t.showHidden) && (t.showHidden = !1), p(t.depth) && (t.depth = 2), p(t.colors) && (t.colors = !1), p(t.customInspect) && (t.customInspect = !0), t.colors && (t.stylize = k), h(t, e, t.depth);
+  }
+  n.inspect = l, l.colors = {
+    bold: [1, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    inverse: [7, 27],
+    white: [37, 39],
+    grey: [90, 39],
+    black: [30, 39],
+    blue: [34, 39],
+    cyan: [36, 39],
+    green: [32, 39],
+    magenta: [35, 39],
+    red: [31, 39],
+    yellow: [33, 39]
+  }, l.styles = {
+    special: "cyan",
+    number: "yellow",
+    boolean: "yellow",
+    undefined: "grey",
+    null: "bold",
+    string: "green",
+    date: "magenta",
+    // "name": intentionally not styling
+    regexp: "red"
+  };
+  function k(e, r) {
+    var t = l.styles[r];
+    return t ? "\x1B[" + l.colors[t][0] + "m" + e + "\x1B[" + l.colors[t][1] + "m" : e;
+  }
+  function B(e, r) {
+    return e;
+  }
+  function H(e) {
+    var r = {};
+    return e.forEach(function(t, i) {
+      r[t] = !0;
+    }), r;
+  }
+  function h(e, r, t) {
+    if (e.customInspect && r && S(r.inspect) && // Filter out the util module, it's inspect function is special
+    r.inspect !== n.inspect && // Also filter out any prototype objects using the circular check.
+    !(r.constructor && r.constructor.prototype === r)) {
+      var i = r.inspect(t, e);
+      return w(i) || (i = h(e, i, t)), i;
+    }
+    var s = J(e, r);
+    if (s)
+      return s;
+    var u = Object.keys(r), o = H(u);
+    if (e.showHidden && (u = Object.getOwnPropertyNames(r)), d(r) && (u.indexOf("message") >= 0 || u.indexOf("description") >= 0))
+      return z(r);
+    if (u.length === 0) {
+      if (S(r)) {
+        var f = r.name ? ": " + r.name : "";
+        return e.stylize("[Function" + f + "]", "special");
+      }
+      if (m(r))
+        return e.stylize(RegExp.prototype.toString.call(r), "regexp");
+      if (j(r))
+        return e.stylize(Date.prototype.toString.call(r), "date");
+      if (d(r))
+        return z(r);
+    }
+    var c = "", a = !1, E = ["{", "}"];
+    if (C(r) && (a = !0, E = ["[", "]"]), S(r)) {
+      var Q = r.name ? ": " + r.name : "";
+      c = " [Function" + Q + "]";
+    }
+    if (m(r) && (c = " " + RegExp.prototype.toString.call(r)), j(r) && (c = " " + Date.prototype.toUTCString.call(r)), d(r) && (c = " " + z(r)), u.length === 0 && (!a || r.length == 0))
+      return E[0] + c + E[1];
+    if (t < 0)
+      return m(r) ? e.stylize(RegExp.prototype.toString.call(r), "regexp") : e.stylize("[Object]", "special");
+    e.seen.push(r);
+    var _;
+    return a ? _ = G(e, r, t, o, u) : _ = u.map(function(X) {
+      return v(e, r, t, o, X, a);
+    }), e.seen.pop(), M(_, c, E);
+  }
+  function J(e, r) {
+    if (p(r))
+      return e.stylize("undefined", "undefined");
+    if (w(r)) {
+      var t = "'" + JSON.stringify(r).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+      return e.stylize(t, "string");
+    }
+    if (F(r))
+      return e.stylize("" + r, "number");
+    if (D(r))
+      return e.stylize("" + r, "boolean");
+    if (O(r))
+      return e.stylize("null", "null");
+  }
+  function z(e) {
+    return "[" + Error.prototype.toString.call(e) + "]";
+  }
+  function G(e, r, t, i, s) {
+    for (var u = [], o = 0, f = r.length; o < f; ++o)
+      T(r, String(o)) ? u.push(v(
+        e,
+        r,
+        t,
+        i,
+        String(o),
+        !0
+      )) : u.push("");
+    return s.forEach(function(c) {
+      c.match(/^\d+$/) || u.push(v(
+        e,
+        r,
+        t,
+        i,
+        c,
+        !0
+      ));
+    }), u;
+  }
+  function v(e, r, t, i, s, u) {
+    var o, f, c;
+    if (c = Object.getOwnPropertyDescriptor(r, s) || { value: r[s] }, c.get ? c.set ? f = e.stylize("[Getter/Setter]", "special") : f = e.stylize("[Getter]", "special") : c.set && (f = e.stylize("[Setter]", "special")), T(i, s) || (o = "[" + s + "]"), f || (e.seen.indexOf(c.value) < 0 ? (O(t) ? f = h(e, c.value, null) : f = h(e, c.value, t - 1), f.indexOf(`
+`) > -1 && (u ? f = f.split(`
+`).map(function(a) {
+      return "  " + a;
+    }).join(`
+`).slice(2) : f = `
+` + f.split(`
+`).map(function(a) {
+      return "   " + a;
+    }).join(`
+`))) : f = e.stylize("[Circular]", "special")), p(o)) {
+      if (u && s.match(/^\d+$/))
+        return f;
+      o = JSON.stringify("" + s), o.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (o = o.slice(1, -1), o = e.stylize(o, "name")) : (o = o.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), o = e.stylize(o, "string"));
+    }
+    return o + ": " + f;
+  }
+  function M(e, r, t) {
+    var i = e.reduce(function(s, u) {
+      return u.indexOf(`
+`) >= 0, s + u.replace(/\u001b\[\d\d?m/g, "").length + 1;
+    }, 0);
+    return i > 60 ? t[0] + (r === "" ? "" : r + `
+ `) + " " + e.join(`,
+  `) + " " + t[1] : t[0] + r + " " + e.join(", ") + " " + t[1];
+  }
+  n.types = re;
+  function C(e) {
+    return Array.isArray(e);
+  }
+  n.isArray = C;
+  function D(e) {
+    return typeof e == "boolean";
+  }
+  n.isBoolean = D;
+  function O(e) {
+    return e === null;
+  }
+  n.isNull = O;
+  function I(e) {
+    return e == null;
+  }
+  n.isNullOrUndefined = I;
+  function F(e) {
+    return typeof e == "number";
+  }
+  n.isNumber = F;
+  function w(e) {
+    return typeof e == "string";
+  }
+  n.isString = w;
+  function Z(e) {
+    return typeof e == "symbol";
+  }
+  n.isSymbol = Z;
+  function p(e) {
+    return e === void 0;
+  }
+  n.isUndefined = p;
+  function m(e) {
+    return g(e) && N(e) === "[object RegExp]";
+  }
+  n.isRegExp = m, n.types.isRegExp = m;
+  function g(e) {
+    return typeof e == "object" && e !== null;
+  }
+  n.isObject = g;
+  function j(e) {
+    return g(e) && N(e) === "[object Date]";
+  }
+  n.isDate = j, n.types.isDate = j;
+  function d(e) {
+    return g(e) && (N(e) === "[object Error]" || e instanceof Error);
+  }
+  n.isError = d, n.types.isNativeError = d;
+  function S(e) {
+    return typeof e == "function";
+  }
+  n.isFunction = S;
+  function V(e) {
+    return e === null || typeof e == "boolean" || typeof e == "number" || typeof e == "string" || typeof e == "symbol" || // ES6 symbol
+    typeof e > "u";
+  }
+  n.isPrimitive = V, n.isBuffer = x;
+  function N(e) {
+    return Object.prototype.toString.call(e);
+  }
+  function R(e) {
+    return e < 10 ? "0" + e.toString(10) : e.toString(10);
+  }
+  var W = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ];
+  function q() {
+    var e = /* @__PURE__ */ new Date(), r = [
+      R(e.getHours()),
+      R(e.getMinutes()),
+      R(e.getSeconds())
+    ].join(":");
+    return [e.getDate(), W[e.getMonth()], r].join(" ");
+  }
+  n.log = function() {
+    console.log("%s - %s", q(), n.format.apply(n, arguments));
+  }, n.inherits = ee, n._extend = function(e, r) {
+    if (!r || !g(r))
+      return e;
+    for (var t = Object.keys(r), i = t.length; i--; )
+      e[t[i]] = r[t[i]];
+    return e;
+  };
+  function T(e, r) {
+    return Object.prototype.hasOwnProperty.call(e, r);
+  }
+  var y = typeof Symbol < "u" ? Symbol("util.promisify.custom") : void 0;
+  n.promisify = function(r) {
+    if (typeof r != "function")
+      throw new TypeError('The "original" argument must be of type Function');
+    if (y && r[y]) {
+      var t = r[y];
+      if (typeof t != "function")
+        throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+      return Object.defineProperty(t, y, {
+        value: t,
+        enumerable: !1,
+        writable: !1,
+        configurable: !0
+      }), t;
+    }
+    function t() {
+      for (var i, s, u = new Promise(function(c, a) {
+        i = c, s = a;
+      }), o = [], f = 0; f < arguments.length; f++)
+        o.push(arguments[f]);
+      o.push(function(c, a) {
+        c ? s(c) : i(a);
+      });
+      try {
+        r.apply(this, o);
+      } catch (c) {
+        s(c);
+      }
+      return u;
+    }
+    return Object.setPrototypeOf(t, Object.getPrototypeOf(r)), y && Object.defineProperty(t, y, {
+      value: t,
+      enumerable: !1,
+      writable: !1,
+      configurable: !0
+    }), Object.defineProperties(
+      t,
+      $(r)
+    );
+  }, n.promisify.custom = y;
+  function K(e, r) {
+    if (!e) {
+      var t = new Error("Promise was rejected with a falsy value");
+      t.reason = e, e = t;
+    }
+    return r(e);
+  }
+  function L(e) {
+    if (typeof e != "function")
+      throw new TypeError('The "original" argument must be of type Function');
+    function r() {
+      for (var t = [], i = 0; i < arguments.length; i++)
+        t.push(arguments[i]);
+      var s = t.pop();
+      if (typeof s != "function")
+        throw new TypeError("The last argument must be of type Function");
+      var u = this, o = function() {
+        return s.apply(u, arguments);
+      };
+      e.apply(this, t).then(
+        function(f) {
+          process.nextTick(o.bind(null, null, f));
+        },
+        function(f) {
+          process.nextTick(K.bind(null, f, o));
+        }
+      );
+    }
+    return Object.setPrototypeOf(r, Object.getPrototypeOf(e)), Object.defineProperties(
+      r,
+      $(e)
+    ), r;
+  }
+  n.callbackify = L;
+})(Y);

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/util-deprecate/browser.mjs

@@ -0,0 +1,29 @@
+import { commonjsGlobal as a } from "../../../../../../../_virtual/_commonjsHelpers.mjs";
+var i = c;
+function c(e, r) {
+  if (o("noDeprecation"))
+    return e;
+  var t = !1;
+  function n() {
+    if (!t) {
+      if (o("throwDeprecation"))
+        throw new Error(r);
+      o("traceDeprecation") ? console.trace(r) : console.warn(r), t = !0;
+    }
+    return e.apply(this, arguments);
+  }
+  return n;
+}
+function o(e) {
+  try {
+    if (!a.localStorage)
+      return !1;
+  } catch {
+    return !1;
+  }
+  var r = a.localStorage[e];
+  return r == null ? !1 : String(r).toLowerCase() === "true";
+}
+export {
+  i as b
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/uuid/dist/esm-browser/native.mjs

@@ -0,0 +1,6 @@
+const o = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), t = {
+  randomUUID: o
+};
+export {
+  t as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/uuid/dist/esm-browser/rng.mjs

@@ -0,0 +1,10 @@
+let t;
+const e = new Uint8Array(16);
+function o() {
+  if (!t && (t = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !t))
+    throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+  return t(e);
+}
+export {
+  o as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/uuid/dist/esm-browser/stringify.mjs

@@ -0,0 +1,9 @@
+const i = [];
+for (let n = 0; n < 256; ++n)
+  i.push((n + 256).toString(16).slice(1));
+function c(n, u = 0) {
+  return i[n[u + 0]] + i[n[u + 1]] + i[n[u + 2]] + i[n[u + 3]] + "-" + i[n[u + 4]] + i[n[u + 5]] + "-" + i[n[u + 6]] + i[n[u + 7]] + "-" + i[n[u + 8]] + i[n[u + 9]] + "-" + i[n[u + 10]] + i[n[u + 11]] + i[n[u + 12]] + i[n[u + 13]] + i[n[u + 14]] + i[n[u + 15]];
+}
+export {
+  c as unsafeStringify
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/uuid/dist/esm-browser/v4.mjs

@@ -0,0 +1,19 @@
+import e from "./native.mjs";
+import i from "./rng.mjs";
+import { unsafeStringify as d } from "./stringify.mjs";
+function g(n, m, t) {
+  if (e.randomUUID && !m && !n)
+    return e.randomUUID();
+  n = n || {};
+  const r = n.random || (n.rng || i)();
+  if (r[6] = r[6] & 15 | 64, r[8] = r[8] & 63 | 128, m) {
+    t = t || 0;
+    for (let a = 0; a < 16; ++a)
+      m[t + a] = r[a];
+    return m;
+  }
+  return d(r);
+}
+export {
+  g as default
+};