stated-protocol 5.0.0

package/dist/esm/index.js

@@ -0,0 +1,2104 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/constants.ts
+var legalForms = {
+  local_government: "local government",
+  state_government: "state government",
+  foreign_affairs_ministry: "foreign affairs ministry",
+  corporation: "corporation"
+};
+var statementTypes = {
+  statement: "statement",
+  organisationVerification: "organisation_verification",
+  personVerification: "person_verification",
+  poll: "poll",
+  vote: "vote",
+  response: "response",
+  disputeContent: "dispute_statement_content",
+  disputeAuthenticity: "dispute_statement_authenticity",
+  rating: "rating",
+  signPdf: "sign_pdf",
+  unsupported: "unsupported"
+};
+var peopleCountBuckets = {
+  "0": "0-10",
+  "10": "10-100",
+  "100": "100-1000",
+  "1000": "1000-10,000",
+  "10000": "10,000-100,000",
+  "100000": "100,000+",
+  "1000000": "1,000,000+",
+  "10000000": "10,000,000+"
+};
+var supportedLanguages = {
+  aa: "aa",
+  ab: "ab",
+  af: "af",
+  ak: "ak",
+  am: "am",
+  ar: "ar",
+  an: "an",
+  as: "as",
+  av: "av",
+  ay: "ay",
+  az: "az",
+  ba: "ba",
+  bm: "bm",
+  be: "be",
+  bn: "bn",
+  bi: "bi",
+  bo: "bo",
+  bs: "bs",
+  br: "br",
+  bg: "bg",
+  ca: "ca",
+  cs: "cs",
+  ch: "ch",
+  ce: "ce",
+  cv: "cv",
+  kw: "kw",
+  co: "co",
+  cr: "cr",
+  cy: "cy",
+  da: "da",
+  de: "de",
+  dv: "dv",
+  dz: "dz",
+  el: "el",
+  en: "en",
+  eo: "eo",
+  et: "et",
+  eu: "eu",
+  ee: "ee",
+  fo: "fo",
+  fa: "fa",
+  fj: "fj",
+  fi: "fi",
+  fr: "fr",
+  fy: "fy",
+  ff: "ff",
+  gd: "gd",
+  ga: "ga",
+  gl: "gl",
+  gv: "gv",
+  gn: "gn",
+  gu: "gu",
+  ht: "ht",
+  ha: "ha",
+  sh: "sh",
+  he: "he",
+  hz: "hz",
+  hi: "hi",
+  ho: "ho",
+  hr: "hr",
+  hu: "hu",
+  hy: "hy",
+  ig: "ig",
+  io: "io",
+  ii: "ii",
+  iu: "iu",
+  ie: "ie",
+  ia: "ia",
+  id: "id",
+  ik: "ik",
+  is: "is",
+  it: "it",
+  jv: "jv",
+  ja: "ja",
+  kl: "kl",
+  kn: "kn",
+  ks: "ks",
+  ka: "ka",
+  kr: "kr",
+  kk: "kk",
+  km: "km",
+  ki: "ki",
+  rw: "rw",
+  ky: "ky",
+  kv: "kv",
+  kg: "kg",
+  ko: "ko",
+  kj: "kj",
+  ku: "ku",
+  lo: "lo",
+  la: "la",
+  lv: "lv",
+  li: "li",
+  ln: "ln",
+  lt: "lt",
+  lb: "lb",
+  lu: "lu",
+  lg: "lg",
+  mh: "mh",
+  ml: "ml",
+  mr: "mr",
+  mk: "mk",
+  mg: "mg",
+  mt: "mt",
+  mn: "mn",
+  mi: "mi",
+  ms: "ms",
+  my: "my",
+  na: "na",
+  nv: "nv",
+  nr: "nr",
+  nd: "nd",
+  ng: "ng",
+  ne: "ne",
+  nl: "nl",
+  nn: "nn",
+  nb: "nb",
+  no: "no",
+  ny: "ny",
+  oc: "oc",
+  oj: "oj",
+  or: "or",
+  om: "om",
+  os: "os",
+  pa: "pa",
+  pi: "pi",
+  pl: "pl",
+  pt: "pt",
+  ps: "ps",
+  qu: "qu",
+  rm: "rm",
+  ro: "ro",
+  rn: "rn",
+  ru: "ru",
+  sg: "sg",
+  sa: "sa",
+  si: "si",
+  sk: "sk",
+  sl: "sl",
+  se: "se",
+  sm: "sm",
+  sn: "sn",
+  sd: "sd",
+  so: "so",
+  st: "st",
+  es: "es",
+  sq: "sq",
+  sc: "sc",
+  sr: "sr",
+  ss: "ss",
+  su: "su",
+  sw: "sw",
+  sv: "sv",
+  ty: "ty",
+  ta: "ta",
+  tt: "tt",
+  te: "te",
+  tg: "tg",
+  tl: "tl",
+  th: "th",
+  ti: "ti",
+  to: "to",
+  tn: "tn",
+  ts: "ts",
+  tk: "tk",
+  tr: "tr",
+  tw: "tw",
+  ug: "ug",
+  uk: "uk",
+  ur: "ur",
+  uz: "uz",
+  ve: "ve",
+  vi: "vi",
+  vo: "vo",
+  wa: "wa",
+  wo: "wo",
+  xh: "xh",
+  yi: "yi",
+  yo: "yo",
+  za: "za",
+  zh: "zh",
+  zu: "zu"
+};
+var UTCFormat = /(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s\d{2}\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s\d{4}\s\d{2}:\d{2}:\d{2}\sGMT/;
+var pollKeys = /(Type: |The poll outcome is finalized when the following nodes agree: |Voting deadline: |Poll: |Option 1: |Option 2: |Option 3: |Option 4: |Option 5: |Allow free text votes: |Who can vote: |Description: |Country scope: |City scope: |Legal form scope: |Domain scope: |All entities with the following property: |As observed by: |Link to query defining who can vote: )/g;
+var organisationVerificationKeys = /(Type: |Description: |Name: |English name: |Country: |Legal entity: |Legal form: |Department using the domain: |Owner of the domain: |Foreign domain used for publishing statements: |Province or state: |Business register number: |City: |Longitude: |Latitude: |Population: |Logo: |Employee count: |Reliability policy: |Confidence: |Public key: )/g;
+var personVerificationKeys = /(Type: |Description: |Name: |Date of birth: |City of birth: |Country of birth: |Job title: |Employer: |Owner of the domain: |Foreign domain used for publishing statements: |Picture: |Verification method: |Confidence: |Reliability policy: )/g;
+var voteKeys = /(Type: |Poll id: |Poll: |Option: )/g;
+var disputeAuthenticityKeys = /(Type: |Description: |Hash of referenced statement: |Confidence: |Reliability policy: )/g;
+var disputeContentKeys = /(Type: |Description: |Hash of referenced statement: |Confidence: |Reliability policy: )/g;
+var responseKeys = /(Type: |Hash of referenced statement: |Response: )/;
+var PDFSigningKeys = /(Type: |Description: |PDF file hash: )/g;
+var ratingKeys = /(Type: |Subject type: |Subject name: |URL that identifies the subject: |Document file hash: |Rated quality: |Our rating: |Comment: )/;
+
+// node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+var oidNist = (suffix) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+
+// node_modules/@noble/hashes/_md.js
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class {
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    __publicField(this, "blockLen");
+    __publicField(this, "outputLen");
+    __publicField(this, "padOffset");
+    __publicField(this, "isLE");
+    // For partial updates less than block size
+    __publicField(this, "buffer");
+    __publicField(this, "view");
+    __publicField(this, "finished", false);
+    __publicField(this, "length", 0);
+    __publicField(this, "pos", 0);
+    __publicField(this, "destroyed", false);
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor());
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+var SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  4089235720,
+  3144134277,
+  2227873595,
+  1013904242,
+  4271175723,
+  2773480762,
+  1595750129,
+  1359893119,
+  2917565137,
+  2600822924,
+  725511199,
+  528734635,
+  4215389547,
+  1541459225,
+  327033209
+]);
+
+// node_modules/@noble/hashes/_u64.js
+var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+var _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    const { h: h2, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h2, l];
+  }
+  return [Ah, Al];
+}
+var shrSH = (h2, _l, s) => h2 >>> s;
+var shrSL = (h2, l, s) => h2 << 32 - s | l >>> s;
+var rotrSH = (h2, l, s) => h2 >>> s | l << 32 - s;
+var rotrSL = (h2, l, s) => h2 << 32 - s | l >>> s;
+var rotrBH = (h2, l, s) => h2 << 64 - s | l >>> s - 32;
+var rotrBL = (h2, l, s) => h2 >>> s - 32 | l << 64 - s;
+function add(Ah, Al, Bh, Bl) {
+  const l = (Al >>> 0) + (Bl >>> 0);
+  return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+}
+var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+
+// node_modules/@noble/hashes/sha2.js
+var SHA256_K = /* @__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
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA2_32B = class extends HashMD {
+  constructor(outputLen) {
+    super(64, outputLen, 8, false);
+  }
+  get() {
+    const { A, B, C: C2, D, E, F, G: G2, H } = this;
+    return [A, B, C2, D, E, F, G2, H];
+  }
+  // prettier-ignore
+  set(A, B, C2, D, E, F, G2, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C2 | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G2 | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C: C2, D, E, F, G: G2, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G2) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C2) | 0;
+      H = G2;
+      G2 = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C2;
+      C2 = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C2 = C2 + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G2 = G2 + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C2, D, E, F, G2, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var _SHA256 = class extends SHA2_32B {
+  constructor() {
+    super(32);
+    // We cannot use array here since array allows indexing by variable
+    // which means optimizer/compiler cannot use registers.
+    __publicField(this, "A", SHA256_IV[0] | 0);
+    __publicField(this, "B", SHA256_IV[1] | 0);
+    __publicField(this, "C", SHA256_IV[2] | 0);
+    __publicField(this, "D", SHA256_IV[3] | 0);
+    __publicField(this, "E", SHA256_IV[4] | 0);
+    __publicField(this, "F", SHA256_IV[5] | 0);
+    __publicField(this, "G", SHA256_IV[6] | 0);
+    __publicField(this, "H", SHA256_IV[7] | 0);
+  }
+};
+var K512 = /* @__PURE__ */ (() => split([
+  "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((n) => BigInt(n))))();
+var SHA512_Kh = /* @__PURE__ */ (() => K512[0])();
+var SHA512_Kl = /* @__PURE__ */ (() => K512[1])();
+var SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+var SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+var SHA2_64B = class extends HashMD {
+  constructor(outputLen) {
+    super(128, outputLen, 16, false);
+  }
+  // prettier-ignore
+  get() {
+    const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+  }
+  // prettier-ignore
+  set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+    this.Ah = Ah | 0;
+    this.Al = Al | 0;
+    this.Bh = Bh | 0;
+    this.Bl = Bl | 0;
+    this.Ch = Ch | 0;
+    this.Cl = Cl | 0;
+    this.Dh = Dh | 0;
+    this.Dl = Dl | 0;
+    this.Eh = Eh | 0;
+    this.El = El | 0;
+    this.Fh = Fh | 0;
+    this.Fl = Fl | 0;
+    this.Gh = Gh | 0;
+    this.Gl = Gl | 0;
+    this.Hh = Hh | 0;
+    this.Hl = Hl | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4) {
+      SHA512_W_H[i] = view.getUint32(offset);
+      SHA512_W_L[i] = view.getUint32(offset += 4);
+    }
+    for (let i = 16; i < 80; i++) {
+      const W15h = SHA512_W_H[i - 15] | 0;
+      const W15l = SHA512_W_L[i - 15] | 0;
+      const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+      const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
+      const W2h = SHA512_W_H[i - 2] | 0;
+      const W2l = SHA512_W_L[i - 2] | 0;
+      const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+      const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
+      const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+      const SUMh = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+      SHA512_W_H[i] = SUMh | 0;
+      SHA512_W_L[i] = SUMl | 0;
+    }
+    let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    for (let i = 0; i < 80; i++) {
+      const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+      const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
+      const CHIh = Eh & Fh ^ ~Eh & Gh;
+      const CHIl = El & Fl ^ ~El & Gl;
+      const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+      const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+      const T1l = T1ll | 0;
+      const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+      const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
+      const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
+      const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
+      Hh = Gh | 0;
+      Hl = Gl | 0;
+      Gh = Fh | 0;
+      Gl = Fl | 0;
+      Fh = Eh | 0;
+      Fl = El | 0;
+      ({ h: Eh, l: El } = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+      Dh = Ch | 0;
+      Dl = Cl | 0;
+      Ch = Bh | 0;
+      Cl = Bl | 0;
+      Bh = Ah | 0;
+      Bl = Al | 0;
+      const All = add3L(T1l, sigma0l, MAJl);
+      Ah = add3H(All, T1h, sigma0h, MAJh);
+      Al = All | 0;
+    }
+    ({ h: Ah, l: Al } = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+    ({ h: Bh, l: Bl } = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+    ({ h: Ch, l: Cl } = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+    ({ h: Dh, l: Dl } = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+    ({ h: Eh, l: El } = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+    ({ h: Fh, l: Fl } = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+    ({ h: Gh, l: Gl } = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+    ({ h: Hh, l: Hl } = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+    this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+  }
+  roundClean() {
+    clean(SHA512_W_H, SHA512_W_L);
+  }
+  destroy() {
+    clean(this.buffer);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+};
+var _SHA512 = class extends SHA2_64B {
+  constructor() {
+    super(64);
+    __publicField(this, "Ah", SHA512_IV[0] | 0);
+    __publicField(this, "Al", SHA512_IV[1] | 0);
+    __publicField(this, "Bh", SHA512_IV[2] | 0);
+    __publicField(this, "Bl", SHA512_IV[3] | 0);
+    __publicField(this, "Ch", SHA512_IV[4] | 0);
+    __publicField(this, "Cl", SHA512_IV[5] | 0);
+    __publicField(this, "Dh", SHA512_IV[6] | 0);
+    __publicField(this, "Dl", SHA512_IV[7] | 0);
+    __publicField(this, "Eh", SHA512_IV[8] | 0);
+    __publicField(this, "El", SHA512_IV[9] | 0);
+    __publicField(this, "Fh", SHA512_IV[10] | 0);
+    __publicField(this, "Fl", SHA512_IV[11] | 0);
+    __publicField(this, "Gh", SHA512_IV[12] | 0);
+    __publicField(this, "Gl", SHA512_IV[13] | 0);
+    __publicField(this, "Hh", SHA512_IV[14] | 0);
+    __publicField(this, "Hl", SHA512_IV[15] | 0);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(
+  () => new _SHA256(),
+  /* @__PURE__ */ oidNist(1)
+);
+var sha512 = /* @__PURE__ */ createHasher(
+  () => new _SHA512(),
+  /* @__PURE__ */ oidNist(3)
+);
+
+// src/hash.ts
+var sha2562 = (input) => {
+  let data;
+  if (typeof input === "string") {
+    const encoder = new TextEncoder();
+    data = encoder.encode(input);
+  } else {
+    data = input;
+  }
+  const hashArray = sha256(data);
+  const base64 = bytesToBase64(hashArray);
+  const urlSafe = base64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  return urlSafe;
+};
+var verify = (content, hash) => {
+  const computed = sha2562(content);
+  return computed === hash;
+};
+var fromUrlSafeBase64 = (urlSafe) => {
+  const base64 = urlSafe.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = "=".repeat((4 - base64.length % 4) % 4);
+  return base64 + padding;
+};
+var toUrlSafeBase64 = (base64) => {
+  return base64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+};
+function bytesToBase64(bytes) {
+  if (typeof btoa !== "undefined") {
+    return btoa(String.fromCharCode(...Array.from(bytes)));
+  } else {
+    return Buffer.from(bytes).toString("base64");
+  }
+}
+function base64ToBytes(base64) {
+  if (typeof atob !== "undefined") {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+  } else {
+    return new Uint8Array(Buffer.from(base64, "base64"));
+  }
+}
+
+// src/utils.ts
+var generateFileHash = (fileContent) => {
+  return sha2562(fileContent);
+};
+var validateFileHash = (fileContent, expectedHash) => {
+  return verify(fileContent, expectedHash);
+};
+var generateStatementContentHash = (statementContent) => {
+  return sha2562(statementContent);
+};
+var validateStatementContentHash = (statementContent, expectedHash) => {
+  return verify(statementContent, expectedHash);
+};
+var generateStatementHash = (statement) => {
+  const signatureRegex = /^([\s\S]+?)---\n[\s\S]+$/;
+  const match = statement.match(signatureRegex);
+  if (match && match[1]) {
+    return sha2562(match[1]);
+  }
+  return sha2562(statement);
+};
+var validateStatementHash = (statement, expectedHash) => {
+  const computedHash = generateStatementHash(statement);
+  return computedHash === expectedHash;
+};
+var generateStatementsFile = (statements) => {
+  return statements.join("\n\n");
+};
+var parseStatementsFile = (statementsFileContent) => {
+  const statementParts = statementsFileContent.split(/\n\nStated protocol version: /);
+  const statements = [];
+  for (let i = 0; i < statementParts.length; i++) {
+    let statement = statementParts[i];
+    if (i === 0 && statement.trim().length === 0) continue;
+    if (i > 0) {
+      statement = "Stated protocol version: " + statement;
+    }
+    statement = statement.replace(/\n+$/, "\n");
+    try {
+      parseStatement({ statement });
+      statements.push(statement);
+    } catch (error) {
+      throw new Error(
+        `Invalid statement at index ${i}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return statements;
+};
+var generateStatementFilename = (statement) => {
+  const hash = generateStatementHash(statement);
+  return `${hash}.txt`;
+};
+var generateAttachmentFilename = (fileContent, extension) => {
+  const hash = generateFileHash(fileContent);
+  const ext = extension.startsWith(".") ? extension.substring(1) : extension;
+  return `${hash}.${ext}`;
+};
+var minPeopleCountToRange = (n) => {
+  if (n >= 1e7) return peopleCountBuckets["10000000"];
+  if (n >= 1e6) return peopleCountBuckets["1000000"];
+  if (n >= 1e5) return peopleCountBuckets["100000"];
+  if (n >= 1e4) return peopleCountBuckets["10000"];
+  if (n >= 1e3) return peopleCountBuckets["1000"];
+  if (n >= 100) return peopleCountBuckets["100"];
+  if (n >= 10) return peopleCountBuckets["10"];
+  if (n >= 0) return peopleCountBuckets["0"];
+};
+var monthIndex = (month) => ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"].indexOf(
+  month.toLowerCase().substr(0, 3)
+);
+var birthDateFormat = /(?<d>\d{1,2})\s(?<month>Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(?<y>\d{4})/;
+
+// node_modules/@noble/ed25519/index.js
+var ed25519_CURVE = {
+  p: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffedn,
+  n: 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3edn,
+  h: 8n,
+  a: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffecn,
+  d: 0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3n,
+  Gx: 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51an,
+  Gy: 0x6666666666666666666666666666666666666666666666666666666666666658n
+};
+var { p: P, n: N, Gx, Gy, a: _a, d: _d, h } = ed25519_CURVE;
+var L = 32;
+var L2 = 64;
+var captureTrace = (...args) => {
+  if ("captureStackTrace" in Error && typeof Error.captureStackTrace === "function") {
+    Error.captureStackTrace(...args);
+  }
+};
+var err = (message = "") => {
+  const e = new Error(message);
+  captureTrace(e, err);
+  throw e;
+};
+var isBig = (n) => typeof n === "bigint";
+var isStr = (s) => typeof s === "string";
+var isBytes2 = (a) => a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+var abytes2 = (value, length, title = "") => {
+  const bytes = isBytes2(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    err(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+};
+var u8n = (len) => new Uint8Array(len);
+var u8fr = (buf) => Uint8Array.from(buf);
+var padh = (n, pad) => n.toString(16).padStart(pad, "0");
+var bytesToHex = (b) => Array.from(abytes2(b)).map((e) => padh(e, 2)).join("");
+var C = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+var _ch = (ch) => {
+  if (ch >= C._0 && ch <= C._9)
+    return ch - C._0;
+  if (ch >= C.A && ch <= C.F)
+    return ch - (C.A - 10);
+  if (ch >= C.a && ch <= C.f)
+    return ch - (C.a - 10);
+  return;
+};
+var hexToBytes = (hex) => {
+  const e = "hex invalid";
+  if (!isStr(hex))
+    return err(e);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2)
+    return err(e);
+  const array = u8n(al);
+  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+    const n1 = _ch(hex.charCodeAt(hi));
+    const n2 = _ch(hex.charCodeAt(hi + 1));
+    if (n1 === void 0 || n2 === void 0)
+      return err(e);
+    array[ai] = n1 * 16 + n2;
+  }
+  return array;
+};
+var cr = () => globalThis?.crypto;
+var subtle = () => cr()?.subtle ?? err("crypto.subtle must be defined, consider polyfill");
+var concatBytes = (...arrs) => {
+  const r = u8n(arrs.reduce((sum, a) => sum + abytes2(a).length, 0));
+  let pad = 0;
+  arrs.forEach((a) => {
+    r.set(a, pad);
+    pad += a.length;
+  });
+  return r;
+};
+var randomBytes = (len = L) => {
+  const c = cr();
+  return c.getRandomValues(u8n(len));
+};
+var big = BigInt;
+var assertRange = (n, min, max, msg = "bad number: out of range") => isBig(n) && min <= n && n < max ? n : err(msg);
+var M = (a, b = P) => {
+  const r = a % b;
+  return r >= 0n ? r : b + r;
+};
+var modN = (a) => M(a, N);
+var invert = (num, md) => {
+  if (num === 0n || md <= 0n)
+    err("no inverse n=" + num + " mod=" + md);
+  let a = M(num, md), b = md, x = 0n, y = 1n, u = 1n, v = 0n;
+  while (a !== 0n) {
+    const q = b / a, r = b % a;
+    const m = x - u * q, n = y - v * q;
+    b = a, a = r, x = u, y = v, u = m, v = n;
+  }
+  return b === 1n ? M(x, md) : err("no inverse");
+};
+var callHash = (name) => {
+  const fn = hashes[name];
+  if (typeof fn !== "function")
+    err("hashes." + name + " not set");
+  return fn;
+};
+var apoint = (p) => p instanceof Point ? p : err("Point expected");
+var B256 = 2n ** 256n;
+var _Point = class _Point {
+  constructor(X, Y, Z, T) {
+    __publicField(this, "X");
+    __publicField(this, "Y");
+    __publicField(this, "Z");
+    __publicField(this, "T");
+    const max = B256;
+    this.X = assertRange(X, 0n, max);
+    this.Y = assertRange(Y, 0n, max);
+    this.Z = assertRange(Z, 1n, max);
+    this.T = assertRange(T, 0n, max);
+    Object.freeze(this);
+  }
+  static CURVE() {
+    return ed25519_CURVE;
+  }
+  static fromAffine(p) {
+    return new _Point(p.x, p.y, 1n, M(p.x * p.y));
+  }
+  /** RFC8032 5.1.3: Uint8Array to Point. */
+  static fromBytes(hex, zip215 = false) {
+    const d = _d;
+    const normed = u8fr(abytes2(hex, L));
+    const lastByte = hex[31];
+    normed[31] = lastByte & ~128;
+    const y = bytesToNumLE(normed);
+    const max = zip215 ? B256 : P;
+    assertRange(y, 0n, max);
+    const y2 = M(y * y);
+    const u = M(y2 - 1n);
+    const v = M(d * y2 + 1n);
+    let { isValid, value: x } = uvRatio(u, v);
+    if (!isValid)
+      err("bad point: y not sqrt");
+    const isXOdd = (x & 1n) === 1n;
+    const isLastByteOdd = (lastByte & 128) !== 0;
+    if (!zip215 && x === 0n && isLastByteOdd)
+      err("bad point: x==0, isLastByteOdd");
+    if (isLastByteOdd !== isXOdd)
+      x = M(-x);
+    return new _Point(x, y, 1n, M(x * y));
+  }
+  static fromHex(hex, zip215) {
+    return _Point.fromBytes(hexToBytes(hex), zip215);
+  }
+  get x() {
+    return this.toAffine().x;
+  }
+  get y() {
+    return this.toAffine().y;
+  }
+  /** Checks if the point is valid and on-curve. */
+  assertValidity() {
+    const a = _a;
+    const d = _d;
+    const p = this;
+    if (p.is0())
+      return err("bad point: ZERO");
+    const { X, Y, Z, T } = p;
+    const X2 = M(X * X);
+    const Y2 = M(Y * Y);
+    const Z2 = M(Z * Z);
+    const Z4 = M(Z2 * Z2);
+    const aX2 = M(X2 * a);
+    const left = M(Z2 * M(aX2 + Y2));
+    const right = M(Z4 + M(d * M(X2 * Y2)));
+    if (left !== right)
+      return err("bad point: equation left != right (1)");
+    const XY = M(X * Y);
+    const ZT = M(Z * T);
+    if (XY !== ZT)
+      return err("bad point: equation left != right (2)");
+    return this;
+  }
+  /** Equality check: compare points P&Q. */
+  equals(other) {
+    const { X: X1, Y: Y1, Z: Z1 } = this;
+    const { X: X2, Y: Y2, Z: Z2 } = apoint(other);
+    const X1Z2 = M(X1 * Z2);
+    const X2Z1 = M(X2 * Z1);
+    const Y1Z2 = M(Y1 * Z2);
+    const Y2Z1 = M(Y2 * Z1);
+    return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+  }
+  is0() {
+    return this.equals(I);
+  }
+  /** Flip point over y coordinate. */
+  negate() {
+    return new _Point(M(-this.X), this.Y, this.Z, M(-this.T));
+  }
+  /** Point doubling. Complete formula. Cost: `4M + 4S + 1*a + 6add + 1*2`. */
+  double() {
+    const { X: X1, Y: Y1, Z: Z1 } = this;
+    const a = _a;
+    const A = M(X1 * X1);
+    const B = M(Y1 * Y1);
+    const C2 = M(2n * M(Z1 * Z1));
+    const D = M(a * A);
+    const x1y1 = X1 + Y1;
+    const E = M(M(x1y1 * x1y1) - A - B);
+    const G2 = D + B;
+    const F = G2 - C2;
+    const H = D - B;
+    const X3 = M(E * F);
+    const Y3 = M(G2 * H);
+    const T3 = M(E * H);
+    const Z3 = M(F * G2);
+    return new _Point(X3, Y3, Z3, T3);
+  }
+  /** Point addition. Complete formula. Cost: `8M + 1*k + 8add + 1*2`. */
+  add(other) {
+    const { X: X1, Y: Y1, Z: Z1, T: T1 } = this;
+    const { X: X2, Y: Y2, Z: Z2, T: T2 } = apoint(other);
+    const a = _a;
+    const d = _d;
+    const A = M(X1 * X2);
+    const B = M(Y1 * Y2);
+    const C2 = M(T1 * d * T2);
+    const D = M(Z1 * Z2);
+    const E = M((X1 + Y1) * (X2 + Y2) - A - B);
+    const F = M(D - C2);
+    const G2 = M(D + C2);
+    const H = M(B - a * A);
+    const X3 = M(E * F);
+    const Y3 = M(G2 * H);
+    const T3 = M(E * H);
+    const Z3 = M(F * G2);
+    return new _Point(X3, Y3, Z3, T3);
+  }
+  subtract(other) {
+    return this.add(apoint(other).negate());
+  }
+  /**
+   * Point-by-scalar multiplication. Scalar must be in range 1 <= n < CURVE.n.
+   * Uses {@link wNAF} for base point.
+   * Uses fake point to mitigate side-channel leakage.
+   * @param n scalar by which point is multiplied
+   * @param safe safe mode guards against timing attacks; unsafe mode is faster
+   */
+  multiply(n, safe = true) {
+    if (!safe && (n === 0n || this.is0()))
+      return I;
+    assertRange(n, 1n, N);
+    if (n === 1n)
+      return this;
+    if (this.equals(G))
+      return wNAF(n).p;
+    let p = I;
+    let f = G;
+    for (let d = this; n > 0n; d = d.double(), n >>= 1n) {
+      if (n & 1n)
+        p = p.add(d);
+      else if (safe)
+        f = f.add(d);
+    }
+    return p;
+  }
+  multiplyUnsafe(scalar) {
+    return this.multiply(scalar, false);
+  }
+  /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
+  toAffine() {
+    const { X, Y, Z } = this;
+    if (this.equals(I))
+      return { x: 0n, y: 1n };
+    const iz = invert(Z, P);
+    if (M(Z * iz) !== 1n)
+      err("invalid inverse");
+    const x = M(X * iz);
+    const y = M(Y * iz);
+    return { x, y };
+  }
+  toBytes() {
+    const { x, y } = this.assertValidity().toAffine();
+    const b = numTo32bLE(y);
+    b[31] |= x & 1n ? 128 : 0;
+    return b;
+  }
+  toHex() {
+    return bytesToHex(this.toBytes());
+  }
+  clearCofactor() {
+    return this.multiply(big(h), false);
+  }
+  isSmallOrder() {
+    return this.clearCofactor().is0();
+  }
+  isTorsionFree() {
+    let p = this.multiply(N / 2n, false).double();
+    if (N % 2n)
+      p = p.add(this);
+    return p.is0();
+  }
+};
+__publicField(_Point, "BASE");
+__publicField(_Point, "ZERO");
+var Point = _Point;
+var G = new Point(Gx, Gy, 1n, M(Gx * Gy));
+var I = new Point(0n, 1n, 1n, 0n);
+Point.BASE = G;
+Point.ZERO = I;
+var numTo32bLE = (num) => hexToBytes(padh(assertRange(num, 0n, B256), L2)).reverse();
+var bytesToNumLE = (b) => big("0x" + bytesToHex(u8fr(abytes2(b)).reverse()));
+var pow2 = (x, power) => {
+  let r = x;
+  while (power-- > 0n) {
+    r *= r;
+    r %= P;
+  }
+  return r;
+};
+var pow_2_252_3 = (x) => {
+  const x2 = x * x % P;
+  const b2 = x2 * x % P;
+  const b4 = pow2(b2, 2n) * b2 % P;
+  const b5 = pow2(b4, 1n) * x % P;
+  const b10 = pow2(b5, 5n) * b5 % P;
+  const b20 = pow2(b10, 10n) * b10 % P;
+  const b40 = pow2(b20, 20n) * b20 % P;
+  const b80 = pow2(b40, 40n) * b40 % P;
+  const b160 = pow2(b80, 80n) * b80 % P;
+  const b240 = pow2(b160, 80n) * b80 % P;
+  const b250 = pow2(b240, 10n) * b10 % P;
+  const pow_p_5_8 = pow2(b250, 2n) * x % P;
+  return { pow_p_5_8, b2 };
+};
+var RM1 = 0x2b8324804fc1df0b2b4d00993dfbd7a72f431806ad2fe478c4ee1b274a0ea0b0n;
+var uvRatio = (u, v) => {
+  const v3 = M(v * v * v);
+  const v7 = M(v3 * v3 * v);
+  const pow = pow_2_252_3(u * v7).pow_p_5_8;
+  let x = M(u * v3 * pow);
+  const vx2 = M(v * x * x);
+  const root1 = x;
+  const root2 = M(x * RM1);
+  const useRoot1 = vx2 === u;
+  const useRoot2 = vx2 === M(-u);
+  const noRoot = vx2 === M(-u * RM1);
+  if (useRoot1)
+    x = root1;
+  if (useRoot2 || noRoot)
+    x = root2;
+  if ((M(x) & 1n) === 1n)
+    x = M(-x);
+  return { isValid: useRoot1 || useRoot2, value: x };
+};
+var modL_LE = (hash) => modN(bytesToNumLE(hash));
+var sha512a = (...m) => hashes.sha512Async(concatBytes(...m));
+var sha512s = (...m) => callHash("sha512")(concatBytes(...m));
+var hash2extK = (hashed) => {
+  const head = hashed.slice(0, L);
+  head[0] &= 248;
+  head[31] &= 127;
+  head[31] |= 64;
+  const prefix = hashed.slice(L, L2);
+  const scalar = modL_LE(head);
+  const point = G.multiply(scalar);
+  const pointBytes = point.toBytes();
+  return { head, prefix, scalar, point, pointBytes };
+};
+var getExtendedPublicKeyAsync = (secretKey) => sha512a(abytes2(secretKey, L)).then(hash2extK);
+var getExtendedPublicKey = (secretKey) => hash2extK(sha512s(abytes2(secretKey, L)));
+var getPublicKey = (priv) => getExtendedPublicKey(priv).pointBytes;
+var hashFinishS = (res) => res.finish(sha512s(res.hashable));
+var _sign = (e, rBytes, msg) => {
+  const { pointBytes: P2, scalar: s } = e;
+  const r = modL_LE(rBytes);
+  const R = G.multiply(r).toBytes();
+  const hashable = concatBytes(R, P2, msg);
+  const finish = (hashed) => {
+    const S = modN(r + modL_LE(hashed) * s);
+    return abytes2(concatBytes(R, numTo32bLE(S)), L2);
+  };
+  return { hashable, finish };
+};
+var sign = (message, secretKey) => {
+  const m = abytes2(message);
+  const e = getExtendedPublicKey(secretKey);
+  const rBytes = sha512s(e.prefix, m);
+  return hashFinishS(_sign(e, rBytes, m));
+};
+var defaultVerifyOpts = { zip215: true };
+var _verify = (sig, msg, pub, opts = defaultVerifyOpts) => {
+  sig = abytes2(sig, L2);
+  msg = abytes2(msg);
+  pub = abytes2(pub, L);
+  const { zip215 } = opts;
+  let A;
+  let R;
+  let s;
+  let SB;
+  let hashable = Uint8Array.of();
+  try {
+    A = Point.fromBytes(pub, zip215);
+    R = Point.fromBytes(sig.slice(0, L), zip215);
+    s = bytesToNumLE(sig.slice(L, L2));
+    SB = G.multiply(s, false);
+    hashable = concatBytes(R.toBytes(), A.toBytes(), msg);
+  } catch (error) {
+  }
+  const finish = (hashed) => {
+    if (SB == null)
+      return false;
+    if (!zip215 && A.isSmallOrder())
+      return false;
+    const k = modL_LE(hashed);
+    const RkA = R.add(A.multiply(k, false));
+    return RkA.add(SB.negate()).clearCofactor().is0();
+  };
+  return { hashable, finish };
+};
+var verify2 = (signature, message, publicKey, opts = defaultVerifyOpts) => hashFinishS(_verify(signature, message, publicKey, opts));
+var hashes = {
+  sha512Async: async (message) => {
+    const s = subtle();
+    const m = concatBytes(message);
+    return u8n(await s.digest("SHA-512", m.buffer));
+  },
+  sha512: void 0
+};
+var randomSecretKey = (seed = randomBytes(L)) => seed;
+var utils = {
+  getExtendedPublicKeyAsync,
+  getExtendedPublicKey,
+  randomSecretKey
+};
+var W = 8;
+var scalarBits = 256;
+var pwindows = Math.ceil(scalarBits / W) + 1;
+var pwindowSize = 2 ** (W - 1);
+var precompute = () => {
+  const points = [];
+  let p = G;
+  let b = p;
+  for (let w = 0; w < pwindows; w++) {
+    b = p;
+    points.push(b);
+    for (let i = 1; i < pwindowSize; i++) {
+      b = b.add(p);
+      points.push(b);
+    }
+    p = b.double();
+  }
+  return points;
+};
+var Gpows = void 0;
+var ctneg = (cnd, p) => {
+  const n = p.negate();
+  return cnd ? n : p;
+};
+var wNAF = (n) => {
+  const comp = Gpows || (Gpows = precompute());
+  let p = I;
+  let f = G;
+  const pow_2_w = 2 ** W;
+  const maxNum = pow_2_w;
+  const mask = big(pow_2_w - 1);
+  const shiftBy = big(W);
+  for (let w = 0; w < pwindows; w++) {
+    let wbits = Number(n & mask);
+    n >>= shiftBy;
+    if (wbits > pwindowSize) {
+      wbits -= maxNum;
+      n += 1n;
+    }
+    const off = w * pwindowSize;
+    const offF = off;
+    const offP = off + Math.abs(wbits) - 1;
+    const isEven = w % 2 !== 0;
+    const isNeg = wbits < 0;
+    if (wbits === 0) {
+      f = f.add(ctneg(isEven, comp[offF]));
+    } else {
+      p = p.add(ctneg(isNeg, comp[offP]));
+    }
+  }
+  if (n !== 0n)
+    err("invalid wnaf");
+  return { p, f };
+};
+
+// src/signature.ts
+hashes.sha512 = (message) => sha512(message);
+var ALGORITHM = "Ed25519";
+var generateKeyPair = async () => {
+  const privateKey = utils.randomSecretKey();
+  const publicKey = await getPublicKey(privateKey);
+  return {
+    publicKey: toUrlSafeBase64(bytesToBase642(publicKey)),
+    privateKey: toUrlSafeBase64(bytesToBase642(privateKey))
+  };
+};
+var signStatement = async (statement, privateKeyUrlSafe) => {
+  const privateKeyBytes = base64ToBytes(fromUrlSafeBase64(privateKeyUrlSafe));
+  const messageBytes = new TextEncoder().encode(statement);
+  const signature = await sign(messageBytes, privateKeyBytes);
+  return toUrlSafeBase64(bytesToBase642(signature));
+};
+var verifySignature = async (statement, signatureUrlSafe, publicKeyUrlSafe) => {
+  try {
+    const publicKeyBytes = base64ToBytes(fromUrlSafeBase64(publicKeyUrlSafe));
+    const signatureBytes = base64ToBytes(fromUrlSafeBase64(signatureUrlSafe));
+    const messageBytes = new TextEncoder().encode(statement);
+    return await verify2(signatureBytes, messageBytes, publicKeyBytes);
+  } catch (error) {
+    return false;
+  }
+};
+var buildSignedStatement = async (statement, privateKeyUrlSafe, publicKeyUrlSafe) => {
+  const statementHash = sha2562(statement);
+  const signature = await signStatement(statement, privateKeyUrlSafe);
+  return statement + `---
+Statement hash: ${statementHash}
+Public key: ${publicKeyUrlSafe}
+Signature: ${signature}
+Algorithm: ${ALGORITHM}
+`;
+};
+var parseSignedStatement = (signedStatement) => {
+  const regex = /^([\s\S]+?)---\nStatement hash: ([A-Za-z0-9_-]+)\nPublic key: ([A-Za-z0-9_-]+)\nSignature: ([A-Za-z0-9_-]+)\nAlgorithm: ([^\n]+)\n$/;
+  const match = signedStatement.match(regex);
+  if (!match) return null;
+  const statement = match[1];
+  const statementHash = match[2];
+  const publicKey = match[3];
+  const signature = match[4];
+  const algorithm = match[5];
+  const computedHash = sha2562(statement);
+  if (computedHash !== statementHash) {
+    return null;
+  }
+  if (algorithm !== ALGORITHM) {
+    return null;
+  }
+  return {
+    statement,
+    publicKey,
+    signature,
+    statementHash,
+    algorithm
+  };
+};
+var verifySignedStatement = async (signedStatement) => {
+  const parsed = parseSignedStatement(signedStatement);
+  if (!parsed) return false;
+  return await verifySignature(parsed.statement, parsed.signature, parsed.publicKey);
+};
+function bytesToBase642(bytes) {
+  if (typeof btoa !== "undefined") {
+    return btoa(String.fromCharCode(...Array.from(bytes)));
+  } else {
+    return Buffer.from(bytes).toString("base64");
+  }
+}
+
+// src/types.ts
+function isLegalForm(value) {
+  return [
+    "local government",
+    "state government",
+    "foreign affairs ministry",
+    "corporation"
+  ].includes(value);
+}
+function isPeopleCountBucket(value) {
+  return [
+    "0-10",
+    "10-100",
+    "100-1000",
+    "1000-10,000",
+    "10,000-100,000",
+    "100,000+",
+    "1,000,000+",
+    "10,000,000+"
+  ].includes(value);
+}
+function isRatingValue(value) {
+  return [1, 2, 3, 4, 5].includes(value);
+}
+
+// src/protocol.ts
+var version = 5;
+var buildStatement = ({
+  domain,
+  author,
+  time,
+  tags,
+  content,
+  representative,
+  supersededStatement,
+  translations,
+  attachments
+}) => {
+  if (content.match(/\nPublishing domain: /))
+    throw new Error(
+      "Statement must not contain 'Publishing domain: ', as this marks the beginning of a new statement."
+    );
+  if (content.match(/\n\n/))
+    throw new Error(
+      "Statement content must not contain two line breaks in a row, as this is used for separating statements."
+    );
+  if (content.match(/\nTranslation [a-z]{2,3}:\n/))
+    throw new Error(
+      "Statement content must not contain 'Translation XX:\\n' pattern, as this is reserved for translations."
+    );
+  if (content.match(/\nAttachments: /))
+    throw new Error(
+      "Statement content must not contain 'Attachments: ' on a new line, as this is reserved for file attachments."
+    );
+  if (typeof time !== "object" || !time.toUTCString) throw new Error("Time must be a Date object.");
+  if (!domain) throw new Error("Publishing domain missing.");
+  if (attachments && attachments.length > 5) throw new Error("Maximum 5 attachments allowed.");
+  if (attachments) {
+    attachments.forEach((attachment, index) => {
+      if (!attachment.match(/^[A-Za-z0-9_-]+\.[a-zA-Z0-9]+$/)) {
+        throw new Error(
+          `Attachment ${index + 1} must be in format 'base64hash.extension' (URL-safe base64)`
+        );
+      }
+    });
+  }
+  if (translations) {
+    for (const [lang, translation] of Object.entries(translations)) {
+      if (translation.match(/\nPublishing domain: /))
+        throw new Error(`Translation for ${lang} must not contain 'Publishing domain: '.`);
+      if (translation.match(/Translation [a-z]{2,3}:\n/))
+        throw new Error(`Translation for ${lang} must not contain 'Translation XX:\\n' pattern.`);
+    }
+  }
+  const translationLines = translations ? Object.entries(translations).map(([lang, translation]) => {
+    const translationWithNewline = translation + (translation.match(/\n$/) ? "" : "\n");
+    const indentedTranslation = translationWithNewline.split("\n").map((line) => line ? "    " + line : line).join("\n");
+    return `Translation ${lang}:
+${indentedTranslation}`;
+  }).join("") : "";
+  const attachmentLines = attachments && attachments.length > 0 ? "Attachments: " + attachments.join(", ") + "\n" : "";
+  const contentWithNewline = content + (content.match(/\n$/) ? "" : "\n");
+  const isTypedContent = contentWithNewline.trim().startsWith("Type:");
+  const finalContent = isTypedContent ? contentWithNewline : contentWithNewline.split("\n").map((line) => line ? "    " + line : line).join("\n");
+  const statement = "Stated protocol version: " + version + "\nPublishing domain: " + domain + "\nAuthor: " + (author || "") + "\n" + (representative && representative?.length > 0 ? "Authorized signing representative: " + (representative || "") + "\n" : "") + "Time: " + time.toUTCString() + "\n" + (tags && tags.length > 0 ? "Tags: " + tags.join(", ") + "\n" : "") + (supersededStatement && supersededStatement?.length > 0 ? "Superseded statement: " + (supersededStatement || "") + "\n" : "") + "Statement content:\n" + finalContent + translationLines + attachmentLines;
+  if (statement.length > 3e3)
+    throw new Error("Statement must not be longer than 3,000 characters.");
+  return statement;
+};
+var parseStatement = ({
+  statement: input
+}) => {
+  if (input.length > 3e3) throw new Error("Statement must not be longer than 3,000 characters.");
+  const beforeTranslations = input.split(/\nTranslation [a-z]{2,3}:\n/)[0];
+  if (beforeTranslations.match(/\n\n/))
+    throw new Error(
+      "Statements cannot contain two line breaks in a row before translations, as this is used for separating statements."
+    );
+  const signatureRegex = new RegExp(
+    "" + /^(?<statement>[\s\S]+?)---\n/.source + /Statement hash: (?<statementHash>[A-Za-z0-9_-]+)\n/.source + /Public key: (?<publicKey>[A-Za-z0-9_-]+)\n/.source + /Signature: (?<signature>[A-Za-z0-9_-]+)\n/.source + /Algorithm: (?<algorithm>[^\n]+)\n/.source + /$/.source
+  );
+  const signatureMatch = input.match(signatureRegex);
+  let statementToVerify = input;
+  let publicKey;
+  let signature;
+  if (signatureMatch && signatureMatch.groups) {
+    statementToVerify = signatureMatch.groups.statement;
+    const statementHash = signatureMatch.groups.statementHash;
+    publicKey = signatureMatch.groups.publicKey;
+    signature = signatureMatch.groups.signature;
+    const algorithm = signatureMatch.groups.algorithm;
+    if (algorithm !== "Ed25519") {
+      throw new Error("Unsupported signature algorithm: " + algorithm);
+    }
+    const computedHash = sha2562(statementToVerify);
+    if (computedHash !== statementHash) {
+      throw new Error("Statement hash mismatch");
+    }
+    const isValid = verifySignature(statementToVerify, signature, publicKey);
+    if (!isValid) {
+      throw new Error("Invalid cryptographic signature");
+    }
+  }
+  const statementRegex = new RegExp(
+    "" + /^Stated protocol version: (?<formatVersion>[^\n]+?)\n/.source + /Publishing domain: (?<domain>[^\n]+?)\n/.source + /Author: (?<author>[^\n]+?)\n/.source + /(?:Authorized signing representative: (?<representative>[^\n]*?)\n)?/.source + /Time: (?<time>[^\n]+?)\n/.source + /(?:Tags: (?<tags>[^\n]*?)\n)?/.source + /(?:Superseded statement: (?<supersededStatement>[^\n]*?)\n)?/.source + /Statement content:\n/.source + /(?:(?<typedContent>    Type: (?<type>[^\n]+?)\n[\s\S]+?)(?=\nTranslation [a-z]{2,3}:\n|Attachments: |$)|(?<content>(?:    [\s\S]+?)?))/.source + /(?=\nTranslation [a-z]{2,3}:\n|Attachments: |$)/.source + /(?<translations>(?:\nTranslation [a-z]{2,3}:\n[\s\S]+?)*)/.source + /(?:Attachments: (?<attachments>[^\n]+?)\n)?/.source + /$/.source
+  );
+  const match = statementToVerify.match(statementRegex);
+  if (!match || !match.groups) throw new Error("Invalid statement format: " + input);
+  const {
+    domain,
+    author,
+    representative,
+    time: timeStr,
+    tags: tagsStr,
+    supersededStatement,
+    attachments: attachmentsStr,
+    formatVersion,
+    content,
+    typedContent,
+    type,
+    translations: translationsStr
+  } = match.groups;
+  const parsed = {
+    domain,
+    author,
+    representative,
+    timeStr,
+    tagsStr,
+    supersededStatement,
+    formatVersion,
+    content: content ? content.split("\n").map((line) => line.startsWith("    ") ? line.substring(4) : line).join("\n").replace(/\n$/, "") : typedContent,
+    type: type ? type.toLowerCase().replace(" ", "_") : void 0,
+    translationsStr
+  };
+  if (!parsed.timeStr.match(UTCFormat))
+    throw new Error("Invalid statement format: time must be in UTC");
+  if (!parsed.domain) throw new Error("Invalid statement format: domain is required");
+  if (!parsed.author) throw new Error("Invalid statement format: author is required");
+  if (!parsed.content) throw new Error("Invalid statement format: statement content is required");
+  if (!parsed.formatVersion)
+    throw new Error("Invalid statement format: format version is required");
+  if (parsed.formatVersion !== "5")
+    throw new Error(
+      `Invalid statement format: only version 5 is supported, got version ${parsed.formatVersion}`
+    );
+  const tags = parsed.tagsStr?.split(", ");
+  const time = new Date(parsed.timeStr);
+  let attachments = void 0;
+  if (attachmentsStr && attachmentsStr.length > 0) {
+    attachments = attachmentsStr.split(", ").map((a) => a.trim());
+    if (attachments.length > 5) {
+      throw new Error("Maximum 5 attachments allowed");
+    }
+  }
+  let translations = void 0;
+  if (parsed.translationsStr && parsed.translationsStr.length > 0) {
+    translations = {};
+    const translationParts = parsed.translationsStr.split(/\nTranslation ([a-z]{2,3}):\n/).filter((part) => part.length > 0);
+    for (let i = 0; i < translationParts.length; i += 2) {
+      if (i + 1 < translationParts.length) {
+        const lang = translationParts[i];
+        const rawTranslation = translationParts[i + 1];
+        const translation = rawTranslation.split("\n").map((line) => line.startsWith("    ") ? line.substring(4) : line).join("\n").replace(/\n$/, "");
+        translations[lang] = translation;
+      }
+    }
+  }
+  return {
+    domain: parsed.domain,
+    author: parsed.author,
+    representative: parsed.representative,
+    time,
+    tags: tags && tags.length > 0 ? tags : void 0,
+    supersededStatement: parsed.supersededStatement,
+    formatVersion: parsed.formatVersion,
+    content: parsed.content,
+    type: parsed.type?.toLowerCase().replace(" ", "_"),
+    translations: translations && Object.keys(translations).length > 0 ? translations : void 0,
+    attachments: attachments && attachments.length > 0 ? attachments : void 0
+  };
+};
+var buildPollContent = ({
+  deadline,
+  poll,
+  scopeDescription,
+  options,
+  allowArbitraryVote
+}) => {
+  if (!poll) throw new Error("Poll must contain a poll question.");
+  if (poll.includes("\n")) throw new Error("Poll question must be single line.");
+  if (scopeDescription && scopeDescription.includes("\n"))
+    throw new Error("Scope description must be single line.");
+  options.forEach((option, index) => {
+    if (option && option.includes("\n"))
+      throw new Error(`Option ${index + 1} must be single line.`);
+  });
+  const content = "    Type: Poll\n" + (deadline ? "    Voting deadline: " + deadline.toUTCString() + "\n" : "") + "    Poll: " + poll + "\n" + (options.length > 0 && options[0] ? "    Option 1: " + options[0] + "\n" : "") + (options.length > 1 && options[1] ? "    Option 2: " + options[1] + "\n" : "") + (options.length > 2 && options[2] ? "    Option 3: " + options[2] + "\n" : "") + (options.length > 3 && options[3] ? "    Option 4: " + options[3] + "\n" : "") + (options.length > 4 && options[4] ? "    Option 5: " + options[4] + "\n" : "") + (allowArbitraryVote === true || allowArbitraryVote === false ? "    Allow free text votes: " + (allowArbitraryVote ? "Yes" : "No") + "\n" : "") + (scopeDescription ? "    Who can vote: " + scopeDescription + "\n" : "");
+  return content;
+};
+var parsePoll = (content, version2) => {
+  if (version2 !== "5") throw new Error("Invalid version " + version2);
+  const pollRegex = new RegExp(
+    "" + /^    Type: Poll\n/.source + /(?:    Voting deadline: (?<deadline>[^\n]+?)\n)?/.source + /    Poll: (?<poll>[^\n]+?)\n/.source + /(?:    Option 1: (?<option1>[^\n]+?)\n)?/.source + /(?:    Option 2: (?<option2>[^\n]+?)\n)?/.source + /(?:    Option 3: (?<option3>[^\n]+?)\n)?/.source + /(?:    Option 4: (?<option4>[^\n]+?)\n)?/.source + /(?:    Option 5: (?<option5>[^\n]+?)\n)?/.source + /(?:    Allow free text votes: (?<allowArbitraryVote>Yes|No)\n)?/.source + /(?:    Who can vote: (?<scopeDescription>[^\n]+?)\n)?/.source + /$/.source
+  );
+  const match = content.match(pollRegex);
+  if (!match || !match.groups) throw new Error("Invalid poll format: " + content);
+  const {
+    deadline,
+    poll,
+    option1,
+    option2,
+    option3,
+    option4,
+    option5,
+    allowArbitraryVote: allowArbitraryVoteStr,
+    scopeDescription
+  } = match.groups;
+  const options = [option1, option2, option3, option4, option5].filter((o) => o);
+  const allowArbitraryVote = allowArbitraryVoteStr === "Yes" ? true : allowArbitraryVoteStr === "No" ? false : void 0;
+  const deadlineStr = deadline;
+  if (deadlineStr && !deadlineStr.match(UTCFormat))
+    throw new Error("Invalid poll, deadline must be in UTC: " + deadlineStr);
+  return {
+    deadline: deadlineStr ? new Date(deadlineStr) : void 0,
+    poll,
+    options,
+    allowArbitraryVote,
+    scopeDescription
+  };
+};
+var buildOrganisationVerificationContent = ({
+  name,
+  englishName,
+  country,
+  city,
+  province,
+  legalForm,
+  department,
+  domain,
+  foreignDomain,
+  serialNumber,
+  confidence,
+  reliabilityPolicy,
+  employeeCount,
+  pictureHash,
+  latitude,
+  longitude,
+  population,
+  publicKey
+}) => {
+  if (!name || !country || !legalForm || !domain && !foreignDomain)
+    throw new Error("Missing required fields");
+  if (!Object.values(legalForms).includes(legalForm))
+    throw new Error("Invalid legal form " + legalForm);
+  if (employeeCount && !Object.values(peopleCountBuckets).includes(employeeCount))
+    throw new Error("Invalid employee count " + employeeCount);
+  if (population && !Object.values(peopleCountBuckets).includes(population))
+    throw new Error("Invalid population " + population);
+  if (confidence && !("" + confidence)?.match(/^[0-9.]+$/))
+    throw new Error("Invalid confidence " + confidence);
+  if (pictureHash && !pictureHash.match(/^[A-Za-z0-9_-]+\.[a-zA-Z0-9]+$/)) {
+    throw new Error("Logo must be in format 'base64hash.extension' (URL-safe base64)");
+  }
+  if (publicKey && !publicKey.match(/^[A-Za-z0-9_-]+$/)) {
+    throw new Error("Public key must be in URL-safe base64 format (A-Z, a-z, 0-9, _, -)");
+  }
+  return "    Type: Organisation verification\n    Description: We verified the following information about an organisation.\n    Name: " + name + "\n" + (englishName ? "    English name: " + englishName + "\n" : "") + "    Country: " + country + "\n    Legal form: " + legalForm + "\n" + (domain ? "    Owner of the domain: " + domain + "\n" : "") + (foreignDomain ? "    Foreign domain used for publishing statements: " + foreignDomain + "\n" : "") + (department ? "    Department using the domain: " + department + "\n" : "") + (province ? "    Province or state: " + province + "\n" : "") + (serialNumber ? "    Business register number: " + serialNumber + "\n" : "") + (city ? "    City: " + city + "\n" : "") + (latitude ? "    Latitude: " + latitude + "\n" : "") + (longitude ? "    Longitude: " + longitude + "\n" : "") + (population ? "    Population: " + population + "\n" : "") + (pictureHash ? "    Logo: " + pictureHash + "\n" : "") + (employeeCount ? "    Employee count: " + employeeCount + "\n" : "") + (publicKey ? "    Public key: " + publicKey + "\n" : "") + (reliabilityPolicy ? "    Reliability policy: " + reliabilityPolicy + "\n" : "") + (confidence ? "    Confidence: " + confidence + "\n" : "");
+};
+var parseOrganisationVerification = (content) => {
+  const organisationVerificationRegex = new RegExp(
+    "" + /^    Type: Organisation verification\n/.source + /    Description: We verified the following information about an organisation.\n/.source + /    Name: (?<name>[^\n]+?)\n/.source + /(?:    English name: (?<englishName>[^\n]+?)\n)?/.source + /    Country: (?<country>[^\n]+?)\n/.source + /    Legal (?:form|entity): (?<legalForm>[^\n]+?)\n/.source + /(?:    Owner of the domain: (?<domain>[^\n]+?)\n)?/.source + /(?:    Foreign domain used for publishing statements: (?<foreignDomain>[^\n]+?)\n)?/.source + /(?:    Department using the domain: (?<department>[^\n]+?)\n)?/.source + /(?:    Province or state: (?<province>[^\n]+?)\n)?/.source + /(?:    Business register number: (?<serialNumber>[^\n]+?)\n)?/.source + /(?:    City: (?<city>[^\n]+?)\n)?/.source + /(?:    Latitude: (?<latitude>[^\n]+?)\n)?/.source + /(?:    Longitude: (?<longitude>[^\n]+?)\n)?/.source + /(?:    Population: (?<population>[^\n]+?)\n)?/.source + /(?:    Logo: (?<pictureHash>[A-Za-z0-9_-]+\.[a-zA-Z0-9]+)\n)?/.source + /(?:    Employee count: (?<employeeCount>[01,+-]+?)\n)?/.source + /(?:    Public key: (?<publicKey>[A-Za-z0-9_-]+)\n)?/.source + /(?:    Reliability policy: (?<reliabilityPolicy>[^\n]+?)\n)?/.source + /(?:    Confidence: (?<confidence>[0-9.]+?))?/.source + /\n?$/.source
+  );
+  const match = content.match(organisationVerificationRegex);
+  if (!match || !match.groups)
+    throw new Error("Invalid organisation verification format: " + content);
+  const {
+    name,
+    englishName,
+    country,
+    legalForm,
+    domain,
+    foreignDomain,
+    department,
+    province,
+    serialNumber,
+    city,
+    latitude,
+    longitude,
+    population,
+    pictureHash,
+    employeeCount,
+    publicKey,
+    reliabilityPolicy,
+    confidence
+  } = match.groups;
+  if (!isLegalForm(legalForm)) {
+    throw new Error("Invalid legal form after validation: " + legalForm);
+  }
+  return {
+    name,
+    englishName,
+    country,
+    legalForm,
+    domain,
+    foreignDomain,
+    department,
+    province,
+    serialNumber,
+    city,
+    latitude: latitude ? parseFloat(latitude) : void 0,
+    longitude: longitude ? parseFloat(longitude) : void 0,
+    population: population && isPeopleCountBucket(population) ? population : void 0,
+    pictureHash,
+    employeeCount: employeeCount && isPeopleCountBucket(employeeCount) ? employeeCount : void 0,
+    publicKey,
+    reliabilityPolicy,
+    confidence: confidence ? parseFloat(confidence) : void 0
+  };
+};
+var buildPersonVerificationContent = ({
+  name,
+  countryOfBirth,
+  cityOfBirth,
+  ownDomain,
+  foreignDomain,
+  dateOfBirth,
+  jobTitle,
+  employer,
+  verificationMethod,
+  confidence,
+  picture,
+  reliabilityPolicy,
+  publicKey
+}) => {
+  if (!name || !countryOfBirth || !cityOfBirth || !dateOfBirth || !ownDomain && !foreignDomain) {
+    throw new Error("Missing required fields for person verification");
+  }
+  if (publicKey && !publicKey.match(/^[A-Za-z0-9_-]+$/)) {
+    throw new Error("Public key must be in URL-safe base64 format (A-Z, a-z, 0-9, _, -)");
+  }
+  const [day, month, year] = dateOfBirth.toUTCString().split(" ").filter((_i, j) => [1, 2, 3].includes(j));
+  const content = "    Type: Person verification\n    Description: We verified the following information about a person.\n    Name: " + name + "\n    Date of birth: " + [day.replace(/^0/, ""), month, year].join(" ") + "\n    City of birth: " + cityOfBirth + "\n    Country of birth: " + countryOfBirth + "\n" + (jobTitle ? "    Job title: " + jobTitle + "\n" : "") + (employer ? "    Employer: " + employer + "\n" : "") + (ownDomain ? "    Owner of the domain: " + ownDomain + "\n" : "") + (foreignDomain ? "    Foreign domain used for publishing statements: " + foreignDomain + "\n" : "") + (picture ? "    Picture: " + picture + "\n" : "") + (verificationMethod ? "    Verification method: " + verificationMethod + "\n" : "") + (publicKey ? "    Public key: " + publicKey + "\n" : "") + (confidence ? "    Confidence: " + confidence + "\n" : "") + (reliabilityPolicy ? "    Reliability policy: " + reliabilityPolicy + "\n" : "");
+  return content;
+};
+var parsePersonVerification = (content) => {
+  const domainVerificationRegex = new RegExp(
+    "" + /^    Type: Person verification\n/.source + /    Description: We verified the following information about a person.\n/.source + /    Name: (?<name>[^\n]+?)\n/.source + /    Date of birth: (?<dateOfBirth>[^\n]+?)\n/.source + /    City of birth: (?<cityOfBirth>[^\n]+?)\n/.source + /    Country of birth: (?<countryOfBirth>[^\n]+?)\n/.source + /(?:    Job title: (?<jobTitle>[^\n]+?)\n)?/.source + /(?:    Employer: (?<employer>[^\n]+?)\n)?/.source + /(?:    Owner of the domain: (?<domain>[^\n]+?)\n)?/.source + /(?:    Foreign domain used for publishing statements: (?<foreignDomain>[^\n]+?)\n)?/.source + /(?:    Picture: (?<picture>[^\n]+?)\n)?/.source + /(?:    Verification method: (?<verificationMethod>[^\n]+?)\n)?/.source + /(?:    Public key: (?<publicKey>[A-Za-z0-9_-]+)\n)?/.source + /(?:    Confidence: (?<confidence>[^\n]+?)\n)?/.source + /(?:    Reliability policy: (?<reliabilityPolicy>[^\n]+?)\n)?/.source + /$/.source
+  );
+  const match = content.match(domainVerificationRegex);
+  if (!match || !match.groups) throw new Error("Invalid person verification format: " + content);
+  const {
+    name,
+    dateOfBirth: dateOfBirthStr,
+    cityOfBirth,
+    countryOfBirth,
+    jobTitle,
+    employer,
+    domain,
+    foreignDomain,
+    picture,
+    verificationMethod,
+    publicKey,
+    confidence,
+    reliabilityPolicy
+  } = match.groups;
+  if (dateOfBirthStr && !dateOfBirthStr.match(birthDateFormat))
+    throw new Error("Invalid birth date format: " + dateOfBirthStr);
+  const { d, month, y } = dateOfBirthStr.match(birthDateFormat)?.groups || {};
+  if (!d || !month || !y) throw new Error("Invalid birth date format: " + dateOfBirthStr);
+  return {
+    name,
+    dateOfBirth: new Date(Date.UTC(parseInt(y), monthIndex(month), parseInt(d))),
+    cityOfBirth,
+    countryOfBirth,
+    jobTitle,
+    employer,
+    ownDomain: domain,
+    foreignDomain,
+    picture,
+    verificationMethod,
+    publicKey,
+    confidence: confidence ? parseFloat(confidence) : void 0,
+    reliabilityPolicy
+  };
+};
+var buildVoteContent = ({ pollHash, poll, vote }) => {
+  const content = "    Type: Vote\n    Poll id: " + pollHash + "\n    Poll:\n        " + poll + "\n    Option:\n        " + vote + "\n";
+  return content;
+};
+var parseVote = (content) => {
+  const voteRegex = new RegExp(
+    "" + /^    Type: Vote\n/.source + /    Poll id: (?<pollHash>[^\n]+?)\n/.source + /    Poll:\n        (?<poll>[^\n]+?)\n/.source + /    Option:\n        (?<vote>[^\n]+?)\n/.source + /$/.source
+  );
+  const match = content.match(voteRegex);
+  if (!match || !match.groups) throw new Error("Invalid vote format: " + content);
+  const { pollHash, poll, vote } = match.groups;
+  return { pollHash, poll, vote };
+};
+var buildDisputeAuthenticityContent = ({
+  hash,
+  confidence,
+  reliabilityPolicy
+}) => {
+  const content = "    Type: Dispute statement authenticity\n    Description: We think that the referenced statement is not authentic.\n    Hash of referenced statement: " + hash + "\n" + (confidence ? "    Confidence: " + confidence + "\n" : "") + (reliabilityPolicy ? "    Reliability policy: " + reliabilityPolicy + "\n" : "");
+  return content;
+};
+var parseDisputeAuthenticity = (content) => {
+  const disputeRegex = new RegExp(
+    "" + /^    Type: Dispute statement authenticity\n/.source + /    Description: We think that the referenced statement is not authentic.\n/.source + /    Hash of referenced statement: (?<hash>[^\n]+?)\n/.source + /(?:    Confidence: (?<confidence>[^\n]*?)\n)?/.source + /(?:    Reliability policy: (?<reliabilityPolicy>[^\n]+?)\n)?/.source + /$/.source
+  );
+  const match = content.match(disputeRegex);
+  if (!match || !match.groups) throw new Error("Invalid dispute authenticity format: " + content);
+  const { hash, confidence, reliabilityPolicy } = match.groups;
+  return {
+    hash,
+    confidence: confidence ? parseFloat(confidence) : void 0,
+    reliabilityPolicy
+  };
+};
+var buildDisputeContentContent = ({
+  hash,
+  confidence,
+  reliabilityPolicy
+}) => {
+  const content = "    Type: Dispute statement content\n    Description: We think that the content of the referenced statement is false.\n    Hash of referenced statement: " + hash + "\n" + (confidence ? "    Confidence: " + confidence + "\n" : "") + (reliabilityPolicy ? "    Reliability policy: " + reliabilityPolicy + "\n" : "");
+  return content;
+};
+var parseDisputeContent = (content) => {
+  const disputeRegex = new RegExp(
+    "" + /^    Type: Dispute statement content\n/.source + /    Description: We think that the content of the referenced statement is false.\n/.source + /    Hash of referenced statement: (?<hash>[^\n]+?)\n/.source + /(?:    Confidence: (?<confidence>[^\n]*?)\n)?/.source + /(?:    Reliability policy: (?<reliabilityPolicy>[^\n]+?)\n)?/.source + /$/.source
+  );
+  const match = content.match(disputeRegex);
+  if (!match || !match.groups) throw new Error("Invalid dispute content format: " + content);
+  const { hash, confidence, reliabilityPolicy } = match.groups;
+  return {
+    hash,
+    confidence: confidence ? parseFloat(confidence) : void 0,
+    reliabilityPolicy
+  };
+};
+var buildResponseContent = ({ hash, response }) => {
+  const content = "    Type: Response\n    Hash of referenced statement: " + hash + "\n    Response:\n        " + response + "\n";
+  return content;
+};
+var parseResponseContent = (content) => {
+  const responseRegex = new RegExp(
+    "" + /^    Type: Response\n/.source + /    Hash of referenced statement: (?<hash>[^\n]+?)\n/.source + /    Response:\n        (?<response>[^\n]*?)\n/.source + /$/.source
+  );
+  const match = content.match(responseRegex);
+  if (!match || !match.groups) throw new Error("Invalid response content format: " + content);
+  const { hash, response } = match.groups;
+  return { hash, response };
+};
+var buildPDFSigningContent = ({ hash }) => {
+  if (!hash.match(/^[A-Za-z0-9_-]+$/)) {
+    throw new Error("PDF file hash must be in URL-safe base64 format (A-Z, a-z, 0-9, _, -)");
+  }
+  const content = "    Type: Sign PDF\n    Description: We hereby digitally sign the referenced PDF file.\n    PDF file hash: " + hash + "\n";
+  return content;
+};
+var parsePDFSigning = (content) => {
+  const signingRegex = new RegExp(
+    "" + /^    Type: Sign PDF\n/.source + /    Description: We hereby digitally sign the referenced PDF file.\n/.source + /    PDF file hash: (?<hash>[A-Za-z0-9_-]+)\n/.source + /$/.source
+  );
+  const match = content.match(signingRegex);
+  if (!match || !match.groups) throw new Error("Invalid PDF signing format: " + content);
+  const { hash } = match.groups;
+  return { hash };
+};
+var buildRating = ({
+  subjectName,
+  subjectType,
+  subjectReference,
+  documentFileHash,
+  rating,
+  quality,
+  comment
+}) => {
+  if (![1, 2, 3, 4, 5].includes(rating)) throw new Error("Invalid rating: " + rating);
+  const content = "    Type: Rating\n" + (subjectType ? "    Subject type: " + subjectType + "\n" : "") + "    Subject name: " + subjectName + "\n" + (subjectReference ? "    URL that identifies the subject: " + subjectReference + "\n" : "") + (documentFileHash ? "    Document file hash: " + documentFileHash + "\n" : "") + (quality ? "    Rated quality: " + quality + "\n" : "") + "    Our rating: " + rating + "/5 Stars\n" + (comment ? "    Comment:\n        " + comment + "\n" : "");
+  return content;
+};
+var parseRating = (content) => {
+  const ratingRegex = new RegExp(
+    "" + /^    Type: Rating\n/.source + /(?:    Subject type: (?<subjectType>[^\n]*?)\n)?/.source + /    Subject name: (?<subjectName>[^\n]*?)\n/.source + /(?:    URL that identifies the subject: (?<subjectReference>[^\n]*?)\n)?/.source + /(?:    Document file hash: (?<documentFileHash>[^\n]*?)\n)?/.source + /(?:    Rated quality: (?<quality>[^\n]*?)\n)?/.source + /    Our rating: (?<rating>[1-5])\/5 Stars\n/.source + /(?:    Comment:\n        (?<comment>[\s\S]+?)\n)?/.source + /$/.source
+  );
+  const match = content.match(ratingRegex);
+  if (!match || !match.groups) throw new Error("Invalid rating format: " + content);
+  const {
+    subjectType,
+    subjectName,
+    subjectReference,
+    documentFileHash,
+    quality,
+    rating: ratingStr,
+    comment
+  } = match.groups;
+  const rating = parseInt(ratingStr);
+  if (![1, 2, 3, 4, 5].includes(rating)) throw new Error("Invalid rating: " + ratingStr);
+  if (subjectType && ![
+    "Organisation",
+    "Policy proposal",
+    "Regulation",
+    "Treaty draft",
+    "Product",
+    "Research publication"
+  ].includes(subjectType))
+    throw new Error("Invalid subject type: " + subjectType);
+  if (!subjectName) throw new Error("Missing subject name");
+  if (!isRatingValue(rating)) {
+    throw new Error("Invalid rating after validation: " + rating);
+  }
+  return {
+    subjectType,
+    subjectName,
+    subjectReference,
+    documentFileHash,
+    quality,
+    rating,
+    comment
+  };
+};
+export {
+  PDFSigningKeys,
+  UTCFormat,
+  base64ToBytes,
+  birthDateFormat,
+  buildDisputeAuthenticityContent,
+  buildDisputeContentContent,
+  buildOrganisationVerificationContent,
+  buildPDFSigningContent,
+  buildPersonVerificationContent,
+  buildPollContent,
+  buildRating,
+  buildResponseContent,
+  buildSignedStatement,
+  buildStatement,
+  buildVoteContent,
+  disputeAuthenticityKeys,
+  disputeContentKeys,
+  fromUrlSafeBase64,
+  generateAttachmentFilename,
+  generateFileHash,
+  generateKeyPair,
+  generateStatementContentHash,
+  generateStatementFilename,
+  generateStatementHash,
+  generateStatementsFile,
+  isLegalForm,
+  isPeopleCountBucket,
+  isRatingValue,
+  legalForms,
+  minPeopleCountToRange,
+  monthIndex,
+  organisationVerificationKeys,
+  parseDisputeAuthenticity,
+  parseDisputeContent,
+  parseOrganisationVerification,
+  parsePDFSigning,
+  parsePersonVerification,
+  parsePoll,
+  parseRating,
+  parseResponseContent,
+  parseSignedStatement,
+  parseStatement,
+  parseStatementsFile,
+  parseVote,
+  peopleCountBuckets,
+  personVerificationKeys,
+  pollKeys,
+  ratingKeys,
+  responseKeys,
+  sha2562 as sha256,
+  signStatement,
+  statementTypes,
+  supportedLanguages,
+  toUrlSafeBase64,
+  validateFileHash,
+  validateStatementContentHash,
+  validateStatementHash,
+  verify,
+  verifySignature,
+  verifySignedStatement,
+  voteKeys
+};
+/*! Bundled license information:
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/ed25519/index.js:
+  (*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=index.js.map