@fin.cx/opendata 4.6.0 → 4.8.0

package/ts/financialstatements/parse.hgb.ts

@@ -0,0 +1,1235 @@
+import { FinancialStatementError } from './classes.financialstatementerror.js';
+import {
+  addAmounts,
+  amountsAgree,
+  formatAmount,
+  namesOtherCurrency,
+  negateAmount,
+  normalizeSpaces,
+  parsePrintedAmount,
+  readsAsAmount,
+  sumAmounts,
+  toAmount,
+  unitsIn,
+  unitStatedBy,
+  withoutOtherCurrencies,
+  withoutUnits,
+  zeroAmount,
+  type IAmount,
+} from './amounts.js';
+import { lastDateIn, lastYearIn, periodIn, withoutDates } from './dates.js';
+import { isMemoLabel, isTotalLabel, splitOutlineCode, type IOutlineCode } from './outline.js';
+import type { ILayoutCell, TLayoutBlock } from './layout.js';
+import type {
+  IHgbStatement,
+  IIncomeStatement,
+  IKeyFigures,
+  IStatementPeriod,
+  IStatementPosition,
+  IStatementUnit,
+  TIncomeStatementMethod,
+  TIsoDate,
+  TStatementLineKind,
+} from './interfaces.js';
+
+type TPeriod = 'current' | 'prior';
+/** the two columns a year may have: the Vorspalte for parts, the main column for what they add up to */
+type TSlot = 'pre' | 'main';
+type TSide = 'assets' | 'liabilities';
+type TMarker = TSide | 'balance' | 'income' | 'other';
+
+const statementPeriods: TPeriod[] = ['current', 'prior'];
+
+const notNull = <T>(valueArg: T | null): valueArg is T => valueArg !== null;
+
+// ---------------------------------------------------------------------------------------------
+// headings that mark the parts of a document
+
+/** the parts of an annual report after the statements, which end them */
+const otherPartPattern =
+  /^(?:Anhang|Lagebericht|Anlagenspiegel|Entwicklung des (?:Konzern-?)?Anlagevermögens|Bestätigungsvermerk|Ergebnisverwendung|Vorschlag (?:für die|zur) (?:Verwendung|Ergebnisverwendung)|Bericht des Aufsichtsrat|Kapitalflussrechnung|Eigenkapitalspiegel|Angaben)/i;
+
+/** a heading set letter by letter, `A K T I V A`, as one word */
+const unspaced = (textArg: string): string => (/^(?:[A-ZÄÖÜ] )+[A-ZÄÖÜ]$/.test(textArg) ? textArg.replace(/ /g, '') : textArg);
+
+/** the part of a document a heading opens; null for any other text */
+const markerOf = (textArg: string): TMarker | null => {
+  const text = unspaced(normalizeSpaces(textArg)).replace(/\s*:$/, '');
+  if (text === '' || text.length > 120) {
+    return null;
+  }
+  if (/^(?:Aktiva|Aktivseite)$/i.test(text)) {
+    return 'assets';
+  }
+  if (/^(?:Passiva|Passivseite)$/i.test(text)) {
+    return 'liabilities';
+  }
+  if (/^(?:Konzern-?)?bilanz\b/i.test(text)) {
+    return 'balance';
+  }
+  if (/^(?:Konzern-?)?Gewinn-? und Verlustrechnung\b/i.test(text) || /^GuV\b/.test(text)) {
+    return 'income';
+  }
+  return otherPartPattern.test(text) && unitStatedBy(text) === null ? 'other' : null;
+};
+
+// ---------------------------------------------------------------------------------------------
+// column headings
+
+const priorWordPattern = /Vorjahr|\bVJ\b|vorhergehend|vorangegangen|Vorperiode/i;
+const currentWordPattern = /Geschäftsjahr|Berichtsjahr|Berichtszeitraum|laufendes|aktuelles|\bGJ\b/i;
+const periodWordPattern = /Jahr|Periode|Zeitraum|Stichtag|\bGJ\b|\bVJ\b/i;
+const notesHeadingPattern = /^(?:Anhang|Anh\.|Anm\.|Tz\.|Ziffer|Ziff\.|Erl\.|Note|Notes)(?![A-Za-zÄÖÜäöüß])/i;
+
+/** the words a column heading may hold besides dates, years and units */
+const headingWords = new Set([
+  'geschäftsjahr', 'geschäftsjahres', 'berichtsjahr', 'berichtsjahres', 'wirtschaftsjahr', 'wirtschaftsjahres',
+  'vorjahr', 'vorjahres', 'vorjahreszahlen', 'vorjahreswerte', 'vorjahresbetrag', 'vorjahresbeträge',
+  'berichtszeitraum', 'berichtszeitraums', 'berichtsperiode', 'vorperiode', 'periode', 'zeitraum', 'stichtag',
+  'jahr', 'jahres', 'laufendes', 'laufenden', 'aktuelles', 'aktuellen', 'vorhergehendes', 'vorhergehenden',
+  'vorangegangenes', 'vorangegangenen', 'gj', 'vj', 'betrag', 'beträge', 'stand', 'zum', 'per', 'am', 'in',
+  'bis', 'vom', 'von', 'für', 'das', 'der', 'die', 'des', 'dem', 'den', 'im', 'anhang', 'anh', 'anm', 'tz',
+  'ziffer', 'ziff', 'erl', 'erläuterung', 'erläuterungen', 'note', 'notes', 'nr', 'januar', 'jänner',
+  'februar', 'märz', 'april', 'mai', 'juni', 'juli', 'august', 'september', 'oktober', 'november', 'dezember',
+]);
+
+/**
+ * whether a cell can head a column: dates, years, units and the words for the two years only; a
+ * currency other than the euro heads a column too, for the statement to be refused for it
+ */
+const isHeadingText = (textArg: string): boolean => {
+  if (readsAsAmount(textArg)) {
+    return false;
+  }
+  const rest = withoutDates(withoutOtherCurrencies(withoutUnits(textArg))).replace(/\b(?:19|20)\d{2}\b/g, ' ');
+  if (/\d/.test(rest)) {
+    return false;
+  }
+  return rest
+    .split(/[^A-Za-zÄÖÜäöüß]+/)
+    .filter((wordArg) => wordArg !== '')
+    .every((wordArg) => headingWords.has(wordArg.toLowerCase()));
+};
+
+/** whether a heading names a year or a unit, not only a note column */
+const namesPeriodOrUnit = (textArg: string): boolean =>
+  unitsIn(textArg).length > 0 ||
+  namesOtherCurrency(textArg) ||
+  lastDateIn(textArg) !== null ||
+  lastYearIn(textArg) !== null ||
+  periodWordPattern.test(textArg);
+
+/**
+ * A row that heads the columns below it: no outline code, and every cell right of the label a
+ * heading, one of them naming a year or a unit.
+ */
+const isHeadingRow = (cellsArg: ILayoutCell[]): boolean => {
+  const labelCell = cellsArg.find((cellArg) => cellArg.first === 0);
+  if (labelCell && splitOutlineCode(labelCell.text).code !== null) {
+    return false;
+  }
+  const headings = cellsArg.filter((cellArg) => cellArg.first > 0);
+  if (headings.length === 0 || !headings.every((cellArg) => isHeadingText(cellArg.text))) {
+    return false;
+  }
+  if (!headings.some((cellArg) => namesPeriodOrUnit(cellArg.text))) {
+    return false;
+  }
+  return (
+    !labelCell ||
+    markerOf(labelCell.text) !== null ||
+    isHeadingText(labelCell.text) ||
+    /^(?:Posten|Position|Bezeichnung|Gliederung)$/i.test(labelCell.text)
+  );
+};
+
+// ---------------------------------------------------------------------------------------------
+// the parts of a document
+
+/** a row of a table in the balance sheet or the income statement */
+interface IRowItem {
+  cells: ILayoutCell[];
+  /** the table it is in */
+  block: number;
+  side: TSide | null;
+  heading: boolean;
+}
+
+interface ISectionDraft {
+  /** the lines of text in the section, its heading among them */
+  contexts: string[];
+  items: IRowItem[];
+  /** the rows with amounts */
+  valueRows: number;
+}
+
+interface ISections {
+  /** the lines of text before the first statement */
+  documentContext: string[];
+  balance: ISectionDraft;
+  income: ISectionDraft;
+  sideValueRows: Record<TSide, number>;
+  sideBySide: boolean;
+  notes: string[];
+}
+
+const hasAmountCell = (cellsArg: ILayoutCell[]): boolean =>
+  cellsArg.some((cellArg) => cellArg.first > 0 && readsAsAmount(cellArg.text));
+
+/**
+ * Splits a document into its balance sheet, its income statement and the text before them, by the
+ * headings that open them. A part ends at the next heading; one that comes again after it was read
+ * in full is left out with a note.
+ */
+const readSections = (blocksArg: TLayoutBlock[]): ISections => {
+  const newDraft = (): ISectionDraft => ({ contexts: [], items: [], valueRows: 0 });
+  const sections: ISections = {
+    documentContext: [],
+    balance: newDraft(),
+    income: newDraft(),
+    sideValueRows: { assets: 0, liabilities: 0 },
+    sideBySide: false,
+    notes: [],
+  };
+  let section: 'none' | 'balance' | 'income' | 'other' = 'none';
+  let side: TSide | null = null;
+  const draft = (): ISectionDraft | null =>
+    section === 'balance' ? sections.balance : section === 'income' ? sections.income : null;
+  const balanceComplete = () => sections.sideValueRows.assets > 0 && sections.sideValueRows.liabilities > 0;
+  const addContext = (textArg: string) => {
+    const target = draft();
+    if (target) {
+      target.contexts.push(textArg);
+    } else if (section === 'none') {
+      sections.documentContext.push(textArg);
+    }
+  };
+  const noteSecond = (whatArg: string) => {
+    const note = `The document holds a second ${whatArg}, which was not read.`;
+    if (!sections.notes.includes(note)) {
+      sections.notes.push(note);
+    }
+  };
+  const enter = (markerArg: TMarker) => {
+    if (markerArg === 'assets' || markerArg === 'liabilities') {
+      if (section !== 'balance') {
+        if (balanceComplete()) {
+          return;
+        }
+        section = 'balance';
+      }
+      side = markerArg;
+    } else if (markerArg === 'balance') {
+      if (section !== 'balance') {
+        if (balanceComplete()) {
+          noteSecond('balance sheet');
+          section = 'other';
+          return;
+        }
+        section = 'balance';
+      }
+    } else if (markerArg === 'income') {
+      if (section !== 'income') {
+        if (sections.income.valueRows > 0) {
+          noteSecond('income statement');
+          section = 'other';
+          return;
+        }
+        section = 'income';
+      }
+    } else {
+      section = 'other';
+    }
+  };
+  blocksArg.forEach((block, blockIndex) => {
+    if (block.kind === 'text') {
+      const marker = markerOf(block.text);
+      if (marker) {
+        enter(marker);
+        addContext(block.text);
+      } else if (block.heading && (draft()?.valueRows ?? 0) > 0) {
+        section = 'other';
+      } else {
+        addContext(block.text);
+      }
+      return;
+    }
+    for (const cells of block.rows) {
+      const valued = hasAmountCell(cells);
+      if (
+        !valued &&
+        cells.some((cellArg) => markerOf(cellArg.text) === 'assets') &&
+        cells.some((cellArg) => markerOf(cellArg.text) === 'liabilities')
+      ) {
+        if (!balanceComplete()) {
+          section = 'balance';
+          sections.sideBySide = true;
+        }
+        continue;
+      }
+      const heading = !valued && isHeadingRow(cells);
+      if (!valued) {
+        const rowText = normalizeSpaces(cells.map((cellArg) => cellArg.text).join(' '));
+        const labelCell = cells.find((cellArg) => cellArg.first === 0);
+        const marker = (labelCell ? markerOf(labelCell.text) : null) ?? (heading ? null : markerOf(rowText));
+        if (marker) {
+          enter(marker);
+          if (!heading) {
+            addContext(rowText);
+          }
+          draft()?.items.push({ cells, block: blockIndex, side, heading });
+          continue;
+        }
+        if (!heading) {
+          addContext(rowText);
+        }
+      }
+      const target = draft();
+      if (!target) {
+        continue;
+      }
+      target.items.push({ cells, block: blockIndex, side, heading });
+      if (valued) {
+        target.valueRows++;
+        if (section === 'balance' && side) {
+          sections.sideValueRows[side]++;
+        }
+      }
+    }
+  });
+  return sections;
+};
+
+// ---------------------------------------------------------------------------------------------
+// columns and rows
+
+/** what a column holds: one of the two years, as its parts or as their sum */
+interface IColumnRole {
+  period: TPeriod;
+  slot: TSlot;
+  /** the column's heading as printed */
+  heading: string;
+  /** the date the heading names */
+  date: TIsoDate | null;
+}
+
+/** a printed row with its amounts, each a year and a column */
+interface IRow {
+  /** the label without its outline code */
+  label: string;
+  code: IOutlineCode | null;
+  memo: boolean;
+  /** an uncoded row that sums the rows above it: Summe, Bilanzsumme, or no label at all */
+  total: boolean;
+  values: Record<TPeriod, Record<TSlot, IAmount | null>>;
+  hasValues: boolean;
+  side: TSide | null;
+}
+
+interface ISectionRows {
+  rows: IRow[];
+  unit: IStatementUnit;
+  /** the years printed in two columns */
+  vorspalte: Set<TPeriod>;
+  /** the main column of each year, as the first table to show it heads it */
+  columns: Partial<Record<TPeriod, IColumnRole>>;
+}
+
+type TFail = (messageArg: string) => never;
+
+/** the tables of a section split where a table or a run of column headings begins */
+const scopesOf = (itemsArg: IRowItem[]): Array<{ headings: IRowItem[]; body: IRowItem[] }> => {
+  const scopes: Array<{ headings: IRowItem[]; body: IRowItem[] }> = [];
+  let previous: IRowItem | null = null;
+  for (const item of itemsArg) {
+    if (!previous || item.block !== previous.block || (item.heading && !previous.heading)) {
+      scopes.push({ headings: [], body: [] });
+    }
+    const scope = scopes[scopes.length - 1];
+    (item.heading && scope.body.length === 0 ? scope.headings : scope.body).push(item);
+    previous = item;
+  }
+  return scopes;
+};
+
+/** the years of a table's columns, from their headings */
+const rolesOf = (headingsArg: string[], failArg: TFail): IColumnRole[] => {
+  const infos = headingsArg.map((headingArg) => {
+    const date = lastDateIn(headingArg);
+    return {
+      word: priorWordPattern.test(headingArg) ? 'prior' : currentWordPattern.test(headingArg) ? 'current' : null,
+      date,
+      year: date ? Number(date.slice(0, 4)) : lastYearIn(headingArg),
+    } as { word: TPeriod | null; date: TIsoDate | null; year: number | null };
+  });
+  const stated = infos.filter((infoArg) => infoArg.word !== null || infoArg.year !== null);
+  const periodsOf: Array<TPeriod | null> = infos.map(() => null);
+  const byLatest = <T>(keyOf: (infoArg: (typeof infos)[number]) => T | null) => {
+    const distinct = [...new Set(stated.map(keyOf))].sort();
+    if (distinct.length > 2) {
+      failArg('shows columns for more than two years.');
+    }
+    infos.forEach((infoArg, index) => {
+      const key = keyOf(infoArg);
+      if (key !== null) {
+        periodsOf[index] = key === distinct[distinct.length - 1] ? 'current' : 'prior';
+      }
+    });
+  };
+  if (stated.length > 0) {
+    if (stated.every((infoArg) => infoArg.date !== null)) {
+      byLatest((infoArg) => infoArg.date);
+    } else if (stated.every((infoArg) => infoArg.year !== null)) {
+      byLatest((infoArg) => infoArg.year);
+    } else if (stated.every((infoArg) => infoArg.word !== null)) {
+      infos.forEach((infoArg, index) => (periodsOf[index] = infoArg.word));
+    } else {
+      failArg('heads some columns with a date and others with a word.');
+    }
+  }
+  infos.forEach((infoArg, index) => {
+    if (infoArg.word !== null && periodsOf[index] !== null && infoArg.word !== periodsOf[index]) {
+      failArg(`heads a column "${headingsArg[index]}", which names another year than its date.`);
+    }
+  });
+  const dates = infos.map((infoArg) => infoArg.date);
+  for (let index = infos.length - 1; index >= 0; index--) {
+    if (periodsOf[index] !== null) {
+      continue;
+    }
+    if (index + 1 < infos.length) {
+      periodsOf[index] = periodsOf[index + 1];
+      dates[index] = dates[index + 1];
+    } else if (infos.length === 1) {
+      periodsOf[index] = 'current';
+    } else {
+      failArg('has columns whose year it does not state.');
+    }
+  }
+  if (!periodsOf.includes('current')) {
+    failArg('has no column for the current year.');
+  }
+  const roles: IColumnRole[] = [];
+  for (const period of statementPeriods) {
+    const indexes = periodsOf.flatMap((periodArg, index) => (periodArg === period ? [index] : []));
+    if (indexes.length > 2) {
+      failArg(`has more than two columns for the ${period} year.`);
+    }
+    indexes.forEach((columnIndex, position) => {
+      roles[columnIndex] = {
+        period,
+        slot: indexes.length === 2 && position === 0 ? 'pre' : 'main',
+        heading: headingsArg[columnIndex],
+        date: dates[columnIndex],
+      };
+    });
+  }
+  return roles;
+};
+
+/** the one unit some lines state; null if none does */
+const unitStatedIn = (linesArg: string[], failArg: TFail): IStatementUnit | null => {
+  const units = new Map(linesArg.map(unitStatedBy).filter(notNull).map((unitArg) => [unitArg.label, unitArg]));
+  if (units.size > 1) {
+    failArg(`states more than one unit (${[...units.keys()].join(', ')}).`);
+  }
+  return [...units.values()][0] ?? null;
+};
+
+/** a cell that holds only a unit, `T€` or `(EUR)` */
+const isUnitOnly = (textArg: string): boolean =>
+  unitsIn(textArg).length > 0 && /^[\s()]*$/.test(withoutUnits(textArg));
+
+/**
+ * Reads the rows of a section: finds each table's amount columns and the year and unit each stands
+ * for, and the label and amounts of each row. Throws `unparseable` where a column's year or unit is
+ * not stated with certainty, or where a row holds text in an amount column.
+ */
+const readSectionRows = (draftArg: ISectionDraft, titleArg: string, documentContextArg: string[]): ISectionRows => {
+  const fail: TFail = (messageArg) => {
+    throw new FinancialStatementError('unparseable', `The ${titleArg} ${messageArg}`);
+  };
+  const contextUnit = unitStatedIn(draftArg.contexts, fail) ?? unitStatedIn(documentContextArg, fail);
+  const result: ISectionRows = { rows: [], unit: null as unknown as IStatementUnit, vorspalte: new Set(), columns: {} };
+  let previous: { columns: number[]; roles: IColumnRole[]; unit: IStatementUnit } | null = null;
+  let sectionUnit: IStatementUnit | null = null;
+  for (const scope of scopesOf(draftArg.items)) {
+    const headingCells = scope.headings.flatMap((itemArg) => itemArg.cells).filter((cellArg) => cellArg.first > 0);
+    const notesColumns = new Set<number>();
+    for (const cell of headingCells) {
+      if (notesHeadingPattern.test(cell.text)) {
+        for (let column = cell.first; column <= cell.last; column++) {
+          notesColumns.add(column);
+        }
+      }
+    }
+    const inNotesColumn = (cellArg: ILayoutCell) => {
+      for (let column = cellArg.first; column <= cellArg.last; column++) {
+        if (!notesColumns.has(column)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    const bodies = scope.body.map((itemArg) => {
+      const cells = itemArg.cells.filter((cellArg) => cellArg.first === 0 || !inNotesColumn(cellArg));
+      return {
+        item: itemArg,
+        cells: cells.filter((cellArg) => cellArg.first === 0 || !isUnitOnly(cellArg.text)),
+        unitCells: cells.filter((cellArg) => cellArg.first > 0 && isUnitOnly(cellArg.text)),
+      };
+    });
+    const columns = [
+      ...new Set(
+        bodies.flatMap((bodyArg) =>
+          bodyArg.cells.filter((cellArg) => cellArg.first > 0 && readsAsAmount(cellArg.text)).map((cellArg) => cellArg.last)
+        )
+      ),
+    ].sort((leftArg, rightArg) => leftArg - rightArg);
+    let roles: IColumnRole[] = [];
+    let unit: IStatementUnit | null = null;
+    if (columns.length > 0) {
+      if (scope.headings.length === 0 && previous) {
+        if (previous.columns.length !== columns.length) {
+          fail('changes its columns without heading them anew.');
+        }
+        roles = previous.roles;
+        unit = previous.unit;
+      } else {
+        const headingOf = (columnArg: number) =>
+          normalizeSpaces(
+            headingCells
+              .filter((cellArg) => cellArg.first <= columnArg && columnArg <= cellArg.last)
+              .map((cellArg) => cellArg.text)
+              .join(' ')
+          );
+        roles = rolesOf(columns.map(headingOf), fail);
+        const headingText = headingCells.map((cellArg) => cellArg.text).join(' ');
+        if (namesOtherCurrency(headingText)) {
+          fail('is in a currency other than the euro.');
+        }
+        const headingUnits = new Map(unitsIn(headingText).map((unitArg) => [unitArg.label, unitArg]));
+        if (headingUnits.size > 1) {
+          fail(`heads its columns with more than one unit (${[...headingUnits.keys()].join(', ')}).`);
+        }
+        const printedUnits = new Map(
+          bodies
+            .flatMap((bodyArg) => [
+              ...bodyArg.cells
+                .filter((cellArg) => columns.includes(cellArg.last) && cellArg.first > 0)
+                .map((cellArg) => parsePrintedAmount(cellArg.text)?.unit ?? null),
+              ...bodyArg.unitCells.map((cellArg) => unitsIn(cellArg.text)[0]),
+            ])
+            .filter(notNull)
+            .map((unitArg) => [unitArg.label, unitArg])
+        );
+        if (printedUnits.size > 1) {
+          fail(`prints amounts in more than one unit (${[...printedUnits.keys()].join(', ')}).`);
+        }
+        unit = [...headingUnits.values()][0] ?? contextUnit ?? [...printedUnits.values()][0] ?? null;
+        if (!unit) {
+          fail('does not state its unit (EUR, TEUR or Mio. EUR).');
+        }
+      }
+      const scopeUnit = unit as IStatementUnit;
+      if (sectionUnit && sectionUnit.label !== scopeUnit.label) {
+        fail(`is printed in more than one unit (${sectionUnit.label}, ${scopeUnit.label}).`);
+      }
+      sectionUnit = scopeUnit;
+      previous = { columns, roles, unit: scopeUnit };
+      for (const role of roles) {
+        if (role.slot === 'pre') {
+          result.vorspalte.add(role.period);
+        } else {
+          result.columns[role.period] ??= role;
+        }
+      }
+    }
+    const labelLimit = columns.length > 0 ? columns[0] : Number.POSITIVE_INFINITY;
+    for (const body of bodies) {
+      const fullLabel = normalizeSpaces(
+        body.cells.filter((cellArg) => cellArg.first < labelLimit).map((cellArg) => cellArg.text).join(' ')
+      );
+      const values: IRow['values'] = { current: { pre: null, main: null }, prior: { pre: null, main: null } };
+      let amounts = 0;
+      let text: string | null = null;
+      for (const cell of body.cells.filter((cellArg) => cellArg.first >= labelLimit)) {
+        const index = columns.indexOf(cell.last);
+        const printed = index >= 0 ? parsePrintedAmount(cell.text) : null;
+        if (!printed) {
+          text ??= cell.text;
+          continue;
+        }
+        const scopeUnit = unit as IStatementUnit;
+        if (printed.unit && printed.unit.label !== scopeUnit.label) {
+          fail(`prints "${cell.text}" in a table in ${scopeUnit.label}.`);
+        }
+        const role = roles[index];
+        if (values[role.period][role.slot]) {
+          fail(`prints two amounts in one column of "${fullLabel}".`);
+        }
+        values[role.period][role.slot] = toAmount(printed, scopeUnit);
+        amounts++;
+      }
+      if (amounts > 0 && text !== null) {
+        fail(`holds text where an amount belongs: "${text}" in "${fullLabel}".`);
+      }
+      for (const cell of body.unitCells) {
+        if (unit && unitsIn(cell.text)[0].label !== unit.label) {
+          fail(`prints "${cell.text}" in a table in ${unit.label}.`);
+        }
+      }
+      const { code, label } = splitOutlineCode(fullLabel);
+      result.rows.push({
+        label,
+        code,
+        memo: isMemoLabel(label),
+        total: code === null && isTotalLabel(label),
+        values,
+        hasValues: amounts > 0,
+        side: body.item.side,
+      });
+    }
+  }
+  if (!sectionUnit) {
+    fail('prints no amounts.');
+  }
+  result.unit = sectionUnit as IStatementUnit;
+  return result;
+};
+
+// ---------------------------------------------------------------------------------------------
+// the outline
+
+/** a position of the outline, with the amount each year gives it */
+interface INode {
+  row: IRow;
+  parent: INode | null;
+  children: INode[];
+  depth: number;
+  codePath: string | null;
+  value: Record<TPeriod, IAmount | null>;
+}
+
+/**
+ * A printed line in its part of a statement:
+ * - `node`: a position;
+ * - `memo`: a "davon" line, belonging to `node`;
+ * - `sum`: a printed sum of the positions above it, such as Summe Anlagevermögen;
+ * - `total`: the total of a side of the balance sheet.
+ */
+interface IPartLine {
+  row: IRow;
+  role: 'node' | 'memo' | 'sum' | 'total';
+  node: INode | null;
+  /** the position before the line */
+  previous: INode | null;
+  /** for a sum, the position whose amount it states, per year */
+  closes: Record<TPeriod, INode | null>;
+}
+
+/** one side of the balance sheet, or the income statement */
+interface IPart {
+  lines: IPartLine[];
+  roots: INode[];
+  nodes: INode[];
+  total: IPartLine | null;
+}
+
+/** the labels of the income statement's intermediate results */
+const subtotalLabelPattern = /ergebnis|Zwischensumme|Summe|Rohertrag/i;
+
+/**
+ * Builds the outline of a part from its rows. Coded rows nest by their codes; an uncoded row with
+ * amounts belongs to the position before it where that position prints none of its own, else stands
+ * beside it. In the balance sheet the last row with amounts, uncoded, is the total of its side, and
+ * other summing rows are printed sums; in the income statement intermediate results stand at the top.
+ */
+const buildPart = (rowsArg: IRow[], incomeArg: boolean): IPart => {
+  const part: IPart = { lines: [], roots: [], nodes: [], total: null };
+  const valued = rowsArg.filter((rowArg) => rowArg.hasValues && !rowArg.memo);
+  const lastValued = valued[valued.length - 1];
+  const totalRow = !incomeArg && lastValued && lastValued.code === null ? lastValued : null;
+  const stack: INode[] = [];
+  let previous: INode | null = null;
+  const line = (rowArg: IRow, roleArg: IPartLine['role'], nodeArg: INode | null): IPartLine => {
+    const result: IPartLine = { row: rowArg, role: roleArg, node: nodeArg, previous, closes: { current: null, prior: null } };
+    part.lines.push(result);
+    return result;
+  };
+  const addNode = (rowArg: IRow, parentArg: INode | null): INode => {
+    let codeAbove: string | null = null;
+    for (let ancestor = parentArg; ancestor && codeAbove === null; ancestor = ancestor.parent) {
+      codeAbove = ancestor.codePath;
+    }
+    const node: INode = {
+      row: rowArg,
+      parent: parentArg,
+      children: [],
+      depth: parentArg ? parentArg.depth + 1 : 0,
+      codePath: rowArg.code ? (codeAbove ? `${codeAbove}.${rowArg.code.key}` : rowArg.code.key) : null,
+      value: { current: null, prior: null },
+    };
+    (parentArg ? parentArg.children : part.roots).push(node);
+    part.nodes.push(node);
+    previous = node;
+    line(rowArg, 'node', node);
+    return node;
+  };
+  for (const row of rowsArg) {
+    if (row === totalRow) {
+      part.total = line(row, 'total', null);
+    } else if (row.memo) {
+      if (row.hasValues) {
+        line(row, 'memo', previous);
+      }
+    } else if (row.code) {
+      while (stack.length > 0 && (stack[stack.length - 1].row.code as IOutlineCode).rank >= row.code.rank) {
+        stack.pop();
+      }
+      stack.push(addNode(row, stack[stack.length - 1] ?? null));
+    } else if (!row.hasValues) {
+      continue;
+    } else if (row.total && !incomeArg) {
+      line(row, 'sum', null);
+    } else if (incomeArg && (row.total || subtotalLabelPattern.test(row.label))) {
+      stack.length = 0;
+      addNode(row, null);
+    } else {
+      const before = previous as INode | null;
+      addNode(row, before && !before.row.hasValues ? before : (before?.parent ?? null));
+    }
+  }
+  return part;
+};
+
+const lastOf = (nodeArg: INode): INode => {
+  let node = nodeArg;
+  while (node.children.length > 0) {
+    node = node.children[node.children.length - 1];
+  }
+  return node;
+};
+
+/** what a position adds to its parent in a year: its own amount, else the sum of its parts' */
+const contributionOf = (nodeArg: INode, periodArg: TPeriod): IAmount | null => {
+  const own = nodeArg.value[periodArg];
+  if (own) {
+    return own;
+  }
+  const parts = nodeArg.children.map((childArg) => contributionOf(childArg, periodArg)).filter(notNull);
+  return parts.length > 0 ? sumAmounts(parts) : null;
+};
+
+const describe = (rowArg: IRow): string =>
+  `"${[rowArg.code?.printed, rowArg.label].filter((partArg) => partArg).join(' ') || '(no label)'}"`;
+
+/**
+ * The position a sum or a main-column amount states: the deepest of the given position and those
+ * above it that it closes, whose parts add up to the amount. A position without an amount of its own
+ * comes first; one whose own amount agrees also does.
+ */
+const closedBy = (fromArg: INode | null, lastArg: INode, amountArg: IAmount, periodArg: TPeriod, ownAllowedArg: boolean): INode | null => {
+  let agreeing: INode | null = null;
+  for (let candidate = fromArg; candidate && lastOf(candidate) === lastArg; candidate = candidate.parent) {
+    const contribution = contributionOf(candidate, periodArg);
+    if (!contribution || !amountsAgree(contribution, amountArg)) {
+      continue;
+    }
+    if (candidate.value[periodArg] === null) {
+      return candidate;
+    }
+    agreeing ??= ownAllowedArg ? candidate : null;
+  }
+  return agreeing;
+};
+
+type TAssignMode = 'vorspalte' | 'own' | 'mirror';
+
+/**
+ * Gives one year's amounts to the positions they belong to. In a year printed in two columns a row
+ * with both gives its first to itself and its second to the position it closes; a row with one
+ * gives it to itself. In a year printed in one column next to such a year, each amount goes where
+ * the row's main amount went (`mirror`), unless the column also prints the parts (`own`). Returns
+ * why the amounts do not fit, or null.
+ */
+const assignYear = (partArg: IPart, periodArg: TPeriod, modeArg: TAssignMode, mainTargetsArg: Map<IRow, INode>): string | null => {
+  for (const line of partArg.lines) {
+    const { pre, main } = line.row.values[periodArg];
+    if (line.role === 'node') {
+      const node = line.node as INode;
+      if (modeArg === 'vorspalte' && pre && main) {
+        if (node.value[periodArg]) {
+          return `${describe(line.row)} receives a second amount.`;
+        }
+        node.value[periodArg] = pre;
+        const target = closedBy(node.parent, node, main, periodArg, false);
+        if (!target) {
+          return `${describe(line.row)} prints ${formatAmount(main)} for no position whose parts add up to it.`;
+        }
+        target.value[periodArg] = main;
+        mainTargetsArg.set(line.row, target);
+      } else if (pre || main) {
+        const amount = (main ?? pre) as IAmount;
+        const target = modeArg === 'mirror' ? (mainTargetsArg.get(line.row) ?? node) : node;
+        if (target.value[periodArg]) {
+          return `${describe(line.row)} gives a second amount to ${describe(target.row)}.`;
+        }
+        target.value[periodArg] = amount;
+        if (modeArg === 'vorspalte' && main) {
+          mainTargetsArg.set(line.row, node);
+        }
+      }
+    } else if (line.role === 'sum') {
+      const amount = main ?? pre;
+      if (!amount) {
+        continue;
+      }
+      const target = line.previous ? closedBy(line.previous, line.previous, amount, periodArg, true) : null;
+      if (!target) {
+        return `${describe(line.row)} of ${formatAmount(amount)} is not the sum of the positions above it.`;
+      }
+      target.value[periodArg] ??= amount;
+      line.closes[periodArg] = target;
+    }
+  }
+  return null;
+};
+
+/** whether every position with an amount and parts with amounts equals their sum; why not, or null */
+const checkParts = (nodesArg: INode[], periodArg: TPeriod): string | null => {
+  for (const node of nodesArg) {
+    const own = node.value[periodArg];
+    const parts = node.children.map((childArg) => contributionOf(childArg, periodArg)).filter(notNull);
+    if (!own || parts.length === 0) {
+      continue;
+    }
+    const sum = sumAmounts(parts);
+    if (!amountsAgree(own, sum)) {
+      return `${describe(node.row)} prints ${formatAmount(own)}, but its parts add up to ${formatAmount(sum)}.`;
+    }
+  }
+  return null;
+};
+
+const clearYear = (partsArg: IPart[], periodArg: TPeriod) => {
+  for (const part of partsArg) {
+    part.nodes.forEach((nodeArg) => (nodeArg.value[periodArg] = null));
+    part.lines.forEach((lineArg) => (lineArg.closes[periodArg] = null));
+  }
+};
+
+const printedAmount = (rowArg: IRow, periodArg: TPeriod): IAmount | null =>
+  rowArg.values[periodArg].main ?? rowArg.values[periodArg].pre;
+
+/**
+ * Gives each year's amounts of a section to its positions and checks them; the years printed in two
+ * columns come first, as the others may follow them. Returns, per year with amounts, why it does not
+ * add up, or null; a year that does not keeps no amounts.
+ */
+const settleSection = (partsArg: IPart[], sectionArg: ISectionRows, checkArg: (periodArg: TPeriod) => string | null): Map<TPeriod, string | null> => {
+  const outcome = new Map<TPeriod, string | null>();
+  const years = statementPeriods.filter((periodArg) =>
+    sectionArg.rows.some((rowArg) => rowArg.values[periodArg].pre || rowArg.values[periodArg].main)
+  );
+  const order = [
+    ...years.filter((periodArg) => sectionArg.vorspalte.has(periodArg)),
+    ...years.filter((periodArg) => !sectionArg.vorspalte.has(periodArg)),
+  ];
+  let mainTargets: Map<IRow, INode> | null = null;
+  for (const period of order) {
+    const targets = new Map<IRow, INode>();
+    let mode: TAssignMode = 'vorspalte';
+    if (!sectionArg.vorspalte.has(period)) {
+      const partsPrinted = sectionArg.rows.some(
+        (rowArg) =>
+          !rowArg.memo &&
+          [...sectionArg.vorspalte].some((yearArg) => rowArg.values[yearArg].pre && !rowArg.values[yearArg].main) &&
+          printedAmount(rowArg, period) !== null
+      );
+      mode = partsPrinted ? 'own' : 'mirror';
+    }
+    let failure: string | null = null;
+    for (const part of partsArg) {
+      failure ??= assignYear(part, period, mode, mode === 'mirror' ? (mainTargets ?? targets) : targets);
+    }
+    failure ??= checkArg(period);
+    if (failure) {
+      clearYear(partsArg, period);
+    } else if (mode === 'vorspalte') {
+      mainTargets ??= targets;
+    }
+    outcome.set(period, failure);
+  }
+  return outcome;
+};
+
+// ---------------------------------------------------------------------------------------------
+// the balance sheet
+
+const checkBalanceYear = (assetsArg: IPart, liabilitiesArg: IPart, periodArg: TPeriod): string | null => {
+  const totals: IAmount[] = [];
+  for (const [part, name] of [
+    [assetsArg, 'assets'],
+    [liabilitiesArg, 'equity and liabilities'],
+  ] as const) {
+    const failure = checkParts(part.nodes, periodArg);
+    if (failure) {
+      return failure;
+    }
+    const total = part.total ? printedAmount(part.total.row, periodArg) : null;
+    if (!total) {
+      return `The ${name} print no total.`;
+    }
+    const sum = sumAmounts(part.roots.map((rootArg) => contributionOf(rootArg, periodArg)).filter(notNull));
+    if (!amountsAgree(total, sum)) {
+      return `The ${name} total ${formatAmount(total)}, but their positions add up to ${formatAmount(sum)}.`;
+    }
+    totals.push(total);
+  }
+  if (totals[0].micros !== totals[1].micros) {
+    return `Total assets of ${formatAmount(totals[0])} differ from total equity and liabilities of ${formatAmount(totals[1])}.`;
+  }
+  return null;
+};
+
+// ---------------------------------------------------------------------------------------------
+// the income statement
+
+/** the expenses of § 275 HGB, which a statement may print as positive amounts to subtract */
+const expensePattern =
+  /aufwend|aufwand|abschreibung|steuern|Verminderung des Bestand|Herstellungskosten|Vertriebskosten|Verwaltungskosten|Verlustübernahme|abgeführte Gewinne/i;
+const isExpense = (labelArg: string): boolean =>
+  expensePattern.test(labelArg) && !/Erhöhung|ergebnis/i.test(labelArg) && !/^Erträge/i.test(labelArg);
+
+const netIncomePattern = /^(?:Konzern-?)?jahres(?:überschuss|fehlbetrag|ergebnis)/i;
+
+interface IIncomeYear {
+  netIncome: IAmount;
+  subtotals: Set<INode>;
+}
+
+/**
+ * Adds an income statement's lines up to its net income, expenses as printed or, with
+ * `expensesPositiveArg`, subtracted. A line that states the sum of the lines before it, or of those
+ * since the last such line, is an intermediate result and not added again.
+ */
+const addUpIncome = (partArg: IPart, netIndexArg: number, periodArg: TPeriod, expensesPositiveArg: boolean): IIncomeYear | string => {
+  let running = zeroAmount;
+  let segment = zeroAmount;
+  const subtotals = new Set<INode>();
+  for (const root of partArg.roots.slice(0, netIndexArg)) {
+    const printed = contributionOf(root, periodArg);
+    if (!printed) {
+      continue;
+    }
+    if (
+      (root.row.total || subtotalLabelPattern.test(root.row.label)) &&
+      (amountsAgree(printed, running) || amountsAgree(printed, segment))
+    ) {
+      subtotals.add(root);
+      segment = zeroAmount;
+      continue;
+    }
+    if (root.row.total) {
+      return `${describe(root.row)} of ${formatAmount(printed)} is the sum of no lines above it.`;
+    }
+    const signed = expensesPositiveArg && isExpense(root.row.label) ? negateAmount(printed) : printed;
+    running = addAmounts(running, signed);
+    segment = addAmounts(segment, signed);
+  }
+  const netNode = partArg.roots[netIndexArg];
+  const net = contributionOf(netNode, periodArg);
+  if (!net) {
+    return 'It prints no net income.';
+  }
+  if (amountsAgree(net, running)) {
+    return { netIncome: net, subtotals };
+  }
+  const lossOnly = /fehlbetrag/i.test(netNode.row.label) && !/überschuss|ergebnis/i.test(netNode.row.label);
+  if (lossOnly && net.micros > 0n && amountsAgree(negateAmount(net), running)) {
+    return { netIncome: negateAmount(net), subtotals };
+  }
+  return `Its lines add up to ${formatAmount(running)}, not to the net income of ${formatAmount(net)}.`;
+};
+
+const methodOf = (partArg: IPart): TIncomeStatementMethod | null => {
+  const labels = partArg.nodes.map((nodeArg) => nodeArg.row.label);
+  const totalCost = labels.some((labelArg) => /Materialaufwand|Personalaufwand/i.test(labelArg));
+  const costOfSales = labels.some((labelArg) => /Herstellungskosten der zur Erzielung|Vertriebskosten/i.test(labelArg));
+  return totalCost === costOfSales ? null : totalCost ? 'total_cost' : 'cost_of_sales';
+};
+
+interface IIncomeRead {
+  rows: ISectionRows;
+  part: IPart;
+  expenses: 'negative' | 'positive';
+  years: Map<TPeriod, IIncomeYear>;
+  priorFailure: string | null;
+}
+
+/** reads the income statement; throws `unparseable` where its current year cannot be read */
+const readIncome = (draftArg: ISectionDraft, documentContextArg: string[]): IIncomeRead => {
+  const fail: TFail = (messageArg) => {
+    throw new FinancialStatementError('unparseable', messageArg);
+  };
+  const rows = readSectionRows(draftArg, 'income statement', documentContextArg);
+  const part = buildPart(rows.rows, true);
+  const netIndex = part.roots.findIndex((rootArg) => netIncomePattern.test(rootArg.row.label));
+  if (netIndex < 0) {
+    fail('The income statement prints no net income (Jahresüberschuss or Jahresfehlbetrag).');
+  }
+  const netLine = part.lines.findIndex((lineArg) => lineArg.node === part.roots[netIndex]);
+  const checked = part.lines
+    .slice(0, netLine + 1)
+    .filter((lineArg) => lineArg.role === 'node')
+    .map((lineArg) => lineArg.node as INode);
+  const outcome = settleSection([part], rows, (periodArg) => checkParts(checked, periodArg));
+  if (!outcome.has('current')) {
+    fail('The income statement prints no amounts for the current year.');
+  }
+  const currentFailure = outcome.get('current');
+  if (currentFailure) {
+    fail(`The income statement does not add up for the current year: ${currentFailure}`);
+  }
+  const years = new Map<TPeriod, IIncomeYear>();
+  let expenses: 'negative' | 'positive' = 'negative';
+  const asPrinted = addUpIncome(part, netIndex, 'current', false);
+  if (typeof asPrinted !== 'string') {
+    years.set('current', asPrinted);
+  } else {
+    const subtracted = addUpIncome(part, netIndex, 'current', true);
+    if (typeof subtracted === 'string') {
+      fail(`The income statement does not add up to its net income for the current year: ${asPrinted}`);
+    }
+    years.set('current', subtracted as IIncomeYear);
+    expenses = 'positive';
+  }
+  let priorFailure = outcome.get('prior') ?? null;
+  if (outcome.has('prior') && !priorFailure) {
+    const prior = addUpIncome(part, netIndex, 'prior', expenses === 'positive');
+    if (typeof prior === 'string') {
+      priorFailure = prior;
+      clearYear([part], 'prior');
+    } else {
+      years.set('prior', prior);
+    }
+  }
+  return { rows, part, expenses, years, priorFailure };
+};
+
+// ---------------------------------------------------------------------------------------------
+// the statement
+
+/** the day a line of a statement names as its balance sheet date: `zum 31.12.2024`, or a period's end */
+const balanceDateIn = (linesArg: string[]): TIsoDate | null => {
+  for (const line of linesArg) {
+    const period = periodIn(line);
+    if (period.start && period.end) {
+      return period.end;
+    }
+    const date = lastDateIn(line);
+    if (date && /\b(?:zum|per|am|Stichtag)\b/i.test(line)) {
+      return date;
+    }
+  }
+  return null;
+};
+
+const rangeIn = (linesArg: string[]): { start: TIsoDate; end: TIsoDate } | null => {
+  for (const line of linesArg) {
+    const period = periodIn(line);
+    if (period.start && period.end) {
+      return { start: period.start, end: period.end };
+    }
+  }
+  return null;
+};
+
+const findNode = (nodesArg: INode[], patternArg: RegExp): INode | null =>
+  nodesArg.find((nodeArg) => patternArg.test(nodeArg.row.label)) ?? null;
+
+const descendantsOf = (nodeArg: INode): INode[] => {
+  const result: INode[] = [];
+  const stack = [...nodeArg.children].reverse();
+  for (let node = stack.pop(); node; node = stack.pop()) {
+    result.push(node);
+    stack.push(...[...node.children].reverse());
+  }
+  return result;
+};
+
+const amountText = (amountArg: IAmount | null): string | null => (amountArg ? formatAmount(amountArg) : null);
+
+/** the printed lines of a part, each with the amounts its year kept */
+const positionsOf = (partArg: IPart, kindsArg: Map<INode, TStatementLineKind>, keptArg: Set<TPeriod>): IStatementPosition[] =>
+  partArg.lines.map((line) => {
+    const amountFor = (periodArg: TPeriod): string | null => {
+      if (!keptArg.has(periodArg)) {
+        return null;
+      }
+      const values = line.row.values[periodArg];
+      if (line.role === 'node') {
+        return amountText((line.node as INode).value[periodArg]);
+      }
+      return amountText(line.role === 'memo' ? (values.pre ?? values.main) : (values.main ?? values.pre));
+    };
+    const node = line.role === 'node' ? (line.node as INode) : null;
+    let level = 0;
+    if (node) {
+      level = node.depth;
+    } else if (line.role === 'memo') {
+      level = line.node ? line.node.depth + 1 : 0;
+    } else if (line.role === 'sum') {
+      level = (line.closes.current ?? line.closes.prior ?? line.previous)?.depth ?? 0;
+    }
+    const kind: TStatementLineKind =
+      line.role === 'memo' ? 'memo' : line.role === 'total' ? 'total' : line.role === 'sum' ? 'subtotal' : (kindsArg.get(node as INode) ?? 'position');
+    return {
+      code: node ? node.codePath : null,
+      printedCode: node ? (line.row.code?.printed ?? null) : null,
+      label: line.row.label,
+      level,
+      kind,
+      current: amountFor('current'),
+      prior: amountFor('prior'),
+    };
+  });
+
+/**
+ * Reads a statement under the HGB from the blocks of its document: the balance sheet (§ 266 HGB),
+ * required, and the income statement (§ 275 HGB), where one is published. Throws `unparseable` where
+ * no balance sheet is found or its current year cannot be read with certainty; leaves out with a
+ * note an income statement that cannot, and a prior year that does not add up.
+ */
+export const readHgbStatement = (blocksArg: TLayoutBlock[]): IHgbStatement => {
+  const unparseable = (messageArg: string): never => {
+    throw new FinancialStatementError('unparseable', messageArg);
+  };
+  const sections = readSections(blocksArg);
+  const notes = [...sections.notes];
+  if (sections.sideBySide) {
+    unparseable('The balance sheet prints its two sides next to each other, which is not read here.');
+  }
+  if (sections.balance.valueRows === 0) {
+    unparseable('No balance sheet was found.');
+  }
+  if (sections.balance.items.some((itemArg) => itemArg.side === null && hasAmountCell(itemArg.cells))) {
+    unparseable('The balance sheet does not mark its sides (Aktiva, Passiva).');
+  }
+  const balanceRows = readSectionRows(sections.balance, 'balance sheet', sections.documentContext);
+  const assets = buildPart(balanceRows.rows.filter((rowArg) => rowArg.side === 'assets'), false);
+  const liabilities = buildPart(balanceRows.rows.filter((rowArg) => rowArg.side === 'liabilities'), false);
+  const balanceOutcome = settleSection([assets, liabilities], balanceRows, (periodArg) =>
+    checkBalanceYear(assets, liabilities, periodArg)
+  );
+  if (!balanceOutcome.has('current')) {
+    unparseable('The balance sheet prints no amounts for the current year.');
+  }
+  const balanceFailure = balanceOutcome.get('current');
+  if (balanceFailure) {
+    unparseable(`The balance sheet does not add up for the current year: ${balanceFailure}`);
+  }
+
+  let income: IIncomeRead | null = null;
+  if (sections.income.valueRows > 0) {
+    try {
+      income = readIncome(sections.income, sections.documentContext);
+    } catch (error) {
+      if (!(error instanceof FinancialStatementError) || error.code !== 'unparseable') {
+        throw error;
+      }
+      notes.push(`The income statement was left out: ${error.message}`);
+    }
+  }
+
+  const priorFailures = [
+    balanceOutcome.get('prior') ? `the balance sheet does not add up for it: ${balanceOutcome.get('prior')}` : null,
+    income?.priorFailure ? `the income statement does not add up for it: ${income.priorFailure}` : null,
+  ].filter(notNull);
+  const priorPrinted = balanceOutcome.has('prior') || (income?.rows.rows.some((rowArg) => printedAmount(rowArg, 'prior')) ?? false);
+  const kept = new Set<TPeriod>(['current']);
+  if (priorPrinted && priorFailures.length === 0) {
+    kept.add('prior');
+  } else if (priorFailures.length > 0) {
+    notes.push(`The prior year's figures were left out: ${priorFailures.join('; ')}`);
+  }
+
+  const equityNode = liabilities.roots.find((rootArg) => /^Eigenkapital/i.test(rootArg.row.label)) ?? null;
+  const balanceNetIncome = equityNode ? findNode(descendantsOf(equityNode), /^(?:Konzern-?)?jahres(?:überschuss|fehlbetrag)/i) : null;
+  const revenueNode = income ? findNode(income.part.nodes, /^Umsatzerlöse/i) : null;
+  const keyFiguresOf = (periodArg: TPeriod): IKeyFigures => ({
+    totalAssets: amountText(assets.total ? printedAmount(assets.total.row, periodArg) : null),
+    equity: amountText(equityNode ? contributionOf(equityNode, periodArg) : null),
+    netIncome: amountText(
+      income?.years.get(periodArg)?.netIncome ?? (balanceNetIncome ? contributionOf(balanceNetIncome, periodArg) : null)
+    ),
+    revenue: amountText(revenueNode ? contributionOf(revenueNode, periodArg) : null),
+  });
+
+  const contexts = [...sections.balance.contexts, ...sections.income.contexts, ...sections.documentContext];
+  const columnOf = (periodArg: TPeriod): IColumnRole | null =>
+    balanceRows.columns[periodArg] ?? income?.rows.columns[periodArg] ?? null;
+  const incomeRange = rangeIn(sections.income.contexts);
+  const documentRange = rangeIn(sections.documentContext);
+  const currentEnd =
+    balanceDateIn(sections.balance.contexts) ??
+    columnOf('current')?.date ??
+    incomeRange?.end ??
+    documentRange?.end ??
+    balanceDateIn(sections.documentContext);
+  const currentStart =
+    currentEnd === null
+      ? null
+      : ([incomeRange, documentRange, rangeIn(contexts.filter((lineArg) => periodIn(lineArg).end === currentEnd))].find(
+          (rangeArg) => rangeArg?.end === currentEnd
+        )?.start ?? null);
+  const periodOf = (periodArg: TPeriod, startArg: TIsoDate | null, endArg: TIsoDate | null): IStatementPeriod => ({
+    heading: columnOf(periodArg)?.heading || null,
+    start: startArg,
+    end: endArg,
+  });
+
+  const incomeKinds = new Map<INode, TStatementLineKind>();
+  let incomeStatement: IIncomeStatement | null = null;
+  if (income) {
+    for (const node of income.years.get('current')?.subtotals ?? []) {
+      incomeKinds.set(node, 'subtotal');
+    }
+    for (const node of income.part.roots) {
+      if (node.row.total) {
+        incomeKinds.set(node, 'subtotal');
+      }
+    }
+    const netNode = income.part.roots.find((rootArg) => netIncomePattern.test(rootArg.row.label));
+    if (netNode) {
+      incomeKinds.set(netNode, 'total');
+    }
+    incomeStatement = {
+      unit: income.rows.unit,
+      method: methodOf(income.part),
+      expenses: income.expenses,
+      positions: positionsOf(income.part, incomeKinds, kept),
+    };
+  }
+
+  return {
+    standard: 'hgb',
+    currency: 'EUR',
+    periods: {
+      current: periodOf('current', currentStart, currentEnd),
+      prior: kept.has('prior') ? periodOf('prior', null, columnOf('prior')?.date ?? null) : null,
+    },
+    keyFigures: {
+      current: keyFiguresOf('current'),
+      prior: kept.has('prior') ? keyFiguresOf('prior') : null,
+    },
+    balanceSheet: {
+      unit: balanceRows.unit,
+      assets: positionsOf(assets, new Map(), kept),
+      equityAndLiabilities: positionsOf(liabilities, new Map(), kept),
+    },
+    incomeStatement,
+    notes,
+  };
+};