@coderoftime/fints 0.1.0 → 0.3.0

package/src/v3/segments.ts

@@ -3,25 +3,37 @@
 import { Account } from '../core/account.js';
 import { Amount, withMark } from '../core/amount.js';
 import { Balance } from '../core/balance.js';
-import { noReference } from '../session/protocol.js';
 import { TanMedium, tanMediumStatusOf } from '../tan/tan-models.js';
 import { formatFintsDate, parseFintsDate, parseFintsDateTime } from '../util/dates.js';
 import { FormatError } from '../util/errors.js';
-import { type Segment, SegmentSpec, type SegmentValue } from './syntax.js';
+import { trimBlanks } from '../util/text.js';
+import { type Segment, SegmentSpec, type SegmentValue, Verbatim } from './syntax.js';
+
+/**
+ * The filler the specification names for a reference that does not exist.
+ *
+ * The bank puts it into a dummy answer when no approval is needed. The client sends it as the TAN medium name in the
+ * dialog that looks up the TAN media, before it knows a medium; the bank ignores it there (PIN/TAN B.4.3.1.3).
+ */
+export const noReference = 'noref';
 
 /** Bank identification (KIK): country code and bank code. */
-export function bankIdentification(countryCode: string, bankCode: string): SegmentValue {
+function bankIdentification(countryCode: string, bankCode: string): SegmentValue {
   return [countryCode, bankCode];
 }
 
 /** National account (KTV): account number, sub-account and bank identification. */
-export function nationalAccount(a: Account): SegmentValue[] {
+function nationalAccount(a: Account): SegmentValue[] {
   return [a.accountNumber, a.subAccount, a.countryCode, a.bankCode];
 }
 
-/** International account (KTI): IBAN, BIC, then the national account. */
-export function internationalAccount(a: Account): SegmentValue[] {
-  return [a.iban, a.bic, ...nationalAccount(a)];
+/**
+ * International account (KTI): IBAN and BIC, then the national account where the bank allows it (HISPAS). An IBAN goes
+ * only with its BIC (Messages B.3.2): without one the national account names the account, where it has a number.
+ */
+function internationalAccount(a: Account, nationalAllowed: boolean): SegmentValue[] {
+  const iban = a.bic !== undefined || a.accountNumber === undefined ? a.iban : undefined;
+  return [iban, a.bic, ...(nationalAllowed || iban === undefined ? nationalAccount(a) : [])];
 }
 
 function dateOrEmpty(date: Date | undefined): string | undefined {
@@ -33,7 +45,10 @@ const orderReferenceField = 5;
 const moreTansField = 6;
 const tanMediumField = 11;
 
-/** Builders for the request segments the client sends. */
+/**
+ * Builders for the request segments the client sends. Values the bank issued, such as the customer system ID, the TAN
+ * order reference and the position to continue at, go back as `Verbatim`.
+ */
 export const Segments = Object.freeze({
   /** HKIDN: who is logging in, from which customer system. */
   identification(parts: {
@@ -46,7 +61,7 @@ export const Segments = Object.freeze({
     return new SegmentSpec('HKIDN', 2, [
       bankIdentification(parts.countryCode, parts.bankCode),
       parts.customerId,
-      parts.systemId,
+      new Verbatim(parts.systemId),
       parts.systemIdRequired ? 1 : 0,
     ]);
   },
@@ -74,71 +89,90 @@ export const Segments = Object.freeze({
   },
 
   dialogEnd(dialogId: string): SegmentSpec {
-    return new SegmentSpec('HKEND', 1, [dialogId]);
+    return new SegmentSpec('HKEND', 1, [new Verbatim(dialogId)]);
   },
 
-  /** HKTAN process 4: asks for strong customer authentication of the `segmentType` sent in the same message. */
-  tanProcess4(version: number, segmentType: string, mediumName?: string): SegmentSpec {
+  /**
+   * HKTAN process 4: asks for strong customer authentication of the `segmentType` sent in the same message, with the TAN
+   * medium `mediumName`: a `Verbatim` where it has to go back as the bank sent it (`ParameterStore.tanMediumToSend`).
+   */
+  tanProcess4(version: number, segmentType: string, mediumName?: string | Verbatim): SegmentSpec {
     return SegmentSpec.numbered('HKTAN', version, { 1: '4', 2: segmentType, [tanMediumField]: mediumName });
   },
 
   /** HKTAN process 2: submits the TAN (carried in the signature) for the order with `reference`. */
   tanProcess2(version: number, reference: string): SegmentSpec {
-    return SegmentSpec.numbered('HKTAN', version, { 1: '2', [orderReferenceField]: reference, [moreTansField]: false });
+    return SegmentSpec.numbered('HKTAN', version, {
+      1: '2',
+      [orderReferenceField]: new Verbatim(reference),
+      [moreTansField]: false,
+    });
   },
 
   /** HKTAN process S: asks whether the order with `reference` was approved in the banking app. */
   tanProcessStatus(version: number, reference: string): SegmentSpec {
-    return SegmentSpec.numbered('HKTAN', version, { 1: 'S', [orderReferenceField]: reference, [moreTansField]: false });
+    return SegmentSpec.numbered('HKTAN', version, {
+      1: 'S',
+      [orderReferenceField]: new Verbatim(reference),
+      [moreTansField]: false,
+    });
   },
 
-  /** HKSAL: the balance of one account (not of all accounts). */
-  balance(version: number, account: Account, continuation?: string): SegmentSpec {
+  /**
+   * HKSAL: the balance of one account (not of all accounts), named by its national account as well where
+   * `nationalAllowed` (HISPAS).
+   */
+  balance(version: number, account: Account, nationalAllowed: boolean, continuation?: string): SegmentSpec {
     return new SegmentSpec('HKSAL', version, [
-      version >= 7 ? internationalAccount(account) : nationalAccount(account),
+      version >= 7 ? internationalAccount(account, nationalAllowed) : nationalAccount(account),
       false,
       null,
-      continuation,
+      Verbatim.of(continuation),
     ]);
   },
 
-  /** HKKAZ: MT940 transactions of one account. */
+  /** HKKAZ: MT940 transactions of one account, named by its national account as well where `nationalAllowed`. */
   transactionsMt940(
     version: number,
     account: Account,
+    nationalAllowed: boolean,
     period: { from?: Date | undefined; to?: Date | undefined; continuation?: string | undefined },
   ): SegmentSpec {
     return new SegmentSpec('HKKAZ', version, [
-      version >= 7 ? internationalAccount(account) : nationalAccount(account),
+      version >= 7 ? internationalAccount(account, nationalAllowed) : nationalAccount(account),
       false,
       dateOrEmpty(period.from),
       dateOrEmpty(period.to),
       null,
-      period.continuation,
+      Verbatim.of(period.continuation),
     ]);
   },
 
-  /** HKCAZ: camt transactions of one account in one of `formats`. */
+  /**
+   * HKCAZ: camt transactions of one account in one of `formats`, named by its national account as well where
+   * `nationalAllowed`.
+   */
   transactionsCamt(
     version: number,
     account: Account,
+    nationalAllowed: boolean,
     formats: readonly string[],
     period: { from?: Date | undefined; to?: Date | undefined; continuation?: string | undefined },
   ): SegmentSpec {
     return new SegmentSpec('HKCAZ', version, [
-      internationalAccount(account),
+      internationalAccount(account, nationalAllowed),
       formats,
       false,
       dateOrEmpty(period.from),
       dateOrEmpty(period.to),
       null,
-      period.continuation,
+      Verbatim.of(period.continuation),
     ]);
   },
 
   /** HKSPA: IBAN and BIC of all accounts. */
   sepaAccounts(version: number, continuation?: string): SegmentSpec {
-    return new SegmentSpec('HKSPA', version, [null, ...(version >= 2 ? [null, continuation] : [])]);
+    return new SegmentSpec('HKSPA', version, [null, ...(version >= 2 ? [null, Verbatim.of(continuation)] : [])]);
   },
 
   /** HKTAB: all TAN media of all classes. */
@@ -155,6 +189,7 @@ export class TanResponse {
   constructor(
     /** The TAN process the segment answers: `4` asks for an approval, `S` answers a status request. */
     readonly process: string | undefined,
+    /** The order reference, as `Segment.verbatim` reads it, to send back byte for byte. */
     readonly reference: string | undefined,
     readonly challenge: string | undefined,
     readonly hhdUc: Uint8Array | undefined,
@@ -165,7 +200,7 @@ export class TanResponse {
   static parse(s: Segment): TanResponse {
     return new TanResponse(
       s.text(Hitan.process),
-      s.text(Hitan.reference),
+      s.verbatim(Hitan.reference),
       s.text(Hitan.challenge),
       s.binary(Hitan.hhdUc),
       parseFintsDateTime(s.text(Hitan.validUntil, 0), s.text(Hitan.validUntil, 1)),
@@ -242,8 +277,17 @@ export function parseBalance(s: Segment, account: Account): Balance {
  * The account a balance (HISAL) belongs to: international (IBAN, BIC, then national) from version 7, national before.
  */
 export function balanceAccount(s: Segment): Account {
-  const fields = s.texts(Hisal.account);
-  const international = s.version >= 7;
+  return accountAt(s, Hisal.account, s.version >= 7);
+}
+
+/** The account camt transactions (HICAZ) belong to, which the first element names (international). */
+export function camtAccount(s: Segment): Account {
+  return accountAt(s, 1, true);
+}
+
+/** The account at `index` of `s`: an `international` one (KTI), else a national one (KTV). */
+function accountAt(s: Segment, index: number, international: boolean): Account {
+  const fields = s.texts(index);
   const national = international ? 2 : 0;
   return new Account({
     iban: international ? fields[0] : undefined,
@@ -295,8 +339,14 @@ export function parseSepaAccounts(s: Segment, defaultCountry: string, defaultBan
  */
 const accountWidth = 4;
 
-/** Parses the TAN media list (HITAB versions 4 and 5, PIN/TAN "TAN-Medium-Liste"). */
-export function parseTanMedia(s: Segment): TanMedium[] {
+/**
+ * Parses the TAN media list (HITAB versions 4 and 5, PIN/TAN "TAN-Medium-Liste").
+ *
+ * Each name whose text would not go back as the bank sent it goes into `namesAsSent` as `Segment.verbatim` reads it,
+ * keyed by its text: a name in UTF-8, which its text does not tell where it fits ISO 8859-1, and one with blanks at
+ * either end, which text goes out without (Formals B.4.1).
+ */
+export function parseTanMedia(s: Segment, namesAsSent?: Map<string, string>): TanMedium[] {
   // Version 5 adds the security function in front of the card number.
   const version5 = s.version >= 5;
   const cardNumber = version5 ? 3 : 2;
@@ -310,6 +360,11 @@ export function parseTanMedia(s: Segment): TanMedium[] {
     const fields = s.texts(i);
     const mediumClass = fields[0];
     if (mediumClass === undefined) continue;
+    const name = fields[after + 3];
+    const nameAsSent = s.verbatim(i, after + 3);
+    if (name !== undefined && nameAsSent !== undefined && nameAsSent !== trimBlanks(name)) {
+      namesAsSent?.set(name, nameAsSent);
+    }
     media.push(
       new TanMedium({
         mediumClass,
@@ -319,7 +374,7 @@ export function parseTanMedia(s: Segment): TanMedium[] {
         cardSequenceNumber: fields[cardNumber + 1],
         validFrom: parseFintsDate(fields[after]),
         validUntil: parseFintsDate(fields[after + 1]),
-        name: fields[after + 3],
+        name,
         mobileNumberMasked: fields[after + 4],
         mobileNumber: fields[after + 5],
         lastUsed: parseFintsDate(fields[after + 13]),

package/src/v3/syntax.ts

@@ -2,7 +2,7 @@
 
 import { BytesBuilder, latin1Decode, latin1Encode, utf8Encode } from '../util/bytes.js';
 import { FormatError } from '../util/errors.js';
-import { decodeBankText, tryParseInt } from '../util/text.js';
+import { decodeBankText, isLatin1, trimBlanks, tryParseInt } from '../util/text.js';
 
 // FinTS 3.0 syntax characters.
 const dataElementSeparator = 0x2b; // '+'
@@ -21,17 +21,30 @@ function isSyntaxCharacter(byte: number): boolean {
   );
 }
 
-/** One (group) data element of a received segment: unescaped text bytes or binary data. */
+/**
+ * One (group) data element of a received segment: text or binary data, from `start` to `end` in `source`. A view or
+ * copy of its own would take more memory than most elements hold.
+ */
 export class DataElement {
   private decoded: string | undefined;
 
   constructor(
-    readonly bytes: Uint8Array,
+    private readonly source: Uint8Array,
+    private readonly start: number,
+    private readonly end: number,
     readonly isBinary: boolean,
+    /** Whether the text holds escape characters, which `bytes` leaves out. */
+    private readonly escaped = false,
   ) {}
 
+  /** The binary data, or the text without escape characters. */
+  get bytes(): Uint8Array {
+    const bytes = this.source.subarray(this.start, this.end);
+    return this.escaped ? unescape(bytes) : bytes;
+  }
+
   get isEmpty(): boolean {
-    return !this.isBinary && this.bytes.length === 0;
+    return !this.isBinary && this.start === this.end;
   }
 
   get text(): string {
@@ -46,10 +59,19 @@ export class DataElement {
  * Index 0 is the segment header (type, number, version, reference); the data elements follow from index 1.
  */
 export class Segment {
-  constructor(readonly elements: readonly (readonly DataElement[])[]) {}
+  private typeValue: string | undefined;
+
+  constructor(
+    readonly elements: readonly (readonly DataElement[])[],
+    /** The bytes the segment was read from: `start` to `end` in `source`, terminator included. */
+    private readonly source: Uint8Array,
+    private readonly start: number,
+    private readonly end: number,
+  ) {}
 
   get type(): string {
-    return this.text(0)?.trim() ?? '';
+    this.typeValue ??= trimBlanks(this.text(0) ?? '');
+    return this.typeValue;
   }
 
   get version(): number {
@@ -74,14 +96,31 @@ export class Segment {
     return e.text;
   }
 
+  /** The binary data at `index`; `undefined` for an element that holds text. */
   binary(index: number, sub = 0): Uint8Array | undefined {
+    const e = this.element(index, sub);
+    return e?.isBinary === true ? e.bytes : undefined;
+  }
+
+  /** The binary data or the text without escape characters at `index`; `undefined` for an empty element. */
+  bytes(index: number, sub = 0): Uint8Array | undefined {
+    const e = this.element(index, sub);
+    return e === undefined || e.isEmpty ? undefined : e.bytes;
+  }
+
+  /**
+   * The element at `index` as the bank sent it, for a value the client sends back, such as the dialog ID: untrimmed,
+   * and one character per byte (ISO 8859-1, the FinTS 3.0 character set), so that `Verbatim` gives the bank back the
+   * very bytes it sent, in whatever encoding. `undefined` for an empty element.
+   */
+  verbatim(index: number, sub = 0): string | undefined {
     const e = this.element(index, sub);
     if (e === undefined || e.isEmpty) return undefined;
-    return e.bytes;
+    return latin1Decode(e.bytes);
   }
 
   integer(index: number, sub = 0): number | undefined {
-    return tryParseInt(this.text(index, sub)?.trim());
+    return tryParseInt(this.text(index, sub));
   }
 
   /** The texts of the group at `index`; `undefined` for empty elements. */
@@ -89,22 +128,9 @@ export class Segment {
     return this.group(index).map((e) => (e.isEmpty ? undefined : e.text));
   }
 
+  /** The bytes the segment was read from, as the bank sent them, terminator included. */
   encode(): Uint8Array {
-    const out = new BytesBuilder();
-    this.elements.forEach((g, i) => {
-      if (i > 0) out.addByte(dataElementSeparator);
-      g.forEach((e, j) => {
-        if (j > 0) out.addByte(groupElementSeparator);
-        if (e.isBinary) writeBinary(out, e.bytes);
-        else writeEscaped(out, e.bytes);
-      });
-    });
-    out.addByte(segmentTerminator);
-    return out.takeBytes();
-  }
-
-  toString(): string {
-    return decodeBankText(this.encode());
+    return this.source.subarray(this.start, this.end);
   }
 }
 
@@ -124,111 +150,162 @@ function writeBinary(out: BytesBuilder, bytes: Uint8Array): void {
 
 /**
  * Encodes `value` in ISO 8859-1, the FinTS 3.0 character set, or in UTF-8 where it does not fit: such text can only
- * come from a bank that sends UTF-8, such as a TAN medium named `Max’s iPhone`. The clients check the login data for
- * ISO 8859-1 up front.
+ * come from a bank that sends UTF-8, such as a TAN medium named `Max’s iPhone`. `FinTsConfig` checks the login data for
+ * ISO 8859-1 up front, and the client the PIN and the TAN.
+ *
+ * @internal Exported for the tests.
  */
 export function encodeText(value: string): Uint8Array {
   return isLatin1(value) ? latin1Encode(value) : utf8Encode(value);
 }
 
-/** Whether `value` fits into ISO 8859-1, the FinTS 3.0 character set. */
-export function isLatin1(value: string): boolean {
-  for (let i = 0; i < value.length; i++) if (value.charCodeAt(i) > 0xff) return false;
-  return true;
+/**
+ * The data elements and segments one parse may produce together, segment headers and group elements included: what
+ * the user parameter data of 6,000 accounts take, at about 155 data elements each, which is about what 9,999 KB, the
+ * largest message size HIBPA can state, hold of real data. Without a limit, a message of nothing but separators would
+ * take a hundred times its size in memory.
+ *
+ * @internal Exported for the tests.
+ */
+export const maxParts = 1_000_000;
+
+/**
+ * What `IncomingMessage3.size` counts for each data element it keeps: more than any of them takes once parsed, so that
+ * a message of many short elements counts as the memory it holds rather than its bytes.
+ */
+export const parsedElementBytes = 512;
+
+/** Every empty data element of a received segment; it has no bytes to change. */
+const emptyElement = new DataElement(new Uint8Array(0), 0, 0, false);
+
+function isSeparator(byte: number | undefined): boolean {
+  return byte === dataElementSeparator || byte === groupElementSeparator || byte === segmentTerminator;
+}
+
+/** Line breaks and spaces between segments are padding, not content. */
+function isPadding(byte: number): boolean {
+  return byte === 0x0a || byte === 0x0d || byte === 0x20;
+}
+
+function isDigit(byte: number | undefined): boolean {
+  return byte !== undefined && byte >= 0x30 && byte <= 0x39;
 }
 
 /**
  * Splits a FinTS 3.0 message into segments, resolving escapes and binary data (`@length@bytes`).
  *
- * Throws `FormatError` for a negative binary length.
+ * The elements share the memory of `data`. Throws `FormatError` for anything a complete message cannot hold: a
+ * malformed binary length, binary data beyond the end of `data` or not followed by a separator, a last segment without
+ * terminator, and more than `maxParts` data elements and segments, an empty one included.
  */
 export function parseSegments(data: Uint8Array): Segment[] {
   const segments: Segment[] = [];
-  let elements: DataElement[][] = [];
-  let group: DataElement[] = [];
-  let current: number[] = [];
-  let binary: Uint8Array | undefined;
-  let segmentStarted = false;
-
-  const endElement = (): void => {
-    group.push(binary !== undefined ? new DataElement(binary, true) : new DataElement(Uint8Array.from(current), false));
-    current = [];
-    binary = undefined;
+  let parts = 0;
+  const count = (): void => {
+    if (++parts > maxParts) throw new FormatError(`More than ${maxParts} data elements and segments`);
   };
+  // Created with their first element: an array that starts empty reserves room for more than most of them hold.
+  let elements: DataElement[][] | undefined;
+  let group: DataElement[] | undefined;
+  let segmentStart = 0;
+  let i = 0;
 
-  const endSegment = (): void => {
-    endElement();
-    elements.push(group);
-    const segment = new Segment(elements);
-    // Skip empty segments, such as a stray double terminator.
-    if (segment.type !== '') segments.push(segment);
-    elements = [];
-    group = [];
-    segmentStarted = false;
+  const readBinary = (): DataElement => {
+    let end = i + 1;
+    let length = 0;
+    while (isDigit(data[end])) {
+      length = length * 10 + data[end++]! - 0x30;
+      if (length > data.length) throw new FormatError('Binary data beyond the end of the message');
+    }
+    if (end === i + 1 || data[end] !== binaryMarker) throw new FormatError('Malformed binary length');
+    const start = end + 1;
+    if (length > data.length - start) throw new FormatError('Binary data beyond the end of the message');
+    i = start + length;
+    if (i < data.length && !isSeparator(data[i])) throw new FormatError('Binary data not followed by a separator');
+    return new DataElement(data, start, i, true);
+  };
+
+  const readText = (): DataElement => {
+    const start = i;
+    let escaped = false;
+    while (i < data.length && !isSeparator(data[i])) {
+      if (data[i] === escapeCharacter) {
+        escaped = true;
+        i++;
+      }
+      i++;
+    }
+    if (i > data.length) throw new FormatError('Escape character at the end of the message');
+    return i === start ? emptyElement : new DataElement(data, start, i, false, escaped);
   };
 
-  let i = 0;
   while (i < data.length) {
-    const c = data[i]!;
-    if (c === escapeCharacter) {
-      if (i + 1 < data.length) current.push(data[i + 1]!);
-      segmentStarted = true;
-      i += 2;
+    if (elements === undefined && group === undefined && isPadding(data[i]!)) {
+      i++;
       continue;
     }
-    if (c === binaryMarker && current.length === 0 && binary === undefined) {
-      const end = data.indexOf(binaryMarker, i + 1);
-      const length = end > i + 1 ? tryParseInt(latin1Decode(data.subarray(i + 1, end))) : undefined;
-      if (length !== undefined && length < 0) throw new FormatError('Negative binary length');
-      // Compared this way round, a huge length cannot overflow the sum.
-      if (length !== undefined && length <= data.length - (end + 1)) {
-        binary = data.subarray(end + 1, end + 1 + length);
-        segmentStarted = true;
-        i = end + 1 + length;
-        continue;
-      }
-    }
-    if (c === groupElementSeparator) {
-      endElement();
-    } else if (c === dataElementSeparator) {
-      endElement();
-      elements.push(group);
-      group = [];
-    } else if (c === segmentTerminator) {
-      endSegment();
-    } else {
-      // Line breaks and spaces between segments are padding, not content.
-      const isPadding =
-        !segmentStarted &&
-        current.length === 0 &&
-        elements.length === 0 &&
-        group.length === 0 &&
-        (c === 0x0a || c === 0x0d || c === 0x20);
-      if (!isPadding) {
-        current.push(c);
-        segmentStarted = true;
-      }
+    count();
+    if (elements === undefined && group === undefined) segmentStart = i;
+    const element = data[i] === binaryMarker ? readBinary() : readText();
+    if (group === undefined) group = [element];
+    else group.push(element);
+    const separator = data[i++];
+    if (separator === groupElementSeparator) continue;
+    if (elements === undefined) elements = [group];
+    else elements.push(group);
+    group = undefined;
+    if (separator === segmentTerminator) {
+      count();
+      const segment = new Segment(elements, data, segmentStart, i);
+      // Skip empty segments, such as a stray double terminator.
+      if (segment.type !== '') segments.push(segment);
+      elements = undefined;
     }
-    i++;
   }
-  if (segmentStarted && current.length > 0) endSegment();
+  if (elements !== undefined || group !== undefined) throw new FormatError('Segment without terminator');
   return segments;
 }
 
+/** `text` without the escape characters in front of syntax characters. */
+function unescape(text: Uint8Array): Uint8Array {
+  const out = new Uint8Array(text.length);
+  let o = 0;
+  for (let j = 0; j < text.length; j++) {
+    if (text[j] === escapeCharacter) j++;
+    out[o++] = text[j]!;
+  }
+  return out.subarray(0, o);
+}
+
 /** Binary data in a segment to send, written as `@length@bytes`. */
 export class Binary {
   constructor(readonly bytes: Uint8Array) {}
 }
 
+/**
+ * A value the bank issued, such as the dialog ID, to send back as `Segment.verbatim` reads it: escaped, but not
+ * trimmed, so that the bank gets back the very bytes it sent. Text from elsewhere, such as a TAN medium name the app
+ * passes, goes out as `encodeText` encodes it.
+ */
+export class Verbatim {
+  constructor(readonly text: string) {}
+
+  /** `text` as a `Verbatim`; `undefined` stays empty. */
+  static of(text: string | undefined): Verbatim | undefined {
+    return text === undefined ? undefined : new Verbatim(text);
+  }
+}
+
 /** A value of a segment to send; see `SegmentSpec`. */
-export type SegmentValue = string | number | boolean | Binary | null | undefined | readonly SegmentValue[];
+export type SegmentValue = string | number | boolean | Binary | Verbatim | null | undefined | readonly SegmentValue[];
 
 /**
  * A segment to send.
  *
  * `elements` holds the data elements after the header: `null` or `undefined` for an empty element, an array for a data
- * element group, a boolean for `J`/`N`, `Binary` for binary data and anything else as its text, without leading and
- * trailing blanks. Trailing empty elements are left out, as the specification asks.
+ * element group, a boolean for `J`/`N`, `Binary` for binary data, `Verbatim` for a value the bank issued, and anything
+ * else as its text, without leading and trailing blanks. Trailing empty elements are left out, as the specification
+ * asks.
  */
 export class SegmentSpec {
   constructor(
@@ -296,12 +373,14 @@ function encodeValue(value: SingleValue): Uint8Array {
     // Empty.
   } else if (value instanceof Binary) {
     writeBinary(out, value.bytes);
+  } else if (value instanceof Verbatim) {
+    writeEscaped(out, encodeText(value.text));
   } else if (typeof value === 'boolean') {
     out.addByte(value ? 0x4a : 0x4e); // 'J' or 'N'
   } else {
     // All but binary data go without leading and trailing blanks (Formals B.4.1). Encode first, then escape the bytes,
     // so that nothing unescaped slips into the syntax.
-    writeEscaped(out, encodeText(String(value).trim()));
+    writeEscaped(out, encodeText(trimBlanks(String(value))));
   }
   return out.takeBytes();
 }

package/dist/session/bank-connection.d.ts

@@ -1,28 +0,0 @@
-import type { MessageDirection, MessageLogger } from '../core/client.js';
-import { type FinTsTransport } from '../core/transport.js';
-/**
- * Throws `FinTsProtocolError` if a message of `size` bytes exceeds the bank's `limit` in kilobytes (1024 bytes): the
- * specification does not allow to send such a message.
- */
-export declare function checkMessageSize(size: number, limit: number | undefined): void;
-/** The bank's FinTS endpoint: posts messages there and reports them to the logger. */
-export declare class BankConnection {
-    /** Where the messages go. */
-    readonly url: URL;
-    private readonly logger;
-    private readonly transport;
-    /** A connection to `url` through `transport`, an `HttpTransport` by default. */
-    constructor(
-    /** Where the messages go. */
-    url: URL, transport: FinTsTransport | undefined, logger: MessageLogger | undefined);
-    /**
-     * Posts `body`; reports any failure of the transport as `FinTsError`, with the original as its `cause`: a custom
-     * transport that calls `fetch` fails with a `TypeError` where the network does.
-     */
-    post(body: Uint8Array, contentType: string): Promise<Uint8Array>;
-    /** Reports a message to the logger; `message` is only built when a logger is set. */
-    log(direction: MessageDirection, message: () => string): void;
-    /** Closes the transport. */
-    close(): void;
-}
-//# sourceMappingURL=bank-connection.d.ts.map

package/dist/session/bank-connection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bank-connection.d.ts","sourceRoot":"","sources":["../../src/session/bank-connection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEzE,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE1E;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAI9E;AAED,sFAAsF;AACtF,qBAAa,cAAc;IAKvB,6BAA6B;IAC7B,QAAQ,CAAC,GAAG,EAAE,GAAG;IAEjB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPzB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiB;IAE3C,gFAAgF;;IAE9E,6BAA6B;IACpB,GAAG,EAAE,GAAG,EACjB,SAAS,EAAE,cAAc,GAAG,SAAS,EACpB,MAAM,EAAE,aAAa,GAAG,SAAS;IAKpD;;;OAGG;IACG,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAStE,qFAAqF;IACrF,GAAG,CAAC,SAAS,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,MAAM,GAAG,IAAI;IAI7D,4BAA4B;IAC5B,KAAK,IAAI,IAAI;CAGd"}