module-develop-kit 1.3.0 → 1.4.0

package/dist/vendor/@noble/curves/esm/utils.js

@@ -0,0 +1,154 @@
+import { hexToBytes as d, abytes as x, bytesToHex as m, isBytes as h, concatBytes as U } from "../../hashes/esm/utils.js";
+import { anumber as C, randomBytes as G, utf8ToBytes as J } from "../../hashes/esm/utils.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const g = /* @__PURE__ */ BigInt(0), p = /* @__PURE__ */ BigInt(1);
+function I(t, e = "") {
+  if (typeof t != "boolean") {
+    const n = e && `"${e}"`;
+    throw new Error(n + "expected boolean, got type=" + typeof t);
+  }
+  return t;
+}
+function _(t, e, n = "") {
+  const o = h(t), i = t?.length, r = e !== void 0;
+  if (!o || r && i !== e) {
+    const f = n && `"${n}" `, c = r ? ` of length ${e}` : "", u = o ? `length=${i}` : `type=${typeof t}`;
+    throw new Error(f + "expected Uint8Array" + c + ", got " + u);
+  }
+  return t;
+}
+function k(t) {
+  const e = t.toString(16);
+  return e.length & 1 ? "0" + e : e;
+}
+function E(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  return t === "" ? g : BigInt("0x" + t);
+}
+function j(t) {
+  return E(m(t));
+}
+function H(t) {
+  return x(t), E(m(Uint8Array.from(t).reverse()));
+}
+function T(t, e) {
+  return d(t.toString(16).padStart(e * 2, "0"));
+}
+function O(t, e) {
+  return T(t, e).reverse();
+}
+function S(t, e, n) {
+  let o;
+  if (typeof e == "string")
+    try {
+      o = d(e);
+    } catch (r) {
+      throw new Error(t + " must be hex string or Uint8Array, cause: " + r);
+    }
+  else if (h(e))
+    o = Uint8Array.from(e);
+  else
+    throw new Error(t + " must be hex string or Uint8Array");
+  const i = o.length;
+  if (typeof n == "number" && i !== n)
+    throw new Error(t + " of length " + n + " expected, got " + i);
+  return o;
+}
+const l = (t) => typeof t == "bigint" && g <= t;
+function $(t, e, n) {
+  return l(t) && l(e) && l(n) && e <= t && t < n;
+}
+function M(t, e, n, o) {
+  if (!$(e, n, o))
+    throw new Error("expected valid " + t + ": " + n + " <= n < " + o + ", got " + e);
+}
+function N(t) {
+  let e;
+  for (e = 0; t > g; t >>= p, e += 1)
+    ;
+  return e;
+}
+const R = (t) => (p << BigInt(t)) - p;
+function z(t, e, n) {
+  if (typeof t != "number" || t < 2)
+    throw new Error("hashLen must be a number");
+  if (typeof e != "number" || e < 2)
+    throw new Error("qByteLen must be a number");
+  if (typeof n != "function")
+    throw new Error("hmacFn must be a function");
+  const o = (s) => new Uint8Array(s), i = (s) => Uint8Array.of(s);
+  let r = o(t), f = o(t), c = 0;
+  const u = () => {
+    r.fill(1), f.fill(0), c = 0;
+  }, y = (...s) => n(f, r, ...s), w = (s = o(0)) => {
+    f = y(i(0), s), r = y(), s.length !== 0 && (f = y(i(1), s), r = y());
+  }, B = () => {
+    if (c++ >= 1e3)
+      throw new Error("drbg: tried 1000 values");
+    let s = 0;
+    const a = [];
+    for (; s < e; ) {
+      r = y();
+      const b = r.slice();
+      a.push(b), s += r.length;
+    }
+    return U(...a);
+  };
+  return (s, a) => {
+    u(), w(s);
+    let b;
+    for (; !(b = a(B())); )
+      w();
+    return u(), b;
+  };
+}
+function D(t, e, n = {}) {
+  if (!t || typeof t != "object")
+    throw new Error("expected valid options object");
+  function o(i, r, f) {
+    const c = t[i];
+    if (f && c === void 0)
+      return;
+    const u = typeof c;
+    if (u !== r || c === null)
+      throw new Error(`param "${i}" is invalid: expected ${r}, got ${u}`);
+  }
+  Object.entries(e).forEach(([i, r]) => o(i, r, !1)), Object.entries(n).forEach(([i, r]) => o(i, r, !0));
+}
+function F(t) {
+  const e = /* @__PURE__ */ new WeakMap();
+  return (n, ...o) => {
+    const i = e.get(n);
+    if (i !== void 0)
+      return i;
+    const r = t(n, ...o);
+    return e.set(n, r), r;
+  };
+}
+export {
+  I as _abool2,
+  _ as _abytes2,
+  D as _validateObject,
+  M as aInRange,
+  x as abytes,
+  C as anumber,
+  N as bitLen,
+  R as bitMask,
+  m as bytesToHex,
+  j as bytesToNumberBE,
+  H as bytesToNumberLE,
+  U as concatBytes,
+  z as createHmacDrbg,
+  S as ensureBytes,
+  d as hexToBytes,
+  E as hexToNumber,
+  $ as inRange,
+  h as isBytes,
+  F as memoized,
+  T as numberToBytesBE,
+  O as numberToBytesLE,
+  k as numberToHexUnpadded,
+  G as randomBytes,
+  J as utf8ToBytes
+};

