@f-o-t/ofx 1.2.0 → 1.3.0

package/README.md

@@ -123,6 +123,112 @@ console.log({
 });
 ```
 
+### Generation Functions
+
+#### `generateBankStatement(options: GenerateBankStatementOptions): string`
+
+Generates a complete OFX bank statement file.
+
+```typescript
+import { generateBankStatement } from "@fot/ofx";
+
+const statement = generateBankStatement({
+  bankId: "123456",
+  accountId: "987654321",
+  accountType: "CHECKING",
+  currency: "USD",
+  startDate: new Date("2025-01-01"),
+  endDate: new Date("2025-01-31"),
+  transactions: [
+    {
+      type: "CREDIT",
+      datePosted: new Date(),
+      amount: 1000,
+      fitId: "1",
+      name: "Deposit",
+    },
+  ],
+});
+
+console.log(statement);
+```
+
+#### `generateCreditCardStatement(options: GenerateCreditCardStatementOptions): string`
+
+Generates a complete OFX credit card statement file.
+
+```typescript
+import { generateCreditCardStatement } from "@fot/ofx";
+
+const statement = generateCreditCardStatement({
+  accountId: "123456789",
+  currency: "USD",
+  startDate: new Date("2025-01-01"),
+  endDate: new Date("2025-01-31"),
+  transactions: [
+    {
+      type: "DEBIT",
+      datePosted: new Date(),
+      amount: -75.5,
+      fitId: "2",
+      name: "Purchase at a store",
+    },
+  ],
+});
+
+console.log(statement);
+```
+
+### Streaming Functions
+
+For processing large OFX files with low memory footprint.
+
+#### `parseStream(input): AsyncGenerator<StreamEvent>`
+
+Parses an OFX file as a stream, yielding events as they are parsed.
+
+```typescript
+import { parseStream } from "@fot/ofx";
+
+// From a ReadableStream (e.g., fetch response)
+const response = await fetch("https://example.com/statement.ofx");
+for await (const event of parseStream(response.body)) {
+  switch (event.type) {
+    case "header":
+      console.log("OFX Version:", event.data.VERSION);
+      break;
+    case "account":
+      console.log("Account:", event.data.ACCTID);
+      break;
+    case "transaction":
+      console.log("Transaction:", event.data.NAME, event.data.TRNAMT);
+      break;
+    case "balance":
+      console.log("Ledger Balance:", event.data.ledger?.BALAMT);
+      break;
+    case "complete":
+      console.log("Total transactions:", event.transactionCount);
+      break;
+  }
+}
+```
+
+#### `parseStreamToArray(input): Promise<StreamResult>`
+
+Collects all stream events into arrays for easier processing.
+
+```typescript
+import { parseStreamToArray } from "@fot/ofx";
+
+const response = await fetch("https://example.com/statement.ofx");
+const result = await parseStreamToArray(response.body);
+
+console.log("Header:", result.header);
+console.log("Transactions:", result.transactions.length);
+console.log("Accounts:", result.accounts);
+console.log("Balances:", result.balances);
+```
+
 ## Types
 
 ### OFXTransaction
@@ -227,6 +333,17 @@ interface BalanceInfo {
 }
 ```
 
+### StreamEvent
+
+```typescript
+type StreamEvent =
+  | { type: "header"; data: OFXHeader }
+  | { type: "transaction"; data: OFXTransaction }
+  | { type: "account"; data: OFXBankAccount | OFXCreditCardAccount }
+  | { type: "balance"; data: { ledger?: OFXBalance; available?: OFXBalance } }
+  | { type: "complete"; transactionCount: number };
+```
+
 ## Schemas
 
 All Zod schemas are exported for custom validation:
@@ -264,13 +381,17 @@ Tested on realistic business statement sizes:
 
 | Transactions | File Size | Parse Time |
 | ------------ | --------- | ---------- |
-| ~10,000      | 2.5 MB    | ~800ms     |
-| ~25,000      | 5.4 MB    | ~1.3s      |
-| ~50,000      | 10.4 MB   | ~4.3s      |
-| ~100,000     | 20.5 MB   | ~27s       |
+| ~5,000       | 1.2 MB    | ~37ms      |
+| ~10,000      | 2.5 MB    | ~108ms     |
+| ~25,000      | 5.4 MB    | ~230ms     |
+| ~50,000      | 10.4 MB   | ~450ms     |
 
 Extraction operations (`getTransactions`, `getBalance`, etc.) are sub-millisecond even on large datasets.
 
