@festapp/banksync 0.0.0-bootstrap.20260831

package/dist/chunk-PBN2BUNR.cjs

@@ -0,0 +1,696 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/normalize.ts
+var ISO_ALIASES = {
+  "k\u010D": "CZK",
+  "kc": "CZK",
+  "czk": "CZK",
+  "\u20AC": "EUR",
+  "eur": "EUR",
+  "$": "USD",
+  "usd": "USD"
+};
+var MINOR_UNIT_DECIMALS = {
+  CZK: 2,
+  EUR: 2,
+  USD: 2
+};
+function normalizeCurrency(raw) {
+  const key = raw.trim().toLowerCase();
+  const out = ISO_ALIASES[key];
+  if (!out) {
+    throw new Error(`unknown_currency: ${JSON.stringify(raw)}`);
+  }
+  return out;
+}
+function toCents(amount, currency) {
+  const dec = MINOR_UNIT_DECIMALS[currency];
+  if (dec === void 0) {
+    throw new Error(`unsupported_currency_minor_unit: ${currency}`);
+  }
+  return Math.round(amount * 10 ** dec);
+}
+
+// src/parser.ts
+var BANK_CODES = {
+  "0100": "Komer\u010Dn\xED banka, a.s.",
+  "0300": "\u010Ceskoslovensk\xE1 obchodn\xED banka, a. s.",
+  "0600": "MONETA Money Bank, a.s.",
+  "0800": "\u010Cesk\xE1 spo\u0159itelna, a.s.",
+  "2010": "Fio banka, a.s.",
+  "2700": "UniCredit Bank Czech Republic and Slovakia, a.s.",
+  "3030": "Air Bank a.s.",
+  "5500": "Raiffeisenbank a.s.",
+  "6210": "mBank S.A.",
+  "6000": "PPF banka a.s.",
+  "4000": "Expobank CZ a.s.",
+  "2250": "Banka CREDITAS a.s."
+};
+function detectProvider(text, accountNumber) {
+  if (accountNumber) {
+    const acc = accountNumber.replace(/\s/g, "");
+    if (acc.includes("/2010")) return "fio_email";
+    if (acc.includes("/3030")) return "airbank_email";
+    if (acc.toUpperCase().startsWith("CZ") && acc.length >= 8) {
+      const bankCode = acc.substring(4, 8);
+      if (bankCode === "2010") return "fio_email";
+      if (bankCode === "3030") return "airbank_email";
+    }
+  }
+  if (/fio/i.test(text)) return "fio_email";
+  if (/air\s*bank/i.test(text)) return "airbank_email";
+  return "unknown";
+}
+function parseAmount(raw) {
+  let s = raw.replace(/\s/g, "");
+  if (s.includes(",") && s.includes(".")) {
+    const lastComma = s.lastIndexOf(",");
+    const lastDot = s.lastIndexOf(".");
+    if (lastComma > lastDot) {
+      s = s.replace(".", "").replace(",", ".");
+    } else {
+      s = s.replace(",", "");
+    }
+  } else if (s.includes(",")) {
+    s = s.replace(",", ".");
+  }
+  return parseFloat(s);
+}
+var MAX_AMOUNT_FIELD_CHARS = 64;
+function isAsciiDigit(char) {
+  const code = char.charCodeAt(0);
+  return code >= 48 && code <= 57;
+}
+function isAsciiLetter(char) {
+  const code = char.charCodeAt(0);
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function isAmountChar(char) {
+  return isAsciiDigit(char) || char === " " || char === "	" || char === "\xA0" || char === "," || char === "." || char === "-";
+}
+function findLabeledLineValue(text, labels) {
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trimStart();
+    const lower = trimmed.toLowerCase();
+    for (const label of labels) {
+      let searchFrom = 0;
+      while (searchFrom < lower.length) {
+        const labelAt = lower.indexOf(label, searchFrom);
+        if (labelAt < 0) break;
+        const before = labelAt > 0 ? _nullishCoalesce(lower[labelAt - 1], () => ( "")) : "";
+        let cursor = labelAt + label.length;
+        while (cursor < trimmed.length && (trimmed[cursor] === " " || trimmed[cursor] === "	")) cursor += 1;
+        if (!isAsciiLetter(before) && trimmed[cursor] === ":") return trimmed.slice(cursor + 1).trimStart();
+        searchFrom = labelAt + label.length;
+      }
+    }
+  }
+  return null;
+}
+function parseLabeledAmount(text, labels) {
+  const value = findLabeledLineValue(text, labels);
+  if (!value) return null;
+  let cursor = 0;
+  while (cursor < value.length && cursor <= MAX_AMOUNT_FIELD_CHARS && isAmountChar(_nullishCoalesce(value[cursor], () => ( "")))) cursor += 1;
+  if (cursor === 0 || cursor > MAX_AMOUNT_FIELD_CHARS) return null;
+  const rawAmount = value.slice(0, cursor).trim();
+  if (![...rawAmount].some(isAsciiDigit)) return null;
+  const currencyStart = cursor;
+  while (cursor < value.length && cursor - currencyStart < 3 && isAsciiLetter(_nullishCoalesce(value[cursor], () => ( "")))) cursor += 1;
+  const currency = value.slice(currencyStart, cursor);
+  if (currency.length < 2 || currency.length > 3 || isAsciiLetter(_nullishCoalesce(value[cursor], () => ( "")))) return null;
+  return { rawAmount, currency };
+}
+function parseAccountPrefix(value) {
+  let cursor = 0;
+  while (cursor < value.length && cursor < 20 && isAsciiDigit(_nullishCoalesce(value[cursor], () => ( "")))) cursor += 1;
+  if (cursor === 0 || value[cursor] !== "/") return null;
+  cursor += 1;
+  for (let digits = 0; digits < 4; digits += 1, cursor += 1) {
+    if (!isAsciiDigit(_nullishCoalesce(value[cursor], () => ( "")))) return null;
+  }
+  if (isAsciiDigit(_nullishCoalesce(value[cursor], () => ( "")))) return null;
+  return value.slice(0, cursor);
+}
+function parseAirbankCounterparty(text) {
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    const lower = trimmed.toLowerCase();
+    const marker = "z \xFA\u010Dtu";
+    const markerAt = lower.indexOf(marker);
+    if (markerAt < 0) continue;
+    const remainder = trimmed.slice(markerAt + marker.length).trimStart();
+    const numberMarker = " \u010D\xEDslo ";
+    const numberAt = remainder.toLowerCase().lastIndexOf(numberMarker);
+    const accountText = numberAt >= 0 ? remainder.slice(numberAt + numberMarker.length).trimStart() : remainder;
+    const account = parseAccountPrefix(accountText);
+    if (!account) continue;
+    const senderName = numberAt >= 0 ? remainder.slice(0, numberAt).trim().replace(/\s+/g, " ") || null : null;
+    return { account, senderName };
+  }
+  return null;
+}
+function g(m, i, fallback = "") {
+  return _nullishCoalesce(m[i], () => ( fallback));
+}
+function parseDateToUTC(raw) {
+  const withOffsetRe = /(\d{2})\.(\d{2})\.(\d{4})\s+(\d{2}):(\d{2})(?::(\d{2}))?\s*([+-])(\d{2}):?(\d{2})/;
+  const wm = raw.match(withOffsetRe);
+  if (wm) {
+    const sign = g(wm, 7);
+    const offsetMin = (parseInt(g(wm, 8), 10) * 60 + parseInt(g(wm, 9), 10)) * (sign === "+" ? 1 : -1);
+    const localMs = Date.UTC(
+      parseInt(g(wm, 3), 10),
+      parseInt(g(wm, 2), 10) - 1,
+      parseInt(g(wm, 1), 10),
+      parseInt(g(wm, 4), 10),
+      parseInt(g(wm, 5), 10),
+      parseInt(g(wm, 6, "0"), 10)
+    ) - offsetMin * 6e4;
+    return { date: new Date(localMs).toISOString(), date_offset_min: offsetMin };
+  }
+  const noOffsetRe = /(\d{2})\.(\d{2})\.(\d{4})\s+(\d{2}):(\d{2})(?::(\d{2}))?/;
+  const nm = raw.match(noOffsetRe);
+  if (nm) {
+    const month = parseInt(g(nm, 2), 10);
+    const pragueOffsetMin = month >= 4 && month <= 10 ? 120 : 60;
+    const localMs = Date.UTC(
+      parseInt(g(nm, 3), 10),
+      parseInt(g(nm, 2), 10) - 1,
+      parseInt(g(nm, 1), 10),
+      parseInt(g(nm, 4), 10),
+      parseInt(g(nm, 5), 10),
+      parseInt(g(nm, 6, "0"), 10)
+    ) - pragueOffsetMin * 6e4;
+    return { date: new Date(localMs).toISOString(), date_offset_min: pragueOffsetMin };
+  }
+  const dateOnlyRe = /(\d{2})\.(\d{2})\.(\d{4})/;
+  const dm = raw.match(dateOnlyRe);
+  if (dm) {
+    const iso = new Date(
+      Date.UTC(parseInt(g(dm, 3), 10), parseInt(g(dm, 2), 10) - 1, parseInt(g(dm, 1), 10), 12, 0, 0)
+    ).toISOString();
+    return { date: iso, date_offset_min: null };
+  }
+  return { date: null, date_offset_min: null };
+}
+function parseEmail(text, provider) {
+  if (provider === "fio_email") {
+    const amountField = parseLabeledAmount(text, ["\u010D\xE1stka", "castka", "amount"]);
+    if (!amountField) return null;
+    const rawCurrencyStr = amountField.currency;
+    const currency = normalizeCurrency(rawCurrencyStr);
+    const amount = parseAmount(amountField.rawAmount);
+    if (isNaN(amount)) return null;
+    if (amount < 0) return null;
+    const amount_cents = toCents(amount, currency);
+    const accountMatch = text.match(/(?:Protiúčet|Protiucet|Account):\s*([0-9\/\s]+)/i);
+    const vsMatch = text.match(/VS:\s*([0-9]+)/i);
+    const ksMatch = text.match(/KS:\s*([0-9]+)/i);
+    const ssMatch = text.match(/SS:\s*([0-9]+)/i);
+    const msgMatch = text.match(/(?:Zpráva pro příjemce|Message):\s*(.*)/i);
+    const nameMatch = text.match(/(?:Název protiúčtu|Account Name):\s*(.*)/i);
+    const idMatch = text.match(/(?:ID pokynu|Transaction ID):\s*([0-9]+)/i);
+    const dateMatch = text.match(
+      /Datum(?:\s+pohybu|\s+provedení|\s+zaúčtování)?:\s*(\d{2}\.\d{2}\.\d{4}(?:\s+\d{2}:\d{2}(?::\d{2})?(?:\s*[+-]\d{2}:?\d{2})?)?)/i
+    );
+    let counter_account = null;
+    let bank_code = null;
+    if (accountMatch) {
+      const rawAcc = (_nullishCoalesce(accountMatch[1], () => ( ""))).replace(/\s/g, "");
+      const parts = rawAcc.split("/");
+      counter_account = _nullishCoalesce(parts[0], () => ( null));
+      bank_code = parts.length > 1 ? _nullishCoalesce(parts[1], () => ( null)) : null;
+    }
+    const { date, date_offset_min } = dateMatch ? parseDateToUTC(_nullishCoalesce(dateMatch[1], () => ( ""))) : { date: null, date_offset_min: null };
+    return {
+      amount_cents,
+      currency,
+      counter_account: counter_account || null,
+      bank_code: bank_code || null,
+      bank_name: bank_code ? _nullishCoalesce(BANK_CODES[bank_code], () => ( null)) : null,
+      vs: vsMatch ? _nullishCoalesce(vsMatch[1], () => ( null)) : null,
+      ks: ksMatch ? _nullishCoalesce(ksMatch[1], () => ( null)) : null,
+      ss: ssMatch ? _nullishCoalesce(ssMatch[1], () => ( null)) : null,
+      message: msgMatch ? (_nullishCoalesce(msgMatch[1], () => ( ""))).trim() || null : null,
+      sender_name: nameMatch ? (_nullishCoalesce(nameMatch[1], () => ( ""))).trim() || null : null,
+      user_identification: null,
+      transaction_type: null,
+      performed_by: null,
+      comment: null,
+      command_id: null,
+      source: "email",
+      date,
+      date_offset_min,
+      transaction_id: idMatch ? _nullishCoalesce(idMatch[1], () => ( null)) : null,
+      external_id: null
+    };
+  }
+  if (provider === "airbank_email") {
+    const amountField = parseLabeledAmount(text, ["\u010D\xE1stka", "castka", "amount"]);
+    if (!amountField) return null;
+    const rawCurrencyStr = amountField.currency;
+    const currency = normalizeCurrency(rawCurrencyStr);
+    const amountStr = amountField.rawAmount.replace(/\s/g, "");
+    if (!amountStr) return null;
+    const amount = parseAmount(amountField.rawAmount);
+    if (isNaN(amount)) return null;
+    if (amount < 0) return null;
+    const amount_cents = toCents(amount, currency);
+    const counterparty = parseAirbankCounterparty(text);
+    const vsMatch = text.match(/(?:Variabilní symbol|\bVS\b)\s*:\s*([0-9]+)/i);
+    const ksMatch = text.match(/(?:Konstantní symbol|\bKS\b)\s*:\s*([0-9]+)/i);
+    const ssMatch = text.match(/(?:Specifický symbol|\bSS\b)\s*:\s*([0-9]+)/i);
+    const msgMatch = text.match(/(?:Zpráva pro příjemce|Zprava)\s*:\s*(.*)/i);
+    const idMatch = text.match(/(?:Kód transakce|Kod transakce)\s*:\s*([0-9]+)/i);
+    const dateMatch = text.match(
+      /(?:Datum zaúčtování|Datum zauctovani)\s*:\s*(\d{2}\.\d{2}\.\d{4}(?:\s+\d{2}:\d{2}(?::\d{2})?(?:\s*[+-]\d{2}:?\d{2})?)?)/i
+    );
+    let counter_account = null;
+    let bank_code = null;
+    let sender_name = null;
+    if (counterparty) {
+      sender_name = counterparty.senderName;
+      const rawAcc = counterparty.account;
+      const parts = rawAcc.split("/");
+      counter_account = _nullishCoalesce(parts[0], () => ( null));
+      bank_code = parts.length > 1 ? _nullishCoalesce(parts[1], () => ( null)) : null;
+    }
+    const { date, date_offset_min } = dateMatch ? parseDateToUTC(_nullishCoalesce(dateMatch[1], () => ( ""))) : { date: null, date_offset_min: null };
+    return {
+      amount_cents,
+      currency,
+      counter_account: counter_account || null,
+      bank_code: bank_code || null,
+      bank_name: bank_code ? _nullishCoalesce(BANK_CODES[bank_code], () => ( null)) : null,
+      vs: vsMatch ? _nullishCoalesce(vsMatch[1], () => ( null)) : null,
+      ks: ksMatch ? _nullishCoalesce(ksMatch[1], () => ( null)) : null,
+      ss: ssMatch ? _nullishCoalesce(ssMatch[1], () => ( null)) : null,
+      message: msgMatch ? (_nullishCoalesce(msgMatch[1], () => ( ""))).trim() || null : null,
+      sender_name,
+      user_identification: null,
+      transaction_type: null,
+      performed_by: null,
+      comment: null,
+      command_id: null,
+      source: "email",
+      date,
+      date_offset_min,
+      transaction_id: idMatch ? _nullishCoalesce(idMatch[1], () => ( null)) : null,
+      external_id: null
+    };
+  }
+  return null;
+}
+
+// src/iso11649.ts
+function mod97(numeric) {
+  let remainder = 0;
+  for (let index = 0; index < numeric.length; index += 7) {
+    remainder = Number(String(remainder) + numeric.slice(index, index + 7)) % 97;
+  }
+  return remainder;
+}
+function toNumeric(value) {
+  let output = "";
+  for (const character of value) {
+    const code = character.charCodeAt(0);
+    if (code >= 48 && code <= 57) output += character;
+    else if (code >= 65 && code <= 90) output += String(code - 55);
+    else return "";
+  }
+  return output;
+}
+function encodeRf(input) {
+  const payload = input.trim().toUpperCase();
+  const numeric = toNumeric(payload + "RF00");
+  if (!numeric) throw new TypeError("ISO 11649 payload must be alphanumeric");
+  const checkDigits = 98 - mod97(numeric);
+  return "RF" + String(checkDigits).padStart(2, "0") + payload;
+}
+function decodeRf(input) {
+  if (typeof input !== "string") return null;
+  const reference = input.replace(/\s+/g, "").toUpperCase();
+  if (!/^RF\d{2}[0-9A-Z]+$/.test(reference)) return null;
+  const numeric = toNumeric(reference.slice(4) + reference.slice(0, 4));
+  if (!numeric || mod97(numeric) !== 1) return null;
+  return reference.slice(4);
+}
+
+// src/referenceCandidates.ts
+var MAX_CANDIDATES = 5;
+function normalizeText(s) {
+  return s.normalize("NFKD").replace(/[̀-ͯ]/g, "").toUpperCase();
+}
+function validVs(value) {
+  const normalized = _nullishCoalesce(_optionalChain([value, 'optionalAccess', _ => _.trim, 'call', _2 => _2()]), () => ( ""));
+  return /^\d{1,10}$/.test(normalized) ? normalized : null;
+}
+function rfCores(text) {
+  const compact = normalizeText(text).replace(/\s+/g, "");
+  const cores = [];
+  for (const match of compact.matchAll(/RF\d{3,12}(?!\d)/g)) {
+    const decoded = decodeRf(match[0]);
+    if (decoded && /^\d{1,10}$/.test(decoded) && !cores.includes(decoded)) {
+      cores.push(decoded);
+    }
+  }
+  return cores;
+}
+function resolveVariableSymbol(src) {
+  const structured = validVs(src.vs);
+  if (structured) return structured;
+  for (const text of [src.vs, src.message, src.ss, src.user_identification, src.comment]) {
+    if (typeof text !== "string") continue;
+    const [decoded] = rfCores(text);
+    if (decoded) return decoded;
+  }
+  return null;
+}
+function extractReferenceCandidates(src) {
+  const out = [];
+  const push = (v) => {
+    if (!v) return;
+    const t = v.trim();
+    if (t && !out.includes(t)) out.push(t);
+  };
+  push(_nullishCoalesce(validVs(src.vs), () => ( void 0)));
+  const texts = [src.message, src.ss, src.user_identification, src.comment].filter((x) => typeof x === "string" && x.length > 0).map(normalizeText);
+  for (const t of texts) {
+    const compact = t.replace(/\s+/g, "");
+    for (const m of compact.matchAll(/VS[:/]?(\d{4,10})/g)) push(m[1]);
+    for (const core of rfCores(t)) push(core);
+  }
+  for (const t of texts) {
+    for (const m of t.matchAll(/(?<!\d)(\d{6,10})(?!\d)/g)) push(m[1]);
+  }
+  return out.slice(0, MAX_CANDIDATES);
+}
+
+// src/relay.ts
+function hex(buffer) {
+  return Array.from(new Uint8Array(buffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function concatBytes(...parts) {
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function buildWebhookEnvelope(args) {
+  return {
+    event: "transaction.received",
+    event_version: "1",
+    delivery_id: args.delivery_id,
+    pairing_code: args.pairing_code,
+    data: args.transaction
+  };
+}
+async function signWebhook(args) {
+  const timestamp = _nullishCoalesce(args.timestamp, () => ( Math.floor(Date.now() / 1e3)));
+  const enc = new TextEncoder();
+  const bodyBytes = enc.encode(JSON.stringify(args.envelope));
+  const signingInput = concatBytes(
+    enc.encode(String(timestamp)),
+    new Uint8Array([46]),
+    enc.encode(args.envelope.delivery_id),
+    new Uint8Array([46]),
+    bodyBytes
+  );
+  const secretBytes = enc.encode(args.secret);
+  const key = await globalThis.crypto.subtle.importKey(
+    "raw",
+    secretBytes.buffer,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const mac = await globalThis.crypto.subtle.sign("HMAC", key, signingInput.buffer);
+  return {
+    bodyBytes,
+    headers: {
+      "Content-Type": "application/json",
+      "X-BankSync-Timestamp": String(timestamp),
+      "X-BankSync-Delivery-Id": args.envelope.delivery_id,
+      "X-BankSync-Signature": "sha256=" + hex(mac)
+    }
+  };
+}
+var WebhookVerificationError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "WebhookVerificationError";
+  }
+  
+};
+function isNullableString(value) {
+  return value === null || typeof value === "string";
+}
+function isPositiveSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isTransaction(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const data = value;
+  const nullableStrings = [
+    "counter_account",
+    "bank_code",
+    "bank_name",
+    "vs",
+    "ks",
+    "ss",
+    "message",
+    "sender_name",
+    "user_identification",
+    "transaction_type",
+    "performed_by",
+    "comment",
+    "command_id",
+    "transaction_id",
+    "external_id"
+  ];
+  return isPositiveSafeInteger(data.id) && isPositiveSafeInteger(data.bank_account_id) && isPositiveSafeInteger(data.amount_cents) && typeof data.currency === "string" && /^[A-Z]{3}$/.test(data.currency) && nullableStrings.every((field) => isNullableString(data[field])) && (data.source === "email" || data.source === "fio_api") && typeof data.date === "string" && data.date.length > 0 && (data.date_offset_min === null || typeof data.date_offset_min === "number" && Number.isSafeInteger(data.date_offset_min));
+}
+async function verifyWebhook(args) {
+  if (!/^\d{10}$/.test(args.timestamp)) throw new WebhookVerificationError("timestamp_invalid");
+  const timestamp = Number(args.timestamp);
+  const now = _nullishCoalesce(args.nowSeconds, () => ( Math.floor(Date.now() / 1e3)));
+  const tolerance = _nullishCoalesce(args.toleranceSeconds, () => ( 300));
+  if (!Number.isSafeInteger(timestamp) || Math.abs(now - timestamp) > tolerance) {
+    throw new WebhookVerificationError("timestamp_out_of_range");
+  }
+  if (!/^sha256=[0-9a-f]{64}$/i.test(args.signature)) {
+    throw new WebhookVerificationError("signature_invalid");
+  }
+  const encoder = new TextEncoder();
+  const signingInput = concatBytes(
+    encoder.encode(args.timestamp),
+    new Uint8Array([46]),
+    encoder.encode(args.deliveryId),
+    new Uint8Array([46]),
+    args.bodyBytes
+  );
+  const key = await globalThis.crypto.subtle.importKey(
+    "raw",
+    encoder.encode(args.secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const mac = await globalThis.crypto.subtle.sign(
+    "HMAC",
+    key,
+    signingInput.buffer
+  );
+  const expected = "sha256=" + hex(mac);
+  if (expected.length !== args.signature.length) throw new WebhookVerificationError("signature_invalid");
+  let difference = 0;
+  for (let index = 0; index < expected.length; index += 1) {
+    difference |= expected.charCodeAt(index) ^ args.signature.charCodeAt(index);
+  }
+  if (difference !== 0) throw new WebhookVerificationError("signature_invalid");
+  let envelope;
+  try {
+    envelope = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(args.bodyBytes));
+  } catch (e) {
+    throw new WebhookVerificationError("body_invalid");
+  }
+  if (!envelope || typeof envelope !== "object" || Array.isArray(envelope)) {
+    throw new WebhookVerificationError("body_invalid");
+  }
+  const value = envelope;
+  if (value.delivery_id !== args.deliveryId) throw new WebhookVerificationError("delivery_id_mismatch");
+  if (typeof value.delivery_id !== "string" || !/^[0-9A-HJKMNP-TV-Z]{26}$/.test(value.delivery_id)) {
+    throw new WebhookVerificationError("body_invalid");
+  }
+  if (value.event !== "transaction.received") throw new WebhookVerificationError("event_unsupported");
+  if (value.event_version !== "1") throw new WebhookVerificationError("event_version_unsupported");
+  if (typeof value.pairing_code !== "string" || !/^[0-9a-f]{10}$/i.test(value.pairing_code) || !isTransaction(value.data)) {
+    throw new WebhookVerificationError("body_invalid");
+  }
+  return envelope;
+}
+
+// src/fio.ts
+var FIO_BASE = "https://fioapi.fio.cz/v1/rest";
+var FioApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "FioApiError";
+  }
+  
+};
+var FioRateLimited = class extends FioApiError {
+  constructor(status, retryAfterS) {
+    super(`Fio API ${status}`, status);
+    this.retryAfterS = retryAfterS;
+    this.name = "FioRateLimited";
+  }
+  
+};
+var FioTransientFailure = class extends FioApiError {
+  constructor(status) {
+    super(`Fio API ${status}`, status);
+    this.name = "FioTransientFailure";
+  }
+};
+function endpoint(path, token) {
+  return `${FIO_BASE}/${path}/${encodeURIComponent(token)}`;
+}
+async function fioRequest(op, token, directUrl, proxy, date) {
+  if (_optionalChain([proxy, 'optionalAccess', _3 => _3.url]) && proxy.secret) {
+    return fetch(proxy.url, {
+      method: "POST",
+      headers: { "content-type": "application/json", "x-fio-proxy-secret": proxy.secret },
+      body: JSON.stringify(date === void 0 ? { op, token } : { op, token, date })
+    });
+  }
+  return fetch(directUrl);
+}
+function retryAfterSeconds(headers) {
+  const raw = headers.get("Retry-After");
+  if (!raw) return null;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : null;
+}
+async function ensureFioResponse(res) {
+  if (res.status === 429) {
+    throw new FioRateLimited(res.status, retryAfterSeconds(res.headers));
+  }
+  if (res.status >= 500) {
+    throw new FioTransientFailure(res.status);
+  }
+  if (!res.ok) {
+    throw new FioApiError(`Fio API ${res.status}`, res.status);
+  }
+}
+async function fetchNewTransactions(token, proxy) {
+  const res = await fioRequest("transactions", token, `${endpoint("last", token)}/transactions.json`, proxy);
+  await ensureFioResponse(res);
+  const json = await res.json();
+  const transactions = _nullishCoalesce(_optionalChain([json, 'access', _4 => _4.accountStatement, 'optionalAccess', _5 => _5.transactionList, 'optionalAccess', _6 => _6.transaction]), () => ( []));
+  return Array.isArray(transactions) ? transactions : [transactions];
+}
+async function setFioPointer(token, yyyyMmDd, proxy) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(yyyyMmDd)) {
+    throw new Error("invalid_fio_pointer_date");
+  }
+  const res = await fioRequest("set-last-date", token, `${endpoint("set-last-date", token)}/${yyyyMmDd}/`, proxy, yyyyMmDd);
+  await ensureFioResponse(res);
+}
+function column(raw, idx) {
+  const value = _optionalChain([raw, 'access', _7 => _7[`column${idx}`], 'optionalAccess', _8 => _8.value]);
+  if (value === null || value === void 0) return null;
+  const s = String(value).trim();
+  return s.length > 0 ? s : null;
+}
+function parseAmount2(raw) {
+  if (raw === null) return 0;
+  const normalized = raw.replace(/\s/g, "").replace(",", ".");
+  return Number.parseFloat(normalized);
+}
+function parseOffsetMinutes(raw) {
+  const m = raw.match(/([+-])(\d{2}):?(\d{2})$/);
+  if (!m) return null;
+  const sign = m[1] === "+" ? 1 : -1;
+  return sign * (Number.parseInt(_nullishCoalesce(m[2], () => ( "0")), 10) * 60 + Number.parseInt(_nullishCoalesce(m[3], () => ( "0")), 10));
+}
+function parseFioDate(raw) {
+  if (!raw) return { date: (/* @__PURE__ */ new Date()).toISOString(), date_offset_min: null };
+  const isoDateOnly = raw.match(/^(\d{4}-\d{2}-\d{2})(?:[+-]\d{2}:?\d{2})?$/);
+  if (isoDateOnly) {
+    return {
+      date: `${isoDateOnly[1]}T12:00:00.000Z`,
+      date_offset_min: parseOffsetMinutes(raw)
+    };
+  }
+  const czechDateOnly = raw.match(/^(\d{2})\.(\d{2})\.(\d{4})$/);
+  if (czechDateOnly) {
+    return {
+      date: `${czechDateOnly[3]}-${czechDateOnly[2]}-${czechDateOnly[1]}T12:00:00.000Z`,
+      date_offset_min: null
+    };
+  }
+  const parsed = new Date(raw);
+  if (!Number.isNaN(parsed.getTime())) {
+    return {
+      date: parsed.toISOString(),
+      date_offset_min: parseOffsetMinutes(raw)
+    };
+  }
+  throw new Error(`invalid_fio_date: ${JSON.stringify(raw)}`);
+}
+function mapFioTransaction(raw) {
+  const amount = parseAmount2(column(raw, 1));
+  if (!(amount > 0)) return null;
+  const currency = normalizeCurrency(_nullishCoalesce(column(raw, 14), () => ( "")));
+  const { date, date_offset_min } = parseFioDate(column(raw, 0));
+  return {
+    amount_cents: toCents(amount, currency),
+    currency,
+    counter_account: column(raw, 2),
+    bank_code: column(raw, 3),
+    bank_name: column(raw, 12),
+    vs: column(raw, 5),
+    ks: column(raw, 4),
+    ss: column(raw, 6),
+    message: column(raw, 16),
+    sender_name: column(raw, 10),
+    user_identification: column(raw, 7),
+    transaction_type: column(raw, 8),
+    performed_by: column(raw, 9),
+    comment: column(raw, 25),
+    command_id: column(raw, 17),
+    source: "fio_api",
+    date,
+    date_offset_min,
+    transaction_id: column(raw, 22),
+    external_id: null
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.normalizeCurrency = normalizeCurrency; exports.toCents = toCents; exports.BANK_CODES = BANK_CODES; exports.detectProvider = detectProvider; exports.parseEmail = parseEmail; exports.encodeRf = encodeRf; exports.decodeRf = decodeRf; exports.resolveVariableSymbol = resolveVariableSymbol; exports.extractReferenceCandidates = extractReferenceCandidates; exports.buildWebhookEnvelope = buildWebhookEnvelope; exports.signWebhook = signWebhook; exports.WebhookVerificationError = WebhookVerificationError; exports.verifyWebhook = verifyWebhook; exports.FioApiError = FioApiError; exports.FioRateLimited = FioRateLimited; exports.FioTransientFailure = FioTransientFailure; exports.fetchNewTransactions = fetchNewTransactions; exports.setFioPointer = setFioPointer; exports.mapFioTransaction = mapFioTransaction;