@freedomofpress/sigstore-browser 0.1.5 → 0.1.6

package/dist/index-CRFtwdjM.js

@@ -0,0 +1,4528 @@
+class Lt extends Error {
+}
+class $t extends Error {
+}
+const It = {
+  BOOLEAN: 1,
+  INTEGER: 2,
+  BIT_STRING: 3,
+  OCTET_STRING: 4,
+  OBJECT_IDENTIFIER: 6,
+  UTC_TIME: 23,
+  GENERALIZED_TIME: 24
+}, we = {
+  UNIVERSAL: 0,
+  CONTEXT_SPECIFIC: 2
+};
+class Es {
+  constructor(t) {
+    if (this.number = t & 31, this.constructed = (t & 32) === 32, this.class = t >> 6, this.number === 31)
+      throw new Lt("long form tags not supported");
+    if (this.class === we.UNIVERSAL && this.number === 0)
+      throw new Lt("unsupported tag 0x00");
+  }
+  isUniversal() {
+    return this.class === we.UNIVERSAL;
+  }
+  isContextSpecific(t) {
+    const s = this.class === we.CONTEXT_SPECIFIC;
+    return t !== void 0 ? s && this.number === t : s;
+  }
+  isBoolean() {
+    return this.isUniversal() && this.number === It.BOOLEAN;
+  }
+  isInteger() {
+    return this.isUniversal() && this.number === It.INTEGER;
+  }
+  isBitString() {
+    return this.isUniversal() && this.number === It.BIT_STRING;
+  }
+  isOctetString() {
+    return this.isUniversal() && this.number === It.OCTET_STRING;
+  }
+  isOID() {
+    return this.isUniversal() && this.number === It.OBJECT_IDENTIFIER;
+  }
+  isUTCTime() {
+    return this.isUniversal() && this.number === It.UTC_TIME;
+  }
+  isGeneralizedTime() {
+    return this.isUniversal() && this.number === It.GENERALIZED_TIME;
+  }
+  toDER() {
+    return this.number | (this.constructed ? 32 : 0) | this.class << 6;
+  }
+}
+function xs(e) {
+  const t = e.getUint8();
+  if ((t & 128) === 0)
+    return t;
+  const s = t & 127;
+  if (s > 6)
+    throw new Lt("length exceeds 6 byte limit");
+  let n = 0;
+  for (let r = 0; r < s; r++)
+    n = n * 256 + e.getUint8();
+  if (n === 0)
+    throw new Lt("indefinite length encoding not supported");
+  return n;
+}
+function Ss(e) {
+  if (e < 128)
+    return new Uint8Array([e]);
+  let t = BigInt(e);
+  const s = [];
+  for (; t > 0n; )
+    s.unshift(Number(t & 255n)), t = t >> 8n;
+  return new Uint8Array([128 | s.length, ...s]);
+}
+function S(e) {
+  const t = atob(e), s = t.length, n = new Uint8Array(s);
+  for (let r = 0; r < s; r++)
+    n[r] = t.charCodeAt(r);
+  return n;
+}
+function qe(e) {
+  let t = e.replace(/-/g, "+").replace(/_/g, "/");
+  for (; t.length % 4 !== 0; )
+    t += "=";
+  return S(t);
+}
+function Me(e) {
+  let t = "";
+  for (let s = 0; s < e.length; s++)
+    t += String.fromCharCode(e[s]);
+  return btoa(t);
+}
+function Kt(e) {
+  if (e.length % 2 !== 0)
+    throw new Error("Hex string must have an even length");
+  const t = e.length / 2, s = new Uint8Array(t);
+  for (let n = 0; n < t; n++)
+    s[n] = parseInt(e.slice(n * 2, n * 2 + 2), 16);
+  return s;
+}
+function ht(e) {
+  let t = "";
+  for (let s = 0; s < e.length; s++) {
+    let n = e[s].toString(16);
+    n.length === 1 && (n = "0" + n), t += n;
+  }
+  return t;
+}
+function un(e) {
+  return new TextEncoder().encode(e);
+}
+function Q(e) {
+  return new TextDecoder("utf-8").decode(e);
+}
+function Is(e, t) {
+  t === void 0 && (t = 0);
+  const s = ht(e.slice(t, t + 8));
+  return BigInt(`0x${s}`);
+}
+function ln(e) {
+  return Q(S(e));
+}
+function H(e, t) {
+  if (e.byteLength !== t.byteLength)
+    return !1;
+  let s = 0;
+  for (let n = 0; n < e.byteLength; n++)
+    s |= e[n] ^ t[n];
+  return s === 0;
+}
+const vs = /^(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\.\d{3})?Z$/, As = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\.\d{3})?Z$/;
+function Os(e) {
+  let t = 0;
+  const s = e.length;
+  let n = e[t];
+  const r = n > 127, i = r ? 255 : 0;
+  for (; n == i && ++t < s; )
+    n = e[t];
+  if (s - t === 0)
+    return BigInt(r ? -1 : 0);
+  n = r ? n - 256 : n;
+  let a = BigInt(n);
+  for (let c = t + 1; c < s; ++c)
+    a = a * BigInt(256) + BigInt(e[c]);
+  return a;
+}
+function Bs(e) {
+  return Q(e);
+}
+function Ze(e, t) {
+  const s = Bs(e), n = t ? vs.exec(s) : As.exec(s);
+  if (!n)
+    throw new Error("invalid time");
+  if (t) {
+    let r = Number(n[1]);
+    r += r >= 50 ? 1900 : 2e3, n[1] = r.toString();
+  }
+  return /* @__PURE__ */ new Date(`${n[1]}-${n[2]}-${n[3]}T${n[4]}:${n[5]}:${n[6]}Z`);
+}
+function Rs(e) {
+  let t = 0;
+  const s = e.length;
+  let n = e[t++];
+  const r = Math.floor(n / 40), i = n % 40;
+  let o = `${r}.${i}`, a = 0;
+  for (; t < s; ++t)
+    n = e[t], a = (a << 7) + (n & 127), (n & 128) === 0 && (o += `.${a}`, a = 0);
+  return o;
+}
+function Cs(e) {
+  return e[0] !== 0;
+}
+function Ts(e) {
+  const t = e[0], s = 1, n = e.length, r = [];
+  for (let i = s; i < n; ++i) {
+    const o = e[i], a = i === n - 1 ? t : 0;
+    for (let c = 7; c >= a; --c)
+      r.push(o >> c & 1);
+  }
+  return r;
+}
+class Ds extends Error {
+}
+class rt {
+  constructor(t) {
+    this.start = 0, this.view = t ?? new Uint8Array(0);
+  }
+  get buffer() {
+    return this.view.subarray(0, this.start);
+  }
+  get length() {
+    return this.view.byteLength;
+  }
+  get position() {
+    return this.start;
+  }
+  seek(t) {
+    this.start = t;
+  }
+  slice(t, s) {
+    const n = t + s;
+    if (n > this.length)
+      throw new Ds("request past end of buffer");
+    return this.view.subarray(t, n);
+  }
+  appendChar(t) {
+    this.ensureCapacity(1), this.view[this.start] = t, this.start += 1;
+  }
+  appendUint16(t) {
+    this.ensureCapacity(2);
+    const s = new Uint16Array([t]), n = new Uint8Array(s.buffer);
+    this.view[this.start] = n[1], this.view[this.start + 1] = n[0], this.start += 2;
+  }
+  appendUint24(t) {
+    this.ensureCapacity(3);
+    const s = new Uint32Array([t]), n = new Uint8Array(s.buffer);
+    this.view[this.start] = n[2], this.view[this.start + 1] = n[1], this.view[this.start + 2] = n[0], this.start += 3;
+  }
+  appendView(t) {
+    this.ensureCapacity(t.length), this.view.set(t, this.start), this.start += t.length;
+  }
+  getBlock(t) {
+    if (t <= 0)
+      return new Uint8Array(0);
+    if (this.start + t > this.view.length)
+      throw new Error("request past end of buffer");
+    const s = this.view.subarray(this.start, this.start + t);
+    return this.start += t, s;
+  }
+  getUint8() {
+    return this.getBlock(1)[0];
+  }
+  getUint16() {
+    const t = this.getBlock(2);
+    return t[0] << 8 | t[1];
+  }
+  ensureCapacity(t) {
+    if (this.start + t > this.view.byteLength) {
+      const s = rt.BLOCK_SIZE + (t > rt.BLOCK_SIZE ? t : 0);
+      this.realloc(this.view.byteLength + s);
+    }
+  }
+  realloc(t) {
+    const s = new Uint8Array(t);
+    s.set(this.view), this.view = s;
+  }
+}
+rt.BLOCK_SIZE = 1024;
+class Mt {
+  constructor(t, s, n) {
+    this.tag = t, this.value = s, this.subs = n;
+  }
+  // Constructs an ASN.1 object from a Buffer of DER-encoded bytes.
+  static parseBuffer(t) {
+    return hn(new rt(t));
+  }
+  toDER() {
+    const t = new rt();
+    if (this.subs.length > 0)
+      for (const r of this.subs)
+        t.appendView(r.toDER());
+    else
+      t.appendView(this.value);
+    const s = t.buffer, n = new rt();
+    return n.appendChar(this.tag.toDER()), n.appendView(Ss(s.length)), n.appendView(s), n.buffer;
+  }
+  /////////////////////////////////////////////////////////////////////////////
+  // Convenience methods for parsing ASN.1 primitives into JS types
+  // Returns the ASN.1 object's value as a boolean. Throws an error if the
+  // object is not a boolean.
+  toBoolean() {
+    if (!this.tag.isBoolean())
+      throw new $t("not a boolean");
+    return Cs(this.value);
+  }
+  // Returns the ASN.1 object's value as a BigInt. Throws an error if the
+  // object is not an integer.
+  toInteger() {
+    if (!this.tag.isInteger())
+      throw new $t("not an integer");
+    return Os(this.value);
+  }
+  // Returns the ASN.1 object's value as an OID string. Throws an error if the
+  // object is not an OID.
+  toOID() {
+    if (!this.tag.isOID())
+      throw new $t("not an OID");
+    return Rs(this.value);
+  }
+  // Returns the ASN.1 object's value as a Date. Throws an error if the object
+  // is not either a UTCTime or a GeneralizedTime.
+  toDate() {
+    switch (!0) {
+      case this.tag.isUTCTime():
+        return Ze(this.value, !0);
+      case this.tag.isGeneralizedTime():
+        return Ze(this.value, !1);
+      default:
+        throw new $t("not a date");
+    }
+  }
+  // Returns the ASN.1 object's value as a number[] where each number is the
+  // value of a bit in the bit string. Throws an error if the object is not a
+  // bit string.
+  toBitString() {
+    if (!this.tag.isBitString())
+      throw new $t("not a bit string");
+    return Ts(this.value);
+  }
+}
+function hn(e) {
+  const t = new Es(e.getUint8()), s = xs(e), n = e.slice(e.position, s), r = e.position;
+  let i = [];
+  if (t.constructed)
+    i = We(e, s);
+  else if (t.isOctetString())
+    try {
+      i = We(e, s);
+    } catch {
+    }
+  return i.length === 0 && e.seek(r + s), new Mt(t, n, i);
+}
+function We(e, t) {
+  const s = e.position + t;
+  if (s > e.length)
+    throw new Lt("invalid length");
+  const n = [];
+  for (; e.position < s; )
+    n.push(hn(e));
+  if (e.position !== s)
+    throw new Lt("invalid length");
+  return n;
+}
+const Us = /-----BEGIN (.*)-----/, _s = /-----END (.*)-----/;
+function dn(e) {
+  let t = "";
+  return e.split(`
+`).forEach((s) => {
+    s.match(Us) || s.match(_s) || (t += s);
+  }), S(t);
+}
+const Ye = ",", Ns = ":", Hs = "[", Vs = "]", js = "{", ks = "}";
+function ze(e) {
+  return '"' + e.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"';
+}
+function Oe(e) {
+  const t = [];
+  if (typeof e == "string")
+    t.push(ze(e));
+  else if (typeof e == "boolean")
+    t.push(JSON.stringify(e));
+  else if (Number.isInteger(e))
+    t.push(JSON.stringify(e));
+  else if (e === null)
+    t.push(JSON.stringify(e));
+  else if (Array.isArray(e)) {
+    t.push(Hs);
+    let s = !0;
+    e.forEach((n) => {
+      s || t.push(Ye), s = !1, t.push(Oe(n));
+    }), t.push(Vs);
+  } else if (typeof e == "object") {
+    t.push(js);
+    let s = !0;
+    Object.keys(e).sort().forEach((n) => {
+      s || t.push(Ye), s = !1, t.push(ze(n)), t.push(Ns), t.push(Oe(e[n]));
+    }), t.push(ks);
+  } else
+    throw new TypeError("cannot encode " + e);
+  return t.join("");
+}
+var P;
+(function(e) {
+  e.Ecdsa = "ECDSA", e.Ed25519 = "Ed25519", e.RSA = "RSA";
+})(P || (P = {}));
+var it;
+(function(e) {
+  e.P256 = "P-256", e.P384 = "P-384", e.P521 = "P-521";
+})(it || (it = {}));
+var U;
+(function(e) {
+  e.SHA256 = "SHA-256", e.SHA384 = "SHA-384", e.SHA512 = "SHA-512";
+})(U || (U = {}));
+var Bt;
+(function(e) {
+  e.PKCS1v15 = "RSASSA-PKCS1-v1_5", e.PSS = "RSA-PSS";
+})(Bt || (Bt = {}));
+var oe;
+(function(e) {
+  e.PKCS1 = "PKCS1", e.RSAPKCS1 = "RSAPKCS1";
+})(oe || (oe = {}));
+const _t = typeof globalThis == "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function de(e) {
+  return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function Be(e) {
+  if (!Number.isSafeInteger(e) || e < 0)
+    throw new Error("positive integer expected, got " + e);
+}
+function Ct(e, ...t) {
+  if (!de(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 gn(e) {
+  if (typeof e != "function" || typeof e.create != "function")
+    throw new Error("Hash should be wrapped by utils.createHasher");
+  Be(e.outputLen), Be(e.blockLen);
+}
+function ae(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 Ls(e, t) {
+  Ct(e);
+  const s = t.outputLen;
+  if (e.length < s)
+    throw new Error("digestInto() expects output buffer of length at least " + s);
+}
+function Pt(...e) {
+  for (let t = 0; t < e.length; t++)
+    e[t].fill(0);
+}
+function be(e) {
+  return new DataView(e.buffer, e.byteOffset, e.byteLength);
+}
+function at(e, t) {
+  return e << 32 - t | e >>> t;
+}
+const wn = /* @ts-ignore */ typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", Ks = /* @__PURE__ */ Array.from({ length: 256 }, (e, t) => t.toString(16).padStart(2, "0"));
+function jt(e) {
+  if (Ct(e), wn)
+    return e.toHex();
+  let t = "";
+  for (let s = 0; s < e.length; s++)
+    t += Ks[e[s]];
+  return t;
+}
+const ut = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function Je(e) {
+  if (e >= ut._0 && e <= ut._9)
+    return e - ut._0;
+  if (e >= ut.A && e <= ut.F)
+    return e - (ut.A - 10);
+  if (e >= ut.a && e <= ut.f)
+    return e - (ut.a - 10);
+}
+function ce(e) {
+  if (typeof e != "string")
+    throw new Error("hex string expected, got " + typeof e);
+  if (wn)
+    return Uint8Array.fromHex(e);
+  const t = e.length, s = t / 2;
+  if (t % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + t);
+  const n = new Uint8Array(s);
+  for (let r = 0, i = 0; r < s; r++, i += 2) {
+    const o = Je(e.charCodeAt(i)), a = Je(e.charCodeAt(i + 1));
+    if (o === void 0 || a === void 0) {
+      const c = e[i] + e[i + 1];
+      throw new Error('hex string expected, got non-hex character "' + c + '" at index ' + i);
+    }
+    n[r] = o * 16 + a;
+  }
+  return n;
+}
+function Ps(e) {
+  if (typeof e != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(e));
+}
+function De(e) {
+  return typeof e == "string" && (e = Ps(e)), Ct(e), e;
+}
+function xt(...e) {
+  let t = 0;
+  for (let n = 0; n < e.length; n++) {
+    const r = e[n];
+    Ct(r), t += r.length;
+  }
+  const s = new Uint8Array(t);
+  for (let n = 0, r = 0; n < e.length; n++) {
+    const i = e[n];
+    s.set(i, r), r += i.length;
+  }
+  return s;
+}
+class bn {
+}
+function Ue(e) {
+  const t = (n) => e().update(De(n)).digest(), s = e();
+  return t.outputLen = s.outputLen, t.blockLen = s.blockLen, t.create = () => e(), t;
+}
+function pn(e = 32) {
+  if (_t && typeof _t.getRandomValues == "function")
+    return _t.getRandomValues(new Uint8Array(e));
+  if (_t && typeof _t.randomBytes == "function")
+    return Uint8Array.from(_t.randomBytes(e));
+  throw new Error("crypto.getRandomValues must be defined");
+}
+function Fs(e, t, s, n) {
+  if (typeof e.setBigUint64 == "function")
+    return e.setBigUint64(t, s, n);
+  const r = BigInt(32), i = BigInt(4294967295), o = Number(s >> r & i), a = Number(s & i), c = n ? 4 : 0, l = n ? 0 : 4;
+  e.setUint32(t + c, o, n), e.setUint32(t + l, a, n);
+}
+function Gs(e, t, s) {
+  return e & t ^ ~e & s;
+}
+function $s(e, t, s) {
+  return e & t ^ e & s ^ t & s;
+}
+class yn extends bn {
+  constructor(t, s, n, r) {
+    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = t, this.outputLen = s, this.padOffset = n, this.isLE = r, this.buffer = new Uint8Array(t), this.view = be(this.buffer);
+  }
+  update(t) {
+    ae(this), t = De(t), Ct(t);
+    const { view: s, buffer: n, blockLen: r } = this, i = t.length;
+    for (let o = 0; o < i; ) {
+      const a = Math.min(r - this.pos, i - o);
+      if (a === r) {
+        const c = be(t);
+        for (; r <= i - o; o += r)
+          this.process(c, o);
+        continue;
+      }
+      n.set(t.subarray(o, o + a), this.pos), this.pos += a, o += a, this.pos === r && (this.process(s, 0), this.pos = 0);
+    }
+    return this.length += t.length, this.roundClean(), this;
+  }
+  digestInto(t) {
+    ae(this), Ls(t, this), this.finished = !0;
+    const { buffer: s, view: n, blockLen: r, isLE: i } = this;
+    let { pos: o } = this;
+    s[o++] = 128, Pt(this.buffer.subarray(o)), this.padOffset > r - o && (this.process(n, 0), o = 0);
+    for (let u = o; u < r; u++)
+      s[u] = 0;
+    Fs(n, r - 8, BigInt(this.length * 8), i), this.process(n, 0);
+    const a = be(t), c = this.outputLen;
+    if (c % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const l = c / 4, h = this.get();
+    if (l > h.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let u = 0; u < l; u++)
+      a.setUint32(4 * u, h[u], i);
+  }
+  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: r, finished: i, destroyed: o, pos: a } = this;
+    return t.destroyed = o, t.finished = i, t.length = r, t.pos = a, r % s && t.buffer.set(n), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const pt = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), $ = /* @__PURE__ */ Uint32Array.from([
+  3418070365,
+  3238371032,
+  1654270250,
+  914150663,
+  2438529370,
+  812702999,
+  355462360,
+  4144912697,
+  1731405415,
+  4290775857,
+  2394180231,
+  1750603025,
+  3675008525,
+  1694076839,
+  1203062813,
+  3204075428
+]), X = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  4089235720,
+  3144134277,
+  2227873595,
+  1013904242,
+  4271175723,
+  2773480762,
+  1595750129,
+  1359893119,
+  2917565137,
+  2600822924,
+  725511199,
+  528734635,
+  4215389547,
+  1541459225,
+  327033209
+]), zt = /* @__PURE__ */ BigInt(2 ** 32 - 1), Qe = /* @__PURE__ */ BigInt(32);
+function Xs(e, t = !1) {
+  return t ? { h: Number(e & zt), l: Number(e >> Qe & zt) } : { h: Number(e >> Qe & zt) | 0, l: Number(e & zt) | 0 };
+}
+function qs(e, t = !1) {
+  const s = e.length;
+  let n = new Uint32Array(s), r = new Uint32Array(s);
+  for (let i = 0; i < s; i++) {
+    const { h: o, l: a } = Xs(e[i], t);
+    [n[i], r[i]] = [o, a];
+  }
+  return [n, r];
+}
+const tn = (e, t, s) => e >>> s, en = (e, t, s) => e << 32 - s | t >>> s, Nt = (e, t, s) => e >>> s | t << 32 - s, Ht = (e, t, s) => e << 32 - s | t >>> s, Jt = (e, t, s) => e << 64 - s | t >>> s - 32, Qt = (e, t, s) => e >>> s - 32 | t << 64 - s;
+function lt(e, t, s, n) {
+  const r = (t >>> 0) + (n >>> 0);
+  return { h: e + s + (r / 2 ** 32 | 0) | 0, l: r | 0 };
+}
+const Ms = (e, t, s) => (e >>> 0) + (t >>> 0) + (s >>> 0), Zs = (e, t, s, n) => t + s + n + (e / 2 ** 32 | 0) | 0, Ws = (e, t, s, n) => (e >>> 0) + (t >>> 0) + (s >>> 0) + (n >>> 0), Ys = (e, t, s, n, r) => t + s + n + r + (e / 2 ** 32 | 0) | 0, zs = (e, t, s, n, r) => (e >>> 0) + (t >>> 0) + (s >>> 0) + (n >>> 0) + (r >>> 0), Js = (e, t, s, n, r, i) => t + s + n + r + i + (e / 2 ** 32 | 0) | 0, Qs = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]), yt = /* @__PURE__ */ new Uint32Array(64);
+class tr extends yn {
+  constructor(t = 32) {
+    super(64, t, 8, !1), this.A = pt[0] | 0, this.B = pt[1] | 0, this.C = pt[2] | 0, this.D = pt[3] | 0, this.E = pt[4] | 0, this.F = pt[5] | 0, this.G = pt[6] | 0, this.H = pt[7] | 0;
+  }
+  get() {
+    const { A: t, B: s, C: n, D: r, E: i, F: o, G: a, H: c } = this;
+    return [t, s, n, r, i, o, a, c];
+  }
+  // prettier-ignore
+  set(t, s, n, r, i, o, a, c) {
+    this.A = t | 0, this.B = s | 0, this.C = n | 0, this.D = r | 0, this.E = i | 0, this.F = o | 0, this.G = a | 0, this.H = c | 0;
+  }
+  process(t, s) {
+    for (let u = 0; u < 16; u++, s += 4)
+      yt[u] = t.getUint32(s, !1);
+    for (let u = 16; u < 64; u++) {
+      const f = yt[u - 15], d = yt[u - 2], p = at(f, 7) ^ at(f, 18) ^ f >>> 3, m = at(d, 17) ^ at(d, 19) ^ d >>> 10;
+      yt[u] = m + yt[u - 7] + p + yt[u - 16] | 0;
+    }
+    let { A: n, B: r, C: i, D: o, E: a, F: c, G: l, H: h } = this;
+    for (let u = 0; u < 64; u++) {
+      const f = at(a, 6) ^ at(a, 11) ^ at(a, 25), d = h + f + Gs(a, c, l) + Qs[u] + yt[u] | 0, m = (at(n, 2) ^ at(n, 13) ^ at(n, 22)) + $s(n, r, i) | 0;
+      h = l, l = c, c = a, a = o + d | 0, o = i, i = r, r = n, n = d + m | 0;
+    }
+    n = n + this.A | 0, r = r + this.B | 0, i = i + this.C | 0, o = o + this.D | 0, a = a + this.E | 0, c = c + this.F | 0, l = l + this.G | 0, h = h + this.H | 0, this.set(n, r, i, o, a, c, l, h);
+  }
+  roundClean() {
+    Pt(yt);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), Pt(this.buffer);
+  }
+}
+const mn = qs([
+  "0x428a2f98d728ae22",
+  "0x7137449123ef65cd",
+  "0xb5c0fbcfec4d3b2f",
+  "0xe9b5dba58189dbbc",
+  "0x3956c25bf348b538",
+  "0x59f111f1b605d019",
+  "0x923f82a4af194f9b",
+  "0xab1c5ed5da6d8118",
+  "0xd807aa98a3030242",
+  "0x12835b0145706fbe",
+  "0x243185be4ee4b28c",
+  "0x550c7dc3d5ffb4e2",
+  "0x72be5d74f27b896f",
+  "0x80deb1fe3b1696b1",
+  "0x9bdc06a725c71235",
+  "0xc19bf174cf692694",
+  "0xe49b69c19ef14ad2",
+  "0xefbe4786384f25e3",
+  "0x0fc19dc68b8cd5b5",
+  "0x240ca1cc77ac9c65",
+  "0x2de92c6f592b0275",
+  "0x4a7484aa6ea6e483",
+  "0x5cb0a9dcbd41fbd4",
+  "0x76f988da831153b5",
+  "0x983e5152ee66dfab",
+  "0xa831c66d2db43210",
+  "0xb00327c898fb213f",
+  "0xbf597fc7beef0ee4",
+  "0xc6e00bf33da88fc2",
+  "0xd5a79147930aa725",
+  "0x06ca6351e003826f",
+  "0x142929670a0e6e70",
+  "0x27b70a8546d22ffc",
+  "0x2e1b21385c26c926",
+  "0x4d2c6dfc5ac42aed",
+  "0x53380d139d95b3df",
+  "0x650a73548baf63de",
+  "0x766a0abb3c77b2a8",
+  "0x81c2c92e47edaee6",
+  "0x92722c851482353b",
+  "0xa2bfe8a14cf10364",
+  "0xa81a664bbc423001",
+  "0xc24b8b70d0f89791",
+  "0xc76c51a30654be30",
+  "0xd192e819d6ef5218",
+  "0xd69906245565a910",
+  "0xf40e35855771202a",
+  "0x106aa07032bbd1b8",
+  "0x19a4c116b8d2d0c8",
+  "0x1e376c085141ab53",
+  "0x2748774cdf8eeb99",
+  "0x34b0bcb5e19b48a8",
+  "0x391c0cb3c5c95a63",
+  "0x4ed8aa4ae3418acb",
+  "0x5b9cca4f7763e373",
+  "0x682e6ff3d6b2b8a3",
+  "0x748f82ee5defb2fc",
+  "0x78a5636f43172f60",
+  "0x84c87814a1f0ab72",
+  "0x8cc702081a6439ec",
+  "0x90befffa23631e28",
+  "0xa4506cebde82bde9",
+  "0xbef9a3f7b2c67915",
+  "0xc67178f2e372532b",
+  "0xca273eceea26619c",
+  "0xd186b8c721c0c207",
+  "0xeada7dd6cde0eb1e",
+  "0xf57d4f7fee6ed178",
+  "0x06f067aa72176fba",
+  "0x0a637dc5a2c898a6",
+  "0x113f9804bef90dae",
+  "0x1b710b35131c471b",
+  "0x28db77f523047d84",
+  "0x32caab7b40c72493",
+  "0x3c9ebe0a15c9bebc",
+  "0x431d67c49c100d4c",
+  "0x4cc5d4becb3e42b6",
+  "0x597f299cfc657e2a",
+  "0x5fcb6fab3ad6faec",
+  "0x6c44198c4a475817"
+].map((e) => BigInt(e))), er = mn[0], nr = mn[1], mt = /* @__PURE__ */ new Uint32Array(80), Et = /* @__PURE__ */ new Uint32Array(80);
+class En extends yn {
+  constructor(t = 64) {
+    super(128, t, 16, !1), this.Ah = X[0] | 0, this.Al = X[1] | 0, this.Bh = X[2] | 0, this.Bl = X[3] | 0, this.Ch = X[4] | 0, this.Cl = X[5] | 0, this.Dh = X[6] | 0, this.Dl = X[7] | 0, this.Eh = X[8] | 0, this.El = X[9] | 0, this.Fh = X[10] | 0, this.Fl = X[11] | 0, this.Gh = X[12] | 0, this.Gl = X[13] | 0, this.Hh = X[14] | 0, this.Hl = X[15] | 0;
+  }
+  // prettier-ignore
+  get() {
+    const { Ah: t, Al: s, Bh: n, Bl: r, Ch: i, Cl: o, Dh: a, Dl: c, Eh: l, El: h, Fh: u, Fl: f, Gh: d, Gl: p, Hh: m, Hl: R } = this;
+    return [t, s, n, r, i, o, a, c, l, h, u, f, d, p, m, R];
+  }
+  // prettier-ignore
+  set(t, s, n, r, i, o, a, c, l, h, u, f, d, p, m, R) {
+    this.Ah = t | 0, this.Al = s | 0, this.Bh = n | 0, this.Bl = r | 0, this.Ch = i | 0, this.Cl = o | 0, this.Dh = a | 0, this.Dl = c | 0, this.Eh = l | 0, this.El = h | 0, this.Fh = u | 0, this.Fl = f | 0, this.Gh = d | 0, this.Gl = p | 0, this.Hh = m | 0, this.Hl = R | 0;
+  }
+  process(t, s) {
+    for (let A = 0; A < 16; A++, s += 4)
+      mt[A] = t.getUint32(s), Et[A] = t.getUint32(s += 4);
+    for (let A = 16; A < 80; A++) {
+      const q = mt[A - 15] | 0, K = Et[A - 15] | 0, ot = Nt(q, K, 1) ^ Nt(q, K, 8) ^ tn(q, K, 7), bt = Ht(q, K, 1) ^ Ht(q, K, 8) ^ en(q, K, 7), F = mt[A - 2] | 0, B = Et[A - 2] | 0, ft = Nt(F, B, 19) ^ Jt(F, B, 61) ^ tn(F, B, 6), nt = Ht(F, B, 19) ^ Qt(F, B, 61) ^ en(F, B, 6), T = Ws(bt, nt, Et[A - 7], Et[A - 16]), b = Ys(T, ot, ft, mt[A - 7], mt[A - 16]);
+      mt[A] = b | 0, Et[A] = T | 0;
+    }
+    let { Ah: n, Al: r, Bh: i, Bl: o, Ch: a, Cl: c, Dh: l, Dl: h, Eh: u, El: f, Fh: d, Fl: p, Gh: m, Gl: R, Hh: _, Hl: et } = this;
+    for (let A = 0; A < 80; A++) {
+      const q = Nt(u, f, 14) ^ Nt(u, f, 18) ^ Jt(u, f, 41), K = Ht(u, f, 14) ^ Ht(u, f, 18) ^ Qt(u, f, 41), ot = u & d ^ ~u & m, bt = f & p ^ ~f & R, F = zs(et, K, bt, nr[A], Et[A]), B = Js(F, _, q, ot, er[A], mt[A]), ft = F | 0, nt = Nt(n, r, 28) ^ Jt(n, r, 34) ^ Jt(n, r, 39), T = Ht(n, r, 28) ^ Qt(n, r, 34) ^ Qt(n, r, 39), b = n & i ^ n & a ^ i & a, w = r & o ^ r & c ^ o & c;
+      _ = m | 0, et = R | 0, m = d | 0, R = p | 0, d = u | 0, p = f | 0, { h: u, l: f } = lt(l | 0, h | 0, B | 0, ft | 0), l = a | 0, h = c | 0, a = i | 0, c = o | 0, i = n | 0, o = r | 0;
+      const g = Ms(ft, T, w);
+      n = Zs(g, B, nt, b), r = g | 0;
+    }
+    ({ h: n, l: r } = lt(this.Ah | 0, this.Al | 0, n | 0, r | 0)), { h: i, l: o } = lt(this.Bh | 0, this.Bl | 0, i | 0, o | 0), { h: a, l: c } = lt(this.Ch | 0, this.Cl | 0, a | 0, c | 0), { h: l, l: h } = lt(this.Dh | 0, this.Dl | 0, l | 0, h | 0), { h: u, l: f } = lt(this.Eh | 0, this.El | 0, u | 0, f | 0), { h: d, l: p } = lt(this.Fh | 0, this.Fl | 0, d | 0, p | 0), { h: m, l: R } = lt(this.Gh | 0, this.Gl | 0, m | 0, R | 0), { h: _, l: et } = lt(this.Hh | 0, this.Hl | 0, _ | 0, et | 0), this.set(n, r, i, o, a, c, l, h, u, f, d, p, m, R, _, et);
+  }
+  roundClean() {
+    Pt(mt, Et);
+  }
+  destroy() {
+    Pt(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+class sr extends En {
+  constructor() {
+    super(48), this.Ah = $[0] | 0, this.Al = $[1] | 0, this.Bh = $[2] | 0, this.Bl = $[3] | 0, this.Ch = $[4] | 0, this.Cl = $[5] | 0, this.Dh = $[6] | 0, this.Dl = $[7] | 0, this.Eh = $[8] | 0, this.El = $[9] | 0, this.Fh = $[10] | 0, this.Fl = $[11] | 0, this.Gh = $[12] | 0, this.Gl = $[13] | 0, this.Hh = $[14] | 0, this.Hl = $[15] | 0;
+  }
+}
+const rr = /* @__PURE__ */ Ue(() => new tr()), ir = /* @__PURE__ */ Ue(() => new En()), or = /* @__PURE__ */ Ue(() => new sr());
+class xn extends bn {
+  constructor(t, s) {
+    super(), this.finished = !1, this.destroyed = !1, gn(t);
+    const n = De(s);
+    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 r = this.blockLen, i = new Uint8Array(r);
+    i.set(n.length > r ? t.create().update(n).digest() : n);
+    for (let o = 0; o < i.length; o++)
+      i[o] ^= 54;
+    this.iHash.update(i), this.oHash = t.create();
+    for (let o = 0; o < i.length; o++)
+      i[o] ^= 106;
+    this.oHash.update(i), Pt(i);
+  }
+  update(t) {
+    return ae(this), this.iHash.update(t), this;
+  }
+  digestInto(t) {
+    ae(this), Ct(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: s, iHash: n, finished: r, destroyed: i, blockLen: o, outputLen: a } = this;
+    return t = t, t.finished = r, t.destroyed = i, t.blockLen = o, t.outputLen = a, t.oHash = s._cloneInto(t.oHash), t.iHash = n._cloneInto(t.iHash), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+}
+const Sn = (e, t, s) => new xn(e, t).update(s).digest();
+Sn.create = (e, t) => new xn(e, t);
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const _e = /* @__PURE__ */ BigInt(0), Re = /* @__PURE__ */ BigInt(1);
+function fe(e, t = "") {
+  if (typeof e != "boolean") {
+    const s = t && `"${t}"`;
+    throw new Error(s + "expected boolean, got type=" + typeof e);
+  }
+  return e;
+}
+function vt(e, t, s = "") {
+  const n = de(e), r = e?.length, i = t !== void 0;
+  if (!n || i && r !== t) {
+    const o = s && `"${s}" `, a = i ? ` of length ${t}` : "", c = n ? `length=${r}` : `type=${typeof e}`;
+    throw new Error(o + "expected Uint8Array" + a + ", got " + c);
+  }
+  return e;
+}
+function te(e) {
+  const t = e.toString(16);
+  return t.length & 1 ? "0" + t : t;
+}
+function In(e) {
+  if (typeof e != "string")
+    throw new Error("hex string expected, got " + typeof e);
+  return e === "" ? _e : BigInt("0x" + e);
+}
+function ge(e) {
+  return In(jt(e));
+}
+function vn(e) {
+  return Ct(e), In(jt(Uint8Array.from(e).reverse()));
+}
+function Ne(e, t) {
+  return ce(e.toString(16).padStart(t * 2, "0"));
+}
+function An(e, t) {
+  return Ne(e, t).reverse();
+}
+function z(e, t, s) {
+  let n;
+  if (typeof t == "string")
+    try {
+      n = ce(t);
+    } catch (r) {
+      throw new Error(e + " must be hex string or Uint8Array, cause: " + r);
+    }
+  else if (de(t))
+    n = Uint8Array.from(t);
+  else
+    throw new Error(e + " must be hex string or Uint8Array");
+  return n.length, n;
+}
+const pe = (e) => typeof e == "bigint" && _e <= e;
+function ar(e, t, s) {
+  return pe(e) && pe(t) && pe(s) && t <= e && e < s;
+}
+function cr(e, t, s, n) {
+  if (!ar(t, s, n))
+    throw new Error("expected valid " + e + ": " + s + " <= n < " + n + ", got " + t);
+}
+function On(e) {
+  let t;
+  for (t = 0; e > _e; e >>= Re, t += 1)
+    ;
+  return t;
+}
+const Wt = (e) => (Re << BigInt(e)) - Re;
+function fr(e, t, s) {
+  if (typeof e != "number" || e < 2)
+    throw new Error("hashLen must be a number");
+  if (typeof t != "number" || t < 2)
+    throw new Error("qByteLen must be a number");
+  if (typeof s != "function")
+    throw new Error("hmacFn must be a function");
+  const n = (d) => new Uint8Array(d), r = (d) => Uint8Array.of(d);
+  let i = n(e), o = n(e), a = 0;
+  const c = () => {
+    i.fill(1), o.fill(0), a = 0;
+  }, l = (...d) => s(o, i, ...d), h = (d = n(0)) => {
+    o = l(r(0), d), i = l(), d.length !== 0 && (o = l(r(1), d), i = l());
+  }, u = () => {
+    if (a++ >= 1e3)
+      throw new Error("drbg: tried 1000 values");
+    let d = 0;
+    const p = [];
+    for (; d < t; ) {
+      i = l();
+      const m = i.slice();
+      p.push(m), d += i.length;
+    }
+    return xt(...p);
+  };
+  return (d, p) => {
+    c(), h(d);
+    let m;
+    for (; !(m = p(u())); )
+      h();
+    return c(), m;
+  };
+}
+function He(e, t, s = {}) {
+  if (!e || typeof e != "object")
+    throw new Error("expected valid options object");
+  function n(r, i, o) {
+    const a = e[r];
+    if (o && a === void 0)
+      return;
+    const c = typeof a;
+    if (c !== i || a === null)
+      throw new Error(`param "${r}" is invalid: expected ${i}, got ${c}`);
+  }
+  Object.entries(t).forEach(([r, i]) => n(r, i, !1)), Object.entries(s).forEach(([r, i]) => n(r, i, !0));
+}
+function nn(e) {
+  const t = /* @__PURE__ */ new WeakMap();
+  return (s, ...n) => {
+    const r = t.get(s);
+    if (r !== void 0)
+      return r;
+    const i = e(s, ...n);
+    return t.set(s, i), i;
+  };
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const tt = BigInt(0), M = BigInt(1), At = /* @__PURE__ */ BigInt(2), Bn = /* @__PURE__ */ BigInt(3), Rn = /* @__PURE__ */ BigInt(4), Cn = /* @__PURE__ */ BigInt(5), ur = /* @__PURE__ */ BigInt(7), Tn = /* @__PURE__ */ BigInt(8), lr = /* @__PURE__ */ BigInt(9), Dn = /* @__PURE__ */ BigInt(16);
+function st(e, t) {
+  const s = e % t;
+  return s >= tt ? s : t + s;
+}
+function sn(e, t) {
+  if (e === tt)
+    throw new Error("invert: expected non-zero number");
+  if (t <= tt)
+    throw new Error("invert: expected positive modulus, got " + t);
+  let s = st(e, t), n = t, r = tt, i = M;
+  for (; s !== tt; ) {
+    const a = n / s, c = n % s, l = r - i * a;
+    n = s, s = c, r = i, i = l;
+  }
+  if (n !== M)
+    throw new Error("invert: does not exist");
+  return st(r, t);
+}
+function Ve(e, t, s) {
+  if (!e.eql(e.sqr(t), s))
+    throw new Error("Cannot find square root");
+}
+function Un(e, t) {
+  const s = (e.ORDER + M) / Rn, n = e.pow(t, s);
+  return Ve(e, n, t), n;
+}
+function hr(e, t) {
+  const s = (e.ORDER - Cn) / Tn, n = e.mul(t, At), r = e.pow(n, s), i = e.mul(t, r), o = e.mul(e.mul(i, At), r), a = e.mul(i, e.sub(o, e.ONE));
+  return Ve(e, a, t), a;
+}
+function dr(e) {
+  const t = Tt(e), s = _n(e), n = s(t, t.neg(t.ONE)), r = s(t, n), i = s(t, t.neg(n)), o = (e + ur) / Dn;
+  return (a, c) => {
+    let l = a.pow(c, o), h = a.mul(l, n);
+    const u = a.mul(l, r), f = a.mul(l, i), d = a.eql(a.sqr(h), c), p = a.eql(a.sqr(u), c);
+    l = a.cmov(l, h, d), h = a.cmov(f, u, p);
+    const m = a.eql(a.sqr(h), c), R = a.cmov(l, h, m);
+    return Ve(a, R, c), R;
+  };
+}
+function _n(e) {
+  if (e < Bn)
+    throw new Error("sqrt is not defined for small field");
+  let t = e - M, s = 0;
+  for (; t % At === tt; )
+    t /= At, s++;
+  let n = At;
+  const r = Tt(e);
+  for (; rn(r, n) === 1; )
+    if (n++ > 1e3)
+      throw new Error("Cannot find square root: probably non-prime P");
+  if (s === 1)
+    return Un;
+  let i = r.pow(n, t);
+  const o = (t + M) / At;
+  return function(c, l) {
+    if (c.is0(l))
+      return l;
+    if (rn(c, l) !== 1)
+      throw new Error("Cannot find square root");
+    let h = s, u = c.mul(c.ONE, i), f = c.pow(l, t), d = c.pow(l, o);
+    for (; !c.eql(f, c.ONE); ) {
+      if (c.is0(f))
+        return c.ZERO;
+      let p = 1, m = c.sqr(f);
+      for (; !c.eql(m, c.ONE); )
+        if (p++, m = c.sqr(m), p === h)
+          throw new Error("Cannot find square root");
+      const R = M << BigInt(h - p - 1), _ = c.pow(u, R);
+      h = p, u = c.sqr(_), f = c.mul(f, u), d = c.mul(d, _);
+    }
+    return d;
+  };
+}
+function gr(e) {
+  return e % Rn === Bn ? Un : e % Tn === Cn ? hr : e % Dn === lr ? dr(e) : _n(e);
+}
+const wr = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function br(e) {
+  const t = {
+    ORDER: "bigint",
+    MASK: "bigint",
+    BYTES: "number",
+    BITS: "number"
+  }, s = wr.reduce((n, r) => (n[r] = "function", n), t);
+  return He(e, s), e;
+}
+function pr(e, t, s) {
+  if (s < tt)
+    throw new Error("invalid exponent, negatives unsupported");
+  if (s === tt)
+    return e.ONE;
+  if (s === M)
+    return t;
+  let n = e.ONE, r = t;
+  for (; s > tt; )
+    s & M && (n = e.mul(n, r)), r = e.sqr(r), s >>= M;
+  return n;
+}
+function Nn(e, t, s = !1) {
+  const n = new Array(t.length).fill(s ? e.ZERO : void 0), r = t.reduce((o, a, c) => e.is0(a) ? o : (n[c] = o, e.mul(o, a)), e.ONE), i = e.inv(r);
+  return t.reduceRight((o, a, c) => e.is0(a) ? o : (n[c] = e.mul(o, n[c]), e.mul(o, a)), i), n;
+}
+function rn(e, t) {
+  const s = (e.ORDER - M) / At, n = e.pow(t, s), r = e.eql(n, e.ONE), i = e.eql(n, e.ZERO), o = e.eql(n, e.neg(e.ONE));
+  if (!r && !i && !o)
+    throw new Error("invalid Legendre symbol result");
+  return r ? 1 : i ? 0 : -1;
+}
+function Hn(e, t) {
+  t !== void 0 && Be(t);
+  const s = t !== void 0 ? t : e.toString(2).length, n = Math.ceil(s / 8);
+  return { nBitLength: s, nByteLength: n };
+}
+function Tt(e, t, s = !1, n = {}) {
+  if (e <= tt)
+    throw new Error("invalid field: expected ORDER > 0, got " + e);
+  let r, i, o = !1, a;
+  if (typeof t == "object" && t != null) {
+    if (n.sqrt || s)
+      throw new Error("cannot specify opts in two arguments");
+    const f = t;
+    f.BITS && (r = f.BITS), f.sqrt && (i = f.sqrt), typeof f.isLE == "boolean" && (s = f.isLE), typeof f.modFromBytes == "boolean" && (o = f.modFromBytes), a = f.allowedLengths;
+  } else
+    typeof t == "number" && (r = t), n.sqrt && (i = n.sqrt);
+  const { nBitLength: c, nByteLength: l } = Hn(e, r);
+  if (l > 2048)
+    throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+  let h;
+  const u = Object.freeze({
+    ORDER: e,
+    isLE: s,
+    BITS: c,
+    BYTES: l,
+    MASK: Wt(c),
+    ZERO: tt,
+    ONE: M,
+    allowedLengths: a,
+    create: (f) => st(f, e),
+    isValid: (f) => {
+      if (typeof f != "bigint")
+        throw new Error("invalid field element: expected bigint, got " + typeof f);
+      return tt <= f && f < e;
+    },
+    is0: (f) => f === tt,
+    // is valid and invertible
+    isValidNot0: (f) => !u.is0(f) && u.isValid(f),
+    isOdd: (f) => (f & M) === M,
+    neg: (f) => st(-f, e),
+    eql: (f, d) => f === d,
+    sqr: (f) => st(f * f, e),
+    add: (f, d) => st(f + d, e),
+    sub: (f, d) => st(f - d, e),
+    mul: (f, d) => st(f * d, e),
+    pow: (f, d) => pr(u, f, d),
+    div: (f, d) => st(f * sn(d, e), e),
+    // Same as above, but doesn't normalize
+    sqrN: (f) => f * f,
+    addN: (f, d) => f + d,
+    subN: (f, d) => f - d,
+    mulN: (f, d) => f * d,
+    inv: (f) => sn(f, e),
+    sqrt: i || ((f) => (h || (h = gr(e)), h(u, f))),
+    toBytes: (f) => s ? An(f, l) : Ne(f, l),
+    fromBytes: (f, d = !0) => {
+      if (a) {
+        if (!a.includes(f.length) || f.length > l)
+          throw new Error("Field.fromBytes: expected " + a + " bytes, got " + f.length);
+        const m = new Uint8Array(l);
+        m.set(f, s ? 0 : m.length - f.length), f = m;
+      }
+      if (f.length !== l)
+        throw new Error("Field.fromBytes: expected " + l + " bytes, got " + f.length);
+      let p = s ? vn(f) : ge(f);
+      if (o && (p = st(p, e)), !d && !u.isValid(p))
+        throw new Error("invalid field element: outside of range 0..ORDER");
+      return p;
+    },
+    // TODO: we don't need it here, move out to separate fn
+    invertBatch: (f) => Nn(u, f),
+    // We can't move this out because Fp6, Fp12 implement it
+    // and it's unclear what to return in there.
+    cmov: (f, d, p) => p ? d : f
+  });
+  return Object.freeze(u);
+}
+function Vn(e) {
+  if (typeof e != "bigint")
+    throw new Error("field order must be bigint");
+  const t = e.toString(2).length;
+  return Math.ceil(t / 8);
+}
+function jn(e) {
+  const t = Vn(e);
+  return t + Math.ceil(t / 2);
+}
+function yr(e, t, s = !1) {
+  const n = e.length, r = Vn(t), i = jn(t);
+  if (n < 16 || n < i || n > 1024)
+    throw new Error("expected " + i + "-1024 bytes of input, got " + n);
+  const o = s ? vn(e) : ge(e), a = st(o, t - M) + M;
+  return s ? An(a, r) : Ne(a, r);
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const Ft = BigInt(0), Ot = BigInt(1);
+function ue(e, t) {
+  const s = t.negate();
+  return e ? s : t;
+}
+function ye(e, t) {
+  const s = Nn(e.Fp, t.map((n) => n.Z));
+  return t.map((n, r) => e.fromAffine(n.toAffine(s[r])));
+}
+function kn(e, t) {
+  if (!Number.isSafeInteger(e) || e <= 0 || e > t)
+    throw new Error("invalid window size, expected [1.." + t + "], got W=" + e);
+}
+function me(e, t) {
+  kn(e, t);
+  const s = Math.ceil(t / e) + 1, n = 2 ** (e - 1), r = 2 ** e, i = Wt(e), o = BigInt(e);
+  return { windows: s, windowSize: n, mask: i, maxNumber: r, shiftBy: o };
+}
+function on(e, t, s) {
+  const { windowSize: n, mask: r, maxNumber: i, shiftBy: o } = s;
+  let a = Number(e & r), c = e >> o;
+  a > n && (a -= i, c += Ot);
+  const l = t * n, h = l + Math.abs(a) - 1, u = a === 0, f = a < 0, d = t % 2 !== 0;
+  return { nextN: c, offset: h, isZero: u, isNeg: f, isNegF: d, offsetF: l };
+}
+function mr(e, t) {
+  if (!Array.isArray(e))
+    throw new Error("array expected");
+  e.forEach((s, n) => {
+    if (!(s instanceof t))
+      throw new Error("invalid point at index " + n);
+  });
+}
+function Er(e, t) {
+  if (!Array.isArray(e))
+    throw new Error("array of scalars expected");
+  e.forEach((s, n) => {
+    if (!t.isValid(s))
+      throw new Error("invalid scalar at index " + n);
+  });
+}
+const Ee = /* @__PURE__ */ new WeakMap(), Ln = /* @__PURE__ */ new WeakMap();
+function xe(e) {
+  return Ln.get(e) || 1;
+}
+function an(e) {
+  if (e !== Ft)
+    throw new Error("invalid wNAF");
+}
+class xr {
+  // Parametrized with a given Point class (not individual point)
+  constructor(t, s) {
+    this.BASE = t.BASE, this.ZERO = t.ZERO, this.Fn = t.Fn, this.bits = s;
+  }
+  // non-const time multiplication ladder
+  _unsafeLadder(t, s, n = this.ZERO) {
+    let r = t;
+    for (; s > Ft; )
+      s & Ot && (n = n.add(r)), r = r.double(), s >>= Ot;
+    return n;
+  }
+  /**
+   * Creates a wNAF precomputation window. Used for caching.
+   * Default window size is set by `utils.precompute()` and is equal to 8.
+   * Number of precomputed points depends on the curve size:
+   * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+   * - 𝑊 is the window size
+   * - 𝑛 is the bitlength of the curve order.
+   * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+   * @param point Point instance
+   * @param W window size
+   * @returns precomputed point tables flattened to a single array
+   */
+  precomputeWindow(t, s) {
+    const { windows: n, windowSize: r } = me(s, this.bits), i = [];
+    let o = t, a = o;
+    for (let c = 0; c < n; c++) {
+      a = o, i.push(a);
+      for (let l = 1; l < r; l++)
+        a = a.add(o), i.push(a);
+      o = a.double();
+    }
+    return i;
+  }
+  /**
+   * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+   * More compact implementation:
+   * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541
+   * @returns real and fake (for const-time) points
+   */
+  wNAF(t, s, n) {
+    if (!this.Fn.isValid(n))
+      throw new Error("invalid scalar");
+    let r = this.ZERO, i = this.BASE;
+    const o = me(t, this.bits);
+    for (let a = 0; a < o.windows; a++) {
+      const { nextN: c, offset: l, isZero: h, isNeg: u, isNegF: f, offsetF: d } = on(n, a, o);
+      n = c, h ? i = i.add(ue(f, s[d])) : r = r.add(ue(u, s[l]));
+    }
+    return an(n), { p: r, f: i };
+  }
+  /**
+   * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
+   * @param acc accumulator point to add result of multiplication
+   * @returns point
+   */
+  wNAFUnsafe(t, s, n, r = this.ZERO) {
+    const i = me(t, this.bits);
+    for (let o = 0; o < i.windows && n !== Ft; o++) {
+      const { nextN: a, offset: c, isZero: l, isNeg: h } = on(n, o, i);
+      if (n = a, !l) {
+        const u = s[c];
+        r = r.add(h ? u.negate() : u);
+      }
+    }
+    return an(n), r;
+  }
+  getPrecomputes(t, s, n) {
+    let r = Ee.get(s);
+    return r || (r = this.precomputeWindow(s, t), t !== 1 && (typeof n == "function" && (r = n(r)), Ee.set(s, r))), r;
+  }
+  cached(t, s, n) {
+    const r = xe(t);
+    return this.wNAF(r, this.getPrecomputes(r, t, n), s);
+  }
+  unsafe(t, s, n, r) {
+    const i = xe(t);
+    return i === 1 ? this._unsafeLadder(t, s, r) : this.wNAFUnsafe(i, this.getPrecomputes(i, t, n), s, r);
+  }
+  // We calculate precomputes for elliptic curve point multiplication
+  // using windowed method. This specifies window size and
+  // stores precomputed values. Usually only base point would be precomputed.
+  createCache(t, s) {
+    kn(s, this.bits), Ln.set(t, s), Ee.delete(t);
+  }
+  hasCache(t) {
+    return xe(t) !== 1;
+  }
+}
+function Sr(e, t, s, n) {
+  let r = t, i = e.ZERO, o = e.ZERO;
+  for (; s > Ft || n > Ft; )
+    s & Ot && (i = i.add(r)), n & Ot && (o = o.add(r)), r = r.double(), s >>= Ot, n >>= Ot;
+  return { p1: i, p2: o };
+}
+function Ir(e, t, s, n) {
+  mr(s, e), Er(n, t);
+  const r = s.length, i = n.length;
+  if (r !== i)
+    throw new Error("arrays of points and scalars must have equal length");
+  const o = e.ZERO, a = On(BigInt(r));
+  let c = 1;
+  a > 12 ? c = a - 3 : a > 4 ? c = a - 2 : a > 0 && (c = 2);
+  const l = Wt(c), h = new Array(Number(l) + 1).fill(o), u = Math.floor((t.BITS - 1) / c) * c;
+  let f = o;
+  for (let d = u; d >= 0; d -= c) {
+    h.fill(o);
+    for (let m = 0; m < i; m++) {
+      const R = n[m], _ = Number(R >> BigInt(d) & l);
+      h[_] = h[_].add(s[m]);
+    }
+    let p = o;
+    for (let m = h.length - 1, R = o; m > 0; m--)
+      R = R.add(h[m]), p = p.add(R);
+    if (f = f.add(p), d !== 0)
+      for (let m = 0; m < c; m++)
+        f = f.double();
+  }
+  return f;
+}
+function cn(e, t, s) {
+  if (t) {
+    if (t.ORDER !== e)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    return br(t), t;
+  } else
+    return Tt(e, { isLE: s });
+}
+function vr(e, t, s = {}, n) {
+  if (n === void 0 && (n = e === "edwards"), !t || typeof t != "object")
+    throw new Error(`expected valid ${e} CURVE object`);
+  for (const c of ["p", "n", "h"]) {
+    const l = t[c];
+    if (!(typeof l == "bigint" && l > Ft))
+      throw new Error(`CURVE.${c} must be positive bigint`);
+  }
+  const r = cn(t.p, s.Fp, n), i = cn(t.n, s.Fn, n), a = ["Gx", "Gy", "a", "b"];
+  for (const c of a)
+    if (!r.isValid(t[c]))
+      throw new Error(`CURVE.${c} must be valid field element of CURVE.Fp`);
+  return t = Object.freeze(Object.assign({}, t)), { CURVE: t, Fp: r, Fn: i };
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const fn = (e, t) => (e + (e >= 0 ? t : -t) / Kn) / t;
+function Ar(e, t, s) {
+  const [[n, r], [i, o]] = t, a = fn(o * e, s), c = fn(-r * e, s);
+  let l = e - a * n - c * i, h = -a * r - c * o;
+  const u = l < gt, f = h < gt;
+  u && (l = -l), f && (h = -h);
+  const d = Wt(Math.ceil(On(s) / 2)) + kt;
+  if (l < gt || l >= d || h < gt || h >= d)
+    throw new Error("splitScalar (endomorphism): failed, k=" + e);
+  return { k1neg: u, k1: l, k2neg: f, k2: h };
+}
+function Ce(e) {
+  if (!["compact", "recovered", "der"].includes(e))
+    throw new Error('Signature format must be "compact", "recovered", or "der"');
+  return e;
+}
+function Se(e, t) {
+  const s = {};
+  for (let n of Object.keys(t))
+    s[n] = e[n] === void 0 ? t[n] : e[n];
+  return fe(s.lowS, "lowS"), fe(s.prehash, "prehash"), s.format !== void 0 && Ce(s.format), s;
+}
+class Or extends Error {
+  constructor(t = "") {
+    super(t);
+  }
+}
+const dt = {
+  // asn.1 DER encoding utils
+  Err: Or,
+  // Basic building block is TLV (Tag-Length-Value)
+  _tlv: {
+    encode: (e, t) => {
+      const { Err: s } = dt;
+      if (e < 0 || e > 256)
+        throw new s("tlv.encode: wrong tag");
+      if (t.length & 1)
+        throw new s("tlv.encode: unpadded data");
+      const n = t.length / 2, r = te(n);
+      if (r.length / 2 & 128)
+        throw new s("tlv.encode: long form length too big");
+      const i = n > 127 ? te(r.length / 2 | 128) : "";
+      return te(e) + i + r + t;
+    },
+    // v - value, l - left bytes (unparsed)
+    decode(e, t) {
+      const { Err: s } = dt;
+      let n = 0;
+      if (e < 0 || e > 256)
+        throw new s("tlv.encode: wrong tag");
+      if (t.length < 2 || t[n++] !== e)
+        throw new s("tlv.decode: wrong tlv");
+      const r = t[n++], i = !!(r & 128);
+      let o = 0;
+      if (!i)
+        o = r;
+      else {
+        const c = r & 127;
+        if (!c)
+          throw new s("tlv.decode(long): indefinite length not supported");
+        if (c > 4)
+          throw new s("tlv.decode(long): byte length is too big");
+        const l = t.subarray(n, n + c);
+        if (l.length !== c)
+          throw new s("tlv.decode: length bytes not complete");
+        if (l[0] === 0)
+          throw new s("tlv.decode(long): zero leftmost byte");
+        for (const h of l)
+          o = o << 8 | h;
+        if (n += c, o < 128)
+          throw new s("tlv.decode(long): not minimal encoding");
+      }
+      const a = t.subarray(n, n + o);
+      if (a.length !== o)
+        throw new s("tlv.decode: wrong value length");
+      return { v: a, l: t.subarray(n + o) };
+    }
+  },
+  // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+  // since we always use positive integers here. It must always be empty:
+  // - add zero byte if exists
+  // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+  _int: {
+    encode(e) {
+      const { Err: t } = dt;
+      if (e < gt)
+        throw new t("integer: negative integers are not allowed");
+      let s = te(e);
+      if (Number.parseInt(s[0], 16) & 8 && (s = "00" + s), s.length & 1)
+        throw new t("unexpected DER parsing assertion: unpadded hex");
+      return s;
+    },
+    decode(e) {
+      const { Err: t } = dt;
+      if (e[0] & 128)
+        throw new t("invalid signature integer: negative");
+      if (e[0] === 0 && !(e[1] & 128))
+        throw new t("invalid signature integer: unnecessary leading zero");
+      return ge(e);
+    }
+  },
+  toSig(e) {
+    const { Err: t, _int: s, _tlv: n } = dt, r = z("signature", e), { v: i, l: o } = n.decode(48, r);
+    if (o.length)
+      throw new t("invalid signature: left bytes after parsing");
+    const { v: a, l: c } = n.decode(2, i), { v: l, l: h } = n.decode(2, c);
+    if (h.length)
+      throw new t("invalid signature: left bytes after parsing");
+    return { r: s.decode(a), s: s.decode(l) };
+  },
+  hexFromSig(e) {
+    const { _tlv: t, _int: s } = dt, n = t.encode(2, s.encode(e.r)), r = t.encode(2, s.encode(e.s)), i = n + r;
+    return t.encode(48, i);
+  }
+}, gt = BigInt(0), kt = BigInt(1), Kn = BigInt(2), ee = BigInt(3), Br = BigInt(4);
+function Vt(e, t) {
+  const { BYTES: s } = e;
+  let n;
+  if (typeof t == "bigint")
+    n = t;
+  else {
+    let r = z("private key", t);
+    try {
+      n = e.fromBytes(r);
+    } catch {
+      throw new Error(`invalid private key: expected ui8a of size ${s}, got ${typeof t}`);
+    }
+  }
+  if (!e.isValidNot0(n))
+    throw new Error("invalid private key: out of range [1..N-1]");
+  return n;
+}
+function Rr(e, t = {}) {
+  const s = vr("weierstrass", e, t), { Fp: n, Fn: r } = s;
+  let i = s.CURVE;
+  const { h: o, n: a } = i;
+  He(t, {}, {
+    allowInfinityPoint: "boolean",
+    clearCofactor: "function",
+    isTorsionFree: "function",
+    fromBytes: "function",
+    toBytes: "function",
+    endo: "object",
+    wrapPrivateKey: "boolean"
+  });
+  const { endo: c } = t;
+  if (c && (!n.is0(i.a) || typeof c.beta != "bigint" || !Array.isArray(c.basises)))
+    throw new Error('invalid endo: expected "beta": bigint and "basises": array');
+  const l = Fn(n, r);
+  function h() {
+    if (!n.isOdd)
+      throw new Error("compression is not supported: Field does not have .isOdd()");
+  }
+  function u(T, b, w) {
+    const { x: g, y } = b.toAffine(), E = n.toBytes(g);
+    if (fe(w, "isCompressed"), w) {
+      h();
+      const v = !n.isOdd(y);
+      return xt(Pn(v), E);
+    } else
+      return xt(Uint8Array.of(4), E, n.toBytes(y));
+  }
+  function f(T) {
+    vt(T, void 0, "Point");
+    const { publicKey: b, publicKeyUncompressed: w } = l, g = T.length, y = T[0], E = T.subarray(1);
+    if (g === b && (y === 2 || y === 3)) {
+      const v = n.fromBytes(E);
+      if (!n.isValid(v))
+        throw new Error("bad point: is not on curve, wrong x");
+      const I = m(v);
+      let x;
+      try {
+        x = n.sqrt(I);
+      } catch (k) {
+        const N = k instanceof Error ? ": " + k.message : "";
+        throw new Error("bad point: is not on curve, sqrt error" + N);
+      }
+      h();
+      const O = n.isOdd(x);
+      return (y & 1) === 1 !== O && (x = n.neg(x)), { x: v, y: x };
+    } else if (g === w && y === 4) {
+      const v = n.BYTES, I = n.fromBytes(E.subarray(0, v)), x = n.fromBytes(E.subarray(v, v * 2));
+      if (!R(I, x))
+        throw new Error("bad point: is not on curve");
+      return { x: I, y: x };
+    } else
+      throw new Error(`bad point: got length ${g}, expected compressed=${b} or uncompressed=${w}`);
+  }
+  const d = t.toBytes || u, p = t.fromBytes || f;
+  function m(T) {
+    const b = n.sqr(T), w = n.mul(b, T);
+    return n.add(n.add(w, n.mul(T, i.a)), i.b);
+  }
+  function R(T, b) {
+    const w = n.sqr(b), g = m(T);
+    return n.eql(w, g);
+  }
+  if (!R(i.Gx, i.Gy))
+    throw new Error("bad curve params: generator point");
+  const _ = n.mul(n.pow(i.a, ee), Br), et = n.mul(n.sqr(i.b), BigInt(27));
+  if (n.is0(n.add(_, et)))
+    throw new Error("bad curve params: a or b");
+  function A(T, b, w = !1) {
+    if (!n.isValid(b) || w && n.is0(b))
+      throw new Error(`bad point coordinate ${T}`);
+    return b;
+  }
+  function q(T) {
+    if (!(T instanceof B))
+      throw new Error("ProjectivePoint expected");
+  }
+  function K(T) {
+    if (!c || !c.basises)
+      throw new Error("no endo");
+    return Ar(T, c.basises, r.ORDER);
+  }
+  const ot = nn((T, b) => {
+    const { X: w, Y: g, Z: y } = T;
+    if (n.eql(y, n.ONE))
+      return { x: w, y: g };
+    const E = T.is0();
+    b == null && (b = E ? n.ONE : n.inv(y));
+    const v = n.mul(w, b), I = n.mul(g, b), x = n.mul(y, b);
+    if (E)
+      return { x: n.ZERO, y: n.ZERO };
+    if (!n.eql(x, n.ONE))
+      throw new Error("invZ was invalid");
+    return { x: v, y: I };
+  }), bt = nn((T) => {
+    if (T.is0()) {
+      if (t.allowInfinityPoint && !n.is0(T.Y))
+        return;
+      throw new Error("bad point: ZERO");
+    }
+    const { x: b, y: w } = T.toAffine();
+    if (!n.isValid(b) || !n.isValid(w))
+      throw new Error("bad point: x or y not field elements");
+    if (!R(b, w))
+      throw new Error("bad point: equation left != right");
+    if (!T.isTorsionFree())
+      throw new Error("bad point: not in prime-order subgroup");
+    return !0;
+  });
+  function F(T, b, w, g, y) {
+    return w = new B(n.mul(w.X, T), w.Y, w.Z), b = ue(g, b), w = ue(y, w), b.add(w);
+  }
+  class B {
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    constructor(b, w, g) {
+      this.X = A("x", b), this.Y = A("y", w, !0), this.Z = A("z", g), Object.freeze(this);
+    }
+    static CURVE() {
+      return i;
+    }
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    static fromAffine(b) {
+      const { x: w, y: g } = b || {};
+      if (!b || !n.isValid(w) || !n.isValid(g))
+        throw new Error("invalid affine point");
+      if (b instanceof B)
+        throw new Error("projective point not allowed");
+      return n.is0(w) && n.is0(g) ? B.ZERO : new B(w, g, n.ONE);
+    }
+    static fromBytes(b) {
+      const w = B.fromAffine(p(vt(b, void 0, "point")));
+      return w.assertValidity(), w;
+    }
+    static fromHex(b) {
+      return B.fromBytes(z("pointHex", b));
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    /**
+     *
+     * @param windowSize
+     * @param isLazy true will defer table computation until the first multiplication
+     * @returns
+     */
+    precompute(b = 8, w = !0) {
+      return nt.createCache(this, b), w || this.multiply(ee), this;
+    }
+    // TODO: return `this`
+    /** A point on curve is valid if it conforms to equation. */
+    assertValidity() {
+      bt(this);
+    }
+    hasEvenY() {
+      const { y: b } = this.toAffine();
+      if (!n.isOdd)
+        throw new Error("Field doesn't support isOdd");
+      return !n.isOdd(b);
+    }
+    /** Compare one point to another. */
+    equals(b) {
+      q(b);
+      const { X: w, Y: g, Z: y } = this, { X: E, Y: v, Z: I } = b, x = n.eql(n.mul(w, I), n.mul(E, y)), O = n.eql(n.mul(g, I), n.mul(v, y));
+      return x && O;
+    }
+    /** Flips point to one corresponding to (x, -y) in Affine coordinates. */
+    negate() {
+      return new B(this.X, n.neg(this.Y), this.Z);
+    }
+    // Renes-Costello-Batina exception-free doubling formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 3
+    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
+    double() {
+      const { a: b, b: w } = i, g = n.mul(w, ee), { X: y, Y: E, Z: v } = this;
+      let I = n.ZERO, x = n.ZERO, O = n.ZERO, C = n.mul(y, y), k = n.mul(E, E), N = n.mul(v, v), D = n.mul(y, E);
+      return D = n.add(D, D), O = n.mul(y, v), O = n.add(O, O), I = n.mul(b, O), x = n.mul(g, N), x = n.add(I, x), I = n.sub(k, x), x = n.add(k, x), x = n.mul(I, x), I = n.mul(D, I), O = n.mul(g, O), N = n.mul(b, N), D = n.sub(C, N), D = n.mul(b, D), D = n.add(D, O), O = n.add(C, C), C = n.add(O, C), C = n.add(C, N), C = n.mul(C, D), x = n.add(x, C), N = n.mul(E, v), N = n.add(N, N), C = n.mul(N, D), I = n.sub(I, C), O = n.mul(N, k), O = n.add(O, O), O = n.add(O, O), new B(I, x, O);
+    }
+    // Renes-Costello-Batina exception-free addition formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 1
+    // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
+    add(b) {
+      q(b);
+      const { X: w, Y: g, Z: y } = this, { X: E, Y: v, Z: I } = b;
+      let x = n.ZERO, O = n.ZERO, C = n.ZERO;
+      const k = i.a, N = n.mul(i.b, ee);
+      let D = n.mul(w, E), V = n.mul(g, v), L = n.mul(y, I), Y = n.add(w, g), j = n.add(E, v);
+      Y = n.mul(Y, j), j = n.add(D, V), Y = n.sub(Y, j), j = n.add(w, y);
+      let G = n.add(E, I);
+      return j = n.mul(j, G), G = n.add(D, L), j = n.sub(j, G), G = n.add(g, y), x = n.add(v, I), G = n.mul(G, x), x = n.add(V, L), G = n.sub(G, x), C = n.mul(k, j), x = n.mul(N, L), C = n.add(x, C), x = n.sub(V, C), C = n.add(V, C), O = n.mul(x, C), V = n.add(D, D), V = n.add(V, D), L = n.mul(k, L), j = n.mul(N, j), V = n.add(V, L), L = n.sub(D, L), L = n.mul(k, L), j = n.add(j, L), D = n.mul(V, j), O = n.add(O, D), D = n.mul(G, j), x = n.mul(Y, x), x = n.sub(x, D), D = n.mul(Y, V), C = n.mul(G, C), C = n.add(C, D), new B(x, O, C);
+    }
+    subtract(b) {
+      return this.add(b.negate());
+    }
+    is0() {
+      return this.equals(B.ZERO);
+    }
+    /**
+     * Constant time multiplication.
+     * Uses wNAF method. Windowed method may be 10% faster,
+     * but takes 2x longer to generate and consumes 2x memory.
+     * Uses precomputes when available.
+     * Uses endomorphism for Koblitz curves.
+     * @param scalar by which the point would be multiplied
+     * @returns New point
+     */
+    multiply(b) {
+      const { endo: w } = t;
+      if (!r.isValidNot0(b))
+        throw new Error("invalid scalar: out of range");
+      let g, y;
+      const E = (v) => nt.cached(this, v, (I) => ye(B, I));
+      if (w) {
+        const { k1neg: v, k1: I, k2neg: x, k2: O } = K(b), { p: C, f: k } = E(I), { p: N, f: D } = E(O);
+        y = k.add(D), g = F(w.beta, C, N, v, x);
+      } else {
+        const { p: v, f: I } = E(b);
+        g = v, y = I;
+      }
+      return ye(B, [g, y])[0];
+    }
+    /**
+     * Non-constant-time multiplication. Uses double-and-add algorithm.
+     * It's faster, but should only be used when you don't care about
+     * an exposed secret key e.g. sig verification, which works over *public* keys.
+     */
+    multiplyUnsafe(b) {
+      const { endo: w } = t, g = this;
+      if (!r.isValid(b))
+        throw new Error("invalid scalar: out of range");
+      if (b === gt || g.is0())
+        return B.ZERO;
+      if (b === kt)
+        return g;
+      if (nt.hasCache(this))
+        return this.multiply(b);
+      if (w) {
+        const { k1neg: y, k1: E, k2neg: v, k2: I } = K(b), { p1: x, p2: O } = Sr(B, g, E, I);
+        return F(w.beta, x, O, y, v);
+      } else
+        return nt.unsafe(g, b);
+    }
+    multiplyAndAddUnsafe(b, w, g) {
+      const y = this.multiplyUnsafe(w).add(b.multiplyUnsafe(g));
+      return y.is0() ? void 0 : y;
+    }
+    /**
+     * Converts Projective point to affine (x, y) coordinates.
+     * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch
+     */
+    toAffine(b) {
+      return ot(this, b);
+    }
+    /**
+     * Checks whether Point is free of torsion elements (is in prime subgroup).
+     * Always torsion-free for cofactor=1 curves.
+     */
+    isTorsionFree() {
+      const { isTorsionFree: b } = t;
+      return o === kt ? !0 : b ? b(B, this) : nt.unsafe(this, a).is0();
+    }
+    clearCofactor() {
+      const { clearCofactor: b } = t;
+      return o === kt ? this : b ? b(B, this) : this.multiplyUnsafe(o);
+    }
+    isSmallOrder() {
+      return this.multiplyUnsafe(o).is0();
+    }
+    toBytes(b = !0) {
+      return fe(b, "isCompressed"), this.assertValidity(), d(B, this, b);
+    }
+    toHex(b = !0) {
+      return jt(this.toBytes(b));
+    }
+    toString() {
+      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+    }
+    // TODO: remove
+    get px() {
+      return this.X;
+    }
+    get py() {
+      return this.X;
+    }
+    get pz() {
+      return this.Z;
+    }
+    toRawBytes(b = !0) {
+      return this.toBytes(b);
+    }
+    _setWindowSize(b) {
+      this.precompute(b);
+    }
+    static normalizeZ(b) {
+      return ye(B, b);
+    }
+    static msm(b, w) {
+      return Ir(B, r, b, w);
+    }
+    static fromPrivateKey(b) {
+      return B.BASE.multiply(Vt(r, b));
+    }
+  }
+  B.BASE = new B(i.Gx, i.Gy, n.ONE), B.ZERO = new B(n.ZERO, n.ONE, n.ZERO), B.Fp = n, B.Fn = r;
+  const ft = r.BITS, nt = new xr(B, t.endo ? Math.ceil(ft / 2) : ft);
+  return B.BASE.precompute(8), B;
+}
+function Pn(e) {
+  return Uint8Array.of(e ? 2 : 3);
+}
+function Fn(e, t) {
+  return {
+    secretKey: t.BYTES,
+    publicKey: 1 + e.BYTES,
+    publicKeyUncompressed: 1 + 2 * e.BYTES,
+    publicKeyHasPrefix: !0,
+    signature: 2 * t.BYTES
+  };
+}
+function Cr(e, t = {}) {
+  const { Fn: s } = e, n = t.randomBytes || pn, r = Object.assign(Fn(e.Fp, s), { seed: jn(s.ORDER) });
+  function i(d) {
+    try {
+      return !!Vt(s, d);
+    } catch {
+      return !1;
+    }
+  }
+  function o(d, p) {
+    const { publicKey: m, publicKeyUncompressed: R } = r;
+    try {
+      const _ = d.length;
+      return p === !0 && _ !== m || p === !1 && _ !== R ? !1 : !!e.fromBytes(d);
+    } catch {
+      return !1;
+    }
+  }
+  function a(d = n(r.seed)) {
+    return yr(vt(d, r.seed, "seed"), s.ORDER);
+  }
+  function c(d, p = !0) {
+    return e.BASE.multiply(Vt(s, d)).toBytes(p);
+  }
+  function l(d) {
+    const p = a(d);
+    return { secretKey: p, publicKey: c(p) };
+  }
+  function h(d) {
+    if (typeof d == "bigint")
+      return !1;
+    if (d instanceof e)
+      return !0;
+    const { secretKey: p, publicKey: m, publicKeyUncompressed: R } = r;
+    if (s.allowedLengths || p === m)
+      return;
+    const _ = z("key", d).length;
+    return _ === m || _ === R;
+  }
+  function u(d, p, m = !0) {
+    if (h(d) === !0)
+      throw new Error("first arg must be private key");
+    if (h(p) === !1)
+      throw new Error("second arg must be public key");
+    const R = Vt(s, d);
+    return e.fromHex(p).multiply(R).toBytes(m);
+  }
+  return Object.freeze({ getPublicKey: c, getSharedSecret: u, keygen: l, Point: e, utils: {
+    isValidSecretKey: i,
+    isValidPublicKey: o,
+    randomSecretKey: a,
+    // TODO: remove
+    isValidPrivateKey: i,
+    randomPrivateKey: a,
+    normPrivateKeyToScalar: (d) => Vt(s, d),
+    precompute(d = 8, p = e.BASE) {
+      return p.precompute(d, !1);
+    }
+  }, lengths: r });
+}
+function Tr(e, t, s = {}) {
+  gn(t), He(s, {}, {
+    hmac: "function",
+    lowS: "boolean",
+    randomBytes: "function",
+    bits2int: "function",
+    bits2int_modN: "function"
+  });
+  const n = s.randomBytes || pn, r = s.hmac || ((w, ...g) => Sn(t, w, xt(...g))), { Fp: i, Fn: o } = e, { ORDER: a, BITS: c } = o, { keygen: l, getPublicKey: h, getSharedSecret: u, utils: f, lengths: d } = Cr(e, s), p = {
+    prehash: !1,
+    lowS: typeof s.lowS == "boolean" ? s.lowS : !1,
+    format: void 0,
+    //'compact' as ECDSASigFormat,
+    extraEntropy: !1
+  }, m = "compact";
+  function R(w) {
+    const g = a >> kt;
+    return w > g;
+  }
+  function _(w, g) {
+    if (!o.isValidNot0(g))
+      throw new Error(`invalid signature ${w}: out of range 1..Point.Fn.ORDER`);
+    return g;
+  }
+  function et(w, g) {
+    Ce(g);
+    const y = d.signature, E = g === "compact" ? y : g === "recovered" ? y + 1 : void 0;
+    return vt(w, E, `${g} signature`);
+  }
+  class A {
+    constructor(g, y, E) {
+      this.r = _("r", g), this.s = _("s", y), E != null && (this.recovery = E), Object.freeze(this);
+    }
+    static fromBytes(g, y = m) {
+      et(g, y);
+      let E;
+      if (y === "der") {
+        const { r: O, s: C } = dt.toSig(vt(g));
+        return new A(O, C);
+      }
+      y === "recovered" && (E = g[0], y = "compact", g = g.subarray(1));
+      const v = o.BYTES, I = g.subarray(0, v), x = g.subarray(v, v * 2);
+      return new A(o.fromBytes(I), o.fromBytes(x), E);
+    }
+    static fromHex(g, y) {
+      return this.fromBytes(ce(g), y);
+    }
+    addRecoveryBit(g) {
+      return new A(this.r, this.s, g);
+    }
+    recoverPublicKey(g) {
+      const y = i.ORDER, { r: E, s: v, recovery: I } = this;
+      if (I == null || ![0, 1, 2, 3].includes(I))
+        throw new Error("recovery id invalid");
+      if (a * Kn < y && I > 1)
+        throw new Error("recovery id is ambiguous for h>1 curve");
+      const O = I === 2 || I === 3 ? E + a : E;
+      if (!i.isValid(O))
+        throw new Error("recovery id 2 or 3 invalid");
+      const C = i.toBytes(O), k = e.fromBytes(xt(Pn((I & 1) === 0), C)), N = o.inv(O), D = K(z("msgHash", g)), V = o.create(-D * N), L = o.create(v * N), Y = e.BASE.multiplyUnsafe(V).add(k.multiplyUnsafe(L));
+      if (Y.is0())
+        throw new Error("point at infinify");
+      return Y.assertValidity(), Y;
+    }
+    // Signatures should be low-s, to prevent malleability.
+    hasHighS() {
+      return R(this.s);
+    }
+    toBytes(g = m) {
+      if (Ce(g), g === "der")
+        return ce(dt.hexFromSig(this));
+      const y = o.toBytes(this.r), E = o.toBytes(this.s);
+      if (g === "recovered") {
+        if (this.recovery == null)
+          throw new Error("recovery bit must be present");
+        return xt(Uint8Array.of(this.recovery), y, E);
+      }
+      return xt(y, E);
+    }
+    toHex(g) {
+      return jt(this.toBytes(g));
+    }
+    // TODO: remove
+    assertValidity() {
+    }
+    static fromCompact(g) {
+      return A.fromBytes(z("sig", g), "compact");
+    }
+    static fromDER(g) {
+      return A.fromBytes(z("sig", g), "der");
+    }
+    normalizeS() {
+      return this.hasHighS() ? new A(this.r, o.neg(this.s), this.recovery) : this;
+    }
+    toDERRawBytes() {
+      return this.toBytes("der");
+    }
+    toDERHex() {
+      return jt(this.toBytes("der"));
+    }
+    toCompactRawBytes() {
+      return this.toBytes("compact");
+    }
+    toCompactHex() {
+      return jt(this.toBytes("compact"));
+    }
+  }
+  const q = s.bits2int || function(g) {
+    if (g.length > 8192)
+      throw new Error("input is too large");
+    const y = ge(g), E = g.length * 8 - c;
+    return E > 0 ? y >> BigInt(E) : y;
+  }, K = s.bits2int_modN || function(g) {
+    return o.create(q(g));
+  }, ot = Wt(c);
+  function bt(w) {
+    return cr("num < 2^" + c, w, gt, ot), o.toBytes(w);
+  }
+  function F(w, g) {
+    return vt(w, void 0, "message"), g ? vt(t(w), void 0, "prehashed message") : w;
+  }
+  function B(w, g, y) {
+    if (["recovered", "canonical"].some((V) => V in y))
+      throw new Error("sign() legacy options not supported");
+    const { lowS: E, prehash: v, extraEntropy: I } = Se(y, p);
+    w = F(w, v);
+    const x = K(w), O = Vt(o, g), C = [bt(O), bt(x)];
+    if (I != null && I !== !1) {
+      const V = I === !0 ? n(d.secretKey) : I;
+      C.push(z("extraEntropy", V));
+    }
+    const k = xt(...C), N = x;
+    function D(V) {
+      const L = q(V);
+      if (!o.isValidNot0(L))
+        return;
+      const Y = o.inv(L), j = e.BASE.multiply(L).toAffine(), G = o.create(j.x);
+      if (G === gt)
+        return;
+      const Yt = o.create(Y * o.create(N + G * O));
+      if (Yt === gt)
+        return;
+      let $e = (j.x === G ? 0 : 2) | Number(j.y & kt), Xe = Yt;
+      return E && R(Yt) && (Xe = o.neg(Yt), $e ^= 1), new A(G, Xe, $e);
+    }
+    return { seed: k, k2sig: D };
+  }
+  function ft(w, g, y = {}) {
+    w = z("message", w);
+    const { seed: E, k2sig: v } = B(w, g, y);
+    return fr(t.outputLen, o.BYTES, r)(E, v);
+  }
+  function nt(w) {
+    let g;
+    const y = typeof w == "string" || de(w), E = !y && w !== null && typeof w == "object" && typeof w.r == "bigint" && typeof w.s == "bigint";
+    if (!y && !E)
+      throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
+    if (E)
+      g = new A(w.r, w.s);
+    else if (y) {
+      try {
+        g = A.fromBytes(z("sig", w), "der");
+      } catch (v) {
+        if (!(v instanceof dt.Err))
+          throw v;
+      }
+      if (!g)
+        try {
+          g = A.fromBytes(z("sig", w), "compact");
+        } catch {
+          return !1;
+        }
+    }
+    return g || !1;
+  }
+  function T(w, g, y, E = {}) {
+    const { lowS: v, prehash: I, format: x } = Se(E, p);
+    if (y = z("publicKey", y), g = F(z("message", g), I), "strict" in E)
+      throw new Error("options.strict was renamed to lowS");
+    const O = x === void 0 ? nt(w) : A.fromBytes(z("sig", w), x);
+    if (O === !1)
+      return !1;
+    try {
+      const C = e.fromBytes(y);
+      if (v && O.hasHighS())
+        return !1;
+      const { r: k, s: N } = O, D = K(g), V = o.inv(N), L = o.create(D * V), Y = o.create(k * V), j = e.BASE.multiplyUnsafe(L).add(C.multiplyUnsafe(Y));
+      return j.is0() ? !1 : o.create(j.x) === k;
+    } catch {
+      return !1;
+    }
+  }
+  function b(w, g, y = {}) {
+    const { prehash: E } = Se(y, p);
+    return g = F(g, E), A.fromBytes(w, "recovered").recoverPublicKey(g).toBytes();
+  }
+  return Object.freeze({
+    keygen: l,
+    getPublicKey: h,
+    getSharedSecret: u,
+    utils: f,
+    lengths: d,
+    Point: e,
+    sign: ft,
+    verify: T,
+    recoverPublicKey: b,
+    Signature: A,
+    hash: t
+  });
+}
+function Dr(e) {
+  const t = {
+    a: e.a,
+    b: e.b,
+    p: e.Fp.ORDER,
+    n: e.n,
+    h: e.h,
+    Gx: e.Gx,
+    Gy: e.Gy
+  }, s = e.Fp;
+  let n = e.allowedPrivateKeyLengths ? Array.from(new Set(e.allowedPrivateKeyLengths.map((o) => Math.ceil(o / 2)))) : void 0;
+  const r = Tt(t.n, {
+    BITS: e.nBitLength,
+    allowedLengths: n,
+    modFromBytes: e.wrapPrivateKey
+  }), i = {
+    Fp: s,
+    Fn: r,
+    allowInfinityPoint: e.allowInfinityPoint,
+    endo: e.endo,
+    isTorsionFree: e.isTorsionFree,
+    clearCofactor: e.clearCofactor,
+    fromBytes: e.fromBytes,
+    toBytes: e.toBytes
+  };
+  return { CURVE: t, curveOpts: i };
+}
+function Ur(e) {
+  const { CURVE: t, curveOpts: s } = Dr(e), n = {
+    hmac: e.hmac,
+    randomBytes: e.randomBytes,
+    lowS: e.lowS,
+    bits2int: e.bits2int,
+    bits2int_modN: e.bits2int_modN
+  };
+  return { CURVE: t, curveOpts: s, hash: e.hash, ecdsaOpts: n };
+}
+function _r(e, t) {
+  const s = t.Point;
+  return Object.assign({}, t, {
+    ProjectivePoint: s,
+    CURVE: Object.assign({}, e, Hn(s.Fn.ORDER, s.Fn.BITS))
+  });
+}
+function Nr(e) {
+  const { CURVE: t, curveOpts: s, hash: n, ecdsaOpts: r } = Ur(e), i = Rr(t, s), o = Tr(i, n, r);
+  return _r(e, o);
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function je(e, t) {
+  const s = (n) => Nr({ ...e, hash: n });
+  return { ...s(t), create: s };
+}
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const Gn = {
+  p: BigInt("0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff"),
+  n: BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551"),
+  h: BigInt(1),
+  a: BigInt("0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc"),
+  b: BigInt("0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b"),
+  Gx: BigInt("0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296"),
+  Gy: BigInt("0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5")
+}, $n = {
+  p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffff"),
+  n: BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973"),
+  h: BigInt(1),
+  a: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000fffffffc"),
+  b: BigInt("0xb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aef"),
+  Gx: BigInt("0xaa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7"),
+  Gy: BigInt("0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f")
+}, Xn = {
+  p: BigInt("0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
+  n: BigInt("0x01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409"),
+  h: BigInt(1),
+  a: BigInt("0x1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc"),
+  b: BigInt("0x0051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00"),
+  Gx: BigInt("0x00c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66"),
+  Gy: BigInt("0x011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650")
+}, Hr = Tt(Gn.p), Vr = Tt($n.p), jr = Tt(Xn.p), kr = je({ ...Gn, Fp: Hr, lowS: !1 }, rr), Lr = je({ ...$n, Fp: Vr, lowS: !1 }, or), Kr = je({ ...Xn, Fp: jr, lowS: !1, allowedPrivateKeyLengths: [130, 131, 132] }, ir);
+function Pr(e) {
+  const t = new Uint8Array([
+    48,
+    13,
+    6,
+    9,
+    42,
+    134,
+    72,
+    134,
+    247,
+    13,
+    1,
+    1,
+    1,
+    5,
+    0
+  ]), s = e.length + 1, n = t.length + 1 + ne(s).length + s, r = new Uint8Array(1 + ne(n).length + n);
+  let i = 0;
+  r[i++] = 48;
+  const o = ne(n);
+  r.set(o, i), i += o.length, r.set(t, i), i += t.length, r[i++] = 3;
+  const a = ne(s);
+  return r.set(a, i), i += a.length, r[i++] = 0, r.set(e, i), r;
+}
+function ne(e) {
+  return e < 128 ? new Uint8Array([e]) : e < 256 ? new Uint8Array([129, e]) : new Uint8Array([130, e >> 8 & 255, e & 255]);
+}
+async function Zt(e, t, s) {
+  class n {
+    constructor() {
+      this.format = "spki", this.keyData = new Uint8Array(0), this.algorithm = { name: P.Ecdsa }, this.extractable = !0, this.usage = ["verify"];
+    }
+  }
+  const r = new n();
+  if (s.includes("BEGIN"))
+    r.format = "spki", r.keyData = dn(s);
+  else if (/^[0-9A-Fa-f]+$/.test(s))
+    r.format = "raw", r.keyData = Kt(s);
+  else {
+    r.format = "spki";
+    const i = S(s);
+    e.toLowerCase().includes("pkcs1") && i[0] === 48 && i[1] === 130 && i[4] === 2 && i[5] === 130 ? r.keyData = Pr(i) : r.keyData = i;
+  }
+  if (e.toLowerCase().includes("ecdsa"))
+    if (t.includes("256"))
+      r.algorithm = { name: P.Ecdsa, namedCurve: it.P256 };
+    else if (t.includes("384"))
+      r.algorithm = { name: P.Ecdsa, namedCurve: it.P384 };
+    else if (t.includes("521"))
+      r.algorithm = { name: P.Ecdsa, namedCurve: it.P521 };
+    else
+      throw new Error("Cannot determine ECDSA key size.");
+  else if (e.toLowerCase().includes("ed25519"))
+    r.algorithm = { name: P.Ed25519 };
+  else if (e.toLowerCase().includes("rsa") || e.toLowerCase().includes("pkcs1")) {
+    let i = U.SHA256;
+    const o = t.toUpperCase().replace(/[-_]/g, "");
+    o.includes("SHA256") || o.includes("256") ? i = U.SHA256 : o.includes("SHA384") || o.includes("384") ? i = U.SHA384 : (o.includes("SHA512") || o.includes("512")) && (i = U.SHA512), o.includes(oe.PKCS1) || o.includes(oe.RSAPKCS1) ? r.algorithm = {
+      name: Bt.PKCS1v15,
+      hash: { name: i }
+    } : r.algorithm = {
+      name: Bt.PSS,
+      hash: { name: i }
+    };
+  } else
+    throw new Error(`Unsupported ${e}`);
+  return await crypto.subtle.importKey(r.format, r.keyData, r.algorithm, r.extractable, r.usage);
+}
+async function Rt(e, t, s, n = "sha256") {
+  const r = {
+    name: e.algorithm.name
+  };
+  if (e.algorithm.name === P.Ecdsa) {
+    const i = e.algorithm.namedCurve;
+    let o = 32;
+    if (i === it.P256 ? o = 32 : i === it.P384 ? o = 48 : i === it.P521 && (o = 66), r.hash = { name: "" }, n.includes("256"))
+      r.hash.name = U.SHA256;
+    else if (n.includes("384"))
+      r.hash.name = U.SHA384;
+    else if (n.includes("512"))
+      r.hash.name = U.SHA512;
+    else
+      throw new Error("Cannot determine hashing algorithm;");
+    let a;
+    try {
+      const c = Mt.parseBuffer(s), l = c.subs[0].toInteger(), h = c.subs[1].toInteger(), u = Kt(l.toString(16).padStart(o * 2, "0")), f = Kt(h.toString(16).padStart(o * 2, "0"));
+      a = new Uint8Array(u.length + f.length), a.set(u, 0), a.set(f, u.length);
+    } catch {
+      return !1;
+    }
+    return await crypto.subtle.verify(r, e, a, t);
+  } else {
+    if (e.algorithm.name === P.Ed25519)
+      return await crypto.subtle.verify(e.algorithm.name, e, s, t);
+    if (e.algorithm.name === Bt.PSS) {
+      const i = e.algorithm.hash.name, o = i === U.SHA256 ? 32 : i === U.SHA384 ? 48 : i === U.SHA512 ? 64 : 32;
+      return await crypto.subtle.verify({
+        name: Bt.PSS,
+        saltLength: o
+      }, e, s, t);
+    } else {
+      if (e.algorithm.name === Bt.PKCS1v15)
+        return await crypto.subtle.verify(e.algorithm.name, e, s, t);
+      throw new Error("Unsupported key type!");
+    }
+  }
+}
+async function Fr(e, t, s) {
+  if (e.algorithm.name !== P.Ecdsa)
+    throw new Error("verifySignatureOverDigest only supports ECDSA keys");
+  const n = e.algorithm.namedCurve;
+  let r;
+  if (n === it.P256)
+    r = kr;
+  else if (n === it.P384)
+    r = Lr;
+  else if (n === it.P521)
+    r = Kr;
+  else
+    throw new Error(`Unsupported curve: ${n}`);
+  const i = await crypto.subtle.exportKey("jwk", e);
+  if (!i.x || !i.y)
+    throw new Error("Invalid ECDSA public key: missing x or y coordinates");
+  const o = qe(i.x), a = qe(i.y), c = new Uint8Array(1 + o.length + a.length);
+  return c[0] = 4, c.set(o, 1), c.set(a, 1 + o.length), r.verify(s, t, c, { format: "der", prehash: !1, lowS: !1 });
+}
+var ie = /* @__PURE__ */ ((e) => (e.certificateAuthorities = "certificateAuthorities", e.ctlogs = "ctlogs", e.timestampAuthorities = "timestampAuthorities", e.tlogs = "tlogs", e))(ie || {});
+const Gr = {
+  sha256: U.SHA256,
+  sha384: U.SHA384,
+  sha512: U.SHA512,
+  SHA2_256: U.SHA256,
+  SHA2_384: U.SHA384,
+  SHA2_512: U.SHA512
+};
+function ke(e) {
+  const t = Gr[e];
+  if (!t)
+    throw new Error(`Unsupported hash algorithm: ${e}`);
+  return t;
+}
+const le = {
+  "1.2.840.10045.4.3.1": "sha224",
+  "1.2.840.10045.4.3.2": "sha256",
+  "1.2.840.10045.4.3.3": "sha384",
+  "1.2.840.10045.4.3.4": "sha512"
+}, he = {
+  "1.2.840.113549.1.1.11": "sha256",
+  // sha256WithRSAEncryption
+  "1.2.840.113549.1.1.12": "sha384",
+  // sha384WithRSAEncryption
+  "1.2.840.113549.1.1.13": "sha512",
+  // sha512WithRSAEncryption
+  "1.2.840.113549.1.1.5": "sha1"
+  // sha1WithRSAEncryption
+}, Ie = "1.2.840.113549.1.1.10", Le = {
+  "2.16.840.1.101.3.4.2.1": "sha256",
+  "2.16.840.1.101.3.4.2.2": "sha384",
+  "2.16.840.1.101.3.4.2.3": "sha512"
+}, se = "sha256", $r = {
+  "1.2.840.10045.3.1.7": "secp256r1",
+  "1.3.132.0.34": "secp384r1",
+  "1.3.132.0.35": "secp521r1"
+};
+class Ke {
+  version;
+  logID;
+  timestamp;
+  extensions;
+  hashAlgorithm;
+  signatureAlgorithm;
+  signature;
+  constructor(t) {
+    this.version = t.version, this.logID = t.logID, this.timestamp = t.timestamp, this.extensions = t.extensions, this.hashAlgorithm = t.hashAlgorithm, this.signatureAlgorithm = t.signatureAlgorithm, this.signature = t.signature;
+  }
+  get datetime() {
+    return new Date(Number(Is(this.timestamp)));
+  }
+  // Returns the hash algorithm used to generate the SCT's signature.
+  // https://www.rfc-editor.org/rfc/rfc5246#section-7.4.1.4.1
+  get algorithm() {
+    switch (this.hashAlgorithm) {
+      /* istanbul ignore next */
+      case 0:
+        return "none";
+      /* istanbul ignore next */
+      case 1:
+        return "md5";
+      /* istanbul ignore next */
+      case 2:
+        return "sha1";
+      /* istanbul ignore next */
+      case 3:
+        return "sha224";
+      case 4:
+        return "sha256";
+      /* istanbul ignore next */
+      case 5:
+        return "sha384";
+      /* istanbul ignore next */
+      case 6:
+        return "sha512";
+      /* istanbul ignore next */
+      default:
+        return "unknown";
+    }
+  }
+  async verify(t, s) {
+    const n = new rt();
+    return n.appendChar(this.version), n.appendChar(0), n.appendView(this.timestamp), n.appendUint16(1), n.appendView(t), n.appendUint16(this.extensions.byteLength), this.extensions.byteLength > 0 && n.appendView(this.extensions), await Rt(
+      s,
+      n.buffer,
+      this.signature,
+      this.algorithm
+    );
+  }
+  // Parses a SignedCertificateTimestamp from a buffer. SCTs are encoded using
+  // TLS encoding which means the fields and lengths of most fields are
+  // specified as part of the SCT and TLS specs.
+  // https://www.rfc-editor.org/rfc/rfc6962#section-3.2
+  // https://www.rfc-editor.org/rfc/rfc5246#section-7.4.1.4.1
+  static parse(t) {
+    const s = new rt(t), n = s.getUint8();
+    if (n !== 0)
+      throw new Error(`Unsupported SCT version: ${n} (expected 0 for v1)`);
+    const r = s.getBlock(32), i = s.getBlock(8), o = s.getUint16(), a = s.getBlock(o), c = s.getUint8(), l = s.getUint8(), h = s.getUint16(), u = s.getBlock(h);
+    if (s.position !== t.length)
+      throw new Error("SCT buffer length mismatch");
+    return new Ke({
+      version: n,
+      logID: r,
+      timestamp: i,
+      extensions: a,
+      hashAlgorithm: c,
+      signatureAlgorithm: l,
+      signature: u
+    });
+  }
+}
+class wt {
+  root;
+  constructor(t) {
+    this.root = t;
+  }
+  get oid() {
+    return this.root.subs[0].toOID();
+  }
+  get critical() {
+    return this.root.subs.length === 3 ? this.root.subs[1].toBoolean() : !1;
+  }
+  get value() {
+    return this.extnValueObj.value;
+  }
+  get valueObj() {
+    return this.extnValueObj;
+  }
+  get extnValueObj() {
+    return this.root.subs[this.root.subs.length - 1];
+  }
+}
+class Xr extends wt {
+  get isCA() {
+    return this.sequence.subs[0]?.toBoolean() ?? !1;
+  }
+  get pathLenConstraint() {
+    return this.sequence.subs.length > 1 ? this.sequence.subs[1].toInteger() : void 0;
+  }
+  // The extnValue field contains a single sequence wrapping the isCA and
+  // pathLenConstraint.
+  get sequence() {
+    return this.extnValueObj.subs[0];
+  }
+}
+class qr extends wt {
+  get digitalSignature() {
+    return this.bitString[0] === 1;
+  }
+  get keyCertSign() {
+    return this.bitString[5] === 1;
+  }
+  get crlSign() {
+    return this.bitString[6] === 1;
+  }
+  // The extnValue field contains a single bit string which is a bit mask
+  // indicating which key usages are enabled.
+  get bitString() {
+    return this.extnValueObj.subs[0].toBitString();
+  }
+}
+class Mr extends wt {
+  get rfc822Name() {
+    const t = this.findGeneralName(1)?.value;
+    if (t !== void 0)
+      return Q(t);
+  }
+  get uri() {
+    const t = this.findGeneralName(6)?.value;
+    if (t !== void 0)
+      return Q(t);
+  }
+  // Retrieve the value of an otherName with the given OID.
+  otherName(t) {
+    const s = this.findGeneralName(0);
+    if (s === void 0 || s.subs[0].toOID() !== t)
+      return;
+    const r = s.subs[1];
+    return Q(r.subs[0].value);
+  }
+  findGeneralName(t) {
+    return this.generalNames.find((s) => s.tag.isContextSpecific(t));
+  }
+  // The extnValue field contains a sequence of GeneralNames.
+  get generalNames() {
+    return this.extnValueObj.subs[0].subs;
+  }
+}
+class Zr extends wt {
+  get keyIdentifier() {
+    return this.findSequenceMember(0)?.value;
+  }
+  findSequenceMember(t) {
+    return this.sequence.subs.find((s) => s.tag.isContextSpecific(t));
+  }
+  // The extnValue field contains a single sequence wrapping the keyIdentifier
+  get sequence() {
+    return this.extnValueObj.subs[0];
+  }
+}
+class Wr extends wt {
+  get keyIdentifier() {
+    return this.extnValueObj.subs[0].value;
+  }
+}
+class Gt extends wt {
+  get stringValue() {
+    return Q(this.extnValueObj.value);
+  }
+}
+class Z extends wt {
+  get stringValue() {
+    return Q(this.extnValueObj.subs[0].value);
+  }
+}
+class Yr extends Gt {
+  get issuer() {
+    return this.stringValue;
+  }
+}
+class zr extends Gt {
+  get workflowTrigger() {
+    return this.stringValue;
+  }
+}
+class Jr extends Gt {
+  get workflowSHA() {
+    return this.stringValue;
+  }
+}
+class Qr extends Gt {
+  get workflowName() {
+    return this.stringValue;
+  }
+}
+class ti extends Gt {
+  get workflowRepository() {
+    return this.stringValue;
+  }
+}
+class ei extends Gt {
+  get workflowRef() {
+    return this.stringValue;
+  }
+}
+class ni extends Z {
+  get issuer() {
+    return this.stringValue;
+  }
+}
+class si extends Z {
+  get buildSignerURI() {
+    return this.stringValue;
+  }
+}
+class ri extends Z {
+  get buildSignerDigest() {
+    return this.stringValue;
+  }
+}
+class ii extends Z {
+  get runnerEnvironment() {
+    return this.stringValue;
+  }
+}
+class oi extends Z {
+  get sourceRepositoryURI() {
+    return this.stringValue;
+  }
+}
+class ai extends Z {
+  get sourceRepositoryDigest() {
+    return this.stringValue;
+  }
+}
+class ci extends Z {
+  get sourceRepositoryRef() {
+    return this.stringValue;
+  }
+}
+class fi extends Z {
+  get sourceRepositoryIdentifier() {
+    return this.stringValue;
+  }
+}
+class ui extends Z {
+  get sourceRepositoryOwnerURI() {
+    return this.stringValue;
+  }
+}
+class li extends Z {
+  get sourceRepositoryOwnerIdentifier() {
+    return this.stringValue;
+  }
+}
+class hi extends Z {
+  get buildConfigURI() {
+    return this.stringValue;
+  }
+}
+class di extends Z {
+  get buildConfigDigest() {
+    return this.stringValue;
+  }
+}
+class gi extends Z {
+  get buildTrigger() {
+    return this.stringValue;
+  }
+}
+class wi extends Z {
+  get runInvocationURI() {
+    return this.stringValue;
+  }
+}
+class bi extends Z {
+  get sourceRepositoryVisibility() {
+    return this.stringValue;
+  }
+}
+class qn extends wt {
+  constructor(t) {
+    super(t);
+  }
+  get signedCertificateTimestamps() {
+    const t = this.extnValueObj.subs[0].value, s = new rt(t), n = s.getUint16() + 2, r = [];
+    for (; s.position < n; ) {
+      const i = s.getUint16(), o = s.getBlock(i);
+      r.push(Ke.parse(o));
+    }
+    if (s.position !== n)
+      throw new Error("SCT list length does not match actual length");
+    return r;
+  }
+}
+const pi = "2.5.29.14", yi = "2.5.29.15", mi = "2.5.29.17", Ei = "2.5.29.19", xi = "2.5.29.35", Mn = "1.3.6.1.4.1.11129.2.4.2", Zn = "1.3.6.1.4.1.57264.1.1", Wn = "1.3.6.1.4.1.57264.1.2", Yn = "1.3.6.1.4.1.57264.1.3", zn = "1.3.6.1.4.1.57264.1.4", Jn = "1.3.6.1.4.1.57264.1.5", Qn = "1.3.6.1.4.1.57264.1.6", Si = "1.3.6.1.4.1.57264.1.7", ts = "1.3.6.1.4.1.57264.1.8", es = "1.3.6.1.4.1.57264.1.9", ns = "1.3.6.1.4.1.57264.1.10", ss = "1.3.6.1.4.1.57264.1.11", rs = "1.3.6.1.4.1.57264.1.12", is = "1.3.6.1.4.1.57264.1.13", os = "1.3.6.1.4.1.57264.1.14", as = "1.3.6.1.4.1.57264.1.15", cs = "1.3.6.1.4.1.57264.1.16", fs = "1.3.6.1.4.1.57264.1.17", us = "1.3.6.1.4.1.57264.1.18", ls = "1.3.6.1.4.1.57264.1.19", hs = "1.3.6.1.4.1.57264.1.20", ds = "1.3.6.1.4.1.57264.1.21", gs = "1.3.6.1.4.1.57264.1.22";
+class J {
+  root;
+  constructor(t) {
+    this.root = t;
+  }
+  static parse(t) {
+    const s = typeof t == "string" ? dn(t) : t, n = Mt.parseBuffer(s);
+    return new J(n);
+  }
+  get tbsCertificate() {
+    return this.tbsCertificateObj;
+  }
+  get version() {
+    return `v${(this.versionObj.subs[0].toInteger() + BigInt(1)).toString()}`;
+  }
+  get serialNumber() {
+    return this.serialNumberObj.value;
+  }
+  get notBefore() {
+    return this.validityObj.subs[0].toDate();
+  }
+  get notAfter() {
+    return this.validityObj.subs[1].toDate();
+  }
+  get issuer() {
+    return this.issuerObj.value;
+  }
+  get subject() {
+    return this.subjectObj.value;
+  }
+  get publicKey() {
+    return this.subjectPublicKeyInfoObj.toDER();
+  }
+  /**
+   * Import the public key with a specific hash algorithm and signature scheme for RSA keys.
+   * For ECDSA keys, both parameters are ignored.
+   * @param hashAlg - Hash algorithm (e.g., "sha384") for RSA keys
+   * @param usePss - If true, import as RSA-PSS key; if false, import as PKCS#1 v1.5
+   */
+  async getPublicKeyObj(t, s) {
+    const n = this.subjectPublicKeyInfoObj.toDER(), r = Mt.parseBuffer(n), i = r.subs[0].subs[0].toOID(), o = i === "1.2.840.113549.1.1.1";
+    if (i === Ie)
+      throw new Error(
+        "RSA-PSS public keys (id-RSASSA-PSS OID) are not supported by WebCrypto. Only certificates with standard RSA keys (rsaEncryption OID) signed using RSA-PSS are supported."
+      );
+    if (o) {
+      const c = t || se, l = s ? c : `PKCS1_${c}`;
+      return Zt(P.RSA, l, Me(n));
+    } else {
+      const c = r.subs[0].subs[1]?.toOID(), l = $r[c];
+      if (!l)
+        throw new Error(`Unknown ECDSA curve OID: ${c}`);
+      return Zt(P.Ecdsa, l, Me(n));
+    }
+  }
+  get publicKeyObj() {
+    return this.getPublicKeyObj();
+  }
+  get signatureAlgorithm() {
+    const t = this.signatureAlgorithmObj.subs[0].toOID();
+    return le[t] || he[t] || this.parseRsaPssHashAlgorithm();
+  }
+  get signatureAlgorithmOid() {
+    return this.signatureAlgorithmObj.subs[0].toOID();
+  }
+  /**
+   * Parse hash algorithm from RSA-PSS signature algorithm parameters.
+   * RSA-PSS parameters are: SEQUENCE { hashAlgorithm, maskGenAlgorithm, saltLength, trailerField }
+   */
+  parseRsaPssHashAlgorithm() {
+    if (this.signatureAlgorithmObj.subs[0].toOID() !== Ie)
+      return "";
+    const s = this.signatureAlgorithmObj.subs[1];
+    if (!s || s.subs.length === 0)
+      return se;
+    const n = s.subs[0];
+    if (n && n.subs.length > 0) {
+      const r = n.subs[0];
+      if (r && r.subs.length > 0) {
+        const i = r.subs[0].toOID();
+        return Le[i] || se;
+      }
+    }
+    return se;
+  }
+  get signatureValue() {
+    return this.signatureValueObj.value.subarray(1);
+  }
+  get subjectAltName() {
+    const t = this.extSubjectAltName;
+    return t?.uri || t?.rfc822Name;
+  }
+  get extensions() {
+    return this.extensionsObj?.subs[0]?.subs || /* istanbul ignore next */
+    [];
+  }
+  get extKeyUsage() {
+    const t = this.findExtension(yi);
+    return t ? new qr(t) : void 0;
+  }
+  get extBasicConstraints() {
+    const t = this.findExtension(Ei);
+    return t ? new Xr(t) : void 0;
+  }
+  get extSubjectAltName() {
+    const t = this.findExtension(mi);
+    return t ? new Mr(t) : void 0;
+  }
+  get extAuthorityKeyID() {
+    const t = this.findExtension(xi);
+    return t ? new Zr(t) : void 0;
+  }
+  get extSubjectKeyID() {
+    const t = this.findExtension(pi);
+    return t ? new Wr(t) : (
+      /* istanbul ignore next */
+      void 0
+    );
+  }
+  get extSCT() {
+    const t = this.findExtension(Mn);
+    return t ? new qn(t) : void 0;
+  }
+  get extFulcioIssuerV1() {
+    const t = this.findExtension(Zn);
+    return t ? new Yr(t) : void 0;
+  }
+  get extFulcioIssuerV2() {
+    const t = this.findExtension(ts);
+    return t ? new ni(t) : void 0;
+  }
+  get extGitHubWorkflowTrigger() {
+    const t = this.findExtension(Wn);
+    return t ? new zr(t) : void 0;
+  }
+  get extGitHubWorkflowSHA() {
+    const t = this.findExtension(Yn);
+    return t ? new Jr(t) : void 0;
+  }
+  get extGitHubWorkflowName() {
+    const t = this.findExtension(zn);
+    return t ? new Qr(t) : void 0;
+  }
+  get extGitHubWorkflowRepository() {
+    const t = this.findExtension(Jn);
+    return t ? new ti(t) : void 0;
+  }
+  get extGitHubWorkflowRef() {
+    const t = this.findExtension(Qn);
+    return t ? new ei(t) : void 0;
+  }
+  get extBuildSignerURI() {
+    const t = this.findExtension(es);
+    return t ? new si(t) : void 0;
+  }
+  get extBuildSignerDigest() {
+    const t = this.findExtension(ns);
+    return t ? new ri(t) : void 0;
+  }
+  get extRunnerEnvironment() {
+    const t = this.findExtension(ss);
+    return t ? new ii(t) : void 0;
+  }
+  get extSourceRepositoryURI() {
+    const t = this.findExtension(rs);
+    return t ? new oi(t) : void 0;
+  }
+  get extSourceRepositoryDigest() {
+    const t = this.findExtension(is);
+    return t ? new ai(t) : void 0;
+  }
+  get extSourceRepositoryRef() {
+    const t = this.findExtension(os);
+    return t ? new ci(t) : void 0;
+  }
+  get extSourceRepositoryIdentifier() {
+    const t = this.findExtension(as);
+    return t ? new fi(t) : void 0;
+  }
+  get extSourceRepositoryOwnerURI() {
+    const t = this.findExtension(cs);
+    return t ? new ui(t) : void 0;
+  }
+  get extSourceRepositoryOwnerIdentifier() {
+    const t = this.findExtension(fs);
+    return t ? new li(t) : void 0;
+  }
+  get extBuildConfigURI() {
+    const t = this.findExtension(us);
+    return t ? new hi(t) : void 0;
+  }
+  get extBuildConfigDigest() {
+    const t = this.findExtension(ls);
+    return t ? new di(t) : void 0;
+  }
+  get extBuildTrigger() {
+    const t = this.findExtension(hs);
+    return t ? new gi(t) : void 0;
+  }
+  get extRunInvocationURI() {
+    const t = this.findExtension(ds);
+    return t ? new wi(t) : void 0;
+  }
+  get extSourceRepositoryVisibility() {
+    const t = this.findExtension(gs);
+    return t ? new bi(t) : void 0;
+  }
+  get isCA() {
+    const t = this.extBasicConstraints?.isCA || !1;
+    return this.extKeyUsage ? t && this.extKeyUsage.keyCertSign : t;
+  }
+  extension(t) {
+    const s = this.findExtension(t);
+    return s ? new wt(s) : void 0;
+  }
+  async verify(t) {
+    const s = this.signatureAlgorithmOid, n = s === Ie, r = n ? this.parseRsaPssHashAlgorithm() : he[s] || le[s], i = t ? await t.getPublicKeyObj(r, n) : await this.getPublicKeyObj(r, n);
+    return await Rt(
+      i,
+      this.tbsCertificate.toDER(),
+      this.signatureValue,
+      this.signatureAlgorithm
+    );
+  }
+  validForDate(t) {
+    return this.notBefore <= t && t <= this.notAfter;
+  }
+  equals(t) {
+    return H(this.root.toDER(), t.root.toDER());
+  }
+  // Creates a copy of the certificate with a new buffer
+  clone() {
+    const t = this.root.toDER(), s = new Uint8Array(t);
+    return J.parse(s);
+  }
+  findExtension(t) {
+    return this.extensions.find((s) => s.subs[0].toOID() === t);
+  }
+  /////////////////////////////////////////////////////////////////////////////
+  // The following properties use the documented x509 structure to locate the
+  // desired ASN.1 object
+  // https://www.rfc-editor.org/rfc/rfc5280#section-4.1
+  // https://www.rfc-editor.org/rfc/rfc5280#section-4.1.1.1
+  get tbsCertificateObj() {
+    return this.root.subs[0];
+  }
+  // https://www.rfc-editor.org/rfc/rfc5280#section-4.1.1.2
+  get signatureAlgorithmObj() {
+    return this.root.subs[1];
+  }
+  // https://www.rfc-editor.org/rfc/rfc5280#section-4.1.1.3
+  get signatureValueObj() {
+    return this.root.subs[2];
+  }
+  // https://www.rfc-editor.org/rfc/rfc5280#section-4.1.2.1
+  get versionObj() {
+    return this.tbsCertificateObj.subs[0];
+  }
+  // https://www.rfc-editor.org/rfc/rfc5280#section-4.1.2.2
+  get serialNumberObj() {
+    return this.tbsCertificateObj.subs[1];
+  }
+  // https://www.rfc-editor.org/rfc/rfc5280#section-4.1.2.4
+  get issuerObj() {
+    return this.tbsCertificateObj.subs[3];
+  }
+  // https://www.rfc-editor.org/rfc/rfc5280#section-4.1.2.5
+  get validityObj() {
+    return this.tbsCertificateObj.subs[4];
+  }
+  // https://www.rfc-editor.org/rfc/rfc5280#section-4.1.2.6
+  get subjectObj() {
+    return this.tbsCertificateObj.subs[5];
+  }
+  // https://www.rfc-editor.org/rfc/rfc5280#section-4.1.2.7
+  get subjectPublicKeyInfoObj() {
+    return this.tbsCertificateObj.subs[6];
+  }
+  // Extensions can't be located by index because their position varies. Instead,
+  // we need to find the extensions context specific tag
+  // https://www.rfc-editor.org/rfc/rfc5280#section-4.1.2.9
+  get extensionsObj() {
+    return this.tbsCertificateObj.subs.find(
+      (t) => t.tag.isContextSpecific(3)
+    );
+  }
+}
+class ws {
+  untrustedCert;
+  trustedCerts;
+  localCerts;
+  timestamp;
+  constructor(t) {
+    this.untrustedCert = t.untrustedCert, this.trustedCerts = t.trustedCerts, this.localCerts = Ii([
+      ...t.trustedCerts,
+      t.untrustedCert
+    ]), this.timestamp = t.timestamp;
+  }
+  async verify() {
+    const t = await this.sort();
+    if (this.checkPath(t), !t.every(
+      (n) => n.validForDate(this.timestamp)
+    ))
+      throw new Error(
+        "certificate is not valid or expired at the specified date"
+      );
+    return t;
+  }
+  async sort() {
+    const t = this.untrustedCert;
+    let s = await this.buildPaths(t);
+    if (s = s.filter(
+      (r) => r.some((i) => this.trustedCerts.includes(i))
+    ), s.length === 0)
+      throw new Error("no trusted certificate path found");
+    const n = s.reduce(
+      (r, i) => r.length < i.length ? r : i
+    );
+    return [t, ...n].slice(0, -1);
+  }
+  async buildPaths(t) {
+    const s = [], n = await this.findIssuer(t);
+    if (n.length === 0)
+      throw new Error("no valid certificate path found");
+    for (let r = 0; r < n.length; r++) {
+      const i = n[r];
+      if (i.equals(t)) {
+        s.push([t]);
+        continue;
+      }
+      const o = await this.buildPaths(i);
+      for (let a = 0; a < o.length; a++)
+        s.push([i, ...o[a]]);
+    }
+    return s;
+  }
+  async findIssuer(t) {
+    let s = [], n;
+    if (H(t.subject, t.issuer) && await t.verify())
+      return [t];
+    t.extAuthorityKeyID && (n = t.extAuthorityKeyID.keyIdentifier), this.localCerts.forEach((i) => {
+      if (n && i.extSubjectKeyID) {
+        H(
+          i.extSubjectKeyID.keyIdentifier,
+          n
+        ) && s.push(i);
+        return;
+      }
+      H(i.subject, t.issuer) && s.push(i);
+    });
+    const r = [];
+    for (const i of s)
+      try {
+        await t.verify(i) && r.push(i);
+      } catch {
+      }
+    return r;
+  }
+  checkPath(t) {
+    if (t.length < 1)
+      throw new Error(
+        "certificate chain must contain at least one certificate"
+      );
+    if (!t.slice(1).every((n) => n.isCA))
+      throw new Error("intermediate certificate is not a CA");
+    for (let n = t.length - 2; n >= 0; n--)
+      if (!H(t[n].issuer, t[n + 1].subject))
+        throw new Error("incorrect certificate name chaining");
+    for (let n = 0; n < t.length; n++) {
+      const r = t[n];
+      if (r.extBasicConstraints?.isCA) {
+        const i = r.extBasicConstraints.pathLenConstraint;
+        if (i !== void 0 && i < BigInt(n - 1))
+          throw new Error("path length constraint exceeded");
+      }
+    }
+  }
+}
+function Ii(e) {
+  for (let t = 0; t < e.length; t++)
+    for (let s = t + 1; s < e.length; s++)
+      e[t].equals(e[s]) && (e.splice(s, 1), s--);
+  return e;
+}
+const vi = "DSSEv1";
+function Ai(e, t) {
+  const s = [
+    vi,
+    e.length,
+    e,
+    t.length,
+    ""
+  ].join(" "), r = new TextEncoder().encode(s);
+  for (let o = 0; o < r.length; o++)
+    if (r[o] > 127)
+      throw new Error(`Invalid non-ASCII character in PAE prefix at position ${o}`);
+  const i = new Uint8Array(r.length + t.length);
+  return i.set(r, 0), i.set(t, r.length), i;
+}
+const ve = new Uint8Array([0]), re = new Uint8Array([1]);
+async function Oi(e) {
+  if (!e.inclusionProof)
+    throw new Error("Missing inclusion proof");
+  const t = e.inclusionProof, s = BigInt(t.logIndex), n = BigInt(t.treeSize);
+  if (s < 0n || s >= n)
+    throw new Error(`Invalid log index: ${s}`);
+  const { inner: r, border: i } = Bi(s, n);
+  if (t.hashes.length !== r + i)
+    throw new Error("Invalid hash count in inclusion proof");
+  const o = t.hashes.slice(0, r).map((u) => S(u)), a = t.hashes.slice(r).map((u) => S(u)), c = await _i(S(e.canonicalizedBody)), l = await Ci(
+    await Ri(c, o, s),
+    a
+  ), h = S(t.rootHash);
+  if (!H(l, h))
+    throw new Error("Calculated root hash does not match inclusion proof");
+}
+function Bi(e, t) {
+  const s = Ti(e, t), n = Di(e >> BigInt(s));
+  return { inner: s, border: n };
+}
+async function Ri(e, t, s) {
+  let n = e;
+  for (let r = 0; r < t.length; r++) {
+    const i = t[r];
+    s >> BigInt(r) & BigInt(1) ? n = await Te(i, n) : n = await Te(n, i);
+  }
+  return n;
+}
+async function Ci(e, t) {
+  let s = e;
+  for (const n of t)
+    s = await Te(n, s);
+  return s;
+}
+function Ti(e, t) {
+  return Ui(e ^ t - BigInt(1));
+}
+function Di(e) {
+  return e.toString(2).split("1").length - 1;
+}
+function Ui(e) {
+  return e === 0n ? 0 : e.toString(2).length;
+}
+async function Te(e, t) {
+  const s = new Uint8Array(
+    re.length + e.length + t.length
+  );
+  s.set(re, 0), s.set(e, re.length), s.set(t, re.length + e.length);
+  const n = await crypto.subtle.digest(U.SHA256, s);
+  return new Uint8Array(n);
+}
+async function _i(e) {
+  const t = new Uint8Array(ve.length + e.length);
+  t.set(ve, 0), t.set(e, ve.length);
+  const s = await crypto.subtle.digest(U.SHA256, t);
+  return new Uint8Array(s);
+}
+const Ae = `
+
+`, Ni = /\u2014 (\S+) (\S+)\n/g;
+class Pe {
+  note;
+  signatures;
+  constructor(t, s) {
+    this.note = t, this.signatures = s;
+  }
+  static fromString(t) {
+    if (!t.includes(Ae))
+      throw new Error("Missing checkpoint separator");
+    const s = t.indexOf(Ae), n = t.slice(0, s + 1), i = t.slice(s + Ae.length).matchAll(Ni), o = [];
+    for (const a of i) {
+      const [, c, l] = a, h = S(l);
+      if (h.length < 5)
+        throw new Error("Malformed checkpoint signature");
+      o.push({
+        name: c,
+        keyHint: h.subarray(0, 4),
+        signature: h.subarray(4)
+      });
+    }
+    if (o.length === 0)
+      throw new Error("No signatures found in checkpoint");
+    return new Pe(n, o);
+  }
+}
+class Fe {
+  origin;
+  logSize;
+  logHash;
+  rest;
+  constructor(t, s, n, r) {
+    this.origin = t, this.logSize = s, this.logHash = n, this.rest = r;
+  }
+  static fromString(t) {
+    const s = t.trimEnd().split(`
+`);
+    if (s.length < 3)
+      throw new Error("Too few lines in checkpoint header");
+    const n = s[0], r = BigInt(s[1]), i = S(s[2]), o = s.slice(3);
+    return new Fe(n, r, i, o);
+  }
+}
+async function Hi(e, t) {
+  if (!e.inclusionProof?.checkpoint)
+    throw new Error("Missing checkpoint in inclusion proof");
+  const s = S(e.logId.keyId), n = t.filter((l) => {
+    const h = S(l.logId.keyId);
+    return H(h, s);
+  }), r = e.integratedTime ? ji(n, new Date(Number(e.integratedTime) * 1e3)) : n, i = e.inclusionProof, o = Pe.fromString(i.checkpoint.envelope), a = Fe.fromString(o.note);
+  if (!await Vi(o, r))
+    throw new Error("Invalid checkpoint signature");
+  const c = S(i.rootHash);
+  if (!H(a.logHash, c))
+    throw new Error("Root hash mismatch between checkpoint and inclusion proof");
+}
+async function Vi(e, t) {
+  const s = un(e.note);
+  let n = !1;
+  for (const r of e.signatures) {
+    const i = t.find((c) => {
+      const l = S(c.logId.keyId);
+      return H(l.subarray(0, 4), r.keyHint);
+    });
+    if (!i)
+      continue;
+    const o = await ki(i);
+    await Rt(
+      o,
+      s,
+      r.signature,
+      i.hashAlgorithm
+    ) && (n = !0);
+  }
+  return n;
+}
+function ji(e, t) {
+  return e.filter((s) => {
+    const n = new Date(s.publicKey.validFor.start), r = s.publicKey.validFor.end ? new Date(s.publicKey.validFor.end) : null;
+    return t >= n && (!r || t <= r);
+  });
+}
+async function ki(e) {
+  const t = e.publicKey.keyDetails;
+  let s, n;
+  if (t === "ecdsa-sha2-nistp256")
+    s = P.Ecdsa, n = "P256-SHA256";
+  else if (t.includes("ECDSA"))
+    s = P.Ecdsa, n = t.replace("PKIX_ECDSA_", "").replaceAll("_", "-");
+  else if (t.includes("ED25519"))
+    s = P.Ed25519, n = P.Ed25519;
+  else if (t.includes("RSA"))
+    s = P.RSA, n = t.replace("PKIX_RSA_", "").replaceAll("_", "-");
+  else
+    throw new Error(`Unsupported key type in keyDetails: ${t}`);
+  return Zt(
+    s,
+    n,
+    e.publicKey.rawBytes
+  );
+}
+async function Li(e, t) {
+  const s = e;
+  switch (s.apiVersion) {
+    case "0.0.1":
+      return Ki(s, t);
+    case "0.0.2":
+      return Pi(s, t);
+    default:
+      throw new Error(
+        `Unsupported hashedrekord version: ${s.apiVersion}`
+      );
+  }
+}
+function Ki(e, t) {
+  const s = e.spec;
+  if (!t.messageSignature)
+    throw new Error("Bundle missing messageSignature for hashedrekord entry");
+  const n = s.signature.content || "", r = S(n), i = S(t.messageSignature.signature);
+  if (!H(r, i))
+    throw new Error("Signature mismatch between TLog entry and bundle");
+  const o = s.data.hash?.value || "", a = Kt(o), c = S(
+    t.messageSignature.messageDigest.digest
+  );
+  if (!H(a, c))
+    throw new Error("Digest mismatch between TLog entry and bundle");
+}
+function Pi(e, t) {
+  const s = e.spec.hashedRekordV002;
+  if (!t.messageSignature)
+    throw new Error("Bundle missing messageSignature for hashedrekord v0.0.2 entry");
+  const n = s.signature.content || "", r = S(n), i = S(t.messageSignature.signature);
+  if (!H(r, i))
+    throw new Error("Signature mismatch between TLog entry and bundle (v0.0.2)");
+  const o = s.data.digest || "", a = S(o), c = S(
+    t.messageSignature.messageDigest.digest
+  );
+  if (!H(a, c))
+    throw new Error("Digest mismatch between TLog entry and bundle (v0.0.2)");
+}
+async function Fi(e, t) {
+  const s = e;
+  switch (s.apiVersion) {
+    case "0.0.1":
+      return Gi(s, t);
+    case "0.0.2":
+      return $i(s, t);
+    default:
+      throw new Error(
+        `Unsupported dsse version: ${s.apiVersion}`
+      );
+  }
+}
+async function Gi(e, t) {
+  if (!t.dsseEnvelope)
+    throw new Error("Bundle missing dsseEnvelope for DSSE entry");
+  if (!e.spec.signatures || e.spec.signatures.length !== 1)
+    throw new Error("DSSE entry must have exactly one signature");
+  const s = e.spec.signatures[0].signature, n = S(s);
+  if (t.dsseEnvelope.signatures.length === 0)
+    throw new Error("Bundle DSSE envelope missing signatures");
+  const r = S(t.dsseEnvelope.signatures[0].sig);
+  if (!H(n, r))
+    throw new Error("DSSE signature mismatch between TLog entry and bundle");
+  if (!e.spec.payloadHash?.value || !e.spec.payloadHash?.algorithm)
+    throw new Error("DSSE entry missing payloadHash or algorithm");
+  const i = ke(e.spec.payloadHash.algorithm), o = Kt(e.spec.payloadHash.value), a = S(t.dsseEnvelope.payload), c = new Uint8Array(
+    await crypto.subtle.digest(i, a)
+  );
+  if (!H(o, c))
+    throw new Error("DSSE payload hash mismatch between TLog entry and bundle");
+}
+async function $i(e, t) {
+  if (!t.dsseEnvelope)
+    throw new Error("Bundle missing dsseEnvelope for DSSE v0.0.2 entry");
+  const s = e.spec.dsseV002;
+  if (!s)
+    throw new Error("DSSE v0.0.2 entry missing dsseV002 spec");
+  if (!s.signatures || s.signatures.length !== 1)
+    throw new Error("DSSE v0.0.2 entry must have exactly one signature");
+  const n = s.signatures[0].content, r = S(n);
+  if (t.dsseEnvelope.signatures.length === 0)
+    throw new Error("Bundle DSSE envelope missing signatures");
+  const i = S(t.dsseEnvelope.signatures[0].sig);
+  if (!H(r, i))
+    throw new Error("DSSE signature mismatch between TLog entry and bundle (v0.0.2)");
+  if (!s.payloadHash?.digest || !s.payloadHash?.algorithm)
+    throw new Error("DSSE v0.0.2 entry missing payloadHash or algorithm");
+  const o = ke(s.payloadHash.algorithm), a = S(s.payloadHash.digest), c = S(t.dsseEnvelope.payload), l = new Uint8Array(
+    await crypto.subtle.digest(o, c)
+  );
+  if (!H(a, l))
+    throw new Error("DSSE payload hash mismatch between TLog entry and bundle (v0.0.2)");
+}
+async function Xi(e, t) {
+  const s = e;
+  if (s.apiVersion !== "0.0.2")
+    throw new Error(
+      `Unsupported intoto version: ${s.apiVersion}`
+    );
+  if (!t.dsseEnvelope)
+    throw new Error("Bundle missing dsseEnvelope for intoto entry");
+  const n = s.spec.content.envelope;
+  if (!n.signatures || n.signatures.length !== 1)
+    throw new Error("Intoto entry must have exactly one signature");
+  const r = n.signatures[0].sig, i = ln(r), o = S(i);
+  if (t.dsseEnvelope.signatures.length === 0)
+    throw new Error("Bundle DSSE envelope missing signatures");
+  const a = S(t.dsseEnvelope.signatures[0].sig);
+  if (!H(o, a))
+    throw new Error("Intoto signature mismatch between TLog entry and bundle");
+  if (s.spec.content.payloadHash) {
+    if (!s.spec.content.payloadHash.algorithm)
+      throw new Error("Intoto entry missing payloadHash algorithm");
+    const c = ke(s.spec.content.payloadHash.algorithm), l = Kt(s.spec.content.payloadHash.value), h = S(t.dsseEnvelope.payload), u = new Uint8Array(
+      await crypto.subtle.digest(c, h)
+    );
+    if (!H(l, u))
+      throw new Error("Intoto payload hash mismatch between TLog entry and bundle");
+  }
+}
+async function qi(e, t) {
+  const s = Mi(e), { kind: n, version: r } = e.kindVersion;
+  if (n !== s.kind || r !== s.apiVersion)
+    throw new Error(
+      `kind/version mismatch - expected: ${n}/${r}, received: ${s.kind}/${s.apiVersion}`
+    );
+  switch (s.kind) {
+    case "hashedrekord":
+      return Li(s, t);
+    case "dsse":
+      return Fi(s, t);
+    case "intoto":
+      return Xi(s, t);
+    default:
+      throw new Error(`Unsupported TLog entry kind: ${s.kind}`);
+  }
+}
+function Mi(e) {
+  try {
+    const t = ln(e.canonicalizedBody), s = JSON.parse(t);
+    if (!s.apiVersion || !s.kind || !s.spec)
+      throw new Error("Invalid Rekor entry structure");
+    return s;
+  } catch (t) {
+    throw new Error(
+      `Failed to parse canonicalized body: ${t instanceof Error ? t.message : String(t)}`
+    );
+  }
+}
+class ct extends Error {
+}
+class Zi {
+  root;
+  constructor(t) {
+    this.root = t;
+  }
+  get version() {
+    return this.root.subs[0].toInteger();
+  }
+  get genTime() {
+    return this.root.subs[4].toDate();
+  }
+  get messageImprintHashAlgorithm() {
+    const t = this.messageImprintObj.subs[0].subs[0].toOID(), s = Le[t];
+    if (!s)
+      throw new Error(`Unknown message imprint hash algorithm OID: ${t}`);
+    return s;
+  }
+  get messageImprintHashedMessage() {
+    return this.messageImprintObj.subs[1].value;
+  }
+  get raw() {
+    return this.root.toDER();
+  }
+  async verify(t) {
+    const s = this.messageImprintHashAlgorithm, n = s === "sha256" ? U.SHA256 : s === "sha384" ? U.SHA384 : s === "sha512" ? U.SHA512 : s, r = await crypto.subtle.digest(
+      n,
+      t
+    );
+    if (!H(new Uint8Array(r), this.messageImprintHashedMessage))
+      throw new ct(
+        "message imprint does not match artifact"
+      );
+  }
+  // https://www.rfc-editor.org/rfc/rfc3161#section-2.4.2
+  get messageImprintObj() {
+    return this.root.subs[2];
+  }
+}
+const Wi = "1.2.840.113549.1.7.2", Yi = "1.2.840.113549.1.9.16.1.4", zi = "1.2.840.113549.1.9.4";
+class Ge {
+  root;
+  constructor(t) {
+    this.root = t;
+  }
+  static parse(t) {
+    const s = Mt.parseBuffer(t);
+    return new Ge(s);
+  }
+  get status() {
+    return this.pkiStatusInfoObj.subs[0].toInteger();
+  }
+  get contentType() {
+    return this.contentTypeObj.toOID();
+  }
+  get eContentType() {
+    return this.eContentTypeObj.toOID();
+  }
+  get signingTime() {
+    return this.tstInfo.genTime;
+  }
+  get signerIssuer() {
+    return this.signerSidObj.subs[0].value;
+  }
+  get signerSerialNumber() {
+    return this.signerSidObj.subs[1].value;
+  }
+  get signerDigestAlgorithm() {
+    const t = this.signerDigestAlgorithmObj.subs[0].toOID(), s = Le[t];
+    if (!s)
+      throw new Error(`Unknown digest algorithm OID: ${t}`);
+    return s;
+  }
+  get signatureAlgorithm() {
+    const t = this.signatureAlgorithmObj.subs[0].toOID();
+    return le[t] || he[t];
+  }
+  get signatureValue() {
+    return this.signatureValueObj.value;
+  }
+  get tstInfo() {
+    return new Zi(this.eContentObj.subs[0].subs[0]);
+  }
+  async verify(t, s) {
+    if (!this.timeStampTokenObj)
+      throw new ct("timeStampToken is missing");
+    if (this.contentType !== Wi)
+      throw new ct(
+        `incorrect content type: ${this.contentType}`
+      );
+    if (this.eContentType !== Yi)
+      throw new ct(
+        `incorrect encapsulated content type: ${this.eContentType}`
+      );
+    await this.tstInfo.verify(t), await this.verifyMessageDigest(), await this.verifySignature(s);
+  }
+  async verifyMessageDigest() {
+    const t = this.signerDigestAlgorithm, s = t === "sha256" ? U.SHA256 : t === "sha384" ? U.SHA384 : t === "sha512" ? U.SHA512 : t, n = await crypto.subtle.digest(
+      s,
+      this.tstInfo.raw
+    ), r = this.messageDigestAttributeObj.subs[1].subs[0].value;
+    if (!H(new Uint8Array(n), r))
+      throw new ct(
+        "signed data does not match tstInfo"
+      );
+  }
+  async verifySignature(t) {
+    const s = this.signedAttrsObj.toDER();
+    s[0] = 49;
+    const n = this.signatureAlgorithmObj.subs[0].toOID(), r = le[n] || he[n];
+    if (!r)
+      throw new ct(
+        `Unsupported signature algorithm OID: ${n}`
+      );
+    if (!await Rt(
+      t,
+      s,
+      this.signatureValue,
+      r
+    ))
+      throw new ct(
+        "signature verification failed"
+      );
+  }
+  // https://www.rfc-editor.org/rfc/rfc3161#section-2.4.2
+  get pkiStatusInfoObj() {
+    return this.root.subs[0];
+  }
+  // https://www.rfc-editor.org/rfc/rfc3161#section-2.4.2
+  get timeStampTokenObj() {
+    return this.root.subs[1];
+  }
+  // https://datatracker.ietf.org/doc/html/rfc5652#section-3
+  get contentTypeObj() {
+    return this.timeStampTokenObj.subs[0];
+  }
+  // https://www.rfc-editor.org/rfc/rfc5652#section-3
+  get signedDataObj() {
+    const t = this.timeStampTokenObj.subs.find(
+      (s) => s.tag.isContextSpecific(0)
+    );
+    if (!t)
+      throw new ct(
+        "Missing timeStampTokenObj sub."
+      );
+    return t.subs[0];
+  }
+  // https://datatracker.ietf.org/doc/html/rfc5652#section-5.1
+  get encapContentInfoObj() {
+    return this.signedDataObj.subs[2];
+  }
+  // https://datatracker.ietf.org/doc/html/rfc5652#section-5.1
+  get signerInfosObj() {
+    const t = this.signedDataObj;
+    return t.subs[t.subs.length - 1];
+  }
+  // https://www.rfc-editor.org/rfc/rfc5652#section-5.1
+  get signerInfoObj() {
+    return this.signerInfosObj.subs[0];
+  }
+  // https://datatracker.ietf.org/doc/html/rfc5652#section-5.2
+  get eContentTypeObj() {
+    return this.encapContentInfoObj.subs[0];
+  }
+  // https://datatracker.ietf.org/doc/html/rfc5652#section-5.2
+  get eContentObj() {
+    return this.encapContentInfoObj.subs[1];
+  }
+  // https://datatracker.ietf.org/doc/html/rfc5652#section-5.3
+  get signedAttrsObj() {
+    const t = this.signerInfoObj.subs.find(
+      (s) => s.tag.isContextSpecific(0)
+    );
+    if (!t)
+      throw new ct("Missing signedAttrsObj.");
+    return t;
+  }
+  // https://datatracker.ietf.org/doc/html/rfc5652#section-5.3
+  get messageDigestAttributeObj() {
+    const t = this.signedAttrsObj.subs.find(
+      (s) => s.subs[0].tag.isOID() && s.subs[0].toOID() === zi
+    );
+    if (!t)
+      throw new ct("Missing messageDigest.");
+    return t;
+  }
+  // https://datatracker.ietf.org/doc/html/rfc5652#section-5.3
+  get signerSidObj() {
+    return this.signerInfoObj.subs[1];
+  }
+  // https://datatracker.ietf.org/doc/html/rfc5652#section-5.3
+  get signerDigestAlgorithmObj() {
+    return this.signerInfoObj.subs[2];
+  }
+  // https://datatracker.ietf.org/doc/html/rfc5652#section-5.3
+  get signatureAlgorithmObj() {
+    return this.signerInfoObj.subs[4];
+  }
+  // https://datatracker.ietf.org/doc/html/rfc5652#section-5.3
+  get signatureValueObj() {
+    return this.signerInfoObj.subs[5];
+  }
+}
+async function Ji(e, t, s) {
+  const n = e.signingTime;
+  let r = Qi(
+    s,
+    n
+  );
+  r = to(r, {
+    serialNumber: e.signerSerialNumber,
+    issuer: e.signerIssuer
+  });
+  const i = await Promise.allSettled(
+    r.map((a) => eo(e, t, a))
+  );
+  if (!i.some(
+    (a) => a.status === "fulfilled"
+  )) {
+    const a = i.filter((c) => c.status === "rejected").map((c) => c.reason?.message || "Unknown error");
+    throw new Error(`Timestamp could not be verified against any trusted authority. Errors: ${a.join(", ")}`);
+  }
+  return n;
+}
+function Qi(e, t) {
+  return e.filter((s) => {
+    if (s.validFor) {
+      const n = s.validFor.start ? new Date(s.validFor.start) : null, r = s.validFor.end ? new Date(s.validFor.end) : null;
+      if (n && t < n || r && t > r)
+        return !1;
+    }
+    return !0;
+  });
+}
+function to(e, t) {
+  return e.filter((s) => {
+    if (!s.certChain || s.certChain.certificates.length === 0)
+      return !1;
+    const n = J.parse(
+      S(s.certChain.certificates[0].rawBytes)
+    );
+    return H(n.serialNumber, t.serialNumber) && H(n.issuer, t.issuer);
+  });
+}
+async function eo(e, t, s) {
+  if (!s.certChain || s.certChain.certificates.length === 0)
+    throw new Error("Certificate authority missing certificate chain");
+  const n = J.parse(
+    S(s.certChain.certificates[0].rawBytes)
+  ), r = e.signingTime, i = s.certChain.certificates.slice(1).map((a) => J.parse(S(a.rawBytes)));
+  try {
+    await new ws({
+      untrustedCert: n,
+      trustedCerts: i,
+      timestamp: r
+    }).verify();
+  } catch (a) {
+    throw new Error(`TSA certificate chain verification failed: ${a instanceof Error ? a.message : String(a)}`);
+  }
+  const o = await n.publicKeyObj;
+  await e.verify(t, o);
+}
+async function no(e, t, s) {
+  if (!e?.rfc3161Timestamps?.length)
+    return [];
+  const n = [];
+  for (const r of e.rfc3161Timestamps) {
+    const i = S(r.signedTimestamp), o = Ge.parse(i), a = await Ji(
+      o,
+      t,
+      s
+    );
+    n.push({
+      signingTime: a,
+      signerSerialNumber: Array.from(o.signerSerialNumber).join(",")
+    });
+  }
+  for (let r = 0; r < n.length; r++)
+    for (let i = r + 1; i < n.length; i++)
+      if (n[r].signingTime.getTime() === n[i].signingTime.getTime() && n[r].signerSerialNumber === n[i].signerSerialNumber)
+        throw new Error("Duplicate TSA timestamp detected");
+  return n.map((r) => r.signingTime);
+}
+const Xt = {
+  metadataUrl: "https://tuf-repo-cdn.sigstore.dev/",
+  targetBaseUrl: "https://tuf-repo-cdn.sigstore.dev/targets/",
+  namespace: "sigstore-browser",
+  trustedRootTarget: "trusted_root.json",
+  cacheTTL: 36e5
+  // 1 hour
+};
+class so {
+  metadataUrl;
+  targetBaseUrl;
+  initialRoot;
+  namespace;
+  trustedRootTarget;
+  cacheTTL;
+  tufClient;
+  cachedRoot;
+  cacheTimestamp;
+  constructor(t = {}) {
+    const s = t.metadataUrl || Xt.metadataUrl;
+    this.metadataUrl = s.endsWith("/") ? s : `${s}/`;
+    const n = t.targetBaseUrl || Xt.targetBaseUrl;
+    this.targetBaseUrl = n.endsWith("/") ? n : `${n}/`, this.initialRoot = t.initialRoot, this.namespace = t.namespace || Xt.namespace, this.trustedRootTarget = t.trustedRootTarget || Xt.trustedRootTarget, this.cacheTTL = t.cacheTTL ?? Xt.cacheTTL;
+  }
+  /**
+   * Initialize the TUF client
+   * Lazy initialization to avoid loading TUF client until needed
+   */
+  async initTUFClient() {
+    if (!this.tufClient)
+      try {
+        const { TUFClient: t } = await import("./tuf-D48cBq5i.js"), s = this.initialRoot || await this.getDefaultRoot();
+        this.tufClient = new t(
+          this.metadataUrl,
+          s,
+          this.namespace,
+          this.targetBaseUrl
+        );
+      } catch (t) {
+        throw new Error(
+          `Failed to initialize TUF client: ${t instanceof Error ? t.message : String(t)}`
+        );
+      }
+  }
+  /**
+   * Get the default embedded root metadata
+   * Returns the TUF root.json that bootstraps the TUF client
+   */
+  async getDefaultRoot() {
+    const s = (await import("./tuf-root-D8m0y2I4.js")).default, n = new TextDecoder(), r = Uint8Array.from(atob(s), (i) => i.charCodeAt(0));
+    return n.decode(r);
+  }
+  /**
+   * Check if cached trusted root is still valid
+   */
+  isCacheValid() {
+    return !this.cachedRoot || !this.cacheTimestamp ? !1 : Date.now() - this.cacheTimestamp < this.cacheTTL;
+  }
+  /**
+   * Get the Sigstore trusted root metadata
+   * Uses TUF to securely fetch and verify the trusted root
+   *
+   * @returns Promise<TrustedRoot> The verified trusted root metadata
+   * @throws Error if TUF verification fails or root cannot be fetched
+   */
+  async getTrustedRoot() {
+    if (this.isCacheValid() && this.cachedRoot)
+      return this.cachedRoot;
+    if (await this.initTUFClient(), !this.tufClient)
+      throw new Error("TUF client not initialized");
+    try {
+      await this.tufClient.updateTUF();
+      const t = await this.tufClient.getTarget(this.trustedRootTarget), s = Q(new Uint8Array(t)), n = JSON.parse(s);
+      return this.cachedRoot = n, this.cacheTimestamp = Date.now(), n;
+    } catch (t) {
+      throw new Error(
+        `Failed to fetch trusted root via TUF: ${t instanceof Error ? t.message : String(t)}`
+      );
+    }
+  }
+  /**
+   * Manually refresh the trusted root from TUF
+   * Bypasses cache and forces a fresh fetch
+   *
+   * @returns Promise<TrustedRoot> The updated trusted root metadata
+   */
+  async refreshTrustedRoot() {
+    return this.cachedRoot = void 0, this.cacheTimestamp = void 0, await this.getTrustedRoot();
+  }
+  /**
+   * Clear the cached trusted root
+   * Next call to getTrustedRoot() will fetch fresh data
+   */
+  clearCache() {
+    this.cachedRoot = void 0, this.cacheTimestamp = void 0;
+  }
+}
+const qt = "application/vnd.dev.sigstore.bundle";
+function ro(e) {
+  switch (e) {
+    case `${qt}+json;version=0.1`:
+      return "0.1";
+    case `${qt}+json;version=0.2`:
+      return "0.2";
+    case `${qt}+json;version=0.3`:
+      return "0.3";
+  }
+  if (e.startsWith(`${qt}.v`) && e.endsWith("+json")) {
+    const t = e.replace(`${qt}.v`, "").replace("+json", "");
+    if (/^\d+\.\d+(\.\d+)?$/.test(t))
+      return t;
+  }
+  return "0.1";
+}
+class oo {
+  root;
+  rawRoot;
+  options;
+  constructor(t = {}) {
+    this.root = void 0, this.rawRoot = void 0, this.options = {
+      tlogThreshold: t.tlogThreshold ?? 1,
+      ctlogThreshold: t.ctlogThreshold ?? 1,
+      tsaThreshold: t.tsaThreshold ?? 0
+    };
+  }
+  async loadLog(t, s) {
+    for (const n of s)
+      if (t > new Date(n.publicKey.validFor.start) && (!n.publicKey.validFor.end || new Date(n.publicKey.validFor.end) > t))
+        return {
+          publicKey: await Zt(
+            n.publicKey.keyDetails,
+            n.publicKey.keyDetails,
+            n.publicKey.rawBytes
+          ),
+          logId: S(n.logId.keyId)
+        };
+  }
+  async loadCTLogs(t, s) {
+    const n = [];
+    for (const r of s) {
+      const i = new Date(r.publicKey.validFor.start), o = r.publicKey.validFor.end ? new Date(r.publicKey.validFor.end) : /* @__PURE__ */ new Date("9999-12-31");
+      if (i <= t) {
+        const a = await Zt(
+          r.publicKey.keyDetails,
+          r.publicKey.keyDetails,
+          r.publicKey.rawBytes
+        );
+        n.push({
+          logID: S(r.logId.keyId),
+          publicKey: a,
+          validFor: { start: i, end: o }
+        });
+      }
+    }
+    if (n.length === 0)
+      throw new Error("Could not find any valid CT logs in sigstore root.");
+    return n;
+  }
+  // Adapted from https://github.com/sigstore/sigstore-js/blob/main/packages/verify/src/key/certificate.ts#L22-L53
+  // Verifies that the leaf certificate chains to a trusted CA and is valid at the given timestamp.
+  // Differences from sigstore-js:
+  // - This is async (uses await) because our CertificateChainVerifier.verify() is async
+  // - sigstore-js filters CAs using filterCertAuthorities() before calling this function,
+  //   we do the timestamp filtering inline within this function
+  async verifyCertificateChain(t, s, n) {
+    let r;
+    for (const i of n)
+      if (!(t < i.validFor.start || t > i.validFor.end))
+        try {
+          return await new ws({
+            trustedCerts: i.certChain,
+            untrustedCert: s,
+            timestamp: t
+          }).verify();
+        } catch (o) {
+          r = o;
+        }
+    throw new Error(`Failed to verify certificate chain: ${r?.message || "No valid CAs found"}`);
+  }
+  // Load timestamp authorities that are valid at the frozen timestamp.
+  // Unlike sigstore-js which doesn't pre-load TSAs (it passes raw TSA data to timestamp verification),
+  // we parse and filter them at initialization time for consistency with how we handle CAs and other roots.
+  loadTSA(t, s) {
+    if (!s || s.length === 0)
+      return [];
+    const n = [];
+    for (const r of s) {
+      const i = new Date(r.validFor.start), o = r.validFor.end ? new Date(r.validFor.end) : /* @__PURE__ */ new Date(864e13);
+      if (t > i && t < o) {
+        const a = r.certChain.certificates.map(
+          (c) => J.parse(S(c.rawBytes))
+        );
+        a.length > 0 && n.push({
+          certChain: a,
+          validFor: { start: i, end: o }
+        });
+      }
+    }
+    return n;
+  }
+  // Load certificate authorities (Fulcio CAs) that are valid at the frozen timestamp.
+  // Similar to sigstore-js's filterCertAuthorities() in trust/filter.ts, but we also
+  // parse the certificates at load time whereas sigstore-js keeps them in the trust material
+  // and parses them during verification. This pre-loading approach is consistent with our
+  // architecture of loading all trusted roots at initialization.
+  loadCA(t, s) {
+    const n = [];
+    for (const r of s) {
+      const i = new Date(r.validFor.start), o = r.validFor.end ? new Date(r.validFor.end) : /* @__PURE__ */ new Date(864e13);
+      if (t > i && t < o) {
+        const a = r.certChain.certificates.map(
+          (c) => J.parse(S(c.rawBytes))
+        );
+        a.length > 0 && n.push({
+          certChain: a,
+          validFor: { start: i, end: o }
+        });
+      }
+    }
+    return n;
+  }
+  async loadSigstoreRoot(t) {
+    const s = /* @__PURE__ */ new Date();
+    this.rawRoot = t, this.root = {
+      rekor: await this.loadLog(s, t[ie.tlogs]),
+      ctlogs: await this.loadCTLogs(s, t[ie.ctlogs]),
+      certificateAuthorities: this.loadCA(
+        s,
+        t[ie.certificateAuthorities]
+      ),
+      timestampAuthorities: this.loadTSA(s, t.timestampAuthorities)
+    };
+  }
+  /**
+   * Load Sigstore trusted root via TUF
+   * Uses The Update Framework for secure, verified updates of trusted root metadata
+   *
+   * @param tufProvider Optional TrustedRootProvider instance. If not provided, uses default Sigstore TUF repository
+   */
+  async loadSigstoreRootWithTUF(t) {
+    const n = await (t || new so()).getTrustedRoot();
+    await this.loadSigstoreRoot(n);
+  }
+  // Adapted from https://github.com/sigstore/sigstore-js/blob/main/packages/verify/src/key/sct.ts
+  // Key differences:
+  // - Adds duplicate SCT detection (not in reference)
+  // - Inline CT log filtering by logID and validity period (reference uses filterTLogAuthorities)
+  // - Returns array of verified SCT logIDs for threshold checking (matches reference behavior)
+  async verifySCT(t, s, n) {
+    let r;
+    const i = t.clone();
+    for (let u = 0; u < i.extensions.length; u++) {
+      const f = i.extensions[u];
+      if (f.subs[0].toOID() === Mn) {
+        r = new qn(f), i.extensions.splice(u, 1);
+        break;
+      }
+    }
+    if (!r)
+      throw new Error("Certificate is missing required SCT extension");
+    if (r.signedCertificateTimestamps.length === 0)
+      throw new Error("SCT extension is present but contains no SCTs");
+    const o = /* @__PURE__ */ new Set();
+    for (const u of r.signedCertificateTimestamps) {
+      const f = ht(u.logID);
+      if (o.has(f))
+        throw new Error(`Duplicate SCT found for log ID: ${f}`);
+      o.add(f);
+    }
+    const a = new rt(), c = new Uint8Array(
+      await crypto.subtle.digest(U.SHA256, s.publicKey)
+    );
+    a.appendView(c);
+    const l = i.tbsCertificate.toDER();
+    a.appendUint24(l.length), a.appendView(l);
+    const h = [];
+    for (const u of r.signedCertificateTimestamps) {
+      const f = n.filter((p) => H(p.logID, u.logID) ? p.validFor.start <= u.datetime && u.datetime <= p.validFor.end : !1);
+      if (!await (async () => {
+        for (const p of f)
+          try {
+            if (await u.verify(a.buffer, p.publicKey))
+              return !0;
+          } catch {
+          }
+        return !1;
+      })())
+        throw new Error("SCT verification failed");
+      h.push(u.logID);
+    }
+    return h;
+  }
+  async verifyInclusionPromise(t, s, n) {
+    const r = s.verificationMaterial.tlogEntries;
+    if (r.length < this.options.tlogThreshold)
+      throw new Error(
+        `Not enough tlog entries: ${r.length} < ${this.options.tlogThreshold}`
+      );
+    const i = 32;
+    if (r.length > i)
+      throw new Error(
+        `Too many tlog entries: ${r.length} > ${i}`
+      );
+    for (let h = 0; h < r.length; h++)
+      for (let u = h + 1; u < r.length; u++) {
+        const f = ht(S(r[h].logId.keyId)), d = ht(S(r[u].logId.keyId));
+        if (f === d && r[h].logIndex === r[u].logIndex)
+          throw new Error(
+            `Duplicate tlog entry found: logID=${f}, logIndex=${r[h].logIndex}`
+          );
+      }
+    const o = r[0], a = ro(s.mediaType);
+    if (parseFloat(a) >= 0.2 && !o.inclusionProof)
+      throw new Error(
+        "Bundle v0.2+ requires an inclusion proof."
+      );
+    if (o.inclusionPromise?.signedEntryTimestamp) {
+      if (!(!n && o.inclusionProof)) {
+        if (!n)
+          throw new Error("Rekor public key not found in trusted root");
+        const h = S(o.logId.keyId);
+        if (!H(n.logId, h))
+          throw new Error(
+            `Rekor log ID mismatch: bundle uses ${ht(h)} but loaded key is for ${ht(n.logId)}`
+          );
+        const u = S(
+          o.inclusionPromise.signedEntryTimestamp
+        ), f = ht(h), d = Number(o.integratedTime), p = un(
+          Oe({
+            body: o.canonicalizedBody,
+            integratedTime: d,
+            logIndex: Number(o.logIndex),
+            logID: f
+          })
+        );
+        if (!await Rt(n.publicKey, p, u))
+          throw new Error(
+            "Failed to verify the inclusion promise in the provided bundle."
+          );
+      }
+    } else if (!o.inclusionProof)
+      throw new Error(
+        "Bundle must have either an inclusion promise or an inclusion proof."
+      );
+    if (o.integratedTime) {
+      const h = Number(o.integratedTime), u = new Date(h * 1e3);
+      if (!t.validForDate(u))
+        throw new Error(
+          "Artifact signing was logged outside of the certificate validity."
+        );
+    } else if (!s.verificationMaterial.timestampVerificationData)
+      throw new Error(
+        "Rekor v2 bundles require a timestamp for verification."
+      );
+    const l = JSON.parse(Q(S(o.canonicalizedBody)));
+    if (l.kind === "hashedrekord") {
+      let h;
+      if (l.spec.hashedRekordV002) {
+        const u = l.spec.hashedRekordV002.signature.verifier;
+        u?.x509Certificate && (h = u.x509Certificate.rawBytes);
+      } else l.spec.signature?.publicKey && (h = l.spec.signature.publicKey.content);
+      if (h) {
+        let u;
+        if (l.spec.hashedRekordV002)
+          u = J.parse(S(h));
+        else {
+          const f = Q(S(h));
+          u = J.parse(f);
+        }
+        if (!t.equals(u))
+          throw new Error(
+            "Certificate in Rekor log does not match the signing certificate."
+          );
+      }
+    } else if (l.kind === "dsse") {
+      const h = l.spec.signatures?.[0]?.verifier;
+      if (h) {
+        const u = Q(S(h)), f = J.parse(u);
+        if (!t.equals(f))
+          throw new Error(
+            "Certificate in DSSE tlog entry does not match the signing certificate."
+          );
+      }
+    } else if (l.kind === "intoto") {
+      const h = l.spec.content?.envelope?.signatures?.[0]?.publicKey;
+      if (h) {
+        const u = Q(S(h)), f = J.parse(u);
+        if (!t.equals(f))
+          throw new Error(
+            "Certificate in intoto tlog entry does not match the signing certificate."
+          );
+      }
+    } else
+      throw new Error(`Unsupported tlog entry kind: ${l.kind}`);
+    return !0;
+  }
+  async verifyInclusionProof(t) {
+    if (!this.rawRoot)
+      throw new Error("Sigstore root is undefined");
+    if (t.verificationMaterial.tlogEntries.length < 1)
+      throw new Error("No transparency log entries found in bundle");
+    for (const s of t.verificationMaterial.tlogEntries)
+      s.inclusionProof && (await Oi(s), s.inclusionProof.checkpoint && await Hi(s, this.rawRoot.tlogs));
+  }
+  async verifyArtifact(t, s, n, r, i = !1) {
+    if (!this.root)
+      throw new Error("Sigstore root is undefined");
+    const o = n.verificationMaterial.certificate || n.verificationMaterial.x509CertificateChain?.certificates[0];
+    if (!o)
+      throw new Error("No certificate found in bundle");
+    const a = J.parse(S(o.rawBytes));
+    let c;
+    if (n.messageSignature)
+      c = S(n.messageSignature.signature);
+    else if (n.dsseEnvelope) {
+      if (!n.dsseEnvelope.signatures || n.dsseEnvelope.signatures.length === 0)
+        throw new Error("DSSE envelope has no signatures");
+      c = S(n.dsseEnvelope.signatures[0].sig);
+    } else
+      throw new Error("Bundle does not contain a message signature or DSSE envelope");
+    if (a.subjectAltName !== t)
+      throw new Error(
+        "Certificate identity (subjectAltName) do not match the verifying one."
+      );
+    if ((a.extFulcioIssuerV2?.issuer || a.extFulcioIssuerV1?.issuer) !== s)
+      throw new Error("Identity issuer is not the verifying one.");
+    const h = await this.verifyCertificateChain(
+      a.notBefore,
+      a,
+      this.root.certificateAuthorities
+    ), u = h.length > 1 ? h[1] : h[0], f = await this.verifySCT(a, u, this.root.ctlogs);
+    if (f.length < this.options.ctlogThreshold)
+      throw new Error(
+        `Not enough valid SCTs: found ${f.length}, required ${this.options.ctlogThreshold}`
+      );
+    if (!await this.verifyInclusionPromise(a, n, this.root.rekor))
+      throw new Error("Inclusion promise validation failed.");
+    await this.verifyInclusionProof(n);
+    for (const p of n.verificationMaterial.tlogEntries)
+      await qi(p, n);
+    const d = await no(
+      n.verificationMaterial.timestampVerificationData,
+      c,
+      this.rawRoot?.timestampAuthorities || []
+    );
+    if (d.length < this.options.tsaThreshold)
+      throw new Error(
+        `Not enough verified TSA timestamps: ${d.length} < ${this.options.tsaThreshold}`
+      );
+    for (const p of d)
+      if (!a.validForDate(p))
+        throw new Error(
+          "Certificate was not valid at the time of timestamping"
+        );
+    if (n.dsseEnvelope) {
+      const p = S(n.dsseEnvelope.payload), m = JSON.parse(Q(p));
+      if (!m.subject || m.subject.length === 0)
+        throw new Error("DSSE payload has no subject");
+      let R;
+      i ? R = ht(r) : R = ht(
+        new Uint8Array(await crypto.subtle.digest(U.SHA256, r))
+      );
+      let _ = null;
+      for (const K of m.subject) {
+        const ot = K.digest?.sha256;
+        if (ot && R === ot.toLowerCase()) {
+          _ = K;
+          break;
+        }
+      }
+      if (!_)
+        throw new Error(
+          `Artifact digest ${R} does not match any subject in DSSE payload`
+        );
+      const et = Ai(n.dsseEnvelope.payloadType, p), A = await a.publicKeyObj;
+      if (!await Rt(A, et, c))
+        throw new Error("DSSE signature verification failed");
+    } else {
+      const p = await a.publicKeyObj;
+      if (i) {
+        if (!await Fr(p, r, c))
+          throw new Error("Error verifying signature over digest");
+      } else if (!await Rt(p, r, c)) {
+        const R = p.algorithm.name || "unknown";
+        throw new Error(`Error verifying artifact signature. Key algorithm: ${R}, Data length: ${r.length}, Signature length: ${c.length}`);
+      }
+    }
+    return !0;
+  }
+}
+class Dt extends Error {
+  constructor(t, s) {
+    super(s), this.code = t, this.name = "VerificationError", Object.setPrototypeOf(this, Dt.prototype);
+  }
+}
+class bs extends Dt {
+  constructor(t) {
+    super("TIMESTAMP_ERROR", t), this.name = "TimestampError", Object.setPrototypeOf(this, bs.prototype);
+  }
+}
+class ps extends Dt {
+  constructor(t) {
+    super("CERTIFICATE_ERROR", t), this.name = "CertificateError", Object.setPrototypeOf(this, ps.prototype);
+  }
+}
+class ys extends Dt {
+  constructor(t) {
+    super("TLOG_ERROR", t), this.name = "TLogError", Object.setPrototypeOf(this, ys.prototype);
+  }
+}
+class ms extends Dt {
+  constructor(t) {
+    super("SIGNATURE_ERROR", t), this.name = "SignatureError", Object.setPrototypeOf(this, ms.prototype);
+  }
+}
+class St extends Dt {
+  constructor(t) {
+    super("POLICY_ERROR", t), this.name = "PolicyError", Object.setPrototypeOf(this, St.prototype);
+  }
+}
+const ao = "https://token.actions.githubusercontent.com";
+class Ut {
+  expectedValue;
+  constructor(t) {
+    this.expectedValue = t;
+  }
+  verify(t) {
+    const s = this.getExtensionValue(t);
+    if (s === void 0)
+      throw new St(
+        `Certificate does not contain ${this.name} (${this.oid}) extension`
+      );
+    if (s !== this.expectedValue)
+      throw new St(
+        `Certificate's ${this.name} does not match (got '${s}', expected '${this.expectedValue}')`
+      );
+  }
+}
+class W extends Ut {
+}
+class io extends Ut {
+  oid = Zn;
+  name = "OIDCIssuer";
+  getExtensionValue(t) {
+    return t.extFulcioIssuerV1?.issuer;
+  }
+}
+class co extends Ut {
+  oid = Wn;
+  name = "GitHubWorkflowTrigger";
+  getExtensionValue(t) {
+    return t.extGitHubWorkflowTrigger?.workflowTrigger;
+  }
+}
+class fo extends Ut {
+  oid = Yn;
+  name = "GitHubWorkflowSHA";
+  getExtensionValue(t) {
+    return t.extGitHubWorkflowSHA?.workflowSHA;
+  }
+}
+class uo extends Ut {
+  oid = zn;
+  name = "GitHubWorkflowName";
+  getExtensionValue(t) {
+    return t.extGitHubWorkflowName?.workflowName;
+  }
+}
+class lo extends Ut {
+  oid = Jn;
+  name = "GitHubWorkflowRepository";
+  getExtensionValue(t) {
+    return t.extGitHubWorkflowRepository?.workflowRepository;
+  }
+}
+class ho extends Ut {
+  oid = Qn;
+  name = "GitHubWorkflowRef";
+  getExtensionValue(t) {
+    return t.extGitHubWorkflowRef?.workflowRef;
+  }
+}
+class go extends W {
+  oid = ts;
+  name = "OIDCIssuerV2";
+  getExtensionValue(t) {
+    return t.extFulcioIssuerV2?.issuer;
+  }
+}
+class wo extends W {
+  oid = es;
+  name = "OIDCBuildSignerURI";
+  getExtensionValue(t) {
+    return t.extBuildSignerURI?.buildSignerURI;
+  }
+}
+class bo extends W {
+  oid = ns;
+  name = "OIDCBuildSignerDigest";
+  getExtensionValue(t) {
+    return t.extBuildSignerDigest?.buildSignerDigest;
+  }
+}
+class po extends W {
+  oid = ss;
+  name = "OIDCRunnerEnvironment";
+  getExtensionValue(t) {
+    return t.extRunnerEnvironment?.runnerEnvironment;
+  }
+}
+class yo extends W {
+  oid = rs;
+  name = "OIDCSourceRepositoryURI";
+  getExtensionValue(t) {
+    return t.extSourceRepositoryURI?.sourceRepositoryURI;
+  }
+}
+class mo extends W {
+  oid = is;
+  name = "OIDCSourceRepositoryDigest";
+  getExtensionValue(t) {
+    return t.extSourceRepositoryDigest?.sourceRepositoryDigest;
+  }
+}
+class Eo extends W {
+  oid = os;
+  name = "OIDCSourceRepositoryRef";
+  getExtensionValue(t) {
+    return t.extSourceRepositoryRef?.sourceRepositoryRef;
+  }
+}
+class xo extends W {
+  oid = as;
+  name = "OIDCSourceRepositoryIdentifier";
+  getExtensionValue(t) {
+    return t.extSourceRepositoryIdentifier?.sourceRepositoryIdentifier;
+  }
+}
+class So extends W {
+  oid = cs;
+  name = "OIDCSourceRepositoryOwnerURI";
+  getExtensionValue(t) {
+    return t.extSourceRepositoryOwnerURI?.sourceRepositoryOwnerURI;
+  }
+}
+class Io extends W {
+  oid = fs;
+  name = "OIDCSourceRepositoryOwnerIdentifier";
+  getExtensionValue(t) {
+    return t.extSourceRepositoryOwnerIdentifier?.sourceRepositoryOwnerIdentifier;
+  }
+}
+class vo extends W {
+  oid = us;
+  name = "OIDCBuildConfigURI";
+  getExtensionValue(t) {
+    return t.extBuildConfigURI?.buildConfigURI;
+  }
+}
+class Ao extends W {
+  oid = ls;
+  name = "OIDCBuildConfigDigest";
+  getExtensionValue(t) {
+    return t.extBuildConfigDigest?.buildConfigDigest;
+  }
+}
+class Oo extends W {
+  oid = hs;
+  name = "OIDCBuildTrigger";
+  getExtensionValue(t) {
+    return t.extBuildTrigger?.buildTrigger;
+  }
+}
+class Bo extends W {
+  oid = ds;
+  name = "OIDCRunInvocationURI";
+  getExtensionValue(t) {
+    return t.extRunInvocationURI?.runInvocationURI;
+  }
+}
+class Ro extends W {
+  oid = gs;
+  name = "OIDCSourceRepositoryVisibility";
+  getExtensionValue(t) {
+    return t.extSourceRepositoryVisibility?.sourceRepositoryVisibility;
+  }
+}
+class Co {
+  children;
+  constructor(t) {
+    this.children = t;
+  }
+  verify(t) {
+    for (const s of this.children)
+      try {
+        s.verify(t);
+        return;
+      } catch {
+      }
+    throw new St(`0 of ${this.children.length} policies succeeded`);
+  }
+}
+class To {
+  children;
+  constructor(t) {
+    this.children = t;
+  }
+  verify(t) {
+    if (this.children.length < 1)
+      throw new St("no child policies to verify");
+    for (const s of this.children)
+      s.verify(t);
+  }
+}
+class Do {
+  identity;
+  issuerPolicy;
+  constructor(t) {
+    this.identity = t.identity, this.issuerPolicy = t.issuer ? new io(t.issuer) : null;
+  }
+  verify(t) {
+    this.issuerPolicy && this.issuerPolicy.verify(t);
+    const s = t.extSubjectAltName;
+    if (!s)
+      throw new St("Certificate does not contain SubjectAlternativeName extension");
+    const n = /* @__PURE__ */ new Set();
+    s.rfc822Name && n.add(s.rfc822Name), s.uri && n.add(s.uri);
+    const r = s.otherName(Si);
+    if (r && n.add(r), !n.has(this.identity))
+      throw new St(
+        `Certificate's SANs do not match ${this.identity}; actual SANs: ${Array.from(n).join(", ")}`
+      );
+  }
+}
+export {
+  ri as $,
+  os as A,
+  as as B,
+  ps as C,
+  cs as D,
+  Mn as E,
+  fs as F,
+  us as G,
+  U as H,
+  ls as I,
+  hs as J,
+  ds as K,
+  gs as L,
+  wt as M,
+  Yr as N,
+  ni as O,
+  St as P,
+  zr as Q,
+  Jr as R,
+  oo as S,
+  bs as T,
+  ht as U,
+  Dt as V,
+  Qr as W,
+  J as X,
+  ti as Y,
+  ei as Z,
+  si as _,
+  Me as a,
+  ii as a0,
+  oi as a1,
+  ai as a2,
+  ci as a3,
+  fi as a4,
+  ui as a5,
+  li as a6,
+  hi as a7,
+  di as a8,
+  gi as a9,
+  Co as aA,
+  Do as aB,
+  wi as aa,
+  bi as ab,
+  ws as ac,
+  ao as ad,
+  io as ae,
+  go as af,
+  co as ag,
+  fo as ah,
+  uo as ai,
+  lo as aj,
+  ho as ak,
+  wo as al,
+  bo as am,
+  po as an,
+  yo as ao,
+  mo as ap,
+  Eo as aq,
+  xo as ar,
+  So as as,
+  Io as at,
+  vo as au,
+  Ao as av,
+  Oo as aw,
+  Bo as ax,
+  Ro as ay,
+  To as az,
+  S as b,
+  Oe as c,
+  Q as d,
+  ys as e,
+  ms as f,
+  Ji as g,
+  Kt as h,
+  Zt as i,
+  no as j,
+  so as k,
+  Zn as l,
+  Wn as m,
+  Yn as n,
+  zn as o,
+  Jn as p,
+  Qn as q,
+  Si as r,
+  un as s,
+  ts as t,
+  es as u,
+  Rt as v,
+  ns as w,
+  ss as x,
+  rs as y,
+  is as z
+};
+//# sourceMappingURL=index-CRFtwdjM.js.map