+### Streaming Performance
+
+The streaming API achieves ~55,000-66,000 transactions/sec throughput with minimal memory overhead, making it ideal for processing very large files or network streams.
+
 ## License
 
 MIT

package/dist/index.d.ts

@@ -42,21 +42,115 @@ type OFXHeader = z.infer<typeof ofxHeaderSchema>;
 declare const ofxDocumentSchema: unknown;
 type OFXDocument = z.infer<typeof ofxDocumentSchema>;
 declare const schemas: {};
+interface BalanceInfo {
+	ledger?: OFXBalance;
+	available?: OFXBalance;
+}
+declare function getTransactions(document: OFXDocument): OFXTransaction[];
+declare function getAccountInfo(document: OFXDocument): (OFXBankAccount | OFXCreditCardAccount)[];
+declare function getBalance(document: OFXDocument): BalanceInfo[];
+declare function getSignOnInfo(document: OFXDocument): OFXSignOnResponse;
+interface GenerateHeaderOptions {
+	version?: string;
+	encoding?: string;
+	charset?: string;
+}
+declare function generateHeader(options?: GenerateHeaderOptions): string;
+interface GenerateTransactionInput {
+	type: OFXTransactionType;
+	datePosted: Date;
+	amount: number;
+	fitId: string;
+	name?: string;
+	memo?: string;
+	checkNum?: string;
+	refNum?: string;
+}
+interface GenerateBankStatementOptions {
+	bankId: string;
+	accountId: string;
+	accountType: OFXAccountType;
+	currency: string;
+	startDate: Date;
+	endDate: Date;
+	transactions: GenerateTransactionInput[];
+	ledgerBalance?: {
+		amount: number;
+		asOfDate: Date;
+	};
+	availableBalance?: {
+		amount: number;
+		asOfDate: Date;
+	};
+	financialInstitution?: {
+		org?: string;
+		fid?: string;
+	};
+	language?: string;
+}
+declare function generateBankStatement(options: GenerateBankStatementOptions): string;
+interface GenerateCreditCardStatementOptions {
+	accountId: string;
+	currency: string;
+	startDate: Date;
+	endDate: Date;
+	transactions: GenerateTransactionInput[];
+	ledgerBalance?: {
+		amount: number;
+		asOfDate: Date;
+	};
+	availableBalance?: {
+		amount: number;
+		asOfDate: Date;
+	};
+	financialInstitution?: {
+		org?: string;
+		fid?: string;
+	};
+	language?: string;
+}
+declare function generateCreditCardStatement(options: GenerateCreditCardStatementOptions): string;
+import { z as z2 } from "zod";
 type ParseResult<T> = {
 	success: true;
 	data: T;
 } | {
 	success: false;
-	error: z.ZodError;
+	error: z2.ZodError;
 };
 declare function parse(content: string): ParseResult<OFXDocument>;
 declare function parseOrThrow(content: string): OFXDocument;
