@coinbase/cdp-core 0.0.53 → 0.0.54

package/dist/web/index.web117.js

@@ -1,20 +1,57 @@
-import { toHex as a } from "viem";
-import { userOperationChainIdToNameMapping as o } from "./index.web30.js";
-import { validateUserConnected as i } from "./index.web19.js";
-import "zustand";
-import "@coinbase/cdp-api-client";
-async function l() {
-  return !(await i()).evmSmartAccounts?.length ? {} : Object.keys(o).reduce(
-    (t, e) => {
-      const r = a(Number(e));
-      return t[r] = {
-        atomic: { status: "supported" },
-        paymasterService: { supported: !0 }
-      }, t;
-    },
-    {}
-  );
+import { encode as d } from "./index.web135.js";
+import y from "./index.web136.js";
+import b from "./index.web137.js";
+import { JWSInvalid as r } from "./index.web52.js";
+import { encoder as s, concat as u, decoder as h } from "./index.web118.js";
+import g from "./index.web138.js";
+import H from "./index.web139.js";
+import P from "./index.web140.js";
+class x {
+  #r;
+  #e;
+  #t;
+  constructor(e) {
+    if (!(e instanceof Uint8Array))
+      throw new TypeError("payload must be an instance of Uint8Array");
+    this.#r = e;
+  }
+  setProtectedHeader(e) {
+    if (this.#e)
+      throw new TypeError("setProtectedHeader can only be called once");
+    return this.#e = e, this;
+  }
+  setUnprotectedHeader(e) {
+    if (this.#t)
+      throw new TypeError("setUnprotectedHeader can only be called once");
+    return this.#t = e, this;
+  }
+  async sign(e, l) {
+    if (!this.#e && !this.#t)
+      throw new r("either setProtectedHeader or setUnprotectedHeader must be called before #sign()");
+    if (!b(this.#e, this.#t))
+      throw new r("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");
+    const c = {
+      ...this.#e,
+      ...this.#t
+    }, p = H(r, /* @__PURE__ */ new Map([["b64", !0]]), l?.crit, this.#e, c);
+    let o = !0;
+    if (p.has("b64") && (o = this.#e.b64, typeof o != "boolean"))
+      throw new r('The "b64" (base64url-encode payload) Header Parameter must be a boolean');
+    const { alg: t } = c;
+    if (typeof t != "string" || !t)
+      throw new r('JWS "alg" (Algorithm) Header Parameter missing or invalid');
+    g(t, e, "sign");
+    let i = this.#r;
+    o && (i = s.encode(d(i)));
+    let n;
+    this.#e ? n = s.encode(d(JSON.stringify(this.#e))) : n = s.encode("");
+    const f = u(n, s.encode("."), i), m = await P(e, t), w = await y(t, m, f), a = {
+      signature: d(w),
+      payload: ""
+    };
+    return o && (a.payload = h.decode(i)), this.#t && (a.header = this.#t), this.#e && (a.protected = h.decode(n)), a;
+  }
 }
 export {
-  l as handleGetCapabilities
+  x as FlattenedSign
 };

package/dist/web/index.web118.js

@@ -1,23 +1,13 @@
-import { hashMessage as o, hexToString as c } from "viem";
-import { signAndWrapTypedDataForSmartAccount as i } from "./index.web36.js";
-import { validateUserOwnsSmartAccount as d, EIP1193ProviderError as m, STANDARD_ERROR_CODES as g } from "./index.web19.js";
-async function S(t, a) {
-  const [n, e] = t, s = await d(e);
-  try {
-    const { signature: r } = await i({
-      smartAccount: e,
-      ownerAddress: s.evmAccounts[0],
-      hash: o(c(n)),
-      chainId: a.getState().chainId
-    });
-    return r;
-  } catch (r) {
-    throw new m(
-      g.provider.userRejectedRequest,
-      r instanceof Error ? r.message : "Signing failed"
-    );
-  }
+const d = new TextEncoder(), s = new TextDecoder();
+function f(...n) {
+  const c = n.reduce((e, { length: r }) => e + r, 0), t = new Uint8Array(c);
+  let o = 0;
+  for (const e of n)
+    t.set(e, o), o += e.length;
+  return t;
 }
 export {
-  S as handlePersonalSign
+  f as concat,
+  s as decoder,
+  d as encoder
 };

package/dist/web/index.web119.js

@@ -1,11 +1,4 @@
-import { fromNumber as c } from "./index.web141.js";
-import { validateUserConnected as o } from "./index.web19.js";
-async function m(t, e) {
-  const n = await o();
-  return t.emit("connect", {
-    chainId: c(e.getState().chainId)
-  }), n.evmSmartAccounts || [];
-}
+const o = (e) => Math.floor(e.getTime() / 1e3);
 export {
-  m as handleRequestAccounts
+  o as default
 };

package/dist/web/index.web120.js

@@ -1,33 +1,47 @@
-import { sendUserOperation as c } from "./index.web6.js";
-import { isChainIdSupportedForCDPUserOps as u, userOperationChainIdToNameMapping as p } from "./index.web30.js";
-import { validateUserHasEvmSmartAccount as d, RPCRequestError as o, STANDARD_ERROR_CODES as s } from "./index.web19.js";
-async function R(r, t) {
-  const [{ calls: n }] = r, i = (await d()).evmSmartAccounts[0], a = t.getState().chainId;
-  if (!u(a))
-    throw new o(
-      s.rpc.invalidParams,
-      "Chain ID is not supported for user operations"
-    );
-  try {
-    return (await c({
-      evmSmartAccount: i,
-      calls: m(n),
-      network: p[a]
-    })).userOperationHash;
-  } catch (e) {
-    throw new o(
-      s.rpc.transactionRejected,
-      e instanceof Error ? e.message : "User operation failed"
-    );
+const o = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i, t = (c) => {
+  const s = o.exec(c);
+  if (!s || s[4] && s[1])
+    throw new TypeError("Invalid time period format");
+  const a = parseFloat(s[2]), r = s[3].toLowerCase();
+  let e;
+  switch (r) {
+    case "sec":
+    case "secs":
+    case "second":
+    case "seconds":
+    case "s":
+      e = Math.round(a);
+      break;
+    case "minute":
+    case "minutes":
+    case "min":
+    case "mins":
+    case "m":
+      e = Math.round(a * 60);
+      break;
+    case "hour":
+    case "hours":
+    case "hr":
+    case "hrs":
+    case "h":
+      e = Math.round(a * 3600);
+      break;
+    case "day":
+    case "days":
+    case "d":
+      e = Math.round(a * 86400);
+      break;
+    case "week":
+    case "weeks":
+    case "w":
+      e = Math.round(a * 604800);
+      break;
+    default:
+      e = Math.round(a * 31557600);
+      break;
   }
-}
-function m(r) {
-  return r.map((t) => ({
-    to: t.to,
-    data: t.data,
-    value: t.value ? BigInt(t.value) : void 0
-  }));
-}
+  return s[1] === "-" || s[4] === "ago" ? -e : e;
+};
 export {
-  R as handleSendCalls
+  t as default
 };

package/dist/web/index.web121.js

@@ -1,10 +1,16 @@
-import { EIP1193ProviderError as r, STANDARD_ERROR_CODES as t } from "./index.web19.js";
-async function a(n, o, s) {
-  throw new r(
-    t.provider.unsupportedMethod,
-    "eth_sendTransaction is not supported with smart accounts. Use wallet_sendCalls instead."
-  );
+function o(t) {
+  return typeof t == "object" && t !== null;
 }
+const r = (t) => {
+  if (!o(t) || Object.prototype.toString.call(t) !== "[object Object]")
+    return !1;
+  if (Object.getPrototypeOf(t) === null)
+    return !0;
+  let e = t;
+  for (; Object.getPrototypeOf(e) !== null; )
+    e = Object.getPrototypeOf(e);
+  return Object.getPrototypeOf(t) === e;
+};
 export {
-  a as handleSendTransaction
+  r as default
 };

package/dist/web/index.web122.js

@@ -1,23 +1,4 @@
-import { hashTypedData as s } from "viem";
-import { signAndWrapTypedDataForSmartAccount as c } from "./index.web36.js";
-import { validateUserOwnsSmartAccount as i, EIP1193ProviderError as d, STANDARD_ERROR_CODES as m } from "./index.web19.js";
-async function A(a, e) {
-  const [t, n] = a, o = await i(t);
-  try {
-    const { signature: r } = await c({
-      smartAccount: t,
-      ownerAddress: o.evmAccounts[0],
-      hash: s(JSON.parse(n)),
-      chainId: e.getState().chainId
-    });
-    return r;
-  } catch (r) {
-    throw new d(
-      m.provider.userRejectedRequest,
-      r instanceof Error ? r.message : "Signing failed"
-    );
-  }
-}
+const o = "2.33.0";
 export {
-  A as handleSignTypedData
+  o as version
 };

package/dist/web/index.web124.js

@@ -1,4 +1,4 @@
-import { getDefaultExportFromCjs as r } from "./index.web140.js";
+import { getDefaultExportFromCjs as r } from "./index.web131.js";
 import { __require as o } from "./index.web142.js";
 var t = o();
 const a = /* @__PURE__ */ r(t);

package/dist/web/index.web127.js

@@ -1,4 +1,4 @@
-import { HashMD as D, SHA256_IV as b, Chi as g, Maj as p } from "./index.web139.js";
+import { HashMD as D, SHA256_IV as b, Chi as g, Maj as p } from "./index.web130.js";
 import { createHasher as u, clean as C, rotr as i } from "./index.web126.js";
 const B = /* @__PURE__ */ Uint32Array.from([
   1116352408,

package/dist/web/index.web130.js

@@ -1,23 +1,81 @@
-import { encoder as t, decoder as o } from "./index.web96.js";
-import { encodeBase64 as c, decodeBase64 as a } from "./index.web152.js";
-function i(r) {
-  if (Uint8Array.fromBase64)
-    return Uint8Array.fromBase64(typeof r == "string" ? r : o.decode(r), {
-      alphabet: "base64url"
-    });
-  let e = r;
-  e instanceof Uint8Array && (e = o.decode(e)), e = e.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, "");
-  try {
-    return a(e);
-  } catch {
-    throw new TypeError("The input to be decoded is not correctly encoded.");
-  }
+import { Hash as g, createView as l, aexists as b, toBytes as a, abytes as d, aoutput as x, clean as w } from "./index.web126.js";
+function y(o, t, s, n) {
+  if (typeof o.setBigUint64 == "function")
+    return o.setBigUint64(t, s, n);
+  const i = BigInt(32), h = BigInt(4294967295), e = Number(s >> i & h), r = Number(s & h), c = n ? 4 : 0, u = n ? 0 : 4;
+  o.setUint32(t + c, e, n), o.setUint32(t + u, r, n);
+}
+function U(o, t, s) {
+  return o & t ^ ~o & s;
+}
+function _(o, t, s) {
+  return o & t ^ o & s ^ t & s;
 }
-function p(r) {
-  let e = r;
-  return typeof e == "string" && (e = t.encode(e)), Uint8Array.prototype.toBase64 ? e.toBase64({ alphabet: "base64url", omitPadding: !0 }) : c(e).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+class m extends g {
+  constructor(t, s, n, i) {
+    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = t, this.outputLen = s, this.padOffset = n, this.isLE = i, this.buffer = new Uint8Array(t), this.view = l(this.buffer);
+  }
+  update(t) {
+    b(this), t = a(t), d(t);
+    const { view: s, buffer: n, blockLen: i } = this, h = t.length;
+    for (let e = 0; e < h; ) {
+      const r = Math.min(i - this.pos, h - e);
+      if (r === i) {
+        const c = l(t);
+        for (; i <= h - e; e += i)
+          this.process(c, e);
+        continue;
+      }
+      n.set(t.subarray(e, e + r), this.pos), this.pos += r, e += r, this.pos === i && (this.process(s, 0), this.pos = 0);
+    }
+    return this.length += t.length, this.roundClean(), this;
+  }
+  digestInto(t) {
+    b(this), x(t, this), this.finished = !0;
+    const { buffer: s, view: n, blockLen: i, isLE: h } = this;
+    let { pos: e } = this;
+    s[e++] = 128, w(this.buffer.subarray(e)), this.padOffset > i - e && (this.process(n, 0), e = 0);
+    for (let f = e; f < i; f++)
+      s[f] = 0;
+    y(n, i - 8, BigInt(this.length * 8), h), this.process(n, 0);
+    const r = l(t), c = this.outputLen;
+    if (c % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const u = c / 4, p = this.get();
+    if (u > p.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let f = 0; f < u; f++)
+      r.setUint32(4 * f, p[f], h);
+  }
+  digest() {
+    const { buffer: t, outputLen: s } = this;
+    this.digestInto(t);
+    const n = t.slice(0, s);
+    return this.destroy(), n;
+  }
+  _cloneInto(t) {
+    t || (t = new this.constructor()), t.set(...this.get());
+    const { blockLen: s, buffer: n, length: i, finished: h, destroyed: e, pos: r } = this;
+    return t.destroyed = e, t.finished = h, t.length = i, t.pos = r, i % s && t.buffer.set(n), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
 }
+const B = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
 export {
-  i as decode,
-  p as encode
+  U as Chi,
+  m as HashMD,
+  _ as Maj,
+  B as SHA256_IV,
+  y as setBigUint64
 };

package/dist/web/index.web131.js

@@ -1,12 +1,6 @@
-import n from "./index.web153.js";
-import s from "./index.web154.js";
-import a from "./index.web155.js";
-const y = async (t, o, e) => {
-  const r = await a(t, o, "sign");
-  s(t, r);
-  const i = await crypto.subtle.sign(n(t, r.algorithm), r, e);
-  return new Uint8Array(i);
-};
+function e(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
 export {
-  y as default
+  e as getDefaultExportFromCjs
 };

package/dist/web/index.web132.js

@@ -1,22 +1,4 @@
-const a = (...o) => {
-  const t = o.filter(Boolean);
-  if (t.length === 0 || t.length === 1)
-    return !0;
-  let e;
-  for (const s of t) {
-    const r = Object.keys(s);
-    if (!e || e.size === 0) {
-      e = new Set(r);
-      continue;
-    }
-    for (const n of r) {
-      if (e.has(n))
-        return !1;
-      e.add(n);
-    }
-  }
-  return !0;
-};
+const o = "0.1.1";
 export {
-  a as default
+  o as version
 };

package/dist/web/index.web133.js

@@ -1,96 +1,111 @@
-import { withAlg as n } from "./index.web156.js";
-import c from "./index.web157.js";
-import { isJWK as p, isSecretJWK as a, isPublicJWK as y, isPrivateJWK as f } from "./index.web158.js";
-const s = (r) => r?.[Symbol.toStringTag], o = (r, e, t) => {
-  if (e.use !== void 0) {
-    let i;
-    switch (t) {
-      case "sign":
-      case "verify":
-        i = "sig";
-        break;
-      case "encrypt":
-      case "decrypt":
-        i = "enc";
-        break;
+import { __module as x } from "./index.web134.js";
+var w;
+function O() {
+  return w ? x.exports : (w = 1, function(d) {
+    var g = Object.prototype.hasOwnProperty, c = "~";
+    function h() {
     }
-    if (e.use !== i)
-      throw new TypeError(`Invalid key for this operation, its "use" must be "${i}" when present`);
-  }
-  if (e.alg !== void 0 && e.alg !== r)
-    throw new TypeError(`Invalid key for this operation, its "alg" must be "${r}" when present`);
-  if (Array.isArray(e.key_ops)) {
-    let i;
-    switch (!0) {
-      case t === "sign":
-      case r === "dir":
-      case r.includes("CBC-HS"):
-        i = t;
-        break;
-      case r.startsWith("PBES2"):
-        i = "deriveBits";
-        break;
-      case /^A\d{3}(?:GCM)?(?:KW)?$/.test(r):
-        !r.includes("GCM") && r.endsWith("KW") ? i = "unwrapKey" : i = t;
-        break;
-      case t === "encrypt":
-        i = "wrapKey";
-        break;
-      case t === "decrypt":
-        i = r.startsWith("RSA") ? "unwrapKey" : "deriveBits";
-        break;
+    Object.create && (h.prototype = /* @__PURE__ */ Object.create(null), new h().__proto__ || (c = !1));
+    function b(s, t, n) {
+      this.fn = s, this.context = t, this.once = n || !1;
     }
-    if (i && e.key_ops?.includes?.(i) === !1)
-      throw new TypeError(`Invalid key for this operation, its "key_ops" must include "${i}" when present`);
-  }
-  return !0;
-}, h = (r, e, t) => {
-  if (!(e instanceof Uint8Array)) {
-    if (p(e)) {
-      if (a(e) && o(r, e, t))
-        return;
-      throw new TypeError('JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present');
+    function m(s, t, n, r, l) {
+      if (typeof n != "function")
+        throw new TypeError("The listener must be a function");
+      var u = new b(n, r || s, l), o = c ? c + t : t;
+      return s._events[o] ? s._events[o].fn ? s._events[o] = [s._events[o], u] : s._events[o].push(u) : (s._events[o] = u, s._eventsCount++), s;
     }
-    if (!c(e))
-      throw new TypeError(n(r, e, "CryptoKey", "KeyObject", "JSON Web Key", "Uint8Array"));
-    if (e.type !== "secret")
-      throw new TypeError(`${s(e)} instances for symmetric algorithms must be of type "secret"`);
-  }
-}, m = (r, e, t) => {
-  if (p(e))
-    switch (t) {
-      case "decrypt":
-      case "sign":
-        if (f(e) && o(r, e, t))
-          return;
-        throw new TypeError("JSON Web Key for this operation be a private JWK");
-      case "encrypt":
-      case "verify":
-        if (y(e) && o(r, e, t))
-          return;
-        throw new TypeError("JSON Web Key for this operation be a public JWK");
+    function y(s, t) {
+      --s._eventsCount === 0 ? s._events = new h() : delete s._events[t];
     }
-  if (!c(e))
-    throw new TypeError(n(r, e, "CryptoKey", "KeyObject", "JSON Web Key"));
-  if (e.type === "secret")
-    throw new TypeError(`${s(e)} instances for asymmetric algorithms must not be of type "secret"`);
-  if (e.type === "public")
-    switch (t) {
-      case "sign":
-        throw new TypeError(`${s(e)} instances for asymmetric algorithm signing must be of type "private"`);
-      case "decrypt":
-        throw new TypeError(`${s(e)} instances for asymmetric algorithm decryption must be of type "private"`);
+    function f() {
+      this._events = new h(), this._eventsCount = 0;
     }
-  if (e.type === "private")
-    switch (t) {
-      case "verify":
-        throw new TypeError(`${s(e)} instances for asymmetric algorithm verifying must be of type "public"`);
-      case "encrypt":
-        throw new TypeError(`${s(e)} instances for asymmetric algorithm encryption must be of type "public"`);
-    }
-}, d = (r, e, t) => {
-  r.startsWith("HS") || r === "dir" || r.startsWith("PBES2") || /^A(?:128|192|256)(?:GCM)?(?:KW)?$/.test(r) || /^A(?:128|192|256)CBC-HS(?:256|384|512)$/.test(r) ? h(r, e, t) : m(r, e, t);
-};
+    f.prototype.eventNames = function() {
+      var t = [], n, r;
+      if (this._eventsCount === 0) return t;
+      for (r in n = this._events)
+        g.call(n, r) && t.push(c ? r.slice(1) : r);
+      return Object.getOwnPropertySymbols ? t.concat(Object.getOwnPropertySymbols(n)) : t;
+    }, f.prototype.listeners = function(t) {
+      var n = c ? c + t : t, r = this._events[n];
+      if (!r) return [];
+      if (r.fn) return [r.fn];
+      for (var l = 0, u = r.length, o = new Array(u); l < u; l++)
+        o[l] = r[l].fn;
+      return o;
+    }, f.prototype.listenerCount = function(t) {
+      var n = c ? c + t : t, r = this._events[n];
+      return r ? r.fn ? 1 : r.length : 0;
+    }, f.prototype.emit = function(t, n, r, l, u, o) {
+      var a = c ? c + t : t;
+      if (!this._events[a]) return !1;
+      var e = this._events[a], p = arguments.length, v, i;
+      if (e.fn) {
+        switch (e.once && this.removeListener(t, e.fn, void 0, !0), p) {
+          case 1:
+            return e.fn.call(e.context), !0;
+          case 2:
+            return e.fn.call(e.context, n), !0;
+          case 3:
+            return e.fn.call(e.context, n, r), !0;
+          case 4:
+            return e.fn.call(e.context, n, r, l), !0;
+          case 5:
+            return e.fn.call(e.context, n, r, l, u), !0;
+          case 6:
+            return e.fn.call(e.context, n, r, l, u, o), !0;
+        }
+        for (i = 1, v = new Array(p - 1); i < p; i++)
+          v[i - 1] = arguments[i];
+        e.fn.apply(e.context, v);
+      } else {
+        var E = e.length, _;
+        for (i = 0; i < E; i++)
+          switch (e[i].once && this.removeListener(t, e[i].fn, void 0, !0), p) {
+            case 1:
+              e[i].fn.call(e[i].context);
+              break;
+            case 2:
+              e[i].fn.call(e[i].context, n);
+              break;
+            case 3:
+              e[i].fn.call(e[i].context, n, r);
+              break;
+            case 4:
+              e[i].fn.call(e[i].context, n, r, l);
+              break;
+            default:
+              if (!v) for (_ = 1, v = new Array(p - 1); _ < p; _++)
+                v[_ - 1] = arguments[_];
+              e[i].fn.apply(e[i].context, v);
+          }
+      }
+      return !0;
+    }, f.prototype.on = function(t, n, r) {
+      return m(this, t, n, r, !1);
+    }, f.prototype.once = function(t, n, r) {
+      return m(this, t, n, r, !0);
+    }, f.prototype.removeListener = function(t, n, r, l) {
+      var u = c ? c + t : t;
+      if (!this._events[u]) return this;
+      if (!n)
+        return y(this, u), this;
+      var o = this._events[u];
+      if (o.fn)
+        o.fn === n && (!l || o.once) && (!r || o.context === r) && y(this, u);
+      else {
+        for (var a = 0, e = [], p = o.length; a < p; a++)
+          (o[a].fn !== n || l && !o[a].once || r && o[a].context !== r) && e.push(o[a]);
+        e.length ? this._events[u] = e.length === 1 ? e[0] : e : y(this, u);
+      }
+      return this;
+    }, f.prototype.removeAllListeners = function(t) {
+      var n;
+      return t ? (n = c ? c + t : t, this._events[n] && y(this, n)) : (this._events = new h(), this._eventsCount = 0), this;
+    }, f.prototype.off = f.prototype.removeListener, f.prototype.addListener = f.prototype.on, f.prefixed = c, f.EventEmitter = f, d.exports = f;
+  }(x), x.exports);
+}
 export {
-  d as default
+  O as __require
 };

package/dist/web/index.web134.js

@@ -1,23 +1,4 @@
-import { JOSENotSupported as f } from "./index.web50.js";
-const w = (n, r, a, e, s) => {
-  if (s.crit !== void 0 && e?.crit === void 0)
-    throw new n('"crit" (Critical) Header Parameter MUST be integrity protected');
-  if (!e || e.crit === void 0)
-    return /* @__PURE__ */ new Set();
-  if (!Array.isArray(e.crit) || e.crit.length === 0 || e.crit.some((i) => typeof i != "string" || i.length === 0))
-    throw new n('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
-  let t;
-  a !== void 0 ? t = new Map([...Object.entries(a), ...r.entries()]) : t = r;
-  for (const i of e.crit) {
-    if (!t.has(i))
-      throw new f(`Extension Header Parameter "${i}" is not recognized`);
-    if (s[i] === void 0)
-      throw new n(`Extension Header Parameter "${i}" is missing`);
-    if (t.get(i) && e[i] === void 0)
-      throw new n(`Extension Header Parameter "${i}" MUST be integrity protected`);
-  }
-  return new Set(e.crit);
-};
+var e = { exports: {} };
 export {
-  w as default
+  e as __module
 };