package/dist/vendor/@noble/hashes/esm/crypto.js

@@ -0,0 +1,4 @@
+const o = typeof globalThis == "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+export {
+  o as crypto
+};

package/dist/vendor/@noble/hashes/esm/hmac.js

@@ -0,0 +1,45 @@
+import { Hash as d, ahash as u, toBytes as H, clean as l, aexists as a, abytes as p } from "./utils.js";
+class r extends d {
+  constructor(t, i) {
+    super(), this.finished = !1, this.destroyed = !1, u(t);
+    const h = H(i);
+    if (this.iHash = t.create(), typeof this.iHash.update != "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
+    const o = this.blockLen, e = new Uint8Array(o);
+    e.set(h.length > o ? t.create().update(h).digest() : h);
+    for (let s = 0; s < e.length; s++)
+      e[s] ^= 54;
+    this.iHash.update(e), this.oHash = t.create();
+    for (let s = 0; s < e.length; s++)
+      e[s] ^= 106;
+    this.oHash.update(e), l(e);
+  }
+  update(t) {
+    return a(this), this.iHash.update(t), this;
+  }
+  digestInto(t) {
+    a(this), p(t, this.outputLen), this.finished = !0, this.iHash.digestInto(t), this.oHash.update(t), this.oHash.digestInto(t), this.destroy();
+  }
+  digest() {
+    const t = new Uint8Array(this.oHash.outputLen);
+    return this.digestInto(t), t;
+  }
+  _cloneInto(t) {
+    t || (t = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash: i, iHash: h, finished: o, destroyed: e, blockLen: s, outputLen: c } = this;
+    return t = t, t.finished = o, t.destroyed = e, t.blockLen = s, t.outputLen = c, t.oHash = i._cloneInto(t.oHash), t.iHash = h._cloneInto(t.iHash), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+}
+const y = (n, t, i) => new r(n, t).update(i).digest();
+y.create = (n, t) => new r(n, t);
+export {
+  r as HMAC,
+  y as hmac
+};

package/dist/vendor/@noble/hashes/esm/utils.js

@@ -0,0 +1,112 @@
+import { crypto as s } from "./crypto.js";
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function h(e) {
+  return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function d(e) {
+  if (!Number.isSafeInteger(e) || e < 0)
+    throw new Error("positive integer expected, got " + e);
+}
+function c(e, ...t) {
+  if (!h(e))
+    throw new Error("Uint8Array expected");
+  if (t.length > 0 && !t.includes(e.length))
+    throw new Error("Uint8Array expected of length " + t + ", got length=" + e.length);
+}
+function m(e) {
+  if (typeof e != "function" || typeof e.create != "function")
+    throw new Error("Hash should be wrapped by utils.createHasher");
+  d(e.outputLen), d(e.blockLen);
+}
+function x(e, t = !0) {
+  if (e.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (t && e.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function E(...e) {
+  for (let t = 0; t < e.length; t++)
+    e[t].fill(0);
+}
+const y = /* @ts-ignore */ typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", w = /* @__PURE__ */ Array.from({ length: 256 }, (e, t) => t.toString(16).padStart(2, "0"));
+function U(e) {
+  if (c(e), y)
+    return e.toHex();
+  let t = "";
+  for (let r = 0; r < e.length; r++)
+    t += w[e[r]];
+  return t;
+}
+const f = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function l(e) {
+  if (e >= f._0 && e <= f._9)
+    return e - f._0;
+  if (e >= f.A && e <= f.F)
+    return e - (f.A - 10);
+  if (e >= f.a && e <= f.f)
+    return e - (f.a - 10);
+}
+function B(e) {
+  if (typeof e != "string")
+    throw new Error("hex string expected, got " + typeof e);
+  if (y)
+    return Uint8Array.fromHex(e);
+  const t = e.length, r = t / 2;
+  if (t % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + t);
+  const n = new Uint8Array(r);
+  for (let o = 0, i = 0; o < r; o++, i += 2) {
+    const u = l(e.charCodeAt(i)), a = l(e.charCodeAt(i + 1));
+    if (u === void 0 || a === void 0) {
+      const g = e[i] + e[i + 1];
+      throw new Error('hex string expected, got non-hex character "' + g + '" at index ' + i);
+    }
+    n[o] = u * 16 + a;
+  }
+  return n;
+}
+function p(e) {
+  if (typeof e != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(e));
+}
+function H(e) {
+  return typeof e == "string" && (e = p(e)), c(e), e;
+}
+function _(...e) {
+  let t = 0;
+  for (let n = 0; n < e.length; n++) {
+    const o = e[n];
+    c(o), t += o.length;
+  }
+  const r = new Uint8Array(t);
+  for (let n = 0, o = 0; n < e.length; n++) {
+    const i = e[n];
+    r.set(i, o), o += i.length;
+  }
+  return r;
+}
+class T {
+}
+function b(e = 32) {
+  if (s && typeof s.getRandomValues == "function")
+    return s.getRandomValues(new Uint8Array(e));
+  if (s && typeof s.randomBytes == "function")
+    return Uint8Array.from(s.randomBytes(e));
+  throw new Error("crypto.getRandomValues must be defined");
+}
+export {
+  T as Hash,
+  c as abytes,
+  x as aexists,
+  m as ahash,
+  d as anumber,
+  U as bytesToHex,
+  E as clean,
+  _ as concatBytes,
+  B as hexToBytes,
+  h as isBytes,
+  b as randomBytes,
+  H as toBytes,
+  p as utf8ToBytes
+};

package/dist/vendor/ieee754/index.js

@@ -1,4 +1,4 @@
-import { __exports as n } from "../../commonjs-virtual-dir/index7.js";
+import { __exports as n } from "../../commonjs-virtual-dir/index5.js";
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
 var d;
 function q() {

package/dist/vendor/sdp-transform/lib/index.js

@@ -1,4 +1,4 @@
-import { __exports as r } from "../../../commonjs-virtual-dir/index5.js";
+import { __exports as r } from "../../../commonjs-virtual-dir/index4.js";
 import { __require as t } from "./parser.js";
 import { __require as m } from "./writer.js";
 import { __require as p } from "./grammar.js";