-declare function getTransactions(document: OFXDocument): OFXTransaction[];
-declare function getAccountInfo(document: OFXDocument): (OFXBankAccount | OFXCreditCardAccount)[];
-interface BalanceInfo {
-	ledger?: OFXBalance;
-	available?: OFXBalance;
-}
-declare function getBalance(document: OFXDocument): BalanceInfo[];
-declare function getSignOnInfo(document: OFXDocument): OFXSignOnResponse;
-export { schemas, parseOrThrow, parse, getTransactions, getSignOnInfo, getBalance, getAccountInfo, ParseResult, OFXTransactionType, OFXTransactionList, OFXTransaction, OFXStatus, OFXSignOnResponse, OFXSignOnMessageSetResponse, OFXResponse, OFXHeader, OFXFinancialInstitution, OFXDocument, OFXDate, OFXCreditCardStatementTransactionResponse, OFXCreditCardStatementResponse, OFXCreditCardMessageSetResponse, OFXCreditCardAccount, OFXBankStatementTransactionResponse, OFXBankStatementResponse, OFXBankMessageSetResponse, OFXBankAccount, OFXBalance, OFXAccountType, BalanceInfo };
+type StreamEvent = {
+	type: "header";
+	data: OFXHeader;
+} | {
+	type: "transaction";
+	data: OFXTransaction;
+} | {
+	type: "account";
+	data: OFXBankAccount | OFXCreditCardAccount;
+} | {
+	type: "balance";
+	data: {
+		ledger?: OFXBalance;
+		available?: OFXBalance;
+	};
+} | {
+	type: "complete";
+	transactionCount: number;
+};
+declare function parseStream(input: ReadableStream<Uint8Array> | AsyncIterable<string>): AsyncGenerator<StreamEvent>;
+declare function parseStreamToArray(input: ReadableStream<Uint8Array> | AsyncIterable<string>): Promise<{
+	header?: OFXHeader;
+	transactions: OFXTransaction[];
+	accounts: (OFXBankAccount | OFXCreditCardAccount)[];
+	balances: {
+		ledger?: OFXBalance;
+		available?: OFXBalance;
+	}[];
+}>;
+declare function formatOfxDate(date: Date, timezone?: {
+	offset: number;
+	name: string;
+}): string;
+export { schemas, parseStreamToArray, parseStream, parseOrThrow, parse, getTransactions, getSignOnInfo, getBalance, getAccountInfo, generateHeader, generateCreditCardStatement, generateBankStatement, formatOfxDate, StreamEvent, ParseResult, OFXTransactionType, OFXTransactionList, OFXTransaction, OFXStatus, OFXSignOnResponse, OFXSignOnMessageSetResponse, OFXResponse, OFXHeader, OFXFinancialInstitution, OFXDocument, OFXDate, OFXCreditCardStatementTransactionResponse, OFXCreditCardStatementResponse, OFXCreditCardMessageSetResponse, OFXCreditCardAccount, OFXBankStatementTransactionResponse, OFXBankStatementResponse, OFXBankMessageSetResponse, OFXBankAccount, OFXBalance, OFXAccountType, GenerateTransactionInput, GenerateHeaderOptions, GenerateCreditCardStatementOptions, GenerateBankStatementOptions, BalanceInfo };

package/dist/index.js

@@ -1,23 +1,296 @@
-// src/index.ts
+// src/utils.ts
+var toArray = (value) => Array.isArray(value) ? value : [value];
+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) {
+  return amount.toFixed(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
+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(`
+`);
+}
+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(`
+`);
+}
+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(`
+`);
+}
+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 z2 } from "zod";
+
+// src/schemas.ts
 import { z } from "zod";
-var toInt = (val) => Number.parseInt(val, 10);
 var toFloat = (val) => Number.parseFloat(val);
-var toArray = (value) => Array.isArray(value) ? value : [value];
+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: toInt(val.substring(6, 8)),
-    hour: toInt(val.substring(8, 10) || "0"),
-    minute: toInt(val.substring(10, 12) || "0"),
-    month: toInt(val.substring(4, 6)),
-    second: toInt(val.substring(12, 14) || "0"),
-    year: toInt(val.substring(0, 4))
+    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 = val.match(/\[([+-]?\d+):(\w+)\]/);
+  const match = TIMEZONE_REGEX.exec(val);
   return {
     name: match?.[2] ?? "UTC",
-    offset: match ? toInt(match[1] ?? "0") : 0
+    offset: match ? +match[1] : 0
   };
 }
 var ofxDateSchema = z.string().transform((val) => {
@@ -194,28 +467,18 @@ var schemas = {
   transactionList: transactionListSchema,
   transactionType: transactionTypeSchema
 };
-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) };
+
+// src/parser.ts
+var ENTITY_MAP = {
+  "&amp;": "&",
+  "&apos;": "'",
+  "&gt;": ">",
+  "&lt;": "<",
+  "&quot;": '"'
+};
+var ENTITY_REGEX = /&(?:amp|lt|gt|quot|apos);/g;
+function decodeEntities(text) {
+  return text.replace(ENTITY_REGEX, (match) => ENTITY_MAP[match] ?? match);
 }
 function addToContent(content, key, value) {
   const existing = content[key];
@@ -233,7 +496,8 @@ function sgmlToObject(sgml) {
   const result = {};
   const tagStack = [{ content: result, name: "root" }];
   const stackMap = new Map([["root", 0]]);
-  const cleanSgml = sgml.replace(/<\?.*?\?>/g, "").replace(/<!--.*?-->/gs, "").trim();
+  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) {
@@ -260,7 +524,8 @@ function sgmlToObject(sgml) {
         tagStack.length = stackIndex;
       }
     } else if (textContent) {
-      addToContent(current.content, tagName, textContent);
+      const decoded = textContent.includes("&") ? decodeEntities(textContent) : textContent;
+      addToContent(current.content, tagName, decoded);
     } else {
       const newObj = {};
       addToContent(current.content, tagName, newObj);
@@ -271,24 +536,82 @@ function sgmlToObject(sgml) {
   }
   return result;
 }
-function processObject(obj) {
-  const processed = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (key === "STMTTRN") {
-      processed[key] = toArray(value).map((v) => typeof v === "object" && v !== null ? processObject(v) : v);
-    } else if (value && typeof value === "object" && !Array.isArray(value)) {
-      processed[key] = processObject(value);
-    } else {
-      processed[key] = value;
+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);
     }
   }
