@coderoftime/fints 0.1.0 → 0.3.0

package/src/formats/mt940.ts

@@ -1,8 +1,11 @@
-import { Amount } from '../core/amount.js';
-import { Transaction, type TransactionStatus } from '../core/transaction.js';
+import { addsUpTo, Amount } from '../core/amount.js';
+import { requireStatus, Transaction, type TransactionStatus } from '../core/transaction.js';
+import { optionalString } from '../util/arguments.js';
 import { clampedDate, parseSwiftDate } from '../util/dates.js';
-import { FormatError } from '../util/errors.js';
-import { escapeRegExp } from '../util/text.js';
+import { fail, FormatError } from '../util/errors.js';
+import { frozenWithInspect } from '../util/inspect.js';
+import { counted, maskedId, nonBlank, trimBlanks } from '../util/text.js';
+import { RecordBudget } from './record-budget.js';
 import { providedReference, SepaPurpose } from './sepa-purpose.js';
 
 /** One statement from an MT940 or MT942 file, with its balances and transactions. */
@@ -17,13 +20,22 @@ export interface Mt940Statement {
   readonly currency: string | undefined;
   /** The balance at the start of the statement (field 60), negative for a debit. */
   readonly openingBalance: Amount | undefined;
-  /** The date of `openingBalance`. */
+  /**
+   * The date of `openingBalance`; `undefined` where the bank states none, as `0` or `000000` for the first statement of
+   * an account.
+   */
   readonly openingDate: Date | undefined;
   /** The balance at the end of the statement (field 62), negative for a debit. */
   readonly closingBalance: Amount | undefined;
-  /** The date of `closingBalance`. */
+  /**
+   * The date of `closingBalance`; `undefined` where the bank states none, as `0` or `000000` for the first statement of
+   * an account.
+   */
   readonly closingDate: Date | undefined;
-  /** The transactions of the statement, in the order the bank lists them. */
+  /**
+   * The transactions of the statement, in the order the bank lists them; they lead from `openingBalance` to
+   * `closingBalance` where the statement states these.
+   */
   readonly transactions: readonly Transaction[];
 }
 
@@ -36,47 +48,104 @@ export interface Mt940Options {
 }
 
 const tagPattern = /^:(\d{2}[A-Z]?):/gm;
-const statementEnd = /\n-\s*$/;
-const trailingNewlines = /\n+$/;
+
+/** Longest field the parser reads, from its tag to the next one: SWIFT fields have a few hundred characters. */
+export const maxFieldLength = 65_536;
 
 /** Parser for SWIFT MT940/MT942 statements, including German structured `:86:` fields. */
 export const Mt940 = Object.freeze({
   /** Parses all transactions; see `parse`. */
   parseTransactions(text: string, options: Mt940Options = {}): Transaction[] {
-    return Mt940.parse(text, options).flatMap((s) => [...s.transactions]);
+    return Mt940.parse(text, options).flatMap((s) => s.transactions);
   },
 
   /**
-   * Parses all statements.
+   * Parses all statements. Their lines are separated by line breaks, and by `@@` as well where the first line holds it,
+   * as some banks separate them.
    *
-   * Throws `FormatError` if a transaction line (`:61:`) cannot be read or the currency of a transaction is unknown.
+   * Throws `FormatError` for text without any field, if a transaction line (`:61:`), a balance or the creation date of
+   * an MT942 (`:13D:`) cannot be read or the currency of a transaction is unknown, and for a closing balance dated
+   * before the opening one. It does as well for a statement that states only one of its opening and closing balances,
+   * one of them, its account, its number or its creation date twice, or transactions that do not lead from the one
+   * balance to the other: a line of a purpose that starts like a field, such as `:61:` or `:25:`, would pass for a
+   * transaction, the account or a statement of its own otherwise. Text of more than 200,000 statements and
+   * transactions, or with a field of more than 65,536 characters, is a `FormatError` as well.
+   *
+   * Throws `TypeError` for a `status` other than `booked` and `pending`, `null` included, and for a `currency` that is
+   * no string; `null` counts as no currency.
    */
   parse(text: string, options: Mt940Options = {}): Mt940Statement[] {
-    const status = options.status ?? 'booked';
-    const lines = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-    // Some banks separate lines with `@@` instead of line breaks; where there are line breaks, `@@` is text.
-    const normalized = lines.includes('\n') ? lines : lines.replace(/@@/g, '\n');
-    const tags = [...normalized.matchAll(tagPattern)];
-    const statements: Mt940Statement[] = [];
-    let current: StatementBuilder | undefined;
-    tags.forEach((tag, i) => {
-      const end = i + 1 < tags.length ? tags[i + 1]!.index : normalized.length;
-      const value = normalized
-        .substring(tag.index + tag[0].length, end)
-        .replace(statementEnd, '')
-        .replace(trailingNewlines, '');
-      if (tag[1] === '20' || current === undefined) {
-        if (current !== undefined) statements.push(current.build());
-        current = new StatementBuilder(status, options.currency);
-      }
-      current.add(tag[1]!, value);
-    });
-    if (current !== undefined) statements.push(current.build());
-    return statements;
+    const status = options.status === undefined ? undefined : requireStatus(options.status);
+    const currency = optionalString(options.currency, 'currency');
+    return parseMt940(text, { status, currency }, new RecordBudget());
   },
 });
 
