@gerege-systems/eid-mongolia-sdk 0.15.0 → 0.15.2

package/dist/chunk-52O3T7DZ.js

@@ -0,0 +1,1043 @@
+// src/pades/bytes.ts
+var enc = new TextEncoder();
+function latin1(s) {
+  const out = new Uint8Array(s.length);
+  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i) & 255;
+  return out;
+}
+function fromLatin1(b, start = 0, end = b.length) {
+  let s = "";
+  for (let i = start; i < end; i += 32768) s += String.fromCharCode(...b.subarray(i, Math.min(end, i + 32768)));
+  return s;
+}
+function concat(parts) {
+  let n = 0;
+  for (const p of parts) n += p.length;
+  const out = new Uint8Array(n);
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+}
+function equal(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function compare(a, b) {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) if (a[i] !== b[i]) return a[i] - b[i];
+  return a.length - b.length;
+}
+var HEX = "0123456789abcdef";
+function toHex(b) {
+  let s = "";
+  for (const x of b) s += HEX[x >> 4] + HEX[x & 15];
+  return s;
+}
+function fromHex(s) {
+  if (s.length % 2 !== 0 || /[^0-9a-fA-F]/.test(s)) throw new Error("hex \u0431\u0443\u0440\u0443\u0443");
+  const out = new Uint8Array(s.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(s.substr(i * 2, 2), 16);
+  return out;
+}
+function toB64(b) {
+  return btoa(fromLatin1(b));
+}
+function fromB64(s) {
+  return latin1(atob(s));
+}
+var ByteWriter = class {
+  buf = new Uint8Array(1 << 16);
+  len = 0;
+  grow(n) {
+    if (this.len + n <= this.buf.length) return;
+    let cap = this.buf.length * 2;
+    while (cap < this.len + n) cap *= 2;
+    const nb = new Uint8Array(cap);
+    nb.set(this.buf.subarray(0, this.len));
+    this.buf = nb;
+  }
+  bytes(b) {
+    this.grow(b.length);
+    this.buf.set(b, this.len);
+    this.len += b.length;
+    return this;
+  }
+  /** ASCII/latin1 мөр. */
+  str(s) {
+    this.grow(s.length);
+    for (let i = 0; i < s.length; i++) this.buf[this.len + i] = s.charCodeAt(i) & 255;
+    this.len += s.length;
+    return this;
+  }
+  byte(x) {
+    this.grow(1);
+    this.buf[this.len++] = x & 255;
+    return this;
+  }
+  /** Хуулбар. */
+  result() {
+    return this.buf.slice(0, this.len);
+  }
+};
+
+// src/pades/crypto.ts
+var subtlePromise;
+var nodeImport = (m) => import(
+  /* @vite-ignore */
+  /* webpackIgnore: true */
+  m
+);
+async function webcrypto() {
+  const g = globalThis.crypto;
+  if (g?.subtle) return g;
+  const m = await nodeImport("node:crypto");
+  if (!m.webcrypto) throw new Error("Web Crypto \u0430\u043B\u0433\u0430");
+  return m.webcrypto;
+}
+function subtle() {
+  subtlePromise ??= webcrypto().then((c) => c.subtle);
+  return subtlePromise;
+}
+async function randomBytes(n) {
+  return (await webcrypto()).getRandomValues(new Uint8Array(n));
+}
+async function sha256(b) {
+  return new Uint8Array(await (await subtle()).digest("SHA-256", b));
+}
+async function sha1(b) {
+  return new Uint8Array(await (await subtle()).digest("SHA-1", b));
+}
+async function digest(alg, b) {
+  return new Uint8Array(await (await subtle()).digest(alg, b));
+}
+
+// src/pades/asn1.ts
+var Asn1Error = class extends Error {
+};
+var TAG = {
+  BOOLEAN: 1,
+  INTEGER: 2,
+  BIT_STRING: 3,
+  OCTET_STRING: 4,
+  NULL: 5,
+  OID: 6,
+  ENUMERATED: 10,
+  UTF8String: 12,
+  SEQUENCE: 48,
+  SET: 49,
+  PrintableString: 19,
+  IA5String: 22,
+  UTCTime: 23,
+  GeneralizedTime: 24
+};
+function readNode(b, off = 0) {
+  if (off + 2 > b.length) throw new Asn1Error("asn1: \u0434\u0443\u0442\u0443\u0443");
+  const tag = b[off];
+  if ((tag & 31) === 31) throw new Asn1Error("asn1: \u043E\u043B\u043E\u043D \u0431\u0430\u0439\u0442 tag \u0434\u044D\u043C\u0436\u0438\u0433\u0434\u044D\u0445\u0433\u04AF\u0439");
+  let len = b[off + 1];
+  let p = off + 2;
+  if (len & 128) {
+    const n = len & 127;
+    if (n === 0 || n > 4) throw new Asn1Error("asn1: \u0443\u0440\u0442 \u0431\u0443\u0440\u0443\u0443");
+    if (p + n > b.length) throw new Asn1Error("asn1: \u0434\u0443\u0442\u0443\u0443");
+    if (b[p] === 0) throw new Asn1Error("asn1: \u0443\u0440\u0442 minimal \u0431\u0438\u0448");
+    len = 0;
+    for (let i = 0; i < n; i++) len = len * 256 + b[p + i];
+    if (len < 128) throw new Asn1Error("asn1: \u0443\u0440\u0442 minimal \u0431\u0438\u0448");
+    p += n;
+  }
+  if (p + len > b.length) throw new Asn1Error("asn1: \u0434\u0443\u0442\u0443\u0443");
+  return { tag, raw: b.subarray(off, p + len), value: b.subarray(p, p + len) };
+}
+function parseOne(b) {
+  const n = readNode(b, 0);
+  if (n.raw.length !== b.length) throw new Asn1Error("asn1: \u0438\u043B\u04AF\u04AF \u04E9\u0433\u04E9\u0433\u0434\u04E9\u043B");
+  return n;
+}
+function children(n) {
+  const v = n instanceof Uint8Array ? n : n.value;
+  const out = [];
+  for (let p = 0; p < v.length; ) {
+    const c = readNode(v, p);
+    out.push(c);
+    p += c.raw.length;
+  }
+  return out;
+}
+function expect(n, tag, what) {
+  if (!n || n.tag !== tag) throw new Asn1Error(`asn1: ${what} \u0445\u04AF\u043B\u044D\u044D\u0441\u044D\u043D`);
+  return n;
+}
+function lenBytes(n) {
+  if (n < 128) return Uint8Array.of(n);
+  const out = [];
+  for (let x = n; x > 0; x = Math.floor(x / 256)) out.unshift(x & 255);
+  return Uint8Array.from([128 | out.length, ...out]);
+}
+function tlv(tag, ...content) {
+  const v = concat(content);
+  return concat([Uint8Array.of(tag), lenBytes(v.length), v]);
+}
+var seq = (...c) => tlv(TAG.SEQUENCE, ...c);
+var set = (...c) => tlv(TAG.SET, ...c);
+var octet = (b) => tlv(TAG.OCTET_STRING, b);
+var nullDer = () => Uint8Array.of(5, 0);
+var ctx = (n, constructed, ...c) => tlv(128 | (constructed ? 32 : 0) | n, ...c);
+function oid(s) {
+  const parts = s.split(".").map((x) => BigInt(x));
+  const body = [];
+  const enc2 = (v) => {
+    const tmp = [Number(v & 0x7fn)];
+    for (v >>= 7n; v > 0n; v >>= 7n) tmp.unshift(Number(v & 0x7fn) | 128);
+    body.push(...tmp);
+  };
+  enc2(parts[0] * 40n + parts[1]);
+  for (const p of parts.slice(2)) enc2(p);
+  return tlv(TAG.OID, Uint8Array.from(body));
+}
+function oidString(v) {
+  const out = [];
+  let cur = 0n;
+  for (const b of v) {
+    cur = cur << 7n | BigInt(b & 127);
+    if (!(b & 128)) {
+      out.push(cur);
+      cur = 0n;
+    }
+  }
+  if (out.length === 0) return "";
+  const first = out[0];
+  const a = first < 40n ? 0n : first < 80n ? 1n : 2n;
+  return [a, first - a * 40n, ...out.slice(1)].join(".");
+}
+function intFromBig(v) {
+  if (v === 0n) return tlv(TAG.INTEGER, Uint8Array.of(0));
+  const bytes = [];
+  if (v > 0n) {
+    for (let x = v; x > 0n; x >>= 8n) bytes.unshift(Number(x & 0xffn));
+    if (bytes[0] & 128) bytes.unshift(0);
+  } else {
+    let x = v;
+    for (; ; ) {
+      bytes.unshift(Number(x & 0xffn));
+      x >>= 8n;
+      if (x === -1n && bytes[0] & 128) break;
+    }
+  }
+  return tlv(TAG.INTEGER, Uint8Array.from(bytes));
+}
+function bigFromBytes(b) {
+  let v = 0n;
+  for (const x of b) v = v << 8n | BigInt(x);
+  return v;
+}
+function intValue(v) {
+  if (v.length === 0) throw new Asn1Error("asn1: \u0445\u043E\u043E\u0441\u043E\u043D INTEGER");
+  let x = bigFromBytes(v);
+  if (v[0] & 128) x -= 1n << BigInt(v.length * 8);
+  return x;
+}
+function parseTime(n) {
+  const s = String.fromCharCode(...n.value);
+  let m;
+  if (n.tag === TAG.UTCTime) {
+    m = /^(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})?(Z|[+-]\d{4})$/.exec(s);
+    if (!m) throw new Asn1Error("asn1: UTCTime \u0431\u0443\u0440\u0443\u0443");
+    let y = Number(m[1]);
+    y += y < 50 ? 2e3 : 1900;
+    return mkDate(y, m[2], m[3], m[4], m[5], m[6] ?? "00", "", m[7]);
+  }
+  if (n.tag === TAG.GeneralizedTime) {
+    m = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\.\d+)?(Z|[+-]\d{4})$/.exec(s);
+    if (!m) throw new Asn1Error("asn1: GeneralizedTime \u0431\u0443\u0440\u0443\u0443");
+    return mkDate(Number(m[1]), m[2], m[3], m[4], m[5], m[6], m[7] ?? "", m[8]);
+  }
+  throw new Asn1Error("asn1: \u0446\u0430\u0433 \u0445\u04AF\u043B\u044D\u044D\u0441\u044D\u043D");
+}
+function parsePreciseTime(n) {
+  const date = parseTime(n);
+  const m = /\.(\d+)/.exec(String.fromCharCode(...n.value));
+  const nanos = m ? Number((m[1] + "000000000").slice(0, 9)) : 0;
+  return { date, nanos };
+}
+function mkDate(y, mo, d, h, mi, s, frac, z) {
+  let t = Date.UTC(y, Number(mo) - 1, Number(d), Number(h), Number(mi), Number(s));
+  if (frac) t += Math.floor(Number("0" + frac) * 1e3);
+  if (z !== "Z") {
+    const off = (Number(z.slice(1, 3)) * 60 + Number(z.slice(3, 5))) * 6e4;
+    t += z[0] === "+" ? -off : off;
+  }
+  return new Date(t);
+}
+
+// src/pades/x509.ts
+var OID = {
+  rsaEncryption: "1.2.840.113549.1.1.1",
+  rsaPSS: "1.2.840.113549.1.1.10",
+  sha256WithRSA: "1.2.840.113549.1.1.11",
+  sha384WithRSA: "1.2.840.113549.1.1.12",
+  sha512WithRSA: "1.2.840.113549.1.1.13",
+  ecPublicKey: "1.2.840.10045.2.1",
+  ecdsaSHA256: "1.2.840.10045.4.3.2",
+  ecdsaSHA384: "1.2.840.10045.4.3.3",
+  ecdsaSHA512: "1.2.840.10045.4.3.4",
+  p256: "1.2.840.10045.3.1.7",
+  p384: "1.3.132.0.34",
+  p521: "1.3.132.0.35",
+  sha1: "1.3.14.3.2.26",
+  sha256: "2.16.840.1.101.3.4.2.1",
+  sha384: "2.16.840.1.101.3.4.2.2",
+  sha512: "2.16.840.1.101.3.4.2.3",
+  commonName: "2.5.4.3",
+  surname: "2.5.4.4",
+  givenName: "2.5.4.42",
+  extKeyUsage: "2.5.29.37",
+  keyUsage: "2.5.29.15",
+  basicConstraints: "2.5.29.19",
+  crlDP: "2.5.29.31",
+  aia: "1.3.6.1.5.5.7.1.1",
+  ocspMethod: "1.3.6.1.5.5.7.48.1",
+  kpTimeStamping: "1.3.6.1.5.5.7.3.8",
+  kpOCSPSigning: "1.3.6.1.5.5.7.3.9",
+  kpAny: "2.5.29.37.0"
+};
+var CertError = class extends Error {
+};
+function bitString(n) {
+  expect(n, TAG.BIT_STRING, "BIT STRING");
+  if (n.value.length === 0) throw new Asn1Error("BIT STRING \u0445\u043E\u043E\u0441\u043E\u043D");
+  return n.value.subarray(1);
+}
+function decodeDirString(n) {
+  if (n.tag === 30) {
+    let s = "";
+    for (let i = 0; i + 1 < n.value.length; i += 2) s += String.fromCharCode(n.value[i] << 8 | n.value[i + 1]);
+    return s;
+  }
+  if (n.tag === TAG.UTF8String) return new TextDecoder().decode(n.value);
+  return String.fromCharCode(...n.value);
+}
+function nameAttrs(name) {
+  const out = [];
+  for (const rdn of children(name)) {
+    for (const atv of children(rdn)) {
+      const [t, v] = children(atv);
+      if (!t || !v) continue;
+      out.push([oidString(t.value), decodeDirString(v)]);
+    }
+  }
+  return out;
+}
+function parseCertificate(der) {
+  try {
+    const top = parseOne(der);
+    expect(top, TAG.SEQUENCE, "Certificate");
+    const [tbsN, sigAlg, sigN] = children(top);
+    const tbs = expect(tbsN, TAG.SEQUENCE, "TBSCertificate");
+    const f = children(tbs);
+    let i = 0;
+    let version = 1;
+    if (f[0]?.tag === 160) {
+      const v = expect(children(f[0])[0], TAG.INTEGER, "version");
+      version = v.value[0] + 1;
+      i++;
+    }
+    const serial = expect(f[i++], TAG.INTEGER, "serial").value;
+    i++;
+    const issuer = expect(f[i++], TAG.SEQUENCE, "issuer");
+    const validity = children(expect(f[i++], TAG.SEQUENCE, "validity"));
+    const subject = expect(f[i++], TAG.SEQUENCE, "subject");
+    const spki = expect(f[i++], TAG.SEQUENCE, "SPKI");
+    const [algN, pkN] = children(spki);
+    const algParts = children(expect(algN, TAG.SEQUENCE, "AlgorithmIdentifier"));
+    const keyAlg = oidString(expect(algParts[0], TAG.OID, "alg").value);
+    const curve = keyAlg === OID.ecPublicKey && algParts[1]?.tag === TAG.OID ? oidString(algParts[1].value) : void 0;
+    const extensions = [];
+    for (; i < f.length; i++) {
+      if (f[i].tag !== 163) continue;
+      for (const e of children(expect(children(f[i])[0], TAG.SEQUENCE, "extensions"))) {
+        const p = children(e);
+        const o = oidString(expect(p[0], TAG.OID, "ext oid").value);
+        let critical = false;
+        let val = p[1];
+        if (val?.tag === TAG.BOOLEAN) {
+          critical = val.value[0] !== 0;
+          val = p[2];
+        }
+        extensions.push({ oid: o, critical, value: expect(val, TAG.OCTET_STRING, "ext value").value });
+      }
+    }
+    const subj = nameAttrs(subject);
+    const iss = nameAttrs(issuer);
+    const last = (a, o) => a.filter(([k]) => k === o).map(([, v]) => v).pop() ?? "";
+    const cert = {
+      raw: top.raw,
+      tbs: tbs.raw,
+      version,
+      serial,
+      sigAlg: expect(sigAlg, TAG.SEQUENCE, "sigAlg"),
+      signature: bitString(sigN),
+      rawIssuer: issuer.raw,
+      rawSubject: subject.raw,
+      spki: spki.raw,
+      keyAlg,
+      curve,
+      publicKey: bitString(pkN),
+      notBefore: parseTime(validity[0]),
+      notAfter: parseTime(validity[1]),
+      extensions,
+      subjectCN: last(subj, OID.commonName),
+      issuerCN: last(iss, OID.commonName),
+      // Go SignerDisplayName: Subject.Names-ийн давталтын сүүлийн утга.
+      givenName: last(subj, OID.givenName),
+      surname: last(subj, OID.surname),
+      ocspServers: [],
+      crlDPs: [],
+      isCA: false,
+      basicConstraintsValid: false,
+      keyUsage: 0,
+      extKeyUsage: []
+    };
+    for (const e of extensions) parseExtension(cert, e);
+    return cert;
+  } catch (e) {
+    throw new CertError(`\u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0437\u0430\u0434\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+function parseExtension(c, e) {
+  const n = parseOne(e.value);
+  switch (e.oid) {
+    case OID.basicConstraints: {
+      c.basicConstraintsValid = true;
+      const p = children(n);
+      c.isCA = p[0]?.tag === TAG.BOOLEAN && p[0].value[0] !== 0;
+      break;
+    }
+    case OID.keyUsage: {
+      const bs = n.value;
+      let ku = 0;
+      for (let i = 1; i < bs.length; i++) {
+        for (let b = 0; b < 8; b++) if (bs[i] & 128 >> b) ku |= 1 << (i - 1) * 8 + b;
+      }
+      c.keyUsage = ku;
+      break;
+    }
+    case OID.extKeyUsage:
+      c.extKeyUsage = children(n).map((x) => oidString(x.value));
+      break;
+    case OID.aia:
+      for (const ad of children(n)) {
+        const [m, loc] = children(ad);
+        if (m && loc && oidString(m.value) === OID.ocspMethod && loc.tag === 134) c.ocspServers.push(String.fromCharCode(...loc.value));
+      }
+      break;
+    case OID.crlDP:
+      for (const dp of children(n)) {
+        for (const f of children(dp)) {
+          if (f.tag !== 160) continue;
+          for (const fn of children(f)) {
+            if (fn.tag !== 160) continue;
+            for (const gn of children(fn)) if (gn.tag === 134) c.crlDPs.push(String.fromCharCode(...gn.value));
+          }
+        }
+      }
+      break;
+  }
+}
+function isTSASigningCert(c) {
+  const ekus = c.extensions.filter((e2) => e2.oid === OID.extKeyUsage);
+  if (ekus.length !== 1) return false;
+  const e = ekus[0];
+  try {
+    const oids = children(parseOne(e.value));
+    return e.critical && oids.length === 1 && oids[0].tag === TAG.OID && oidString(oids[0].value) === OID.kpTimeStamping;
+  } catch {
+    return false;
+  }
+}
+var HASH_BY_OID = {
+  [OID.sha1]: "SHA-1",
+  [OID.sha256]: "SHA-256",
+  [OID.sha384]: "SHA-384",
+  [OID.sha512]: "SHA-512"
+};
+function schemeFor(alg) {
+  const p = children(alg);
+  const o = oidString(expect(p[0], TAG.OID, "sigAlg").value);
+  switch (o) {
+    case "1.2.840.113549.1.1.5":
+      return { kind: "rsa", hash: "SHA-1" };
+    case OID.sha256WithRSA:
+      return { kind: "rsa", hash: "SHA-256" };
+    case OID.sha384WithRSA:
+      return { kind: "rsa", hash: "SHA-384" };
+    case OID.sha512WithRSA:
+      return { kind: "rsa", hash: "SHA-512" };
+    case OID.ecdsaSHA256:
+      return { kind: "ecdsa", hash: "SHA-256" };
+    case OID.ecdsaSHA384:
+      return { kind: "ecdsa", hash: "SHA-384" };
+    case OID.ecdsaSHA512:
+      return { kind: "ecdsa", hash: "SHA-512" };
+    case OID.rsaPSS: {
+      let hash = "SHA-1";
+      let salt = 20;
+      for (const f of p[1] ? children(p[1]) : []) {
+        if (f.tag === 160) hash = HASH_BY_OID[oidString(children(children(f)[0])[0].value)] ?? hash;
+        if (f.tag === 162) salt = Number(children(f)[0].value[0]);
+      }
+      return { kind: "pss", hash, saltLength: salt };
+    }
+  }
+  throw new CertError(`\u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u0433\u0438\u0439\u043D \u0430\u043B\u0433\u043E\u0440\u0438\u0442\u043C \u0434\u044D\u043C\u0436\u0438\u0433\u0434\u044D\u0445\u0433\u04AF\u0439: ${o}`);
+}
+var CURVES = {
+  [OID.p256]: { name: "P-256", size: 32 },
+  [OID.p384]: { name: "P-384", size: 48 },
+  [OID.p521]: { name: "P-521", size: 66 }
+};
+function ecdsaDerToRaw(der, size) {
+  const [r, s] = children(parseOne(der));
+  const out = new Uint8Array(2 * size);
+  const put = (v, at) => {
+    let x = v;
+    while (x.length > 0 && x[0] === 0) x = x.subarray(1);
+    if (x.length > size) throw new CertError("ECDSA \u0443\u0442\u0433\u0430 \u0445\u044D\u0442 \u0443\u0440\u0442");
+    out.set(x, at + size - x.length);
+  };
+  put(expect(r, TAG.INTEGER, "r").value, 0);
+  put(expect(s, TAG.INTEGER, "s").value, size);
+  return out;
+}
+async function verifySignature(pub, alg, data, sig) {
+  const sch = schemeFor(alg);
+  return verifyWith(pub, sch, data, sig);
+}
+async function verifyWith(pub, sch, data, sig) {
+  const s = await subtle();
+  try {
+    if (sch.kind === "ecdsa") {
+      if (pub.keyAlg !== OID.ecPublicKey) return false;
+      const c = CURVES[pub.curve ?? ""];
+      if (!c) return false;
+      const key2 = await s.importKey("spki", pub.spki, { name: "ECDSA", namedCurve: c.name }, false, ["verify"]);
+      return await s.verify({ name: "ECDSA", hash: sch.hash }, key2, ecdsaDerToRaw(sig, c.size), data);
+    }
+    if (pub.keyAlg !== OID.rsaEncryption) return false;
+    if (sch.kind === "pss") {
+      const key2 = await s.importKey("spki", pub.spki, { name: "RSA-PSS", hash: sch.hash }, false, ["verify"]);
+      return await s.verify({ name: "RSA-PSS", saltLength: sch.saltLength ?? 32 }, key2, sig, data);
+    }
+    const key = await s.importKey("spki", pub.spki, { name: "RSASSA-PKCS1-v1_5", hash: sch.hash }, false, ["verify"]);
+    return await s.verify({ name: "RSASSA-PKCS1-v1_5" }, key, sig, data);
+  } catch {
+    return false;
+  }
+}
+async function verifyCitizen(cert, signedAttrs, sig) {
+  if (cert.keyAlg === OID.rsaEncryption) {
+    return await verifyWith(cert, { kind: "rsa", hash: "SHA-256" }, signedAttrs, sig) ? sig : void 0;
+  }
+  if (cert.keyAlg === OID.ecPublicKey) {
+    const c = CURVES[cert.curve ?? ""];
+    if (!c) return void 0;
+    if (sig.length === 2 * c.size) {
+      const der = rawToEcdsaDer(sig, c.size);
+      if (await verifyWith(cert, { kind: "ecdsa", hash: "SHA-256" }, signedAttrs, der)) return der;
+    }
+    try {
+      return await verifyWith(cert, { kind: "ecdsa", hash: "SHA-256" }, signedAttrs, sig) ? sig : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function rawToEcdsaDer(raw, size) {
+  const int = (v) => {
+    let x = Array.from(v);
+    while (x.length > 1 && x[0] === 0) x = x.slice(1);
+    if (x.length === 1 && x[0] === 0) return [2, 1, 0];
+    if (x[0] & 128) x = [0, ...x];
+    return [2, x.length, ...x];
+  };
+  const body = [...int(raw.subarray(0, size)), ...int(raw.subarray(size))];
+  return Uint8Array.from(body.length < 128 ? [48, body.length, ...body] : [48, 129, body.length, ...body]);
+}
+function checkSignature(parent, alg, signed, sig) {
+  return verifySignature(parent, alg, signed, sig);
+}
+async function checkSignatureFrom(c, parent) {
+  if (parent.version === 3 && !parent.basicConstraintsValid || parent.basicConstraintsValid && !parent.isCA) return false;
+  if (parent.keyUsage !== 0 && !(parent.keyUsage & 1 << 5)) return false;
+  return verifySignature(parent, c.sigAlg, c.tbs, c.signature);
+}
+async function verifyChain(leaf, pool, roots, at, eku) {
+  const valid = (c) => c.notBefore.getTime() <= at.getTime() && at.getTime() <= c.notAfter.getTime();
+  if (!valid(leaf)) return false;
+  if (leaf.extKeyUsage.length > 0 && !leaf.extKeyUsage.includes(eku) && !leaf.extKeyUsage.includes(OID.kpAny)) return false;
+  if (hasUnhandledCritical(leaf)) return false;
+  const walk = async (cur, depth) => {
+    if (depth > 8) return false;
+    for (const r of roots) {
+      if (equal(r.rawSubject, cur.rawIssuer) && await checkSignatureFrom(cur, r)) return true;
+    }
+    for (const p of pool) {
+      if (equal(p.raw, cur.raw) || !equal(p.rawSubject, cur.rawIssuer) || !valid(p) || hasUnhandledCritical(p)) continue;
+      if (p.extKeyUsage.length > 0 && !p.extKeyUsage.includes(eku) && !p.extKeyUsage.includes(OID.kpAny)) continue;
+      if (await checkSignatureFrom(cur, p) && await walk(p, depth + 1)) return true;
+    }
+    return false;
+  };
+  return walk(leaf, 0);
+}
+var HANDLED = /* @__PURE__ */ new Set([
+  OID.keyUsage,
+  OID.extKeyUsage,
+  OID.basicConstraints,
+  "2.5.29.17",
+  // SAN
+  "2.5.29.30",
+  // name constraints
+  "2.5.29.32",
+  // policies
+  OID.crlDP,
+  OID.aia,
+  "2.5.29.14",
+  "2.5.29.35"
+]);
+function hasUnhandledCritical(c) {
+  return c.extensions.some((e) => e.critical && !HANDLED.has(e.oid));
+}
+
+// src/pades/cms.ts
+var O = {
+  data: "1.2.840.113549.1.7.1",
+  signedData: "1.2.840.113549.1.7.2",
+  contentType: "1.2.840.113549.1.9.3",
+  messageDigest: "1.2.840.113549.1.9.4",
+  signingTime: "1.2.840.113549.1.9.5",
+  signingCertV2: "1.2.840.113549.1.9.16.2.47",
+  timeStampToken: "1.2.840.113549.1.9.16.2.14",
+  signerAttrV2: "0.4.0.19122.1.1",
+  role: "2.5.4.72"
+};
+var CLAIMED_ROLE_MAX_RUNES = 900;
+async function signedAttributes(messageDigest, signer, claimedRole) {
+  if (messageDigest.length !== 32) throw new Error("pades: messageDigest SHA-256 \u0431\u0438\u0448");
+  if (claimedRole !== "" && ([...claimedRole].length > CLAIMED_ROLE_MAX_RUNES || /[\ud800-\udfff]/.test(claimedRole.replace(/[\ud800-\udbff][\udc00-\udfff]/g, "")))) {
+    throw new Error("pades: claimed role \u0431\u0443\u0440\u0443\u0443 \u044D\u0441\u0432\u044D\u043B \u0445\u044D\u0442 \u0443\u0440\u0442");
+  }
+  const certHash = await sha256(signer.raw);
+  const attr = (o, ...vals) => seq(oid(o), set(...vals));
+  const attrs = [
+    attr(O.contentType, oid(O.data)),
+    attr(O.messageDigest, octet(messageDigest)),
+    attr(
+      O.signingCertV2,
+      seq(seq(seq(octet(certHash), seq(seq(ctx(4, true, signer.rawIssuer)), tlv(TAG.INTEGER, signer.serial)))))
+    )
+  ];
+  if (claimedRole !== "") {
+    attrs.push(attr(O.signerAttrV2, seq(ctx(0, true, seq(seq(oid(O.role), set(tlv(TAG.UTF8String, enc.encode(claimedRole)))))))));
+  }
+  attrs.sort(compare);
+  return set(...attrs);
+}
+function assembleCMS(signedAttrs, signer, chain, signature, tst) {
+  if (signedAttrs.length < 2 || signedAttrs[0] !== 49) throw new Error("pades: signedAttrs \u043D\u044C DER SET \u0431\u0438\u0448");
+  let sigAlg;
+  if (signer.keyAlg === OID.rsaEncryption) sigAlg = seq(oid(OID.sha256WithRSA), nullDer());
+  else if (signer.keyAlg === OID.ecPublicKey) sigAlg = seq(oid(OID.ecdsaSHA256));
+  else throw new Error("pades: \u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u0433\u0438\u0439\u043D \u0442\u04AF\u043B\u0445\u04AF\u04AF\u0440\u0438\u0439\u043D \u0442\u04E9\u0440\u04E9\u043B \u0434\u044D\u043C\u0436\u0438\u0433\u0434\u044D\u0445\u0433\u04AF\u0439");
+  const implicitAttrs = signedAttrs.slice();
+  implicitAttrs[0] = 160;
+  const certs = [signer.raw];
+  for (const c of chain) if (!equal(c.raw, signer.raw)) certs.push(c.raw);
+  certs.sort(compare);
+  const sha256Alg = seq(oid(OID.sha256));
+  const unsigned = tst.length > 0 ? [ctx(1, true, seq(oid(O.timeStampToken), set(tst)))] : [];
+  const signerInfo = seq(
+    intFromBig(1n),
+    seq(signer.rawIssuer, tlv(TAG.INTEGER, signer.serial)),
+    sha256Alg,
+    implicitAttrs,
+    sigAlg,
+    octet(signature),
+    ...unsigned
+  );
+  const sd = seq(intFromBig(1n), set(sha256Alg), seq(oid(O.data)), ctx(0, true, ...certs), set(signerInfo));
+  return seq(oid(O.signedData), ctx(0, true, sd));
+}
+function parseSignedData(contentInfo) {
+  const ci = children(expect(parseOne(contentInfo), TAG.SEQUENCE, "ContentInfo"));
+  if (oidString(expect(ci[0], TAG.OID, "contentType").value) !== O.signedData) throw new Error("pkcs7: SignedData \u0431\u0438\u0448");
+  const sd = children(expect(children(expect(ci[1], 160, "[0]"))[0], TAG.SEQUENCE, "SignedData"));
+  let i = 1;
+  const digestAlgs = children(expect(sd[i++], TAG.SET, "digestAlgorithms"));
+  const eci = children(expect(sd[i++], TAG.SEQUENCE, "EncapsulatedContentInfo"));
+  let content = new Uint8Array();
+  if (eci[1]) {
+    const inner = children(expect(eci[1], 160, "eContent"))[0];
+    if (inner?.tag === TAG.OCTET_STRING) content = inner.value;
+    else if (inner?.tag === 36) content = concat(children(inner).map((x) => x.value));
+  }
+  const certificates = [];
+  if (sd[i]?.tag === 160) {
+    for (const c of children(sd[i])) if (c.tag === TAG.SEQUENCE) certificates.push(parseCertificate(c.raw));
+    i++;
+  }
+  if (sd[i]?.tag === 161) i++;
+  const signerInfos = children(expect(sd[i], TAG.SET, "signerInfos"));
+  return { content, certificates, signerInfos, digestAlgs };
+}
+var HASHES = {
+  [OID.sha1]: "SHA-1",
+  [OID.sha256]: "SHA-256",
+  [OID.sha384]: "SHA-384",
+  [OID.sha512]: "SHA-512"
+};
+function signerCert(sd, si) {
+  const f = children(si);
+  const sid = f[1];
+  if (sid.tag === TAG.SEQUENCE) {
+    const [iss, ser] = children(sid);
+    return sd.certificates.find((c) => equal(c.rawIssuer, iss.raw) && equal(c.serial, ser.value));
+  }
+  return void 0;
+}
+async function verifySignedData(sd) {
+  if (sd.signerInfos.length === 0) return false;
+  for (const si of sd.signerInfos) {
+    const cert = signerCert(sd, si);
+    if (!cert) return false;
+    const f = children(si);
+    let i = 2;
+    const digAlg = oidString(children(f[i++])[0].value);
+    const hash = HASHES[digAlg];
+    if (!hash) return false;
+    let attrs;
+    if (f[i]?.tag === 160) attrs = f[i++];
+    const sigAlg = f[i++];
+    const sig = expect(f[i++], TAG.OCTET_STRING, "signature").value;
+    let signed = sd.content;
+    if (attrs) {
+      let md;
+      let signingTime;
+      for (const a of children(attrs)) {
+        const [t, v] = children(a);
+        if (!t || !v) continue;
+        const o = oidString(t.value);
+        if (o === O.messageDigest) md = children(v)[0]?.value;
+        if (o === O.signingTime) {
+          const n = children(v)[0];
+          if (n) signingTime = parseTime(n);
+        }
+      }
+      if (!md || !equal(md, await digest(hash, sd.content))) return false;
+      if (signingTime && (signingTime > cert.notAfter || signingTime < cert.notBefore)) return false;
+      signed = concat([Uint8Array.of(49), attrs.raw.subarray(1)]);
+    }
+    let alg = sigAlg;
+    const so = oidString(children(sigAlg)[0].value);
+    if (so === OID.rsaEncryption) {
+      const m = { "SHA-1": "1.2.840.113549.1.1.5", "SHA-256": OID.sha256WithRSA, "SHA-384": OID.sha384WithRSA, "SHA-512": OID.sha512WithRSA };
+      alg = parseOne(seq(oid(m[hash]), nullDer()));
+    } else if (so === OID.ecPublicKey) {
+      const m = { "SHA-256": OID.ecdsaSHA256, "SHA-384": OID.ecdsaSHA384, "SHA-512": OID.ecdsaSHA512 };
+      if (!m[hash]) return false;
+      alg = parseOne(seq(oid(m[hash])));
+    }
+    if (!await verifySignature(cert, alg, signed, sig)) return false;
+  }
+  return true;
+}
+
+// src/pades/ltv.ts
+var MAX_TSA_SKEW_MS = 10 * 6e4;
+var tsMs = (t) => t.date.getTime();
+function after(a, b) {
+  const am = Math.floor(a.date.getTime() / 1e3);
+  const bm = Math.floor(b.date.getTime() / 1e3);
+  if (am !== bm) return am > bm;
+  return a.nanos > b.nanos;
+}
+function tsaRequest(hash, nonce) {
+  return seq(intFromBig(1n), seq(seq(oid(OID.sha256), nullDer()), octet(hash)), intFromBig(bigFromBytes(nonce)), Uint8Array.of(1, 1, 255));
+}
+async function timestampToken(f, tsaURL, signature, roots, inter, now, nonce) {
+  const sum = await sha256(signature);
+  const body = await f.do("POST", tsaURL, "application/timestamp-query", tsaRequest(sum, nonce));
+  const top = children(expect(parseOne(body), TAG.SEQUENCE, "TimeStampResp"));
+  const status = intValue(expect(children(expect(top[0], TAG.SEQUENCE, "PKIStatusInfo"))[0], TAG.INTEGER, "status").value);
+  if (status > 0n) throw new Error(`TSA status ${status}`);
+  const tok = top[1];
+  if (!tok || tok.value.length === 0) throw new Error("no pkcs7 data in Time-Stamp response");
+  const rawToken = tok.raw;
+  const sd = parseSignedData(rawToken);
+  if (sd.certificates.length > 0 && !await verifySignedData(sd)) throw new Error("TSA token-\u0438\u0439\u043D \u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 \u0431\u0443\u0440\u0443\u0443");
+  const info = children(expect(parseOne(sd.content), TAG.SEQUENCE, "TSTInfo"));
+  const mi = children(expect(info[2], TAG.SEQUENCE, "messageImprint"));
+  const hashAlg = oidString(children(mi[0])[0].value);
+  const hashed = expect(mi[1], TAG.OCTET_STRING, "hashedMessage").value;
+  if (hashed.length === 0) throw new Error("Time-Stamp response contains no hashed message");
+  const genTime = parsePreciseTime(expect(info[4], TAG.GeneralizedTime, "genTime"));
+  let tsNonce;
+  for (const n of info.slice(5)) if (n.tag === TAG.INTEGER) tsNonce = n.value;
+  if (!tsNonce || intValue(tsNonce) !== bigFromBytes(nonce)) throw new Error("nonce \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439");
+  if (!equal(hashed, sum) || hashAlg !== OID.sha256) throw new Error("timestamp hash does not match");
+  if (sd.signerInfos.length !== 1) throw new Error("TSA signer \u0433\u0430\u043D\u0446 \u0431\u0438\u0448");
+  const sid = children(sd.signerInfos[0])[1];
+  const [iss, ser] = children(sid);
+  const signer = sd.certificates.find((c) => equal(c.rawIssuer, iss.raw) && equal(c.serial, ser.value));
+  if (!signer) throw new Error("signer cert \u043E\u043B\u0434\u0441\u043E\u043D\u0433\u04AF\u0439");
+  if (!isTSASigningCert(signer)) throw new Error("signer cert-\u0438\u0439\u043D EKU \u043D\u044C critical {timeStamping} \u0431\u0438\u0448 (RFC 3161 \xA72.3)");
+  const pool = [...sd.certificates, ...inter].filter((c) => !equal(c.raw, signer.raw));
+  if (!await verifyChain(signer, pool, roots, genTime.date, OID.kpTimeStamping)) throw new Error("TSA cert \u0433\u0438\u043D\u0436");
+  const d = now.getTime() - tsMs(genTime);
+  if (d > MAX_TSA_SKEW_MS || d < -MAX_TSA_SKEW_MS) throw new Error("TSA genTime \u043B\u043E\u043A\u0430\u043B \u0446\u0430\u0433\u0430\u0430\u0441 10 \u043C\u0438\u043D\u0443\u0442\u0430\u0430\u0441 \u0438\u0445 \u0437\u04E9\u0440\u04E9\u0432");
+  if (sd.certificates.length === 0) throw new Error("TSA token-\u0434 \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0430\u043B\u0433\u0430");
+  return { rawToken, time: genTime, certificates: sd.certificates };
+}
+async function ocspRequest(c, issuer) {
+  const keyHash = await sha1(issuer.publicKey);
+  const nameHash = await sha1(issuer.rawSubject);
+  const certID = seq(seq(oid(OID.sha1), nullDer()), octet(nameHash), octet(keyHash), Uint8Array.of(TAG.INTEGER, ...lenOf(c.serial.length), ...c.serial));
+  return seq(seq(seq(seq(certID))));
+}
+function lenOf(n) {
+  if (n < 128) return [n];
+  const out = [];
+  for (let x = n; x > 0; x = Math.floor(x / 256)) out.unshift(x & 255);
+  return [128 | out.length, ...out];
+}
+var OID_OCSP_BASIC = "1.3.6.1.5.5.7.48.1.1";
+async function parseOCSPForCert(der, c, issuer) {
+  const top = children(expect(parseOne(der), TAG.SEQUENCE, "OCSPResponse"));
+  if (expect(top[0], TAG.ENUMERATED, "status").value[0] !== 0) throw new Error("OCSP response status");
+  const rb = children(expect(children(expect(top[1], 160, "responseBytes"))[0], TAG.SEQUENCE, "ResponseBytes"));
+  if (oidString(expect(rb[0], TAG.OID, "responseType").value) !== OID_OCSP_BASIC) throw new Error("bad OCSP response type");
+  const basic = children(expect(parseOne(expect(rb[1], TAG.OCTET_STRING, "response").value), TAG.SEQUENCE, "BasicOCSPResponse"));
+  const tbs = expect(basic[0], TAG.SEQUENCE, "tbsResponseData");
+  const sigAlg = expect(basic[1], TAG.SEQUENCE, "sigAlg");
+  const sigBits = expect(basic[2], TAG.BIT_STRING, "signature").value.subarray(1);
+  const tf = children(tbs);
+  let i = 0;
+  if (tf[0]?.tag === 160) i++;
+  const rid = tf[i++];
+  if (rid.tag !== 161 && rid.tag !== 162) throw new Error("invalid responder id tag");
+  i++;
+  const responses = children(expect(tf[i], TAG.SEQUENCE, "responses"));
+  if (responses.length === 0) throw new Error("OCSP response contains bad number of responses");
+  const serial = intValue(c.serial);
+  let single;
+  for (const r of responses) {
+    const f = children(r);
+    const cid2 = children(f[0]);
+    if (intValue(expect(cid2[3], TAG.INTEGER, "serial").value) === serial) {
+      single = f;
+      break;
+    }
+  }
+  if (!single) throw new Error("no response matching the supplied certificate");
+  let certificate;
+  if (basic[3]?.tag === 160) {
+    const certs = children(expect(children(basic[3])[0], TAG.SEQUENCE, "certs"));
+    if (certs[0]) certificate = parseCertificate(certs[0].raw);
+  }
+  if (certificate) {
+    if (!await verifySignature(certificate, sigAlg, tbs.raw, sigBits)) throw new Error("bad signature on embedded certificate");
+    if (!await checkSignature(issuer, certificate.sigAlg, certificate.tbs, certificate.signature)) throw new Error("bad OCSP signature");
+  } else if (!await verifySignature(issuer, sigAlg, tbs.raw, sigBits)) {
+    throw new Error("bad OCSP signature");
+  }
+  const cid = children(single[0]);
+  const hashAlg = oidString(children(cid[0])[0].value);
+  if (![OID.sha1, OID.sha256, OID.sha384, OID.sha512].includes(hashAlg)) throw new Error("unsupported issuer hash algorithm");
+  const st = single[1];
+  const status = st.tag === 128 ? "good" : st.tag === 161 ? "revoked" : st.tag === 130 ? "unknown" : void 0;
+  if (!status) throw new Error("OCSP certStatus");
+  const thisUpdate = parsePreciseTime(expect(single[2], TAG.GeneralizedTime, "thisUpdate"));
+  let nextUpdate;
+  for (const x of single.slice(3)) {
+    if (x.tag === 160) nextUpdate = parsePreciseTime(children(x)[0]).date;
+    if (x.tag === 161) {
+      for (const ext of children(children(x)[0])) {
+        const e = children(ext);
+        if (e[1]?.tag === TAG.BOOLEAN && e[1].value[0] !== 0) throw new Error("unsupported critical extension");
+      }
+    }
+  }
+  return { status, thisUpdate, nextUpdate, certificate };
+}
+function responderOK(resp, issuer) {
+  if (!resp.certificate || equal(resp.certificate.raw, issuer.raw)) return true;
+  return resp.certificate.extKeyUsage.includes(OID.kpOCSPSigning);
+}
+var NotFresh = class extends Error {
+};
+async function fetchOCSP(f, url, c, issuer, now, fresh) {
+  const der = await f.do("POST", url, "application/ocsp-request", await ocspRequest(c, issuer));
+  const resp = await parseOCSPForCert(der, c, issuer);
+  if (!responderOK(resp, issuer)) throw new Error("OCSP responder-\u0438\u0439\u043D EKU OCSPSigning \u0431\u0438\u0448");
+  if (resp.status !== "good" || resp.nextUpdate && resp.nextUpdate.getTime() < now.getTime()) throw new Error(`OCSP ${c.subjectCN}: ${resp.status}`);
+  if (fresh && !after(resp.thisUpdate, fresh)) throw new NotFresh("OCSP thisUpdate \u043D\u044C timestamp-\u0430\u0430\u0441 \u0445\u043E\u0436\u0443\u0443 \u0431\u0438\u0448");
+  return [der, resp];
+}
+async function crlCovers(der, c, issuer, now) {
+  try {
+    const top = children(expect(parseOne(der), TAG.SEQUENCE, "CertificateList"));
+    const tbs = expect(top[0], TAG.SEQUENCE, "TBSCertList");
+    const sigAlg = expect(top[1], TAG.SEQUENCE, "sigAlg");
+    const sig = expect(top[2], TAG.BIT_STRING, "sig").value.subarray(1);
+    const f = children(tbs);
+    let i = 0;
+    if (f[0]?.tag === TAG.INTEGER) i++;
+    i++;
+    const iss = expect(f[i++], TAG.SEQUENCE, "issuer");
+    if (!equal(iss.raw, c.rawIssuer)) return false;
+    if (issuer.version === 3 && !issuer.basicConstraintsValid) return false;
+    if (issuer.keyUsage !== 0 && !(issuer.keyUsage & 1 << 6)) return false;
+    if (!await verifySignature(issuer, sigAlg, tbs.raw, sig)) return false;
+    i++;
+    const nu = f[i];
+    if (!nu || nu.tag !== TAG.UTCTime && nu.tag !== TAG.GeneralizedTime) return false;
+    if (parsePreciseTime(nu).date.getTime() < now.getTime()) return false;
+    i++;
+    const serial = intValue(c.serial);
+    const revoked = f[i];
+    if (revoked?.tag === TAG.SEQUENCE) {
+      for (const e of children(revoked)) {
+        if (intValue(expect(children(e)[0], TAG.INTEGER, "serial").value) === serial) return false;
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function collectLTV(f, now, fresh, roots, chains) {
+  const d = { certs: [], ocsps: [], crls: [] };
+  const addTo = (list, der) => {
+    if (!list.some((b) => equal(b, der))) list.push(der);
+  };
+  const pool = chains.flat();
+  const issuerOf = async (c) => {
+    for (const cand of [...pool, ...roots]) if (equal(cand.rawSubject, c.rawIssuer) && await checkSignatureFrom(c, cand)) return cand;
+    return void 0;
+  };
+  const isRoot = (c) => roots.some((r) => equal(r.raw, c.raw));
+  const seen = /* @__PURE__ */ new Set();
+  for (const ch of chains) {
+    for (let i = 0; i < ch.length; i++) {
+      const c = ch[i];
+      const k = toHex(c.raw);
+      if (seen.has(k) || isRoot(c)) continue;
+      seen.add(k);
+      addTo(d.certs, c.raw);
+      const issuer = await issuerOf(c);
+      if (!issuer) throw new LTVError(`${c.subjectCN}-\u0438\u0439\u043D \u043E\u043B\u0433\u043E\u0433\u0447 \u043E\u043B\u0434\u0441\u043E\u043D\u0433\u04AF\u0439`);
+      let ok = false;
+      let freshErr;
+      const fr = i === 0 ? fresh : void 0;
+      for (const u of c.ocspServers) {
+        try {
+          const [der, resp] = await fetchOCSP(f, u, c, issuer, now, fr);
+          addTo(d.ocsps, der);
+          if (resp.certificate && !equal(resp.certificate.raw, issuer.raw)) addTo(d.certs, resp.certificate.raw);
+          ok = true;
+          break;
+        } catch (e) {
+          if (e instanceof NotFresh) freshErr = e;
+        }
+      }
+      for (const u of c.crlDPs) {
+        let der;
+        try {
+          der = await f.do("GET", u, "");
+        } catch {
+          continue;
+        }
+        if (await crlCovers(der, c, issuer, now)) {
+          addTo(d.crls, der);
+          ok = true;
+        }
+      }
+      if (!ok) {
+        if (freshErr) throw freshErr;
+        throw new LTVError(`${c.subjectCN}-\u0434 \u0445\u04AF\u0447\u0438\u043D\u0442\u044D\u0439 OCSP/CRL \u0430\u043B\u0433\u0430`);
+      }
+      if (i === 0 && freshErr && c.ocspServers.length > 0 && !await hasFreshOCSP(d.ocsps, c, issuer, fresh)) throw freshErr;
+    }
+  }
+  return d;
+}
+async function hasFreshOCSP(list, c, issuer, fresh) {
+  for (const der of list) {
+    try {
+      if (after((await parseOCSPForCert(der, c, issuer)).thisUpdate, fresh)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var LTVError = class extends Error {
+};
+var OCSP_AFTER_TS_MS = 2e3;
+var OCSP_WAIT_MAX_MS = 5e3;
+var OCSP_RETRY_MS = 1e3;
+async function collectLTVWithWait(f, now, sleep, genTime, roots, chains) {
+  let waited = 0;
+  const genSec = Math.floor(genTime.date.getTime() / 1e3) * 1e3;
+  let d = Math.min(genSec + OCSP_AFTER_TS_MS - now().getTime(), OCSP_WAIT_MAX_MS);
+  for (; ; ) {
+    if (d > 0) {
+      await sleep(d);
+      waited += d;
+    }
+    try {
+      return await collectLTV(f, now(), genTime, roots, chains);
+    } catch (e) {
+      if (!(e instanceof NotFresh) || waited + OCSP_RETRY_MS > OCSP_WAIT_MAX_MS) throw e;
+    }
+    d = OCSP_RETRY_MS;
+  }
+}
+
+export {
+  enc,
+  latin1,
+  fromLatin1,
+  concat,
+  equal,
+  toHex,
+  fromHex,
+  toB64,
+  fromB64,
+  ByteWriter,
+  TAG,
+  readNode,
+  children,
+  oidString,
+  randomBytes,
+  sha256,
+  sha1,
+  OID,
+  parseCertificate,
+  verifyCitizen,
+  checkSignatureFrom,
+  CLAIMED_ROLE_MAX_RUNES,
+  signedAttributes,
+  assembleCMS,
+  parseSignedData,
+  verifySignedData,
+  timestampToken,
+  ocspRequest,
+  parseOCSPForCert,
+  LTVError,
+  collectLTVWithWait
+};