-  return processed;
 }
 function normalizeTransactions(data) {
-  return processObject(data);
+  const ofx = data.OFX;
+  if (!ofx)
+    return 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 z2.ZodError([
+          {
+            code: "invalid_type",
+            expected: "string",
+            message: "Expected string, received " + typeof content,
+            path: []
+          }
+        ]),
+        success: false
+      };
+    }
+    if (content.trim() === "") {
+      return {
+        error: new z2.ZodError([
+          {
+            code: "custom",
+            message: "Content cannot be empty",
+            path: []
+          }
+        ]),
+        success: false
+      };
+    }
     const { header, body } = parseHeader(content);
     const rawData = sgmlToObject(body);
     const normalizedData = normalizeTransactions(rawData);
@@ -301,7 +624,7 @@ function parse(content) {
       success: true
     };
   } catch (err) {
-    if (err instanceof z.ZodError) {
+    if (err instanceof z2.ZodError) {
       return { error: err, success: false };
     }
     throw err;
@@ -314,56 +637,244 @@ function parseOrThrow(content) {
   }
   return result.data;
 }
-function extractFromBankResponses(document, extractor) {
-  const bankResponse = document.OFX.BANKMSGSRSV1?.STMTTRNRS;
-  if (!bankResponse)
-    return [];
-  const results = [];
-  for (const response of toArray(bankResponse)) {
-    const result = extractor(response);
-    if (result !== undefined) {
-      results.push(result);
-    }
-  }
-  return results;
+// src/stream.ts
+var ENTITY_MAP2 = {
+  "&amp;": "&",
+  "&apos;": "'",
+  "&gt;": ">",
+  "&lt;": "<",
+  "&quot;": '"'
+};
+var ENTITY_REGEX2 = /&(?:amp|lt|gt|quot|apos);/g;
+function decodeEntities2(text) {
+  if (!text.includes("&"))
+    return text;
+  return text.replace(ENTITY_REGEX2, (match) => ENTITY_MAP2[match] ?? match);
 }
-function extractFromCreditCardResponses(document, extractor) {
-  const ccResponse = document.OFX.CREDITCARDMSGSRSV1?.CCSTMTTRNRS;
-  if (!ccResponse)
-    return [];
-  const results = [];
-  for (const response of toArray(ccResponse)) {
-    const result = extractor(response);
-    if (result !== undefined) {
-      results.push(result);
+function parseHeaderFromBuffer(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;
     }
   }
-  return results;
+  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 getTransactions(document) {
-  const bankTransactions = extractFromBankResponses(document, (r) => r.STMTRS?.BANKTRANLIST?.STMTTRN);
-  const ccTransactions = extractFromCreditCardResponses(document, (r) => r.CCSTMTRS?.BANKTRANLIST?.STMTTRN);
-  return [...bankTransactions, ...ccTransactions].flat();
+function tryParseTransaction(obj) {
+  const result = transactionSchema.safeParse(obj);
+  return result.success ? result.data : null;
 }
-function getAccountInfo(document) {
-  const bankAccounts = extractFromBankResponses(document, (r) => r.STMTRS?.BANKACCTFROM);
-  const ccAccounts = extractFromCreditCardResponses(document, (r) => r.CCSTMTRS?.CCACCTFROM);
-  return [...bankAccounts, ...ccAccounts];
+function tryParseBankAccount(obj) {
+  const result = bankAccountSchema.safeParse(obj);
+  return result.success ? result.data : null;
 }
-function getBalance(document) {
-  const bankBalances = extractFromBankResponses(document, (r) => r.STMTRS ? { available: r.STMTRS.AVAILBAL, ledger: r.STMTRS.LEDGERBAL } : undefined);
-  const ccBalances = extractFromCreditCardResponses(document, (r) => r.CCSTMTRS ? { available: r.CCSTMTRS.AVAILBAL, ledger: r.CCSTMTRS.LEDGERBAL } : undefined);
-  return [...bankBalances, ...ccBalances];
+function tryParseCreditCardAccount(obj) {
+  const result = creditCardAccountSchema.safeParse(obj);
+  return result.success ? result.data : null;
 }
-function getSignOnInfo(document) {
-  return document.OFX.SIGNONMSGSRSV1.SONRS;
+function tryParseBalance(obj) {
+  const result = balanceSchema.safeParse(obj);
+  return result.success ? result.data : null;
+}
+async function* parseStream(input) {
+  const state = {
+    buffer: "",
+    currentObject: {},
+    currentPath: [],
+    headerParsed: false,
+    inHeader: true,
+    objectStack: [{}],
+    transactionCount: 0
+  };
+  const decoder = new TextDecoder;
+  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 = parseHeaderFromBuffer(state.buffer);
+      if (headerResult) {
+        state.headerParsed = true;
+        state.inHeader = false;
+        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 = decodeEntities2(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();
+    try {
+      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) {
+  const result = {
+    accounts: [],
+    balances: [],
+    transactions: []
+  };
+  for await (const event of parseStream(input)) {
+    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;
 }
 export {
   schemas,
+  parseStreamToArray,
+  parseStream,
   parseOrThrow,
   parse,
   getTransactions,
   getSignOnInfo,
   getBalance,
-  getAccountInfo
+  getAccountInfo,
+  generateHeader,
+  generateCreditCardStatement,
+  generateBankStatement,
+  formatOfxDate
 };

package/package.json

@@ -7,26 +7,27 @@
    },
    "description": "Typesafe ofx handling",
    "devDependencies": {
-      "@biomejs/biome": "^2.3.7",
+      "@biomejs/biome": "2.3.8",
       "@types/bun": "1.3.3",
       "bumpp": "10.3.2",
       "bunup": "0.16.10",
-      "simple-git-hooks": "2.13.1",
       "typescript": "5.9.3"
    },
    "exports": {
       ".": {
+         "bun": "./src/index.ts",
          "import": {
             "default": "./dist/index.js",
             "types": "./dist/index.d.ts"
-         }
+         },
+         "types": "./src/index.ts"
       },
       "./package.json": "./package.json"
    },
    "files": [
       "dist"
    ],
-   "homepage": "https://github.com/F-O-T/montte-nx#readme",
+   "homepage": "https://github.com/F-O-T/montte-nx/blob/master/libraries/ofx",
    "license": "MIT",
    "module": "./dist/index.js",
    "name": "@f-o-t/ofx",
@@ -48,20 +49,16 @@
    },
    "scripts": {
       "build": "bunup",
+      "check": "biome check --write .",
       "dev": "bunup --watch",
-      "lint": "biome check .",
-      "lint:fix": "biome check --write .",
-      "postinstall": "bun simple-git-hooks",
+      "publish": "bunx npm publish",
       "release": "bumpp --commit --push --tag",
       "test": "bun test",
       "test:coverage": "bun test --coverage",
       "test:watch": "bun test --watch",
       "type-check": "tsc --noEmit"
    },
-   "simple-git-hooks": {
-      "pre-commit": "bun run lint && bun run type-check"
-   },
    "type": "module",
    "types": "./dist/index.d.ts",
-   "version": "1.2.0"
+   "version": "1.3.0"
 }