@coderoftime/fints 0.1.0 → 0.3.0

package/src/util/immutable-map.ts

@@ -1,47 +1,50 @@
-/** A map that cannot be changed, also not at runtime: it has no `set`, `delete` or `clear`. */
+/**
+ * A map that cannot be changed, also not at runtime: it has no `set`, `delete` or `clear`, and no other code reaches
+ * the map that holds its entries.
+ */
 export class ImmutableMap<K, V> implements ReadonlyMap<K, V> {
-  private readonly map: Map<K, V>;
+  readonly #map: Map<K, V>;
 
   constructor(entries?: Iterable<readonly [K, V]>) {
-    this.map = new Map(entries);
+    this.#map = new Map(entries);
   }
 
   get size(): number {
-    return this.map.size;
+    return this.#map.size;
   }
 
   get(key: K): V | undefined {
-    return this.map.get(key);
+    return this.#map.get(key);
   }
 
   has(key: K): boolean {
-    return this.map.has(key);
+    return this.#map.has(key);
   }
 
   forEach(callback: (value: V, key: K, map: ReadonlyMap<K, V>) => void): void {
-    this.map.forEach((value, key) => {
+    this.#map.forEach((value, key) => {
       callback(value, key, this);
     });
   }
 
   entries(): MapIterator<[K, V]> {
-    return this.map.entries();
+    return this.#map.entries();
   }
 
   keys(): MapIterator<K> {
-    return this.map.keys();
+    return this.#map.keys();
   }
 
   values(): MapIterator<V> {
-    return this.map.values();
+    return this.#map.values();
   }
 
   [Symbol.iterator](): MapIterator<[K, V]> {
-    return this.map.entries();
+    return this.#map.entries();
   }
 
   /** A plain object of the entries, for JSON and for display. */
   toJSON(): Record<string, V> {
-    return Object.fromEntries([...this.map].map(([key, value]) => [String(key), value]));
+    return Object.fromEntries([...this.#map].map(([key, value]) => [String(key), value]));
   }
 }

package/src/util/inspect.ts

@@ -0,0 +1,14 @@
+/**
+ * The key of the method by which Node.js's `util.inspect`, and so `console.log`, shows an object, as do Deno and Bun:
+ * its registered name, so that no Node.js import is needed.
+ */
+export const inspectCustom = Symbol.for('nodejs.util.inspect.custom');
+
+/**
+ * `value` frozen, with `show` as what `util.inspect` shows of it instead of its fields. The method is no enumerable
+ * property, so that `JSON.stringify`, `structuredClone` and comparisons in tests see the same plain object as before.
+ */
+export function frozenWithInspect<T extends object>(value: T, show: (value: T) => string): Readonly<T> {
+  Object.defineProperty(value, inspectCustom, { value: () => show(value) });
+  return Object.freeze(value);
+}

package/src/util/json.ts

@@ -25,6 +25,14 @@ export function readOptionalInt(json: JsonObject, key: string): number | undefin
   return value;
 }
 
+/** The optional boolean at `key`; throws `FormatError` for a value of another type. */
+export function readOptionalBoolean(json: JsonObject, key: string): boolean | undefined {
+  const value = json[key];
+  if (value === undefined || value === null) return undefined;
+  if (typeof value !== 'boolean') throw new FormatError(`Saved state: "${key}" is not a boolean`);
+  return value;
+}
+
 /** The object at `key`; throws `FormatError` if it is missing or not an object. */
 export function readObject(json: JsonObject, key: string): JsonObject {
   const value = json[key];
@@ -32,6 +40,14 @@ export function readObject(json: JsonObject, key: string): JsonObject {
   return value;
 }
 
+/** The optional object at `key`; throws `FormatError` for a value of another type. */
+export function readOptionalObject(json: JsonObject, key: string): JsonObject | undefined {
+  const value = json[key];
+  if (value === undefined || value === null) return undefined;
+  if (!isJsonObject(value)) throw new FormatError(`Saved state: "${key}" is not an object`);
+  return value;
+}
+
 /** The optional list at `key`, each element checked by `isElement`; throws `FormatError` for anything else. */
 export function readOptionalList<T>(
   json: JsonObject,

package/src/util/text.ts

@@ -1,14 +1,20 @@
-import { base64Decode, latin1Decode, utf8Decode } from './bytes.js';
+import { base64Decode, fromCharCodes, latin1Decode, utf8Decode } from './bytes.js';
 import { FormatError } from './errors.js';
 
 const xmlEncodingDeclaration = /encoding\s*=\s*["']([A-Za-z0-9._-]+)["']/;
 const whitespace = /\s/g;
+const whiteSpaceCharacter = /\s/;
 
-/** Decodes text from the bank, which may be UTF-8 (with or without BOM) or ISO 8859-1. */
+/**
+ * Decodes text from the bank, which may be UTF-8 (with or without BOM) or ISO 8859-1; ASCII reads the same in both.
+ *
+ * UTF-8 comes first, since some banks send it. ISO 8859-1 text that happens to be valid UTF-8, such as `ß°`, reads as
+ * UTF-8 then: a rare misreading of text shown, as values sent back to the bank are read byte for byte
+ * (`Segment.verbatim`).
+ */
 export function decodeBankText(bytes: Uint8Array): string {
   const hasBom = bytes.length >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf;
   const content = hasBom ? bytes.subarray(3) : bytes;
-  if (content.every((b) => b < 0x80)) return latin1Decode(content);
   try {
     return utf8Decode(content);
   } catch (error) {
@@ -44,11 +50,18 @@ const windows1252High = [
   0x0153, 0x009d, 0x017e, 0x0178,
 ];
 
-/** Decodes Windows-1252, which matches ISO 8859-1 except for `€`, typographic quotes and a few letters. */
+/**
+ * Decodes Windows-1252, which matches ISO 8859-1 except for `€`, typographic quotes and a few letters.
+ *
+ * @internal Exported for the tests.
+ */
 export function decodeWindows1252(bytes: Uint8Array): string {
-  let text = '';
-  for (const b of bytes) text += String.fromCharCode(b >= 0x80 && b < 0xa0 ? windows1252High[b - 0x80]! : b);
-  return text;
+  const codes = new Uint16Array(bytes.length);
+  for (let i = 0; i < bytes.length; i++) {
+    const b = bytes[i]!;
+    codes[i] = b >= 0x80 && b < 0xa0 ? windows1252High[b - 0x80]! : b;
+  }
+  return fromCharCodes(codes);
 }
 
 /**
@@ -59,6 +72,63 @@ export function maskedId(id: string): string {
   return id.length <= 4 ? '…' : `…${id.substring(id.length - 4)}`;
 }
 
+/** `count` and `noun`, in the plural unless `count` is 1, such as `3 transactions`. */
+export function counted(count: number, noun: string): string {
+  return `${count} ${noun}${count === 1 ? '' : 's'}`;
+}
+
+/** 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;
+}
+
+/**
+ * Whether the UTF-16 code unit `code` is a blank: white space to `String.prototype.trim`, or U+0085 (NEL), which it
+ * keeps although Unicode counts it as white space. ISO 8859-1 bank data hold it as the byte 0x85.
+ */
+function isBlank(code: number): boolean {
+  // Below U+1680, the first white space beyond these, without a regular expression, which takes many times as long.
+  if (code < 0x1680) return code === 0x20 || (code >= 0x09 && code <= 0x0d) || code === 0x85 || code === 0xa0;
+  return whiteSpaceCharacter.test(String.fromCharCode(code));
+}
+
+/** `text` without blanks (`isBlank`) at its `start` and its `end`. */
+export function trimBlanks(text: string, { start = true, end = true } = {}): string {
+  let first = 0;
+  let last = text.length;
+  if (start) while (first < last && isBlank(text.charCodeAt(first))) first++;
+  if (end) while (last > first && isBlank(text.charCodeAt(last - 1))) last--;
+  return text.substring(first, last);
+}
+
+/** `text` without blanks around it (`trimBlanks`); `undefined` if that leaves nothing. */
+export function nonBlank(text: string | undefined): string | undefined {
+  const trimmed = text === undefined ? undefined : trimBlanks(text);
+  return trimmed === '' ? undefined : trimmed;
+}
+
+/**
+ * The character the numeric character reference `name` names, such as `#x41` or `#65`; `undefined` for any other name,
+ * and for a number that is no character as XML defines them: `NUL`, half a surrogate pair, or beyond Unicode.
+ */
+export function characterReference(name: string): string | undefined {
+  const m = /^#(?:x([0-9a-fA-F]+)|([0-9]+))$/.exec(name);
+  if (!m) return undefined;
+  const code = m[1] === undefined ? parseInt(m[2]!, 10) : parseInt(m[1], 16);
+  return code > 0 && (code < 0xd800 || code > 0xdfff) && code <= 0x10ffff ? String.fromCodePoint(code) : undefined;
+}
+
+/**
+ * `text` with its full-width characters, which East Asian input methods type, as their ASCII counterparts: U+FF01 to
+ * U+FF5E as U+0021 to U+007E, and the ideographic space U+3000 as a blank.
+ */
+export function withAsciiForms(text: string): string {
+  return text
+    .replace(/[\uff01-\uff5e]/g, (c) => String.fromCharCode(c.charCodeAt(0) - 0xfee0))
+    .replaceAll('\u3000', ' ');
+}
+
 /** `text` without spaces and line breaks. */
 export function withoutWhitespace(text: string): string {
   return text.replace(whitespace, '');
@@ -69,14 +139,16 @@ export function decodeBase64Lines(text: string): Uint8Array {
   return base64Decode(withoutWhitespace(text));
 }
 
-/** `text` with every match of `pattern`, a literal string, escaped for use in a regular expression. */
-export function escapeRegExp(text: string): string {
-  return text.replace(/[.*+?^${}()|[\]\\/-]/g, '\\$&');
-}
-
-/** The integer `text` states, decimal digits with an optional sign and blanks around; `undefined` for anything else. */
+/**
+ * The integer `text` states, decimal digits with an optional sign and blanks around, `-0` as 0; `undefined` for
+ * anything else, such as hex, and for a value beyond `Number.MAX_SAFE_INTEGER`, which a number holds only
+ * approximately.
+ */
 export function tryParseInt(text: string | undefined): number | undefined {
   if (text === undefined) return undefined;
-  const match = /^\s*([+-]?\d+)\s*$/.exec(text);
-  return match ? Number(match[1]) : undefined;
+  const integer = trimBlanks(text);
+  if (!/^[+-]?\d+$/.test(integer)) return undefined;
+  const value = Number(integer);
+  if (!Number.isSafeInteger(value)) return undefined;
+  return value === 0 ? 0 : value;
 }

package/src/util/xml.ts

@@ -1,4 +1,5 @@
 import { FormatError } from './errors.js';
+import { characterReference, nonBlank } from './text.js';
 
 /**
  * An element of a parsed XML document, looked up by local name: camt documents come with and without namespace
@@ -10,7 +11,7 @@ export class XmlElement {
   constructor(
     /** The name without namespace prefix. */
     readonly localName: string,
-    /** The attributes by name without namespace prefix; namespace declarations are left out. */
+    /** The attributes by name, namespace prefix and all. */
     readonly attributes: ReadonlyMap<string, string>,
   ) {}
 
@@ -23,13 +24,14 @@ export class XmlElement {
     return this.children.map((c) => (c instanceof XmlElement ? c.innerText : c)).join('');
   }
 
-  getAttribute(localName: string): string | undefined {
-    return this.attributes.get(localName);
+  /** The attribute called `name`: an unprefixed name finds no prefixed attribute, which is of another namespace. */
+  getAttribute(name: string): string | undefined {
+    return this.attributes.get(name);
   }
 
   /** The first child element called `localName`. */
   child(localName: string): XmlElement | undefined {
-    return this.childElements.find((c) => c.localName === localName);
+    return this.children.find((c): c is XmlElement => c instanceof XmlElement && c.localName === localName);
   }
 
   /** The element reached by following child names along `path`; this element for an empty path. */
@@ -39,71 +41,122 @@ export class XmlElement {
 
   /** The trimmed text of the element at `path`, or `undefined` if it is missing or empty. */
   textAt(path: readonly string[]): string | undefined {
-    const text = this.at(path)?.innerText.trim();
-    return text === undefined || text === '' ? undefined : text;
+    return nonBlank(this.at(path)?.innerText);
   }
 
-  /** All elements below this one called `localName`, in document order. */
-  descendantsNamed(localName: string): XmlElement[] {
-    const found: XmlElement[] = [];
-    const visit = (element: XmlElement): void => {
-      for (const c of element.childElements) {
-        if (c.localName === localName) found.push(c);
-        visit(c);
-      }
-    };
-    visit(this);
-    return found;
+  /** The child elements called `localName`, in document order. */
+  childrenNamed(localName: string): XmlElement[] {
+    return this.children.filter((c): c is XmlElement => c instanceof XmlElement && c.localName === localName);
   }
 }
 
-const namePattern = /[^\s<>/=!?"']+/y;
-const attributePattern = /\s+([^\s<>/=!?"']+)\s*=\s*(?:"([^"<]*)"|'([^'<]*)')/y;
+/** The characters an XML name starts with (XML 1.0, production 4). */
+const nameStartCharacters = String.raw`:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}`;
+/**
+ * An XML name (XML 1.0, production 5). The combining marks lead the class of the characters after the first: after
+ * another one, ESLint's `no-misleading-character-class` takes them for a combined character.
+ */
+const xmlName = String.raw`[${nameStartCharacters}][\u0300-\u036F${nameStartCharacters}\-.0-9\u00B7\u203F-\u2040]*`;
+const namePattern = new RegExp(xmlName, 'uy');
+
+/**
+ * White space to Unicode, U+0085 (NEL) among them, which separates the parts of a tag, and `<?xml` of the rest of the
+ * XML declaration, as the Dart package has it.
+ */
+const blank = String.raw`[\s\u0085]`;
+const blankPattern = new RegExp(blank);
+const attributePattern = new RegExp(
+  String.raw`${blank}+(${xmlName})${blank}*=${blank}*(?:"([^"<]*)"|'([^'<]*)')`,
+  'uy',
+);
+/** The start of the XML declaration, whose content is not read. */
+const declarationPattern = new RegExp(String.raw`<\?xml(?:${blank}|\?>)`, 'y');
+/** The text of a reference after its `&`, up to the `;` that ends it. */
+const referenceNamePattern = /[^;&\s]*/y;
 
 /** The match of the sticky `pattern` at `position` in `text`. */
 function matchAt(pattern: RegExp, text: string, position: number): RegExpExecArray | null {
   pattern.lastIndex = position;
   return pattern.exec(text);
 }
-const predefinedEntities: Record<string, string> = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" };
+const predefinedEntities = new Map([
+  ['amp', '&'],
+  ['lt', '<'],
+  ['gt', '>'],
+  ['quot', '"'],
+  ['apos', "'"],
+]);
+
+/** Deepest nesting of elements the parser takes: camt needs fewer than 20 levels, and `innerText` recurses. */
+const maxDepth = 100;
 
+/**
+ * Most nodes besides text a document may hold, unless it is long enough for one node per `charactersPerNode`
+ * characters: real camt spends 16 to 40 characters on each, while nodes as short as `<a/>` take a hundred times their
+ * length in memory.
+ */
+const maxNodes = 500_000;
+const charactersPerNode = 16;
+
+const noAttributes: ReadonlyMap<string, string> = new Map();
+
+/** The name without namespace prefix; `:a` has none, but is no unprefixed `a` either. */
 function localNameOf(qualified: string): string {
   const colon = qualified.indexOf(':');
-  return colon < 0 ? qualified : qualified.substring(colon + 1);
+  return colon > 0 ? qualified.substring(colon + 1) : qualified;
 }
 
-/** Resolves the character and predefined entity references in `text`; throws `FormatError` for any other. */
+/**
+ * Resolves the character and predefined entity references in `text`; throws `FormatError` for any other, at the first.
+ * A global `replace` would find all of them before it looked at the first: a gigabyte for megabytes of `&`.
+ */
 function decodeEntities(text: string): string {
-  return text.replace(/&([^;&\s]*);?/g, (match, name: string) => {
-    if (!match.endsWith(';')) throw new FormatError('Invalid XML: unterminated entity reference');
-    if (name.startsWith('#')) {
-      const hex = name.startsWith('#x');
-      const digits = name.substring(hex ? 2 : 1);
-      const code = (hex ? /^[0-9a-fA-F]+$/ : /^\d+$/).test(digits) ? parseInt(digits, hex ? 16 : 10) : NaN;
-      if (!(code > 0 && code <= 0x10ffff && (code < 0xd800 || code > 0xdfff))) {
-        throw new FormatError('Invalid XML character reference', match);
-      }
-      return String.fromCodePoint(code);
-    }
-    const value = predefinedEntities[name];
-    if (value === undefined) throw new FormatError('Invalid XML: unknown entity', match);
-    return value;
-  });
+  let decoded = '';
+  let position = 0;
+  for (let ampersand = text.indexOf('&'); ampersand >= 0; ampersand = text.indexOf('&', position)) {
+    const name = matchAt(referenceNamePattern, text, ampersand + 1)![0];
+    const end = ampersand + 1 + name.length;
+    if (text.charAt(end) !== ';') throw new FormatError('Invalid XML: unterminated entity reference');
+    decoded += text.substring(position, ampersand) + resolved(name, text.substring(ampersand, end + 1));
+    position = end + 1;
+  }
+  return position === 0 ? text : decoded + text.substring(position);
+}
+
+/** The text the `reference` called `name` stands for. */
+function resolved(name: string, reference: string): string {
+  if (name.startsWith('#')) {
+    const character = characterReference(name);
+    if (character === undefined) throw new FormatError('Invalid XML character reference', reference);
+    return character;
+  }
+  const value = predefinedEntities.get(name);
+  if (value === undefined) throw new FormatError('Invalid XML: unknown entity', reference);
+  return value;
 }
 
 /**
- * Parses an XML document and returns its root element; throws `FormatError` if it is not well-formed.
+ * Parses an XML document and returns its root element; throws `FormatError` if it is not well-formed, nests elements
+ * deeper than 100 levels, or holds more than 500,000 nodes besides text (elements, attributes, comments, processing
+ * instructions, the XML declaration and CDATA sections) or one per 16 characters, whichever is more.
  *
  * A document type declaration is refused: bank data have none, and its entities could expand without limit.
  */
 export function parseXml(xml: string): XmlElement {
   let position = 0;
   const stack: XmlElement[] = [];
+  const openNames: string[] = [];
   let root: XmlElement | undefined;
+  let declared = false;
+  let nodes = 0;
+  const nodeLimit = Math.max(maxNodes, Math.floor(xml.length / charactersPerNode));
 
   const fail = (reason: string): never => {
     throw new FormatError(`Invalid XML: ${reason} at position ${position}`);
   };
+  const countNode = (): void => {
+    if (++nodes > nodeLimit) fail(`more than ${nodeLimit} nodes`);
+  };
   const skipPast = (terminator: string, what: string): void => {
     const end = xml.indexOf(terminator, position);
     if (end < 0) fail(`unterminated ${what}`);
@@ -115,18 +168,37 @@ export function parseXml(xml: string): XmlElement {
     const textEnd = lt < 0 ? xml.length : lt;
     if (textEnd > position) {
       const text = xml.substring(position, textEnd);
-      const parent = stack.at(-1);
-      if (parent) parent.children.push(decodeEntities(text));
-      else if (text.trim() !== '') fail('text outside the root element');
+      // Blanks are dropped only where they follow no text, as between elements: kept, they would double the nodes of a
+      // document with line breaks. Between two texts they are content, and a counted node separates the two.
+      if (nonBlank(text) !== undefined || typeof stack.at(-1)?.children.at(-1) === 'string') {
+        (stack.at(-1) ?? fail('text outside the root element')).children.push(decodeEntities(text));
+      }
       position = textEnd;
       continue;
     }
     if (xml.startsWith('<?', position)) {
+      countNode();
+      if (matchAt(declarationPattern, xml, position)) {
+        if (root) fail('XML declaration inside or after the root element');
+        if (declared) fail('a second XML declaration');
+        declared = true;
+      } else {
+        position += 2;
+        const target = matchAt(namePattern, xml, position)?.[0] ?? fail('missing processing instruction target');
+        position += target.length;
+        if (!xml.startsWith('?>', position) && !blankPattern.test(xml.charAt(position))) {
+          fail('malformed processing instruction');
+        }
+      }
       skipPast('?>', 'processing instruction');
     } else if (xml.startsWith('<!--', position)) {
+      countNode();
+      // Past the `<!--`, whose dashes end no comment: `<!-->` starts one.
+      position += 4;
       skipPast('-->', 'comment');
     } else if (xml.startsWith('<![CDATA[', position)) {
       const parent = stack.at(-1) ?? fail('CDATA outside the root element');
+      countNode();
       const start = position + 9;
       skipPast(']]>', 'CDATA section');
       parent.children.push(xml.substring(start, position - 3));
@@ -136,37 +208,43 @@ export function parseXml(xml: string): XmlElement {
       position += 2;
       const name = matchAt(namePattern, xml, position)?.[0] ?? fail('missing end tag name');
       position += name.length;
-      while (/\s/.test(xml.charAt(position))) position++;
+      while (blankPattern.test(xml.charAt(position))) position++;
       if (xml.charAt(position) !== '>') fail('malformed end tag');
       position++;
-      const open = stack.pop();
-      if (open === undefined || open.localName !== localNameOf(name)) fail(`unexpected end tag ${name}`);
+      stack.pop();
+      if (openNames.pop() !== name) fail(`unexpected end tag ${name}`);
     } else {
+      if (stack.length >= maxDepth) fail(`elements nested deeper than ${maxDepth} levels`);
+      countNode();
       position++;
       const name = matchAt(namePattern, xml, position)?.[0] ?? fail('missing element name');
       position += name.length;
-      const attributes = new Map<string, string>();
+      let attributes: Map<string, string> | undefined;
       for (;;) {
         const attribute = matchAt(attributePattern, xml, position);
         if (!attribute) break;
         position += attribute[0].length;
+        countNode();
         const attributeName = attribute[1]!;
-        if (attributeName !== 'xmlns' && !attributeName.startsWith('xmlns:')) {
-          attributes.set(localNameOf(attributeName), decodeEntities(attribute[2] ?? attribute[3] ?? ''));
-        }
+        attributes ??= new Map();
+        if (attributes.has(attributeName)) fail(`duplicate attribute ${attributeName}`);
+        attributes.set(attributeName, decodeEntities(attribute[2] ?? attribute[3] ?? ''));
       }
-      while (/\s/.test(xml.charAt(position))) position++;
+      while (blankPattern.test(xml.charAt(position))) position++;
       const selfClosing = xml.startsWith('/>', position);
       if (!selfClosing && xml.charAt(position) !== '>') fail(`malformed start tag ${name}`);
       position += selfClosing ? 2 : 1;
-      const element = new XmlElement(localNameOf(name), attributes);
+      const element = new XmlElement(localNameOf(name), attributes ?? noAttributes);
       const parent = stack.at(-1);
       if (parent) parent.children.push(element);
       else if (root) fail('a second root element');
       else root = element;
-      if (!selfClosing) stack.push(element);
+      if (!selfClosing) {
+        stack.push(element);
+        openNames.push(name);
+      }
     }
   }
-  if (stack.length > 0) fail(`unclosed element ${stack.at(-1)!.localName}`);
+  if (stack.length > 0) fail(`unclosed element ${openNames.at(-1)!}`);
   return root ?? fail('no root element');
 }

package/src/v3/account-extension.ts

@@ -4,7 +4,9 @@ import { AccountDataStatus, type Account } from '../core/account.js';
 import { Amount, withMark } from '../core/amount.js';
 import { Balance } from '../core/balance.js';
 import { parseFintsDate, parseUtcPlusOneDateTime } from '../util/dates.js';
-import { FormatError } from '../util/errors.js';
+import { fail, FormatError } from '../util/errors.js';
+import { isJsonObject } from '../util/json.js';
+import { nonBlank } from '../util/text.js';
 
 /** A booked or pending balance of the extension: credit/debit mark, value, date and time. */
 interface Saldo {
@@ -47,7 +49,7 @@ export class AccountExtension {
   static tryParse(json: string): AccountExtension | undefined {
     try {
       const decoded: unknown = JSON.parse(json);
-      return isObject(decoded) ? AccountExtension.read(new Json(decoded)) : undefined;
+      return isJsonObject(decoded) ? AccountExtension.read(new Json(decoded)) : undefined;
     } catch (error) {
       if (error instanceof FormatError || error instanceof SyntaxError) return undefined;
       throw error;
@@ -76,6 +78,7 @@ export class AccountExtension {
     if (b === undefined || !this.balanceComplete) return undefined;
     return new Balance({
       account,
+      productName: account.productName,
       booked: b.booked.amount,
       bookedAsOf: b.booked.date,
       bookedAsOfTime: b.booked.time,
@@ -129,14 +132,6 @@ function moment(json: Json, defaultTime?: string): Date | undefined {
   return parseUtcPlusOneDateTime(json.string('Date'), time) ?? fail('Extension date or time is malformed');
 }
 
-function fail(message: string): never {
-  throw new FormatError(message);
-}
-
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
 /**
  * A JSON object of the extension, read by key without regard to case: the specification itself spells some keys
  * differently (`OverDraftLim` and `OverdraftLim`). Values of the wrong type are a `FormatError`.
@@ -156,7 +151,7 @@ class Json {
   string(key: string): string | undefined {
     const value = this.value(key);
     if (value === undefined || value === null) return undefined;
-    if (typeof value === 'string') return value.trim() === '' ? undefined : value.trim();
+    if (typeof value === 'string') return nonBlank(value);
     if (typeof value === 'number') return String(value);
     throw new FormatError(`Extension element "${key}" is not text`);
   }
@@ -172,7 +167,7 @@ class Json {
   object(key: string): Json | undefined {
     const value = this.value(key);
     if (value === undefined || value === null) return undefined;
-    if (isObject(value)) return new Json(value);
+    if (isJsonObject(value)) return new Json(value);
     throw new FormatError(`Extension element "${key}" is not an object`);
   }