@f-o-t/ofx 2.4.2 → 2.4.6

package/dist/index.js

@@ -0,0 +1,1260 @@
+// @bun
+// src/utils.ts
+var toArray = (value) => Array.isArray(value) ? value : [value];
+var ENTITY_MAP = {
+  "&": "&",
+  "'": "'",
+  ">": ">",
+  "&lt;": "<",
+  "&quot;": '"'
+};
+var ENTITY_REGEX = /&(?:amp|lt|gt|quot|apos);/g;
+function decodeEntities(text) {
+  if (!text.includes("&"))
+    return text;
+  return text.replace(ENTITY_REGEX, (match) => ENTITY_MAP[match] ?? match);
+}
+var pad = (n, width = 2) => n.toString().padStart(width, "0");
+function escapeOfxText(text) {
+  if (!text.includes("&") && !text.includes("<") && !text.includes(">")) {
+    return text;
+  }
+  return text.replace(/[&<>]/g, (c) => c === "&" ? "&amp;" : c === "<" ? "&lt;" : "&gt;");
+}
+function formatAmount(amount) {
+  const rounded = Math.round(amount * 100) / 100;
+  const [intPart, decPart = ""] = rounded.toString().split(".");
+  return `${intPart}.${decPart.padEnd(2, "0").slice(0, 2)}`;
+}
+function formatOfxDate(date, timezone) {
+  const tz = timezone ?? { name: "GMT", offset: 0 };
+  const offsetMs = tz.offset * 60 * 60 * 1000;
+  const adjustedDate = new Date(date.getTime() + offsetMs);
+  const year = adjustedDate.getUTCFullYear();
+  const month = pad(adjustedDate.getUTCMonth() + 1);
+  const day = pad(adjustedDate.getUTCDate());
+  const hour = pad(adjustedDate.getUTCHours());
+  const minute = pad(adjustedDate.getUTCMinutes());
+  const second = pad(adjustedDate.getUTCSeconds());
+  const sign = tz.offset >= 0 ? "+" : "";
+  return `${year}${month}${day}${hour}${minute}${second}[${sign}${tz.offset}:${tz.name}]`;
+}
+
+// src/extractors.ts
+function getTransactions(document) {
+  const results = [];
+  const bankResponse = document.OFX.BANKMSGSRSV1?.STMTTRNRS;
+  if (bankResponse) {
+    for (const r of toArray(bankResponse)) {
+      const txns = r.STMTRS?.BANKTRANLIST?.STMTTRN;
+      if (txns)
+        results.push(...txns);
+    }
+  }
+  const ccResponse = document.OFX.CREDITCARDMSGSRSV1?.CCSTMTTRNRS;
+  if (ccResponse) {
+    for (const r of toArray(ccResponse)) {
+      const txns = r.CCSTMTRS?.BANKTRANLIST?.STMTTRN;
+      if (txns)
+        results.push(...txns);
+    }
+  }
+  return results;
+}
+function getAccountInfo(document) {
+  const results = [];
+  const bankResponse = document.OFX.BANKMSGSRSV1?.STMTTRNRS;
+  if (bankResponse) {
+    for (const r of toArray(bankResponse)) {
+      const account = r.STMTRS?.BANKACCTFROM;
+      if (account)
+        results.push(account);
+    }
+  }
+  const ccResponse = document.OFX.CREDITCARDMSGSRSV1?.CCSTMTTRNRS;
+  if (ccResponse) {
+    for (const r of toArray(ccResponse)) {
+      const account = r.CCSTMTRS?.CCACCTFROM;
+      if (account)
+        results.push(account);
+    }
+  }
+  return results;
+}
+function getBalance(document) {
+  const results = [];
+  const bankResponse = document.OFX.BANKMSGSRSV1?.STMTTRNRS;
+  if (bankResponse) {
+    for (const r of toArray(bankResponse)) {
+      if (r.STMTRS) {
+        results.push({
+          available: r.STMTRS.AVAILBAL,
+          ledger: r.STMTRS.LEDGERBAL
+        });
+      }
+    }
+  }
+  const ccResponse = document.OFX.CREDITCARDMSGSRSV1?.CCSTMTTRNRS;
+  if (ccResponse) {
+    for (const r of toArray(ccResponse)) {
+      if (r.CCSTMTRS) {
+        results.push({
+          available: r.CCSTMTRS.AVAILBAL,
+          ledger: r.CCSTMTRS.LEDGERBAL
+        });
+      }
+    }
+  }
+  return results;
+}
+function getSignOnInfo(document) {
+  return document.OFX.SIGNONMSGSRSV1.SONRS;
+}
+// src/generator.ts
+import { z as z2 } from "zod";
+
+// src/schemas.ts
+import { z } from "zod";
+var toFloat = (val) => Number.parseFloat(val);
+var dateComponentsSchema = z.object({
+  year: z.number(),
+  month: z.number(),
+  day: z.number(),
+  hour: z.number(),
+  minute: z.number(),
+  second: z.number()
+});
+var DATE_REGEX = /^(\d{4})(\d{2})(\d{2})(\d{2})?(\d{2})?(\d{2})?/;
+var TIMEZONE_REGEX = /\[([+-]?\d+):(\w+)\]/;
+function parseDateComponents(val) {
+  const m = DATE_REGEX.exec(val);
+  if (!m)
+    return { day: 0, hour: 0, minute: 0, month: 0, second: 0, year: 0 };
+  return {
+    day: +m[3],
+    hour: +(m[4] || 0),
+    minute: +(m[5] || 0),
+    month: +m[2],
+    second: +(m[6] || 0),
+    year: +m[1]
+  };
+}
+function parseTimezone(val) {
+  const match = TIMEZONE_REGEX.exec(val);
+  return {
+    name: match?.[2] ?? "UTC",
+    offset: match ? +match[1] : 0
+  };
+}
+var ofxDateSchema = z.string().transform((val) => {
+  const components = parseDateComponents(val);
+  const timezone = parseTimezone(val);
+  return {
+    ...components,
+    raw: val,
+    timezone,
+    toDate() {
+      const offsetMs = timezone.offset * 60 * 60 * 1000;
+      return new Date(Date.UTC(components.year, components.month - 1, components.day, components.hour, components.minute, components.second) - offsetMs);
+    }
+  };
+});
+var statusSchema = z.object({
+  CODE: z.string(),
+  MESSAGE: z.string().optional(),
+  SEVERITY: z.enum(["INFO", "WARN", "ERROR"])
+});
+var financialInstitutionSchema = z.object({
+  FID: z.string().optional(),
+  ORG: z.string().optional()
+});
+var transactionTypeSchema = z.enum([
+  "CREDIT",
+  "DEBIT",
+  "INT",
+  "DIV",
+  "FEE",
+  "SRVCHG",
+  "DEP",
+  "ATM",
+  "POS",
+  "XFER",
+  "CHECK",
+  "PAYMENT",
+  "CASH",
+  "DIRECTDEP",
+  "DIRECTDEBIT",
+  "REPEATPMT",
+  "HOLD",
+  "OTHER"
+]);
+var transactionSchema = z.object({
+  CHECKNUM: z.string().optional(),
+  CORRECTACTION: z.enum(["DELETE", "REPLACE"]).optional(),
+  CORRECTFITID: z.string().optional(),
+  CURRENCY: z.string().optional(),
+  DTAVAIL: ofxDateSchema.optional(),
+  DTPOSTED: ofxDateSchema,
+  DTUSER: ofxDateSchema.optional(),
+  FITID: z.string().optional(),
+  MEMO: z.string().optional(),
+  NAME: z.string().optional(),
+  PAYEEID: z.string().optional(),
+  REFNUM: z.string().optional(),
+  SIC: z.string().optional(),
+  SRVRTID: z.string().optional(),
+  TRNAMT: z.string().transform(toFloat),
+  TRNTYPE: transactionTypeSchema
+});
+var accountTypeSchema = z.enum([
+  "CHECKING",
+  "SAVINGS",
+  "MONEYMRKT",
+  "CREDITLINE",
+  "CD"
+]);
+var extendedAccountTypeSchema = z.enum([
+  "CHECKING",
+  "SAVINGS",
+  "MONEYMRKT",
+  "CREDITLINE",
+  "CD",
+  "CREDITCARD"
+]);
+var bankAccountSchema = z.object({
+  ACCTID: z.string(),
+  ACCTKEY: z.string().optional(),
+  ACCTTYPE: accountTypeSchema,
+  BANKID: z.string(),
+  BRANCHID: z.string().optional()
+});
+var flexibleBankAccountSchema = z.object({
+  ACCTID: z.string(),
+  ACCTKEY: z.string().optional(),
+  ACCTTYPE: extendedAccountTypeSchema.optional(),
+  BANKID: z.string().optional(),
+  BRANCHID: z.string().optional()
+});
+var creditCardAccountSchema = z.object({
+  ACCTID: z.string(),
+  ACCTKEY: z.string().optional()
+});
+var balanceSchema = z.object({
+  BALAMT: z.string().transform(toFloat),
+  DTASOF: ofxDateSchema
+});
+var transactionListSchema = z.object({
+  DTEND: ofxDateSchema,
+  DTSTART: ofxDateSchema,
+  STMTTRN: z.array(transactionSchema).default([])
+});
+var bankStatementResponseSchema = z.object({
+  AVAILBAL: balanceSchema.optional(),
+  BANKACCTFROM: bankAccountSchema,
+  BANKTRANLIST: transactionListSchema.optional(),
+  CURDEF: z.string().default("USD"),
+  LEDGERBAL: balanceSchema.optional(),
+  MKTGINFO: z.string().optional()
+});
+var creditCardStatementResponseSchema = z.object({
+  AVAILBAL: balanceSchema.optional(),
+  BANKACCTFROM: flexibleBankAccountSchema.optional(),
+  BANKTRANLIST: transactionListSchema.optional(),
+  CCACCTFROM: creditCardAccountSchema.optional(),
+  CURDEF: z.string().default("USD"),
+  LEDGERBAL: balanceSchema.optional(),
+  MKTGINFO: z.string().optional()
+}).refine((data) => data.CCACCTFROM || data.BANKACCTFROM, {
+  message: "Either CCACCTFROM or BANKACCTFROM is required"
+});
+var signOnResponseSchema = z.object({
+  ACCESSKEY: z.string().optional(),
+  DTSERVER: ofxDateSchema,
+  FI: financialInstitutionSchema.optional(),
+  LANGUAGE: z.string().default("ENG"),
+  SESSCOOKIE: z.string().optional(),
+  STATUS: statusSchema
+});
+var bankStatementTransactionResponseSchema = z.object({
+  STATUS: statusSchema.optional(),
+  STMTRS: bankStatementResponseSchema.optional(),
+  TRNUID: z.string().optional()
+});
+var creditCardStatementTransactionResponseSchema = z.object({
+  CCSTMTRS: creditCardStatementResponseSchema.optional(),
+  STATUS: statusSchema.optional(),
+  TRNUID: z.string().optional()
+});
+var singleOrArray = (schema) => z.union([schema, z.array(schema)]).optional();
+var bankMessageSetResponseSchema = z.object({
+  STMTTRNRS: singleOrArray(bankStatementTransactionResponseSchema)
+});
+var creditCardMessageSetResponseSchema = z.object({
+  CCSTMTTRNRS: singleOrArray(creditCardStatementTransactionResponseSchema)
+});
+var signOnMessageSetResponseSchema = z.object({
+  SONRS: signOnResponseSchema
+});
+var ofxResponseSchema = z.object({
+  BANKMSGSRSV1: bankMessageSetResponseSchema.optional(),
+  CREDITCARDMSGSRSV1: creditCardMessageSetResponseSchema.optional(),
+  SIGNONMSGSRSV1: signOnMessageSetResponseSchema
+});
+var ofxHeaderSchema = z.object({
+  CHARSET: z.string().optional(),
+  COMPRESSION: z.string().optional(),
+  DATA: z.string().optional(),
+  ENCODING: z.string().optional(),
+  NEWFILEUID: z.string().optional(),
+  OFXHEADER: z.string().optional(),
+  OLDFILEUID: z.string().optional(),
+  SECURITY: z.string().optional(),
+  VERSION: z.string().optional()
+});
+var ofxDocumentSchema = z.object({
+  header: ofxHeaderSchema,
+  OFX: ofxResponseSchema
+});
+
+// src/generator.ts
+var generateHeaderOptionsSchema = z2.object({
+  version: z2.string().optional(),
+  encoding: z2.string().optional(),
+  charset: z2.string().optional()
+}).optional();
+function generateHeader(options) {
+  const version = options?.version ?? "100";
+  const encoding = options?.encoding ?? "USASCII";
+  const charset = options?.charset ?? "1252";
+  return [
+    "OFXHEADER:100",
+    "DATA:OFXSGML",
+    `VERSION:${version}`,
+    "SECURITY:NONE",
+    `ENCODING:${encoding}`,
+    `CHARSET:${charset}`,
+    "COMPRESSION:NONE",
+    "OLDFILEUID:NONE",
+    "NEWFILEUID:NONE",
+    ""
+  ].join(`
+`);
+}
+var generateTransactionInputSchema = z2.object({
+  type: transactionTypeSchema,
+  datePosted: z2.date(),
+  amount: z2.number(),
+  fitId: z2.string().min(1),
+  name: z2.string().optional(),
+  memo: z2.string().optional(),
+  checkNum: z2.string().optional(),
+  refNum: z2.string().optional()
+});
+function generateTransaction(trn) {
+  const lines = [
+    "<STMTTRN>",
+    `<TRNTYPE>${trn.type}`,
+    `<DTPOSTED>${formatOfxDate(trn.datePosted)}`,
+    `<TRNAMT>${formatAmount(trn.amount)}`,
+    `<FITID>${escapeOfxText(trn.fitId)}`
+  ];
+  if (trn.name) {
+    lines.push(`<NAME>${escapeOfxText(trn.name)}`);
+  }
+  if (trn.memo) {
+    lines.push(`<MEMO>${escapeOfxText(trn.memo)}`);
+  }
+  if (trn.checkNum) {
+    lines.push(`<CHECKNUM>${escapeOfxText(trn.checkNum)}`);
+  }
+  if (trn.refNum) {
+    lines.push(`<REFNUM>${escapeOfxText(trn.refNum)}`);
+  }
+  lines.push("</STMTTRN>");
+  return lines.join(`
+`);
+}
+var balanceSchema2 = z2.object({
+  amount: z2.number(),
+  asOfDate: z2.date()
+});
+var financialInstitutionSchema2 = z2.object({
+  org: z2.string().optional(),
+  fid: z2.string().optional()
+});
+var generateBankStatementOptionsSchema = z2.object({
+  bankId: z2.string().min(1),
+  accountId: z2.string().min(1),
+  accountType: accountTypeSchema,
+  currency: z2.string().min(1),
+  startDate: z2.date(),
+  endDate: z2.date(),
+  transactions: z2.array(generateTransactionInputSchema),
+  ledgerBalance: balanceSchema2.optional(),
+  availableBalance: balanceSchema2.optional(),
+  financialInstitution: financialInstitutionSchema2.optional(),
+  language: z2.string().optional()
+});
+function generateBankStatement(options) {
+  const parts = [generateHeader()];
+  const serverDate = formatOfxDate(new Date);
+  const language = options.language ?? "POR";
+  parts.push(`<OFX>
+<SIGNONMSGSRSV1>
+<SONRS>
+<STATUS>
+<CODE>0
+<SEVERITY>INFO
+</STATUS>
+<DTSERVER>${serverDate}
+<LANGUAGE>${language}`);
+  if (options.financialInstitution) {
+    parts.push("<FI>");
+    if (options.financialInstitution.org) {
+      parts.push(`<ORG>${escapeOfxText(options.financialInstitution.org)}`);
+    }
+    if (options.financialInstitution.fid) {
+      parts.push(`<FID>${escapeOfxText(options.financialInstitution.fid)}`);
+    }
+    parts.push("</FI>");
+  }
+  parts.push(`</SONRS>
+</SIGNONMSGSRSV1>
+<BANKMSGSRSV1>
+<STMTTRNRS>
+<TRNUID>0
+<STATUS>
+<CODE>0
+<SEVERITY>INFO
+</STATUS>
+<STMTRS>
+<CURDEF>${options.currency}
+<BANKACCTFROM>
+<BANKID>${escapeOfxText(options.bankId)}
+<ACCTID>${escapeOfxText(options.accountId)}
+<ACCTTYPE>${options.accountType}
+</BANKACCTFROM>
+<BANKTRANLIST>
+<DTSTART>${formatOfxDate(options.startDate)}
+<DTEND>${formatOfxDate(options.endDate)}`);
+  for (const trn of options.transactions) {
+    parts.push(generateTransaction(trn));
+  }
+  parts.push("</BANKTRANLIST>");
+  if (options.ledgerBalance) {
+    parts.push(`<LEDGERBAL>
+<BALAMT>${formatAmount(options.ledgerBalance.amount)}
+<DTASOF>${formatOfxDate(options.ledgerBalance.asOfDate)}
+</LEDGERBAL>`);
+  }
+  if (options.availableBalance) {
+    parts.push(`<AVAILBAL>
+<BALAMT>${formatAmount(options.availableBalance.amount)}
+<DTASOF>${formatOfxDate(options.availableBalance.asOfDate)}
+</AVAILBAL>`);
+  }
+  parts.push(`</STMTRS>
+</STMTTRNRS>
+</BANKMSGSRSV1>
+</OFX>`);
+  return parts.join(`
+`);
+}
+var generateCreditCardStatementOptionsSchema = z2.object({
+  accountId: z2.string().min(1),
+  currency: z2.string().min(1),
+  startDate: z2.date(),
+  endDate: z2.date(),
+  transactions: z2.array(generateTransactionInputSchema),
+  ledgerBalance: balanceSchema2.optional(),
+  availableBalance: balanceSchema2.optional(),
+  financialInstitution: financialInstitutionSchema2.optional(),
+  language: z2.string().optional()
+});
+function generateCreditCardStatement(options) {
+  const parts = [generateHeader()];
+  const serverDate = formatOfxDate(new Date);
+  const language = options.language ?? "POR";
+  parts.push(`<OFX>
+<SIGNONMSGSRSV1>
+<SONRS>
+<STATUS>
+<CODE>0
+<SEVERITY>INFO
+</STATUS>
+<DTSERVER>${serverDate}
+<LANGUAGE>${language}`);
+  if (options.financialInstitution) {
+    parts.push("<FI>");
+    if (options.financialInstitution.org) {
+      parts.push(`<ORG>${escapeOfxText(options.financialInstitution.org)}`);
+    }
+    if (options.financialInstitution.fid) {
+      parts.push(`<FID>${escapeOfxText(options.financialInstitution.fid)}`);
+    }
+    parts.push("</FI>");
+  }
+  parts.push(`</SONRS>
+</SIGNONMSGSRSV1>
+<CREDITCARDMSGSRSV1>
+<CCSTMTTRNRS>
+<TRNUID>0
+<STATUS>
+<CODE>0
+<SEVERITY>INFO
+</STATUS>
+<CCSTMTRS>
+<CURDEF>${options.currency}
+<CCACCTFROM>
+<ACCTID>${escapeOfxText(options.accountId)}
+</CCACCTFROM>
+<BANKTRANLIST>
+<DTSTART>${formatOfxDate(options.startDate)}
+<DTEND>${formatOfxDate(options.endDate)}`);
+  for (const trn of options.transactions) {
+    parts.push(generateTransaction(trn));
+  }
+  parts.push("</BANKTRANLIST>");
+  if (options.ledgerBalance) {
+    parts.push(`<LEDGERBAL>
+<BALAMT>${formatAmount(options.ledgerBalance.amount)}
+<DTASOF>${formatOfxDate(options.ledgerBalance.asOfDate)}
+</LEDGERBAL>`);
+  }
+  if (options.availableBalance) {
+    parts.push(`<AVAILBAL>
+<BALAMT>${formatAmount(options.availableBalance.amount)}
+<DTASOF>${formatOfxDate(options.availableBalance.asOfDate)}
+</AVAILBAL>`);
+  }
+  parts.push(`</CCSTMTRS>
+</CCSTMTTRNRS>
+</CREDITCARDMSGSRSV1>
+</OFX>`);
+  return parts.join(`
+`);
+}
+// src/parser.ts
+import { z as z3 } from "zod";
+var CHARSET_MAP = {
+  "1252": "windows-1252",
+  "WINDOWS-1252": "windows-1252",
+  CP1252: "windows-1252",
+  "8859-1": "windows-1252",
+  "ISO-8859-1": "windows-1252",
+  LATIN1: "windows-1252",
+  "LATIN-1": "windows-1252",
+  "UTF-8": "utf-8",
+  UTF8: "utf-8",
+  NONE: "utf-8",
+  "": "utf-8"
+};
+function getEncodingFromCharset(charset) {
+  if (!charset)
+    return "utf-8";
+  const normalized = charset.toUpperCase().trim();
+  return CHARSET_MAP[normalized] ?? "windows-1252";
+}
+function addToContent(content, key, value) {
+  if (key === "__proto__" || key === "constructor" || key === "prototype") {
+    return;
+  }
+  const existing = content[key];
+  if (existing !== undefined) {
+    if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      content[key] = [existing, value];
+    }
+  } else {
+    content[key] = value;
+  }
+}
+function sgmlToObject(sgml) {
+  const result = {};
+  const tagStack = [{ content: result, name: "root" }];
+  const stackMap = new Map([["root", 0]]);
+  const hasSpecialContent = sgml.includes("<?") || sgml.includes("<!--");
+  const cleanSgml = hasSpecialContent ? sgml.replace(/<\?.*?\?>|<!--.*?-->/gs, "").trim() : sgml.trim();
+  const tagRegex = /<(\/?)([\w.]+)>([^<]*)/g;
+  let match = tagRegex.exec(cleanSgml);
+  while (match !== null) {
+    const isClosing = match[1];
+    const tagName = match[2];
+    const textContent = match[3]?.trim() ?? "";
+    if (!tagName) {
+      match = tagRegex.exec(cleanSgml);
+      continue;
+    }
+    const current = tagStack[tagStack.length - 1];
+    if (!current) {
+      match = tagRegex.exec(cleanSgml);
+      continue;
+    }
+    if (isClosing) {
+      const stackIndex = stackMap.get(tagName);
+      if (stackIndex !== undefined && stackIndex > 0) {
+        for (let i = tagStack.length - 1;i >= stackIndex; i--) {
+          const item = tagStack[i];
+          if (item)
+            stackMap.delete(item.name);
+        }
+        tagStack.length = stackIndex;
+      }
+    } else if (textContent) {
+      const decoded = textContent.includes("&") ? decodeEntities(textContent) : textContent;
+      addToContent(current.content, tagName, decoded);
+    } else {
+      const newObj = {};
+      addToContent(current.content, tagName, newObj);
+      stackMap.set(tagName, tagStack.length);
+      tagStack.push({ content: newObj, name: tagName });
+    }
+    match = tagRegex.exec(cleanSgml);
+  }
+  return result;
+}
+function generateFitId(txn, index) {
+  const date = String(txn.DTPOSTED ?? "");
+  const amount = String(txn.TRNAMT ?? "0");
+  const name = String(txn.NAME ?? txn.MEMO ?? "");
+  const input = `${date}:${amount}:${name}:${index}`;
+  let hash = 0;
+  for (let i = 0;i < input.length; i++) {
+    hash = (hash << 5) - hash + input.charCodeAt(i);
+    hash = hash | 0;
+  }
+  return `AUTO${Math.abs(hash).toString(16).toUpperCase().padStart(8, "0")}`;
+}
+function normalizeResponseArray(msgs, responseKey, statementKey) {
+  const responses = msgs[responseKey];
+  if (!responses)
+    return;
+  for (const response of toArray(responses)) {
+    const stmt = response?.[statementKey];
+    const tranList = stmt?.BANKTRANLIST;
+    if (tranList?.STMTTRN !== undefined) {
+      tranList.STMTTRN = toArray(tranList.STMTTRN);
+      const transactions = tranList.STMTTRN;
+      transactions.forEach((txn, idx) => {
+        if (!txn.FITID) {
+          txn.FITID = generateFitId(txn, idx);
+        }
+      });
+    }
+  }
+}
+function normalizeSignOn(data) {
+  const ofx = data.OFX;
+  if (!ofx)
+    return;
+  const signonMsgs = ofx.SIGNONMSGSRSV1;
+  const sonrs = signonMsgs?.SONRS;
+  if (!sonrs)
+    return;
+  const status = sonrs.STATUS;
+  if (!status)
+    return;
+  if (!sonrs.DTSERVER && status.DTSERVER) {
+    sonrs.DTSERVER = status.DTSERVER;
+    delete status.DTSERVER;
+  }
+  if (!sonrs.LANGUAGE && status.LANGUAGE) {
+    sonrs.LANGUAGE = status.LANGUAGE;
+    delete status.LANGUAGE;
+  }
+}
+function normalizeTransactions(data) {
+  const ofx = data.OFX;
+  if (!ofx)
+    return data;
+  normalizeSignOn(data);
+  const bankMsgs = ofx.BANKMSGSRSV1;
+  if (bankMsgs) {
+    normalizeResponseArray(bankMsgs, "STMTTRNRS", "STMTRS");
+  }
+  const ccMsgs = ofx.CREDITCARDMSGSRSV1;
+  if (ccMsgs) {
+    normalizeResponseArray(ccMsgs, "CCSTMTTRNRS", "CCSTMTRS");
+  }
+  return data;
+}
+function parseHeader(content) {
+  const lines = content.split(/\r?\n/);
+  const header = {};
+  let bodyStartIndex = 0;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i]?.trim() ?? "";
+    if (line.startsWith("<?xml") || line.startsWith("<OFX>")) {
+      bodyStartIndex = i;
+      break;
+    }
+    const match = line.match(/^(\w+):(.*)$/);
+    if (match?.[1] && match[2] !== undefined) {
+      header[match[1]] = match[2];
+    }
+    if (line === "" && Object.keys(header).length > 0) {
+      bodyStartIndex = i + 1;
+      break;
+    }
+  }
+  const body = lines.slice(bodyStartIndex).join(`
+`);
+  return { body, header: ofxHeaderSchema.parse(header) };
+}
+function parse(content) {
+  try {
+    if (typeof content !== "string") {
+      return {
+        error: new z3.ZodError([
+          {
+            code: "invalid_type",
+            expected: "string",
+            message: `Expected string, received ${typeof content}`,
+            path: []
+          }
+        ]),
+        success: false
+      };
+    }
+    if (content.trim() === "") {
+      return {
+        error: new z3.ZodError([
+          {
+            code: "custom",
+            message: "Content cannot be empty",
+            path: []
+          }
+        ]),
+        success: false
+      };
+    }
+    const { header, body } = parseHeader(content);
+    const rawData = sgmlToObject(body);
+    const normalizedData = normalizeTransactions(rawData);
+    const parseResult = ofxResponseSchema.safeParse(normalizedData.OFX);
+    if (!parseResult.success) {
+      return { error: parseResult.error, success: false };
+    }
+    return {
+      data: { header, OFX: parseResult.data },
+      success: true
+    };
+  } catch (err) {
+    if (err instanceof z3.ZodError) {
+      return { error: err, success: false };
+    }
+    throw err;
+  }
+}
+function parseOrThrow(content) {
+  const result = parse(content);
+  if (!result.success) {
+    throw result.error;
+  }
+  return result.data;
+}
+function isValidUtf8(buffer) {
+  let i = 0;
+  while (i < buffer.length) {
+    const byte = buffer[i];
+    if (byte === undefined)
+      break;
+    if (byte <= 127) {
+      i++;
+    } else if ((byte & 224) === 192) {
+      const b1 = buffer[i + 1];
+      if (i + 1 >= buffer.length || b1 === undefined || (b1 & 192) !== 128)
+        return false;
+      i += 2;
+    } else if ((byte & 240) === 224) {
+      const b1 = buffer[i + 1];
+      const b2 = buffer[i + 2];
+      if (i + 2 >= buffer.length || b1 === undefined || b2 === undefined || (b1 & 192) !== 128 || (b2 & 192) !== 128)
+        return false;
+      i += 3;
+    } else if ((byte & 248) === 240) {
+      const b1 = buffer[i + 1];
+      const b2 = buffer[i + 2];
+      const b3 = buffer[i + 3];
+      if (i + 3 >= buffer.length || b1 === undefined || b2 === undefined || b3 === undefined || (b1 & 192) !== 128 || (b2 & 192) !== 128 || (b3 & 192) !== 128)
+        return false;
+      i += 4;
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+function hasUtf8MultiByte(buffer) {
+  for (let i = 0;i < buffer.length; i++) {
+    const byte = buffer[i];
+    if (byte !== undefined && byte > 127) {
+      return true;
+    }
+  }
+  return false;
+}
+function parseHeaderFromBuffer(buffer) {
+  const maxHeaderSize = Math.min(buffer.length, 1000);
+  const headerSection = new TextDecoder("windows-1252").decode(buffer.slice(0, maxHeaderSize));
+  const header = {};
+  const singleLineMatch = headerSection.match(/^(OFXHEADER:\d+.*?)(?=<OFX|<\?xml)/is);
+  if (singleLineMatch?.[1]) {
+    const headerPart = singleLineMatch[1];
+    const fieldRegex = /(\w+):([^\s<]+)/g;
+    let fieldMatch = fieldRegex.exec(headerPart);
+    while (fieldMatch !== null) {
+      const key = fieldMatch[1];
+      const value = fieldMatch[2];
+      if (key && value !== undefined) {
+        header[key] = value;
+      }
+      fieldMatch = fieldRegex.exec(headerPart);
+    }
+  } else {
+    const lines = headerSection.split(/\r?\n/);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("<?xml") || trimmed.startsWith("<OFX")) {
+        break;
+      }
+      const match = trimmed.match(/^(\w+):(.*)$/);
+      if (match?.[1] && match[2] !== undefined) {
+        header[match[1]] = match[2];
+      }
+      if (trimmed === "" && Object.keys(header).length > 0) {
+        break;
+      }
+    }
+  }
+  const parsedHeader = ofxHeaderSchema.parse(header);
+  let encoding = getEncodingFromCharset(parsedHeader.CHARSET);
+  if (encoding !== "utf-8" && hasUtf8MultiByte(buffer) && isValidUtf8(buffer)) {
+    encoding = "utf-8";
+  }
+  return { encoding, header: parsedHeader };
+}
+function decodeOfxBuffer(buffer) {
+  const { encoding } = parseHeaderFromBuffer(buffer);
+  const decoder = new TextDecoder(encoding);
+  return decoder.decode(buffer);
+}
+function parseBuffer(buffer) {
+  try {
+    if (!(buffer instanceof Uint8Array)) {
+      return {
+        error: new z3.ZodError([
+          {
+            code: "invalid_type",
+            expected: "object",
+            message: "Expected Uint8Array",
+            path: []
+          }
+        ]),
+        success: false
+      };
+    }
+    if (buffer.length === 0) {
+      return {
+        error: new z3.ZodError([
+          {
+            code: "custom",
+            message: "Buffer cannot be empty",
+            path: []
+          }
+        ]),
+        success: false
+      };
+    }
+    const content = decodeOfxBuffer(buffer);
+    return parse(content);
+  } catch (err) {
+    if (err instanceof z3.ZodError) {
+      return { error: err, success: false };
+    }
+    throw err;
+  }
+}
+function parseBufferOrThrow(buffer) {
+  const result = parseBuffer(buffer);
+  if (!result.success) {
+    throw result.error;
+  }
+  return result.data;
+}
+// src/stream.ts
+function parseHeaderFromBuffer2(buffer) {
+  const lines = buffer.split(/\r?\n/);
+  const header = {};
+  let bodyStartIndex = 0;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i]?.trim() ?? "";
+    if (line.startsWith("<?xml") || line.startsWith("<OFX>")) {
+      bodyStartIndex = i;
+      break;
+    }
+    const match = line.match(/^(\w+):(.*)$/);
+    if (match?.[1] && match[2] !== undefined) {
+      header[match[1]] = match[2];
+    }
+    if (line === "" && Object.keys(header).length > 0) {
+      bodyStartIndex = i + 1;
+      break;
+    }
+  }
+  if (Object.keys(header).length === 0)
+    return null;
+  const headerResult = ofxHeaderSchema.safeParse(header);
+  if (!headerResult.success)
+    return null;
+  const bodyStartChar = lines.slice(0, bodyStartIndex).join(`
+`).length + 1;
+  return { bodyStart: bodyStartChar, header: headerResult.data };
+}
+function tryParseTransaction(obj) {
+  const result = transactionSchema.safeParse(obj);
+  return result.success ? result.data : null;
+}
+function tryParseBankAccount(obj) {
+  const result = bankAccountSchema.safeParse(obj);
+  return result.success ? result.data : null;
+}
+function tryParseCreditCardAccount(obj) {
+  const result = creditCardAccountSchema.safeParse(obj);
+  return result.success ? result.data : null;
+}
+function tryParseBalance(obj) {
+  const result = balanceSchema.safeParse(obj);
+  return result.success ? result.data : null;
+}
+async function* parseStream(input, options) {
+  const state = {
+    buffer: "",
+    currentObject: {},
+    currentPath: [],
+    headerParsed: false,
+    inHeader: true,
+    objectStack: [{}],
+    transactionCount: 0
+  };
+  let detectedEncoding = options?.encoding;
+  let decoder = new TextDecoder(detectedEncoding ?? "utf-8");
+  const tagRegex = /<(\/?)([\w.]+)>([^<]*)/g;
+  let pendingLedgerBalance;
+  let pendingAvailableBalance;
+  let emittedBalanceForCurrentStatement = false;
+  async function* processChunk(chunk, isLast = false) {
+    state.buffer += chunk;
+    if (!state.headerParsed) {
+      const headerResult = parseHeaderFromBuffer2(state.buffer);
+      if (headerResult) {
+        state.headerParsed = true;
+        state.inHeader = false;
+        if (!detectedEncoding && headerResult.header.CHARSET) {
+          detectedEncoding = getEncodingFromCharset(headerResult.header.CHARSET);
+          decoder = new TextDecoder(detectedEncoding);
+        }
+        yield { data: headerResult.header, type: "header" };
+        state.buffer = state.buffer.slice(headerResult.bodyStart);
+      } else {
+        return;
+      }
+    }
+    const lastLt = state.buffer.lastIndexOf("<");
+    const safeEnd = isLast ? state.buffer.length : lastLt;
+    if (safeEnd <= 0)
+      return;
+    const safeBuffer = state.buffer.slice(0, safeEnd);
+    let processedUpTo = 0;
+    tagRegex.lastIndex = 0;
+    for (let match = tagRegex.exec(safeBuffer);match !== null; match = tagRegex.exec(safeBuffer)) {
+      const isClosing = match[1] === "/";
+      const tagName = match[2];
+      const textContent = match[3]?.trim() ?? "";
+      if (!tagName)
+        continue;
+      const currentObj = state.objectStack[state.objectStack.length - 1];
+      if (!currentObj)
+        continue;
+      if (isClosing) {
+        if (tagName === "STMTTRN") {
+          const txn = tryParseTransaction(currentObj);
+          if (txn) {
+            state.transactionCount++;
+            yield { data: txn, type: "transaction" };
+          }
+        } else if (tagName === "BANKACCTFROM") {
+          const account = tryParseBankAccount(currentObj);
+          if (account) {
+            yield { data: account, type: "account" };
+          }
+        } else if (tagName === "CCACCTFROM") {
+          const account = tryParseCreditCardAccount(currentObj);
+          if (account) {
+            yield { data: account, type: "account" };
+          }
+        } else if (tagName === "LEDGERBAL") {
+          pendingLedgerBalance = tryParseBalance(currentObj) ?? undefined;
+        } else if (tagName === "AVAILBAL") {
+          pendingAvailableBalance = tryParseBalance(currentObj) ?? undefined;
+        } else if ((tagName === "STMTRS" || tagName === "CCSTMTRS") && !emittedBalanceForCurrentStatement) {
+          if (pendingLedgerBalance || pendingAvailableBalance) {
+            yield {
+              data: {
+                available: pendingAvailableBalance,
+                ledger: pendingLedgerBalance
+              },
+              type: "balance"
+            };
+            emittedBalanceForCurrentStatement = true;
+          }
+        } else if (tagName === "STMTTRNRS" || tagName === "CCSTMTTRNRS") {
+          pendingLedgerBalance = undefined;
+          pendingAvailableBalance = undefined;
+          emittedBalanceForCurrentStatement = false;
+        }
+        const pathIndex = state.currentPath.lastIndexOf(tagName);
+        if (pathIndex !== -1) {
+          state.currentPath.length = pathIndex;
+          state.objectStack.length = Math.max(pathIndex + 1, 1);
+        }
+      } else if (textContent) {
+        const decoded = decodeEntities(textContent);
+        const existing = currentObj[tagName];
+        if (existing !== undefined) {
+          if (Array.isArray(existing)) {
+            existing.push(decoded);
+          } else {
+            currentObj[tagName] = [existing, decoded];
+          }
+        } else {
+          currentObj[tagName] = decoded;
+        }
+      } else {
+        const newObj = {};
+        const existing = currentObj[tagName];
+        if (existing !== undefined) {
+          if (Array.isArray(existing)) {
+            existing.push(newObj);
+          } else {
+            currentObj[tagName] = [existing, newObj];
+          }
+        } else {
+          currentObj[tagName] = newObj;
+        }
+        state.currentPath.push(tagName);
+        state.objectStack.push(newObj);
+      }
+      processedUpTo = tagRegex.lastIndex;
+    }
+    if (processedUpTo > 0) {
+      state.buffer = state.buffer.slice(processedUpTo);
+    }
+    tagRegex.lastIndex = 0;
+  }
+  if (input instanceof ReadableStream) {
+    const reader = input.getReader();
+    const initialChunks = [];
+    let headerFound = false;
+    try {
+      while (!headerFound) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        initialChunks.push(value);
+        const combined = new Uint8Array(initialChunks.reduce((sum, chunk) => sum + chunk.length, 0));
+        let offset = 0;
+        for (const chunk of initialChunks) {
+          combined.set(chunk, offset);
+          offset += chunk.length;
+        }
+        const headerSection = new TextDecoder("windows-1252").decode(combined.slice(0, Math.min(combined.length, 1000)));
+        if (headerSection.includes("<OFX") || headerSection.includes("<?xml")) {
+          const charsetMatch = headerSection.match(/CHARSET:(\S+)/i);
+          if (charsetMatch && !detectedEncoding) {
+            detectedEncoding = getEncodingFromCharset(charsetMatch[1]);
+            decoder = new TextDecoder(detectedEncoding);
+          }
+          headerFound = true;
+          const content = decoder.decode(combined);
+          yield* processChunk(content);
+        }
+      }
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        yield* processChunk(decoder.decode(value, { stream: true }));
+      }
+      yield* processChunk(decoder.decode(), true);
+    } finally {
+      reader.releaseLock();
+    }
+  } else {
+    const chunks = [];
+    for await (const chunk of input) {
+      chunks.push(chunk);
+    }
+    for (let i = 0;i < chunks.length; i++) {
+      yield* processChunk(chunks[i] ?? "", i === chunks.length - 1);
+    }
+  }
+  yield { transactionCount: state.transactionCount, type: "complete" };
+}
+async function parseStreamToArray(input, options) {
+  const result = {
+    accounts: [],
+    balances: [],
+    transactions: []
+  };
+  for await (const event of parseStream(input, options)) {
+    switch (event.type) {
+      case "header":
+        result.header = event.data;
+        break;
+      case "transaction":
+        result.transactions.push(event.data);
+        break;
+      case "account":
+        result.accounts.push(event.data);
+        break;
+      case "balance":
+        result.balances.push(event.data);
+        break;
+    }
+  }
+  return result;
+}
+async function* createChunkIterable(content, chunkSize = 65536) {
+  for (let i = 0;i < content.length; i += chunkSize) {
+    yield content.slice(i, i + chunkSize);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+}
+async function* parseBatchStream(files, options) {
+  let totalTransactions = 0;
+  let errorCount = 0;
+  for (let i = 0;i < files.length; i++) {
+    const file = files[i];
+    if (!file)
+      continue;
+    yield { type: "file_start", fileIndex: i, filename: file.filename };
+    try {
+      let fileTransactionCount = 0;
+      const content = decodeOfxBuffer(file.buffer);
+      const chunkIterable = createChunkIterable(content);
+      for await (const event of parseStream(chunkIterable, options)) {
+        switch (event.type) {
+          case "header":
+            yield { type: "header", fileIndex: i, data: event.data };
+            break;
+          case "transaction":
+            yield { type: "transaction", fileIndex: i, data: event.data };
+            fileTransactionCount++;
+            break;
+          case "account":
+            yield { type: "account", fileIndex: i, data: event.data };
+            break;
+          case "balance":
+            yield { type: "balance", fileIndex: i, data: event.data };
+            break;
+          case "complete":
+            break;
+        }
+      }
+      totalTransactions += fileTransactionCount;
+      yield {
+        type: "file_complete",
+        fileIndex: i,
+        filename: file.filename,
+        transactionCount: fileTransactionCount
+      };
+    } catch (err) {
+      errorCount++;
+      yield {
+        type: "file_error",
+        fileIndex: i,
+        filename: file.filename,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  yield {
+    type: "batch_complete",
+    totalFiles: files.length,
+    totalTransactions,
+    errorCount
+  };
+}
+async function parseBatchStreamToArray(files, options) {
+  const results = files.map((file, index) => ({
+    fileIndex: index,
+    filename: file.filename,
+    transactions: [],
+    accounts: [],
+    balances: []
+  }));
+  for await (const event of parseBatchStream(files, options)) {
+    switch (event.type) {
+      case "header": {
+        const result = results[event.fileIndex];
+        if (result)
+          result.header = event.data;
+        break;
+      }
+      case "transaction": {
+        const result = results[event.fileIndex];
+        if (result)
+          result.transactions.push(event.data);
+        break;
+      }
+      case "account": {
+        const result = results[event.fileIndex];
+        if (result)
+          result.accounts.push(event.data);
+        break;
+      }
+      case "balance": {
+        const result = results[event.fileIndex];
+        if (result)
+          result.balances.push(event.data);
+        break;
+      }
+      case "file_error": {
+        const result = results[event.fileIndex];
+        if (result)
+          result.error = event.error;
+        break;
+      }
+    }
+  }
+  return results;
+}
+export {
+  parseStreamToArray,
+  parseStream,
+  parseOrThrow,
+  parseBufferOrThrow,
+  parseBuffer,
+  parseBatchStreamToArray,
+  parseBatchStream,
+  parse,
+  getTransactions,
+  getSignOnInfo,
+  getEncodingFromCharset,
+  getBalance,
+  getAccountInfo,
+  generateTransactionInputSchema,
+  generateHeaderOptionsSchema,
+  generateHeader,
+  generateCreditCardStatementOptionsSchema,
+  generateCreditCardStatement,
+  generateBankStatementOptionsSchema,
+  generateBankStatement,
+  formatOfxDate,
+  decodeOfxBuffer
+};
+
+//# debugId=7C69B4A1D0DBA73E64756E2164756E21