-const balancePattern = /^([CD])(\d{6})([A-Z]{3})(\d+,\d*)/;
+/** `Mt940.parse`, which takes each statement and transaction from `budget`, before it builds it. */
+export function parseMt940(text: string, options: Mt940Options, budget: RecordBudget): Mt940Statement[] {
+  const status = options.status ?? 'booked';
+  const normalized = withLineFeeds(text);
+  const statements: Mt940Statement[] = [];
+  let current: StatementBuilder | undefined;
+  for (const [tag, value] of taggedParts(normalized, tagPattern)) {
+    if (value.length > maxFieldLength) throw new FormatError(`MT940 field :${tag}: too long`);
+    if (tag === '20' || current === undefined) {
+      if (current !== undefined) statements.push(current.build());
+      budget.take();
+      current = new StatementBuilder(status, options.currency);
+    }
+    if (tag === '61') budget.take();
+    current.add(tag, fieldValue(value));
+  }
+  if (current !== undefined) statements.push(current.build());
+  else if (normalized.trim() !== '') throw new FormatError('MT940 data without fields');
+  return statements;
+}
+
+/**
+ * The parts of `text` that the matches of `tag` start, each the first group of its match and the text up to the next
+ * match: the fields of a statement, or the subfields of a `:86:`. One by one: text of a few megabytes holds millions of
+ * them. A pattern that matched the text up to the next tag as well would run out of backtracking stack on a part of a
+ * few million characters.
+ */
+function* taggedParts(text: string, tag: RegExp): Generator<[tag: string, text: string]> {
+  let current: string | undefined;
+  let start = 0;
+  for (const match of text.matchAll(tag)) {
+    if (current !== undefined) yield [current, text.substring(start, match.index)];
+    current = match[1]!;
+    start = match.index + match[0].length;
+  }
+  if (current !== undefined) yield [current, text.substring(start)];
+}
+
+/**
+ * `text` with line feeds between its lines, without the blanks and the byte order mark it may start with, which would
+ * hide its first tag. Some banks separate the lines with `@@`, and may still break the line between statements or at
+ * the ends. So `@@` separates lines where the first line holds it, which the bank writes; in other text, `@@` may be
+ * part of a purpose, which the payer writes.
+ */
+function withLineFeeds(text: string): string {
+  const lines = trimBlanks(text.replace(/\r\n?/g, '\n'), { end: false });
+  return lines.split('\n', 1)[0]!.includes('@@') ? lines.replace(/@@/g, '\n') : lines;
+}
+
+/**
+ * The value of a field in `text`, which runs from its tag to the next one: without the statement end (`-`) and the line
+ * feeds at its end. Other blanks there stay: the subfield of a `:86:` that ends it may precede others in the purpose.
+ *
+ * Trimmed without a pattern such as `/\n+$/`, which takes quadratic time on a long run of line breaks.
+ */
+function fieldValue(text: string): string {
+  const trimmed = text.trimEnd();
+  let end = trimmed.endsWith('\n-') ? trimmed.length - 2 : text.length;
+  while (end > 0 && text.charCodeAt(end - 1) === 0x0a) end--;
+  return text.substring(0, end);
+}
+
+/** The date is `0` or `000000` for the first statement of an account. */
+const balancePattern = /^([CD])(\d{6}|0)([A-Z]{3})(\d+,\d*)/;
+const dateTimePattern = /^(\d{6})\d{4}/;
 const currencyPrefix = /^([A-Z]{3})/;
 
 class StatementBuilder {
@@ -88,6 +157,8 @@ class StatementBuilder {
   openingDate: Date | undefined;
   closing: Amount | undefined;
   closingDate: Date | undefined;
+  /** The day an MT942 was created (field 13D). */
+  creationDate: Date | undefined;
   readonly transactions: TransactionLines[] = [];
 
   /**
@@ -105,35 +176,52 @@ class StatementBuilder {
   add(tag: string, value: string): void {
     switch (tag) {
       case '20':
-        this.reference = value.trim();
+        this.reference = trimBlanks(value);
         break;
       case '25':
-        this.accountId = value.trim();
+        if (this.accountId !== undefined) throw new FormatError('MT940 statement with two accounts', this.reference);
+        this.accountId = trimBlanks(value);
         break;
       case '28C':
       case '28':
-        this.statementNumber = value.trim();
+        if (this.statementNumber !== undefined) {
+          throw new FormatError('MT940 statement with two statement numbers', this.reference);
+        }
+        this.statementNumber = trimBlanks(value);
+        break;
+      case '13D':
+      case '13': {
+        if (this.creationDate !== undefined) {
+          throw new FormatError('MT940 statement with two creation dates', this.reference);
+        }
+        const m = dateTimePattern.exec(trimBlanks(value));
+        this.creationDate = (m && parseSwiftDate(m[1]!)) ?? fail('Invalid MT940 creation date', value);
         break;
+      }
       case '60F':
       case '60M': {
-        const balance = parseBalance(value);
-        if (balance) {
-          [this.opening, this.openingDate] = balance;
-          this.currency ??= balance[0].currency;
+        if (this.opening !== undefined) {
+          throw new FormatError('MT940 statement with two opening balances', this.reference);
         }
+        const [balance, date] = parseBalance(value);
+        this.opening = balance;
+        this.openingDate = date;
+        this.currency ??= balance.currency;
         break;
       }
       case '62F':
       case '62M': {
-        const balance = parseBalance(value);
-        if (balance) {
-          [this.closing, this.closingDate] = balance;
-          this.currency ??= balance[0].currency;
+        if (this.closing !== undefined) {
+          throw new FormatError('MT940 statement with two closing balances', this.reference);
         }
+        const [balance, date] = parseBalance(value);
+        this.closing = balance;
+        this.closingDate = date;
+        this.currency ??= balance.currency;
         break;
       }
       case '34F':
-        this.currency ??= currencyPrefix.exec(value.trim())?.[1];
+        this.currency ??= currencyPrefix.exec(trimBlanks(value))?.[1];
         break;
       case '61':
         this.transactions.push(new TransactionLines(value));
@@ -150,26 +238,52 @@ class StatementBuilder {
     if (statementCurrency === undefined && this.transactions.length > 0) {
       throw new FormatError('MT940 statement without currency', this.reference);
     }
-    return Object.freeze({
-      reference: this.reference,
-      accountId: this.accountId,
-      statementNumber: this.statementNumber,
-      currency: statementCurrency,
-      openingBalance: this.opening,
-      openingDate: this.openingDate,
-      closingBalance: this.closing,
-      closingDate: this.closingDate,
-      transactions: Object.freeze(this.transactions.map((t) => t.toTransaction(statementCurrency!, this.status))),
-    });
+    const { openingDate, closingDate } = this;
+    if (openingDate && closingDate && closingDate.getTime() < openingDate.getTime()) {
+      throw new FormatError('MT940 closing balance dated before the opening balance', this.reference);
+    }
+    const period = openingDate && closingDate ? ([openingDate, closingDate] as const) : undefined;
+    const transactions = this.transactions.map((t) =>
+      t.toTransaction(statementCurrency!, this.status, period, this.creationDate),
+    );
+    this.checkBalances(transactions);
+    return frozenWithInspect(
+      {
+        reference: this.reference,
+        accountId: this.accountId,
+        statementNumber: this.statementNumber,
+        currency: statementCurrency,
+        openingBalance: this.opening,
+        openingDate: this.openingDate,
+        closingBalance: this.closing,
+        closingDate: this.closingDate,
+        transactions: Object.freeze(transactions),
+      },
+      (s) => `Mt940Statement(${maskedId(s.accountId ?? '')}, ${counted(s.transactions.length, 'transaction')})`,
+    );
+  }
+
+  /** Checks that the statement states both balances or neither, and that its `transactions` lead from one to the other. */
+  private checkBalances(transactions: readonly Transaction[]): void {
+    const { opening, closing } = this;
+    if (opening === undefined && closing === undefined) return;
+    if (opening === undefined || closing === undefined) {
+      throw new FormatError('MT940 statement with only one of its balances', this.reference);
+    }
+    if (opening.currency !== this.currency || closing.currency !== this.currency) {
+      throw new FormatError('MT940 balances in another currency than the statement', this.reference);
+    }
+    if (!addsUpTo([opening, ...transactions.map((t) => t.amount)], closing)) {
+      throw new FormatError('MT940 transactions do not add up to the closing balance', this.reference);
+    }
   }
 }
 
-function parseBalance(value: string): [Amount, Date] | undefined {
-  const m = balancePattern.exec(value.trim());
-  if (!m) return undefined;
+function parseBalance(value: string): [Amount, Date | undefined] {
+  const m = balancePattern.exec(trimBlanks(value));
+  if (!m) throw new FormatError('Unreadable MT940 balance', value);
   const amount = Amount.parseDecimal(m[4]!, m[3]!);
-  const date = parseSwiftDate(m[2]!);
-  if (date === undefined) throw new FormatError('Invalid balance date', value);
+  const date = Number(m[2]) === 0 ? undefined : (parseSwiftDate(m[2]!) ?? fail('Invalid balance date', value));
   return [m[1] === 'D' ? amount.negate() : amount, date];
 }
 
@@ -180,34 +294,48 @@ function parseBalance(value: string): [Amount, Date] | undefined {
 const line61 =
   /^(\d{6})(\d{4})?(RC|RD|C|D)([A-Z])?(\d+,\d*)([NFS][A-Z0-9]{3})([^\n]*?)(?:\/\/([^\n]*))?(?:\n([\s\S]*))?$/;
 
+/**
+ * The dates between which the transactions of a statement are booked: those of its opening and its closing balance. A
+ * statement without balances, such as an MT942, has the period from the value date of each to the date the statement
+ * was created, or that value date alone.
+ */
+type Period = readonly [first: Date, last: Date];
+
+function spanning(a: Date, b: Date): Period {
+  return a.getTime() <= b.getTime() ? [a, b] : [b, a];
+}
+
 /** The `:61:` line of a transaction and its `:86:` details. */
 class TransactionLines {
   details: string | undefined;
 
   constructor(readonly line: string) {}
 
-  toTransaction(currency: string, status: TransactionStatus): Transaction {
-    const m = line61.exec(this.line.trim());
+  toTransaction(
+    currency: string,
+    status: TransactionStatus,
+    period: Period | undefined,
+    created: Date | undefined,
+  ): Transaction {
+    const m = line61.exec(trimBlanks(this.line));
     const valueDate = m ? parseSwiftDate(m[1]!) : undefined;
     if (!m || valueDate === undefined) throw new FormatError('Unreadable MT940 transaction line (:61:)', this.line);
     const mark = m[3]!;
     const amount = Amount.parseDecimal(m[5]!, currency);
     const debit = mark === 'D' || mark === 'RC';
-    const customerReference = m[7]?.trim();
-    const bankReference = m[8]?.trim();
     const d = Details.parse(this.details);
+    const reference = nonBlank(m[7]);
+    // `KREF+` stands for the customer reference that :86: states.
+    const customerReference = reference === 'KREF+' ? d.sepa.get('KREF') : reference;
     return new Transaction({
       status,
-      bookingDate: this.bookingDate(m[2], valueDate),
+      bookingDate: this.bookingDate(m[2], valueDate, period ?? spanning(valueDate, created ?? valueDate)),
       valueDate,
       amount: debit ? amount.negate() : amount,
       isReversal: mark.startsWith('R'),
       transactionTypeId: m[6],
-      customerReference:
-        customerReference === undefined || customerReference === '' || customerReference === 'NONREF'
-          ? undefined
-          : customerReference,
-      bankReference: bankReference === undefined || bankReference === '' ? undefined : bankReference,
+      customerReference: customerReference === 'NONREF' ? undefined : customerReference,
+      bankReference: nonBlank(m[8]),
       transactionCode: d.transactionCode,
       bookingText: d.bookingText,
       primaNota: d.primaNota,
@@ -226,34 +354,43 @@ class TransactionLines {
     });
   }
 
-  /** The booking date `MMDD`, in the year that places it closest to `valueDate` (across a year end). */
-  private bookingDate(mmdd: string | undefined, valueDate: Date): Date | undefined {
+  /**
+   * The booking date `MMDD`, in the year that places it within `period`, or else closest to it; of several such years,
+   * the one closest to `valueDate`. The value date alone misleads: banks book refunds and corrections with the value
+   * date of the original booking, up to 13 months before.
+   */
+  private bookingDate(mmdd: string | undefined, valueDate: Date, [first, last]: Period): Date | undefined {
     if (mmdd === undefined) return undefined;
     const month = Number(mmdd.substring(0, 2));
     const day = Number(mmdd.substring(2, 4));
-    let year = valueDate.getFullYear();
-    if (month === 12 && valueDate.getMonth() === 0) year--;
-    if (month === 1 && valueDate.getMonth() === 11) year++;
-    const date = clampedDate(year, month, day);
-    if (date === undefined) throw new FormatError('Invalid booking date', this.line);
-    return date;
+    const outside = (date: Date): number =>
+      Math.max(first.getTime() - date.getTime(), date.getTime() - last.getTime(), 0);
+    const fromValueDate = (date: Date): number => Math.abs(date.getTime() - valueDate.getTime());
+    // The best year lies next to one of these, however long the period.
+    const years = new Set(
+      [first, valueDate, last].flatMap((d) => [d.getFullYear() - 1, d.getFullYear(), d.getFullYear() + 1]),
+    );
+    let best: Date | undefined;
+    for (const year of years) {
+      const date = clampedDate(year, month, day);
+      if (date === undefined) throw new FormatError('Invalid booking date', this.line);
+      if (best === undefined || (outside(date) - outside(best) || fromValueDate(date) - fromValueDate(best)) < 0) {
+        best = date;
+      }
+    }
+    return best;
   }
 }
 
 /**
- * Three-digit business transaction code (GVC), then the first subfield: a separator, usually `?`, and its two-digit
- * number. Text that merely starts with three digits, such as `100 Euro`, is free text.
+ * Three-digit business transaction code (GVC), then the first subfield: `?` and its two-digit number. Text that merely
+ * starts with three digits, such as `100 Euro` or `100,00 EUR`, is free text.
  */
-const structuredPattern = /^(\d{3})([^\w\s])\d{2}/;
+const structuredPattern = /^\d{3}\?\d{2}/;
+const subfieldTag = /\?(\d{2})/g;
 const ibanPattern = /^[A-Z]{2}\d{2}[A-Z0-9]+$/;
 const bicPattern = /^[A-Z]{6}[A-Z0-9]{2}([A-Z0-9]{3})?$/;
 
-/** Subfield pattern for a separator: the separator, a two-digit key, then everything up to the next subfield. */
-function subfieldPattern(separator: string): RegExp {
-  const s = escapeRegExp(separator);
-  return new RegExp(`${s}(\\d{2})((?:(?!${s}\\d{2})[\\s\\S])*)`, 'g');
-}
-
 /** The German structured `:86:` field: a business transaction code and `?nn` subfields. */
 class Details {
   transactionCode: string | undefined;
@@ -271,20 +408,16 @@ class Details {
     const d = new Details();
     if (raw === undefined) return d;
     const text = raw.replace(/\n/g, '');
-    const structured = structuredPattern.exec(text);
-    if (!structured) {
+    if (!structuredPattern.test(text)) {
       // Free text, whose lines are separate phrases; the purpose and its keywords are read from the same text.
-      const free = raw.replace(/\n/g, ' ').trim();
+      const free = trimBlanks(raw.replace(/\n/g, ' '));
       d.sepa = SepaPurpose.parse(free);
-      d.purpose = d.sepa.get('SVWZ') ?? (free === '' ? undefined : free);
+      d.purpose = d.sepa.get('SVWZ') ?? nonBlank(free);
       return d;
     }
-    d.transactionCode = structured[1];
-    const subfields = Details.subfields(text.substring(3), structured[2]!);
-    const subfield = (key: number): string | undefined => {
-      const value = subfields.get(key)?.trim();
-      return value === undefined || value === '' ? undefined : value;
-    };
+    d.transactionCode = text.substring(0, 3);
+    const subfields = Details.subfields(text.substring(3));
+    const subfield = (key: number): string | undefined => nonBlank(subfields.get(key));
     // Subfields continue each other: they are joined keeping the spaces at their boundaries.
     const parts = (keys: number[]): string[] =>
       keys.map((k) => subfields.get(k)).filter((v): v is string => v !== undefined);
@@ -292,42 +425,31 @@ class Details {
     d.bookingText = subfield(0);
     d.primaNota = subfield(10);
     const purposeParts = parts([20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 60, 61, 62, 63]);
-    const purpose = purposeParts.join('').trim();
     d.sepa = SepaPurpose.parseParts(purposeParts);
-    d.purpose = d.sepa.get('SVWZ') ?? (purpose === '' ? undefined : purpose);
-    const name = parts([32, 33]).join('').trim();
-    d.name = name === '' ? undefined : name;
+    d.purpose = d.sepa.get('SVWZ') ?? nonBlank(purposeParts.join(''));
+    d.name = nonBlank(parts([32, 33]).join(''));
     d.readCounterpartyAccount(subfield(30), subfield(31));
-    d.iban ??= d.sepa.get('IBAN');
-    d.bic ??= d.sepa.get('BIC');
     return d;
   }
 
   /** The text of each subfield (`?nn` and what follows), by its number; a subfield that appears twice is joined. */
-  private static subfields(text: string, separator: string): Map<number, string> {
+  private static subfields(text: string): Map<number, string> {
     const subfields = new Map<number, string>();
-    for (const m of text.matchAll(subfieldPattern(separator))) {
-      const key = Number(m[1]);
-      subfields.set(key, (subfields.get(key) ?? '') + m[2]!);
+    for (const [tag, value] of taggedParts(text, subfieldTag)) {
+      const key = Number(tag);
+      subfields.set(key, (subfields.get(key) ?? '') + value);
     }
     return subfields;
   }
 
   /**
-   * Takes the counterparty's account from subfields 30 (bank) and 31 (account): IBAN and BIC, or account number and
-   * bank code.
+   * Takes the counterparty's account from subfields 30 (bank) and 31 (account): a BIC, or else a bank code, and an IBAN,
+   * or else an account number.
    */
   private readCounterpartyAccount(bank: string | undefined, account: string | undefined): void {
-    if (account !== undefined && ibanPattern.test(account)) {
-      this.iban = account;
-      this.bic = bank;
-      return;
-    }
-    this.accountNumber = account;
-    if (bank !== undefined && bicPattern.test(bank)) {
-      this.bic = bank;
-    } else {
-      this.bankCode = bank;
-    }
+    if (bank !== undefined && bicPattern.test(bank)) this.bic = bank;
+    else this.bankCode = bank;
+    if (account !== undefined && ibanPattern.test(account)) this.iban = account;
+    else this.accountNumber = account;
   }
 }

package/src/formats/readers.ts

@@ -1,56 +1,53 @@
 import type { Transaction } from '../core/transaction.js';
-import { BytesBuilder } from '../util/bytes.js';
 import { decodeBankText, decodeXmlText } from '../util/text.js';
-import { Camt } from './camt.js';
-import { Mt940 } from './mt940.js';
+import { parseCamt } from './camt.js';
+import { parseMt940 } from './mt940.js';
+import { RecordBudget } from './record-budget.js';
 
 /**
  * The transactions in MT940 data: the `booked` parts joined, since a statement may continue on the next page, then the
  * `pending` ones (MT942).
  *
- * `currency` applies to statements that do not state one; throws `FormatError` if both are missing.
+ * `currency` applies to statements that do not state one; throws `FormatError` if both are missing, and for more than
+ * 200,000 statements and transactions in all.
  */
 export function mt940Transactions(
   booked: readonly Uint8Array[],
   pending: readonly Uint8Array[],
   currency: string | undefined,
 ): Transaction[] {
+  const budget = new RecordBudget();
   return [
-    ...Mt940.parseTransactions(joinedMt940(booked), { currency }),
-    ...Mt940.parseTransactions(joinedMt940(pending), { currency, status: 'pending' }),
-  ];
+    ...parseMt940(joinedMt940(booked), { currency }, budget),
+    ...parseMt940(joinedMt940(pending), { currency, status: 'pending' }, budget),
+  ].flatMap((statement) => statement.transactions);
 }
 
-const lineFeed = 0x0a;
-const carriageReturn = 0x0d;
-const atSign = 0x40;
-
 /**
- * The MT940 `parts` as one text.
+ * The MT940 `parts` as one text, whose line separator the parser takes from its first line: a later page may start
+ * with a purpose, which the payer writes.
  *
- * Each part ends a line before the next one follows, since the parser finds fields at the start of a line and a bank
- * need not end its pages with a line break. Banks that separate lines with `@@` get that separator.
+ * Each part is decoded on its own, since a bank may start each page with a byte order mark. Each part ends a line
+ * before the next one follows, since the parser finds fields at the start of a line and a bank need not end its pages
+ * with a line break. Where no part holds a line break, a part ends its line with `@@` instead: a line break after a
+ * first page without `@@`, such as `:20:X`, would make the parser read the `@@` of the others as text.
  */
 function joinedMt940(parts: readonly Uint8Array[]): string {
-  const pages = parts.filter((part) => part.length > 0);
-  const atSigns = !pages.some((p) => p.includes(lineFeed) || p.includes(carriageReturn));
-  const endsLine = (page: Uint8Array): boolean =>
-    atSigns
-      ? page.length >= 2 && page[page.length - 1] === atSign && page[page.length - 2] === atSign
-      : page.at(-1) === lineFeed || page.at(-1) === carriageReturn;
-
-  const bytes = new BytesBuilder();
-  pages.forEach((page, i) => {
-    if (i > 0 && !endsLine(pages[i - 1]!)) bytes.add(atSigns ? [atSign, atSign] : [lineFeed]);
-    bytes.add(page);
-  });
-  return decodeBankText(bytes.takeBytes());
+  const pages = parts.filter((part) => part.length > 0).map((part) => decodeBankText(part));
+  const lineEnd = pages.some((page) => page.includes('\n') || page.includes('\r')) ? '\n' : '@@';
+  return pages
+    .map((page, i) => (i + 1 < pages.length && !page.endsWith(lineEnd) ? `${page}${lineEnd}` : page))
+    .join('');
 }
 
-/** The transactions in camt documents; each document stands on its own. */
+/**
+ * The transactions in camt documents; each document stands on its own. Throws `FormatError` for more than 200,000
+ * statements and transactions in all.
+ */
 export function camtTransactions(booked: readonly Uint8Array[], pending: readonly Uint8Array[]): Transaction[] {
+  const budget = new RecordBudget();
   return [
-    ...booked.flatMap((document) => Camt.parseTransactions(decodeXmlText(document))),
-    ...pending.flatMap((document) => Camt.parseTransactions(decodeXmlText(document), 'pending')),
-  ];
+    ...booked.flatMap((document) => parseCamt(decodeXmlText(document), undefined, budget)),
+    ...pending.flatMap((document) => parseCamt(decodeXmlText(document), 'pending', budget)),
+  ].flatMap((statement) => statement.transactions);
 }

package/src/formats/record-budget.ts

@@ -0,0 +1,18 @@
+import { FormatError } from '../util/errors.js';
+
+/**
+ * Most statements and transactions the parsers build for one query: several times what a year of a busy business
+ * account holds, and few enough that a hostile answer cannot exhaust the memory, at about 600 bytes each. The size of
+ * the answer does not bound them: a transaction takes up to 25 times the bytes of its MT940 line.
+ */
+const maxRecords = 200_000;
+
+/** The statements and transactions the parsers may still build; the parses of one query share one budget. */
+export class RecordBudget {
+  private left = maxRecords;
+
+  /** Counts a statement or transaction about to be built; throws `FormatError` for one beyond the budget. */
+  take(): void {
+    if (--this.left < 0) throw new FormatError(`More than ${maxRecords} statements and transactions`);
+  }
+}