@kreiseck/kasseneck-api 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -4,6 +4,41 @@ Was vor 0.7.0 geschah, steht in der Commit-Historie (`git log`); ab hier wird
 es hier geführt. Ein Eintrag nennt die Änderung **und ihren Grund** —
 nur der Grund überlebt den nächsten Umbau.
 
+## 1.1.0
+
+Receipt printers that print umlauts and special characters correctly.
+Reason: `ESC t n` selects the character table, but the number n differs
+between manufacturers; many low-cost printers ignore `ESC t 16` or put
+another table there and print garbage instead of `ä`. The printer wizard
+now prints a test sheet, the user taps the first row that looks right, and
+the register keeps that choice per printer on the device.
+
+Additive, no breaking change. Without a chosen table every receipt is byte
+for byte the same as in 1.0.0 (all golden receipts unchanged).
+
+- **Code-table catalogue** (`./printing`): `CodeTableId`, `CodeTable`,
+  `CODE_TABLES` (six tables: `wpc1252` = `ESC t 16`, `pc858` = 19,
+  `pc850` = 2, `pc437` = 0, `iso8859_15` = 40, `replacement` = 0),
+  `codeTableById`, `codeTableFromSetting`, `encodeForCodeTable`. For
+  ä ö ü Ä Ö Ü ß € § ° every table answers with its own byte or, where the
+  table lacks the character, with replacement letters (`ae`, `EUR`, `Par.`,
+  `Grad`), never `?`. Shared contract with the Dart twin:
+  `fixtures/code-tables.json`.
+- **Test sheet** (`./receipt`): `codeTableTestSheet` (line model for the
+  screen, 32 columns) and `codeTableTestSheetBytes` (ESC/POS, centred on
+  80 mm), `codeTableReferenceImage`. Contract:
+  `fixtures/expected/code-table-test-sheet.*`. New texts in
+  `fixtures/pos-texts.json` (`codetable.*`).
+- **Receipts with a chosen table**: `escPosLayoutBytes(layout, { codeTable })`
+  accepts a `CodeTableId`. `€`, `§` and `°` go out as the table's real
+  byte where the table has them, otherwise as replacement letters. Missing
+  characters are replaced in the text before the columns are laid out, so
+  a character that becomes several letters never shifts a column.
+  `escPosPrintableText(text, codeTable?)` takes the same optional table;
+  without it (or with `null`/`CP1252`) it behaves as before.
+- **`CP437` and `§`**: on the old `CP437` name `§` now prints as `Par.`
+  (was `?`), with the columns measured after the replacement.
+
 ## 1.0.0
 
 The package speaks the English API `/v3` and nothing else, and its own

package/dist/cjs/pos/texte.d.ts

@@ -469,6 +469,12 @@ declare const MELDUNGEN_ROH: {
     readonly 'print.wizard_cancelled': {
         readonly text: "Nichts gespeichert.";
     };
+    readonly 'codetable.question': {
+        readonly text: "Welche Zeile sieht auf dem Papier aus wie oben?";
+    };
+    readonly 'codetable.instruction': {
+        readonly text: "Die Nummer der ersten Zeile, die genau wie oben aussieht, in der Kasse antippen.";
+    };
     readonly 'bluetooth.off': {
         readonly text: "Bluetooth ist ausgeschaltet. Bitte einschalten und erneut suchen.";
         readonly only: readonly ["app"];
@@ -964,6 +970,32 @@ declare const BESCHRIFTUNGEN_ROH: {
     readonly 'cancellation.difference': {
         readonly text: "Differenz";
     };
+    readonly 'codetable.title': {
+        readonly text: "ZEICHENSATZ-TEST";
+    };
+    readonly 'codetable.reference': {
+        readonly text: "So muss jede Zeile aussehen:";
+    };
+    readonly 'codetable.replacement_note': {
+        readonly text: "(Ersatz, passt immer)";
+    };
+    readonly 'codetable.missing': {
+        readonly text: "ohne {chars}";
+        readonly placeholders: readonly ["chars"];
+    };
+    readonly 'codetable.print_again': {
+        readonly text: "Nochmal drucken";
+    };
+    readonly 'codetable.not_checked': {
+        readonly text: "Umlaute noch nicht geprüft";
+    };
+    readonly 'codetable.check': {
+        readonly text: "Umlaute prüfen";
+    };
+    readonly 'codetable.current': {
+        readonly text: "Zeichensatz: Nr. {number}";
+        readonly placeholders: readonly ["number"];
+    };
 };
 export type LabelKey = keyof typeof BESCHRIFTUNGEN_ROH;
 export declare const LABELS: Record<LabelKey, TextEntry>;

package/dist/cjs/pos/texte.js

@@ -255,6 +255,10 @@ const MELDUNGEN_ROH = {
     // Abbrechen an jeder Stelle: nichts gespeichert. Der Satz sagt genau das,
     // damit niemand einen halb eingerichteten Drucker vermutet.
     'print.wizard_cancelled': { text: 'Nichts gespeichert.' },
+    // Zeichensatz-Test im Drucker-Wizard: das Testblatt nennt die Anleitung,
+    // der Bildschirm stellt die Frage daneben.
+    'codetable.question': { text: 'Welche Zeile sieht auf dem Papier aus wie oben?' },
+    'codetable.instruction': { text: 'Die Nummer der ersten Zeile, die genau wie oben aussieht, in der Kasse antippen.' },
     'bluetooth.off': { text: 'Bluetooth ist ausgeschaltet. Bitte einschalten und erneut suchen.', only: ['app'] },
     'bluetooth.permission_missing': { text: 'Bitte die Freigabe in den Geräte-Einstellungen erteilen.', only: ['app'] },
     'bluetooth.search_failed': { text: 'Die Suche ist fehlgeschlagen: {reason}', placeholders: ['reason'], only: ['app'] },
@@ -566,6 +570,18 @@ const BESCHRIFTUNGEN_ROH = {
     'cancellation.all_cash': { text: 'Alles bar' },
     'cancellation.payment_remainder': { text: 'Rest {amount}', placeholders: ['amount'] },
     'cancellation.difference': { text: 'Differenz' },
+    // --- Zeichensatz-Test (Testblatt und Drucker & Lade) ----------------------
+    // Das Testblatt druckt diese Texte; sie bleiben reines ASCII bis auf die
+    // Knoepfe am Bildschirm. `{chars}` sind die fehlenden Zeichen einer Zeile
+    // („€“ bzw. „€ §“), `{number}` die gewaehlte Zeile (1-6).
+    'codetable.title': { text: 'ZEICHENSATZ-TEST' },
+    'codetable.reference': { text: 'So muss jede Zeile aussehen:' },
+    'codetable.replacement_note': { text: '(Ersatz, passt immer)' },
+    'codetable.missing': { text: 'ohne {chars}', placeholders: ['chars'] },
+    'codetable.print_again': { text: 'Nochmal drucken' },
+    'codetable.not_checked': { text: 'Umlaute noch nicht geprüft' },
+    'codetable.check': { text: 'Umlaute prüfen' },
+    'codetable.current': { text: 'Zeichensatz: Nr. {number}', placeholders: ['number'] },
 };
 exports.LABELS = BESCHRIFTUNGEN_ROH;
 /** Die Beschriftung zum Schluessel, Platzhalter ersetzt; fehlt ein Wert, wirft es wie `messageText`. */

package/dist/cjs/printing/code-tables.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Katalog der Code-Tabellen fuer Bondrucker und die Umwandlung von Text in
+ * Bytes je Tabelle.
+ *
+ * Warum ein Katalog: `ESC t n` waehlt die Zeichentabelle, aber die Nummer n
+ * ist nicht einheitlich. Epson legt WPC1252 auf 16, viele guenstige Drucker
+ * nummerieren anders oder kennen die Tabelle gar nicht. Wer am Testblatt
+ * sieht, welche Nummer seine Umlaute richtig druckt, waehlt hier die
+ * passende Tabelle. Gemeinsamer Prueffall mit dem Dart-Zwilling:
+ * `fixtures/code-tables.json`.
+ *
+ * Jede Tabelle setzt die zehn deutschen Zeichen (Umlaute, ß, €, §, °) auf
+ * ein Byte oder, wo die Tabelle das Zeichen nicht hat, auf Ersatzbuchstaben
+ * (`€` -> `EUR`). Fuer diese zehn Zeichen kommt nie `?` heraus.
+ */
+/** Kennung einer Code-Tabelle. */
+export type CodeTableId = 'wpc1252' | 'pc858' | 'pc850' | 'pc437' | 'iso8859_15' | 'replacement';
+/** Eine Code-Tabelle des Katalogs. */
+export interface CodeTable {
+    /** Kennung. */
+    id: CodeTableId;
+    /** Nummer auf dem Testblatt (1-6). */
+    number: 1 | 2 | 3 | 4 | 5 | 6;
+    /** n fuer `ESC t n`. */
+    escT: number;
+    /** Zeichen der zehn, die diese Tabelle nicht hat und durch Ersatzbuchstaben druckt. */
+    missing: readonly string[];
+}
+/**
+ * Ersatzbuchstaben fuer eines der zehn Zeichen (paketintern, fuer
+ * `escPosPrintableText` mit gewaehlter Tabelle).
+ */
+export declare function ersatzBuchstaben(zeichen: string): string;
+/** Alle Code-Tabellen in der Reihenfolge des Testblatts (Nummer 1-6). */
+export declare const CODE_TABLES: readonly CodeTable[];
+/** Die Tabelle zu einer Kennung; eine unbekannte Kennung wird gemeldet. */
+export declare function codeTableById(id: CodeTableId): CodeTable;
+/**
+ * Tabelle aus der gespeicherten Einstellung (`cp1252`/`cp437`). Alles andere,
+ * auch keine Einstellung, ist die Vorgabe `wpc1252`.
+ */
+export declare function codeTableFromSetting(setting: 'cp1252' | 'cp437' | null | undefined): CodeTableId;
+/**
+ * Zeichen, die das Vorbild vor dem Kodieren ersetzt (generator.dart `_encode`).
+ *
+ * **Eine bewusste Abweichung:** Fuer `•` sagt generator.dart `.`,
+ * print_paper.dart (portiert als `escPosPrintableText`) dagegen `*`. In Darts
+ * eigener Kette faellt das nie auf, weil print_paper vor dem Erzeuger ersetzt
+ * und der Erzeuger den Punkt nie zu sehen bekommt -- die gedruckte Antwort ist
+ * dort also `*`. Ein Verbraucher dieses Pakets kann `escPosText` aber auch
+ * direkt aufrufen, und dann duerfen nicht zwei Zeichen fuer dasselbe Zeichen
+ * herauskommen. Deshalb gilt hier dieselbe Antwort wie dort.
+ */
+export declare const ZEICHEN_ERSATZ: ReadonlyArray<readonly [string, string]>;
+/**
+ * Latin-1-Byte -> CP437-Byte fuer die Zeichen, die CP437 kennt (deutsche
+ * Umlaute, ß, westeuropaeische Akzente, Waehrungs-/Sonderzeichen). Alles
+ * andere ab 0x80 hat in CP437 keinen Platz und wird zu "?".
+ */
+export declare const CP437_AUS_LATIN1: ReadonlyMap<number, number>;
+/**
+ * Wandelt Text in die Bytes einer Code-Tabelle: erst die vorhandenen
+ * Ersetzungen (`ZEICHEN_ERSATZ`), dann die zehn deutschen Zeichen je Tabelle
+ * (Byte oder Ersatzbuchstaben), ASCII unveraendert, alles uebrige ueber die
+ * Abbildung der Tabelle, sonst `?`. Ein Zeichen, das die Tabelle nicht
+ * kennt, ist genau ein Byte; nur die Ersatzbuchstaben machen aus einem
+ * Zeichen mehrere. Spalten darum immer an den fertigen Bytes messen.
+ */
+export declare function encodeForCodeTable(text: string, table: CodeTableId): Uint8Array;
+/** Wendet `ZEICHEN_ERSATZ` an (paketintern, nicht exportiert ueber den Einstieg). */
+export declare function replaceKnownCharacters(text: string): string;
+/**
+ * Wie `encodeForCodeTable`, aber fuer Text, der `ZEICHEN_ERSATZ` schon hinter
+ * sich hat (paketintern: der alte Pfad in `encodeEscPosText` ersetzt vor der
+ * Latin-1-Pruefung und soll nicht zweimal ersetzen).
+ */
+export declare function encodeReplaced(aufbereitet: string, table: CodeTableId): Uint8Array;

package/dist/cjs/printing/code-tables.js

@@ -0,0 +1,224 @@
+"use strict";
+/**
+ * Katalog der Code-Tabellen fuer Bondrucker und die Umwandlung von Text in
+ * Bytes je Tabelle.
+ *
+ * Warum ein Katalog: `ESC t n` waehlt die Zeichentabelle, aber die Nummer n
+ * ist nicht einheitlich. Epson legt WPC1252 auf 16, viele guenstige Drucker
+ * nummerieren anders oder kennen die Tabelle gar nicht. Wer am Testblatt
+ * sieht, welche Nummer seine Umlaute richtig druckt, waehlt hier die
+ * passende Tabelle. Gemeinsamer Prueffall mit dem Dart-Zwilling:
+ * `fixtures/code-tables.json`.
+ *
+ * Jede Tabelle setzt die zehn deutschen Zeichen (Umlaute, ß, €, §, °) auf
+ * ein Byte oder, wo die Tabelle das Zeichen nicht hat, auf Ersatzbuchstaben
+ * (`€` -> `EUR`). Fuer diese zehn Zeichen kommt nie `?` heraus.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CP437_AUS_LATIN1 = exports.ZEICHEN_ERSATZ = exports.CODE_TABLES = void 0;
+exports.ersatzBuchstaben = ersatzBuchstaben;
+exports.codeTableById = codeTableById;
+exports.codeTableFromSetting = codeTableFromSetting;
+exports.encodeForCodeTable = encodeForCodeTable;
+exports.replaceKnownCharacters = replaceKnownCharacters;
+exports.encodeReplaced = encodeReplaced;
+/** Die zehn Zeichen, fuer die jede Tabelle eine feste Antwort hat. */
+const ZEHN_ZEICHEN = ['ä', 'ö', 'ü', 'Ä', 'Ö', 'Ü', 'ß', '€', '§', '°'];
+/** Ersatzbuchstaben, wenn die Tabelle das Zeichen nicht hat. */
+const ERSATZ_BUCHSTABEN = {
+    'ä': 'ae', 'ö': 'oe', 'ü': 'ue', 'Ä': 'Ae', 'Ö': 'Oe', 'Ü': 'Ue', 'ß': 'ss', '€': 'EUR', '§': 'Par.', '°': 'Grad',
+};
+/**
+ * Byte je Zeichen und Tabelle; fehlt ein Zeichen, gilt der Ersatz. Werte aus
+ * den Zeichentabellen (Windows-1252, IBM 858/850/437, ISO 8859-15).
+ */
+const BYTES_JE_TABELLE = {
+    wpc1252: { 'ä': 0xe4, 'ö': 0xf6, 'ü': 0xfc, 'Ä': 0xc4, 'Ö': 0xd6, 'Ü': 0xdc, 'ß': 0xdf, '€': 0x80, '§': 0xa7, '°': 0xb0 },
+    pc858: { 'ä': 0x84, 'ö': 0x94, 'ü': 0x81, 'Ä': 0x8e, 'Ö': 0x99, 'Ü': 0x9a, 'ß': 0xe1, '€': 0xd5, '§': 0xf5, '°': 0xf8 },
+    pc850: { 'ä': 0x84, 'ö': 0x94, 'ü': 0x81, 'Ä': 0x8e, 'Ö': 0x99, 'Ü': 0x9a, 'ß': 0xe1, '§': 0xf5, '°': 0xf8 },
+    pc437: { 'ä': 0x84, 'ö': 0x94, 'ü': 0x81, 'Ä': 0x8e, 'Ö': 0x99, 'Ü': 0x9a, 'ß': 0xe1, '°': 0xf8 },
+    iso8859_15: { 'ä': 0xe4, 'ö': 0xf6, 'ü': 0xfc, 'Ä': 0xc4, 'Ö': 0xd6, 'Ü': 0xdc, 'ß': 0xdf, '€': 0xa4, '§': 0xa7, '°': 0xb0 },
+    replacement: {},
+};
+/**
+ * Ersatzbuchstaben fuer eines der zehn Zeichen (paketintern, fuer
+ * `escPosPrintableText` mit gewaehlter Tabelle).
+ */
+function ersatzBuchstaben(zeichen) {
+    const ersatz = ERSATZ_BUCHSTABEN[zeichen];
+    if (ersatz === undefined)
+        throw new Error(`Kein Ersatz fuer ${zeichen}`);
+    return ersatz;
+}
+function tabelle(id, number, escT) {
+    const bytes = BYTES_JE_TABELLE[id];
+    return Object.freeze({ id, number, escT, missing: Object.freeze(ZEHN_ZEICHEN.filter((z) => bytes[z] === undefined)) });
+}
+/** Alle Code-Tabellen in der Reihenfolge des Testblatts (Nummer 1-6). */
+exports.CODE_TABLES = Object.freeze([
+    tabelle('wpc1252', 1, 16),
+    tabelle('pc858', 2, 19),
+    tabelle('pc850', 3, 2),
+    tabelle('pc437', 4, 0),
+    tabelle('iso8859_15', 5, 40),
+    tabelle('replacement', 6, 0),
+]);
+/** Die Tabelle zu einer Kennung; eine unbekannte Kennung wird gemeldet. */
+function codeTableById(id) {
+    const gefunden = exports.CODE_TABLES.find((t) => t.id === id);
+    if (gefunden === undefined)
+        throw new Error(`Unbekannte Code-Tabelle: ${String(id)}`);
+    return gefunden;
+}
+/**
+ * Tabelle aus der gespeicherten Einstellung (`cp1252`/`cp437`). Alles andere,
+ * auch keine Einstellung, ist die Vorgabe `wpc1252`.
+ */
+function codeTableFromSetting(setting) {
+    return setting === 'cp437' ? 'pc437' : 'wpc1252';
+}
+/**
+ * Zeichen, die das Vorbild vor dem Kodieren ersetzt (generator.dart `_encode`).
+ *
+ * **Eine bewusste Abweichung:** Fuer `•` sagt generator.dart `.`,
+ * print_paper.dart (portiert als `escPosPrintableText`) dagegen `*`. In Darts
+ * eigener Kette faellt das nie auf, weil print_paper vor dem Erzeuger ersetzt
+ * und der Erzeuger den Punkt nie zu sehen bekommt -- die gedruckte Antwort ist
+ * dort also `*`. Ein Verbraucher dieses Pakets kann `escPosText` aber auch
+ * direkt aufrufen, und dann duerfen nicht zwei Zeichen fuer dasselbe Zeichen
+ * herauskommen. Deshalb gilt hier dieselbe Antwort wie dort.
+ */
+exports.ZEICHEN_ERSATZ = [
+    ['’', "'"], // typografisches Apostroph
+    ['´', "'"], // Akut
+    ['•', '*'], // Aufzaehlungspunkt (siehe Kommentar oben)
+];
+/**
+ * Latin-1-Byte -> CP437-Byte fuer die Zeichen, die CP437 kennt (deutsche
+ * Umlaute, ß, westeuropaeische Akzente, Waehrungs-/Sonderzeichen). Alles
+ * andere ab 0x80 hat in CP437 keinen Platz und wird zu "?".
+ */
+exports.CP437_AUS_LATIN1 = new Map([
+    [0xc7, 0x80], [0xfc, 0x81], [0xe9, 0x82], [0xe2, 0x83], [0xe4, 0x84], [0xe0, 0x85], [0xe5, 0x86], [0xe7, 0x87],
+    [0xea, 0x88], [0xeb, 0x89], [0xe8, 0x8a], [0xef, 0x8b], [0xee, 0x8c], [0xec, 0x8d], [0xc4, 0x8e], [0xc5, 0x8f],
+    [0xc9, 0x90], [0xe6, 0x91], [0xc6, 0x92], [0xf4, 0x93], [0xf6, 0x94], [0xf2, 0x95], [0xfb, 0x96], [0xf9, 0x97],
+    [0xff, 0x98], [0xd6, 0x99], [0xdc, 0x9a], [0xa2, 0x9b], [0xa3, 0x9c], [0xa5, 0x9d], [0xe1, 0xa0], [0xed, 0xa1],
+    [0xf3, 0xa2], [0xfa, 0xa3], [0xf1, 0xa4], [0xd1, 0xa5], [0xaa, 0xa6], [0xba, 0xa7], [0xbf, 0xa8], [0xac, 0xaa],
+    [0xbd, 0xab], [0xbc, 0xac], [0xa1, 0xad], [0xab, 0xae], [0xbb, 0xaf], [0xdf, 0xe1], [0xb5, 0xe6], [0xb1, 0xf1],
+    [0xf7, 0xf6], [0xb0, 0xf8], [0xb7, 0xfa], [0xb2, 0xfd], [0xa0, 0xff],
+]);
+/**
+ * Latin-1-Byte -> PC850-Byte (IBM 850, gleich fuer 858 bis auf das €, das
+ * die zehn Zeichen oben schon setzen). PC850 hat fuer jedes Latin-1-Zeichen
+ * ab 0xA0 einen Platz; die Steuerzeichen 0x80-0x9F werden zu "?".
+ */
+const PC850_AUS_LATIN1 = new Map([
+    [0xa0, 0xff], [0xa1, 0xad], [0xa2, 0xbd], [0xa3, 0x9c], [0xa4, 0xcf], [0xa5, 0xbe], [0xa6, 0xdd], [0xa7, 0xf5],
+    [0xa8, 0xf9], [0xa9, 0xb8], [0xaa, 0xa6], [0xab, 0xae], [0xac, 0xaa], [0xad, 0xf0], [0xae, 0xa9], [0xaf, 0xee],
+    [0xb0, 0xf8], [0xb1, 0xf1], [0xb2, 0xfd], [0xb3, 0xfc], [0xb4, 0xef], [0xb5, 0xe6], [0xb6, 0xf4], [0xb7, 0xfa],
+    [0xb8, 0xf7], [0xb9, 0xfb], [0xba, 0xa7], [0xbb, 0xaf], [0xbc, 0xac], [0xbd, 0xab], [0xbe, 0xf3], [0xbf, 0xa8],
+    [0xc0, 0xb7], [0xc1, 0xb5], [0xc2, 0xb6], [0xc3, 0xc7], [0xc4, 0x8e], [0xc5, 0x8f], [0xc6, 0x92], [0xc7, 0x80],
+    [0xc8, 0xd4], [0xc9, 0x90], [0xca, 0xd2], [0xcb, 0xd3], [0xcc, 0xde], [0xcd, 0xd6], [0xce, 0xd7], [0xcf, 0xd8],
+    [0xd0, 0xd1], [0xd1, 0xa5], [0xd2, 0xe3], [0xd3, 0xe0], [0xd4, 0xe2], [0xd5, 0xe5], [0xd6, 0x99], [0xd7, 0x9e],
+    [0xd8, 0x9d], [0xd9, 0xeb], [0xda, 0xe9], [0xdb, 0xea], [0xdc, 0x9a], [0xdd, 0xed], [0xde, 0xe8], [0xdf, 0xe1],
+    [0xe0, 0x85], [0xe1, 0xa0], [0xe2, 0x83], [0xe3, 0xc6], [0xe4, 0x84], [0xe5, 0x86], [0xe6, 0x91], [0xe7, 0x87],
+    [0xe8, 0x8a], [0xe9, 0x82], [0xea, 0x88], [0xeb, 0x89], [0xec, 0x8d], [0xed, 0xa1], [0xee, 0x8c], [0xef, 0x8b],
+    [0xf0, 0xd0], [0xf1, 0xa4], [0xf2, 0x95], [0xf3, 0xa2], [0xf4, 0x93], [0xf5, 0xe4], [0xf6, 0x94], [0xf7, 0xf6],
+    [0xf8, 0x9b], [0xf9, 0x97], [0xfa, 0xa3], [0xfb, 0x96], [0xfc, 0x81], [0xfd, 0xec], [0xfe, 0xe7], [0xff, 0x98],
+]);
+const FRAGEZEICHEN = 0x3f;
+/**
+ * Windows-1252 belegt 0x80-0x9F mit eigenen Zeichen (Latin-1 hat dort nur
+ * Steuerzeichen). € setzen die zehn Zeichen, ’ und • ersetzt ZEICHEN_ERSATZ
+ * vorher (eine Antwort auf jedem Ausgabeweg); der Rest steht hier.
+ */
+const WPC1252_NEU = new Map([
+    [0x201a, 0x82], [0x0192, 0x83], [0x201e, 0x84], [0x2026, 0x85], [0x2020, 0x86], [0x2021, 0x87], [0x02c6, 0x88],
+    [0x2030, 0x89], [0x0160, 0x8a], [0x2039, 0x8b], [0x0152, 0x8c], [0x017d, 0x8e], [0x2018, 0x91], [0x2019, 0x92],
+    [0x201c, 0x93], [0x201d, 0x94], [0x2022, 0x95], [0x2013, 0x96], [0x2014, 0x97], [0x02dc, 0x98], [0x2122, 0x99],
+    [0x0161, 0x9a], [0x203a, 0x9b], [0x0153, 0x9c], [0x017e, 0x9e], [0x0178, 0x9f],
+]);
+/**
+ * ISO 8859-15 belegt acht Stellen anders als Latin-1: dort stehen € Š š Ž ž
+ * Œ œ Ÿ statt ¤ ¦ ¨ ´ ¸ ¼ ½ ¾. Die acht Latin-1-Zeichen fehlen der Tabelle
+ * (Ersetzung, sonst `?`), die neuen stehen hier mit ihrem Byte (€ setzen
+ * schon die zehn Zeichen). C1-Steuerzeichen (0x80-0x9F) gehen nie roh hinaus.
+ */
+const ISO8859_15_ANDERS = new Set([0xa4, 0xa6, 0xa8, 0xb4, 0xb8, 0xbc, 0xbd, 0xbe]);
+const ISO8859_15_NEU = new Map([
+    [0x0160, 0xa6], [0x0161, 0xa8], [0x017d, 0xb4], [0x017e, 0xb8], [0x0152, 0xbc], [0x0153, 0xbd], [0x0178, 0xbe],
+]);
+/** Byte fuer ein Zeichen ab 0x80, das nicht zu den zehn gehoert. */
+function uebrigesZeichen(codepunkt, id) {
+    switch (id) {
+        case 'wpc1252':
+            if (codepunkt < 0xa0)
+                return FRAGEZEICHEN; // C1-Steuerzeichen
+            if (codepunkt <= 0xff)
+                return codepunkt;
+            return WPC1252_NEU.get(codepunkt) ?? FRAGEZEICHEN;
+        case 'iso8859_15':
+            if (codepunkt < 0xa0)
+                return FRAGEZEICHEN; // C1-Steuerzeichen
+            if (codepunkt <= 0xff)
+                return ISO8859_15_ANDERS.has(codepunkt) ? FRAGEZEICHEN : codepunkt;
+            return ISO8859_15_NEU.get(codepunkt) ?? FRAGEZEICHEN;
+        case 'pc437':
+            return exports.CP437_AUS_LATIN1.get(codepunkt) ?? FRAGEZEICHEN;
+        case 'pc858':
+        case 'pc850':
+            return PC850_AUS_LATIN1.get(codepunkt) ?? FRAGEZEICHEN;
+        case 'replacement':
+            return FRAGEZEICHEN;
+    }
+}
+/**
+ * Wandelt Text in die Bytes einer Code-Tabelle: erst die vorhandenen
+ * Ersetzungen (`ZEICHEN_ERSATZ`), dann die zehn deutschen Zeichen je Tabelle
+ * (Byte oder Ersatzbuchstaben), ASCII unveraendert, alles uebrige ueber die
+ * Abbildung der Tabelle, sonst `?`. Ein Zeichen, das die Tabelle nicht
+ * kennt, ist genau ein Byte; nur die Ersatzbuchstaben machen aus einem
+ * Zeichen mehrere. Spalten darum immer an den fertigen Bytes messen.
+ */
+function encodeForCodeTable(text, table) {
+    return encodeReplaced(replaceKnownCharacters(text), table);
+}
+/** Wendet `ZEICHEN_ERSATZ` an (paketintern, nicht exportiert ueber den Einstieg). */
+function replaceKnownCharacters(text) {
+    let aufbereitet = text;
+    for (const [von, nach] of exports.ZEICHEN_ERSATZ) {
+        aufbereitet = aufbereitet.split(von).join(nach);
+    }
+    return aufbereitet;
+}
+/**
+ * Wie `encodeForCodeTable`, aber fuer Text, der `ZEICHEN_ERSATZ` schon hinter
+ * sich hat (paketintern: der alte Pfad in `encodeEscPosText` ersetzt vor der
+ * Latin-1-Pruefung und soll nicht zweimal ersetzen).
+ */
+function encodeReplaced(aufbereitet, table) {
+    const bytesDerTabelle = BYTES_JE_TABELLE[table];
+    if (bytesDerTabelle === undefined)
+        throw new Error(`Unbekannte Code-Tabelle: ${String(table)}`);
+    const bytes = [];
+    for (const zeichen of aufbereitet) {
+        const codepunkt = zeichen.codePointAt(0);
+        if (codepunkt < 0x80) {
+            bytes.push(codepunkt);
+            continue;
+        }
+        const byte = bytesDerTabelle[zeichen];
+        if (byte !== undefined) {
+            bytes.push(byte);
+            continue;
+        }
+        const ersatz = ERSATZ_BUCHSTABEN[zeichen];
+        if (ersatz !== undefined) {
+            for (let i = 0; i < ersatz.length; i++)
+                bytes.push(ersatz.charCodeAt(i));
+            continue;
+        }
+        bytes.push(uebrigesZeichen(codepunkt, table));
+    }
+    return Uint8Array.from(bytes);
+}

package/dist/cjs/printing/escpos.d.ts

@@ -23,11 +23,14 @@
  * `ESC t 16` und bleiben in CP437; dann werden die Umlaute auf ihre
  * CP437-Plaetze umkodiert (ä = 0x84, ü = 0x81, ß = 0xE1, ...). Zeichen ohne
  * CP437-Platz werden zu `?` — weiterhin ein Byte je Zeichen.
+ * Weitere Tabellen (PC858, PC850, ISO 8859-15, reine Ersatzbuchstaben) und
+ * ihre `ESC t`-Nummern stehen im Katalog `code-tables.ts`.
  *
  * Nicht enthalten (bewusst): Bilddekodierung (PNG/JPEG liest die Huelle),
  * Capability-Profile einzelner Druckermodelle, Kassenlade, 1D-Barcodes.
  * Fertige einfarbige Rasterbilder (Logo) gehen ueber [escPosRasterImage].
  */
+import { type CodeTableId } from './code-tables.js';
 import { type QrModuleSize } from './qr-groesse.js';
 /** Papierbreite der Bonrolle. */
 export type PosPaperSize = 'mm58' | 'mm80';
@@ -37,8 +40,12 @@ export type PosAlign = 'left' | 'center' | 'right';
 export type PosFont = 'fontA' | 'fontB';
 /** Voller oder teilweiser Papierschnitt. */
 export type PosCutMode = 'full' | 'partial';
-/** Vom Drucker zu verwendende Codepage. */
-export type PosCodeTable = 'CP437' | 'CP1252';
+/**
+ * Vom Drucker zu verwendende Codepage: eine Tabelle des Katalogs
+ * (`CODE_TABLES`) oder einer der alten Namen. `CP1252` entspricht `wpc1252`,
+ * `CP437` entspricht `pc437`.
+ */
+export type PosCodeTable = 'CP437' | 'CP1252' | CodeTableId;
 /** Zeichenvergroesserung (1 = einfach, 2 = doppelt, ... bis 8). */
 export type PosTextSize = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
 /** Modulgroesse des QR-Codes (Punkte je Modul). */
@@ -171,10 +178,16 @@ export interface EscPosDocument {
     styles: AktuelleStile;
 }
 /**
- * Kodiert Text so, wie ihn der Drucker erwartet: ein Byte je Zeichen nach
- * Latin-1, vorher die vier Zeichenersetzungen des Vorbilds. Ein Umlaut wird
- * damit zu genau einem Byte — Voraussetzung dafuer, dass die Spaltenrechnung
- * stimmt.
+ * Kodiert Text so, wie ihn der Drucker erwartet: ein Byte je Zeichen in der
+ * gewaehlten Tabelle (`encodeForCodeTable`). Ein Umlaut wird damit zu genau
+ * einem Byte -- Voraussetzung dafuer, dass die Spaltenrechnung stimmt.
+ *
+ * Die alten Namen `CP1252` und `CP437` bleiben streng: ein Zeichen ausserhalb
+ * Latin-1 wird gemeldet statt verstuemmelt (vorher `escPosPrintableText`
+ * anwenden). `CP1252` gibt Latin-1 byte-gleich wie bisher aus (auch ein
+ * C1-Steuerzeichen roh, das `wpc1252` zu `?` macht); `CP437` hat die Bytes
+ * von `pc437`. Die Tabellen des Katalogs wandeln dagegen jedes Zeichen um
+ * (Ersatzbuchstaben, sonst `?`).
  */
 export declare function encodeEscPosText(text: string, codeTable?: PosCodeTable): Uint8Array;
 /** Zeichen je Zeile fuer Papier und Schrift (`fontA`, wenn nichts gesetzt ist). */

package/dist/cjs/printing/escpos.js

@@ -24,6 +24,8 @@
  * `ESC t 16` und bleiben in CP437; dann werden die Umlaute auf ihre
  * CP437-Plaetze umkodiert (ä = 0x84, ü = 0x81, ß = 0xE1, ...). Zeichen ohne
  * CP437-Platz werden zu `?` — weiterhin ein Byte je Zeichen.
+ * Weitere Tabellen (PC858, PC850, ISO 8859-15, reine Ersatzbuchstaben) und
+ * ihre `ESC t`-Nummern stehen im Katalog `code-tables.ts`.
  *
  * Nicht enthalten (bewusst): Bilddekodierung (PNG/JPEG liest die Huelle),
  * Capability-Profile einzelner Druckermodelle, Kassenlade, 1D-Barcodes.
@@ -54,6 +56,7 @@ exports.qrRasterDots = qrRasterDots;
 exports.rasterRowsBytes = rasterRowsBytes;
 exports.rasterRowsBase64 = rasterRowsBase64;
 exports.escPosRasterImage = escPosRasterImage;
+const code_tables_js_1 = require("./code-tables.js");
 const qr_groesse_js_1 = require("./qr-groesse.js");
 // -------------------------------------------------------------- Befehlsbytes
 // Wortwoertlich aus commands.dart. Die Zahlen sind ASCII-Codes der dortigen
@@ -87,8 +90,15 @@ const C_POS = [ESC, 0x24]; // ESC $ nL nH
 const C_FEED_N = [ESC, 0x64]; // ESC d n
 const C_QR_HEADER = [GS, 0x28, 0x6b]; // GS ( k
 const ZEILENUMBRUCH = 0x0a;
-/** Codepage-Nummern fuer `ESC t n` — aus capability_profile.dart. */
-const CODEPAGE_ID = { CP437: 0, CP1252: 16 };
+/**
+ * Codepage-Nummern fuer `ESC t n`: die alten Namen aus capability_profile.dart
+ * (CP437 = 0, CP1252 = 16), dazu jede Tabelle des Katalogs.
+ */
+const CODEPAGE_ID = {
+    CP437: 0,
+    CP1252: 16,
+    ...Object.fromEntries(code_tables_js_1.CODE_TABLES.map((t) => [t.id, t.escT])),
+};
 /** Korrekturstufen fuer GS ( k Funktion 169 — aus qrcode.dart. */
 const QR_KORREKTUR = { L: 48, M: 49, Q: 50, H: 51 };
 /** Nennbreite der Rolle in Millimetern — nur fuer Meldungstexte. */
@@ -108,22 +118,6 @@ const ZEICHEN_JE_ZEILE = {
     mm58: { fontA: 32, fontB: 42 },
     mm80: { fontA: 48, fontB: 64 },
 };
-/**
- * Zeichen, die das Vorbild vor dem Kodieren ersetzt (generator.dart `_encode`).
- *
- * **Eine bewusste Abweichung:** Fuer `•` sagt generator.dart `.`,
- * print_paper.dart (portiert als `escPosPrintableText`) dagegen `*`. In Darts
- * eigener Kette faellt das nie auf, weil print_paper vor dem Erzeuger ersetzt
- * und der Erzeuger den Punkt nie zu sehen bekommt — die gedruckte Antwort ist
- * dort also `*`. Ein Verbraucher dieses Pakets kann `escPosText` aber auch
- * direkt aufrufen, und dann duerfen nicht zwei Zeichen fuer dasselbe Zeichen
- * herauskommen. Deshalb gilt hier dieselbe Antwort wie dort.
- */
-const ZEICHEN_ERSATZ = [
-    ['’', "'"], // typografisches Apostroph
-    ['´', "'"], // Akut
-    ['•', '*'], // Aufzaehlungspunkt (siehe Kommentar oben)
-];
 // ------------------------------------------------------------------ Helfer
 function anhaengen(doc, bytes) {
     const ziel = doc.bytes;
@@ -154,40 +148,25 @@ function latin1(text) {
     return bytes;
 }
 /**
- * Kodiert Text so, wie ihn der Drucker erwartet: ein Byte je Zeichen nach
- * Latin-1, vorher die vier Zeichenersetzungen des Vorbilds. Ein Umlaut wird
- * damit zu genau einem Byte — Voraussetzung dafuer, dass die Spaltenrechnung
- * stimmt.
+ * Kodiert Text so, wie ihn der Drucker erwartet: ein Byte je Zeichen in der
+ * gewaehlten Tabelle (`encodeForCodeTable`). Ein Umlaut wird damit zu genau
+ * einem Byte -- Voraussetzung dafuer, dass die Spaltenrechnung stimmt.
+ *
+ * Die alten Namen `CP1252` und `CP437` bleiben streng: ein Zeichen ausserhalb
+ * Latin-1 wird gemeldet statt verstuemmelt (vorher `escPosPrintableText`
+ * anwenden). `CP1252` gibt Latin-1 byte-gleich wie bisher aus (auch ein
+ * C1-Steuerzeichen roh, das `wpc1252` zu `?` macht); `CP437` hat die Bytes
+ * von `pc437`. Die Tabellen des Katalogs wandeln dagegen jedes Zeichen um
+ * (Ersatzbuchstaben, sonst `?`).
  */
 function encodeEscPosText(text, codeTable = 'CP1252') {
-    let aufbereitet = text;
-    for (const [von, nach] of ZEICHEN_ERSATZ) {
-        aufbereitet = aufbereitet.split(von).join(nach);
-    }
-    const bytes = latin1(aufbereitet);
-    if (codeTable !== 'CP437')
-        return bytes;
-    for (let i = 0; i < bytes.length; i++) {
-        const b = bytes[i] ?? 0;
-        if (b >= 0x80)
-            bytes[i] = CP437_AUS_LATIN1.get(b) ?? 0x3f;
+    if (codeTable === 'CP1252' || codeTable === 'CP437') {
+        const aufbereitet = (0, code_tables_js_1.replaceKnownCharacters)(text);
+        const bytes = latin1(aufbereitet); // wirft ausserhalb Latin-1
+        return codeTable === 'CP1252' ? bytes : (0, code_tables_js_1.encodeReplaced)(aufbereitet, 'pc437');
     }
-    return bytes;
+    return (0, code_tables_js_1.encodeForCodeTable)(text, codeTable);
 }
-/**
- * Latin-1-Byte -> CP437-Byte fuer die Zeichen, die CP437 kennt (deutsche
- * Umlaute, ß, westeuropaeische Akzente, Waehrungs-/Sonderzeichen). Alles
- * andere ab 0x80 hat in CP437 keinen Platz und wird zu "?".
- */
-const CP437_AUS_LATIN1 = new Map([
-    [0xc7, 0x80], [0xfc, 0x81], [0xe9, 0x82], [0xe2, 0x83], [0xe4, 0x84], [0xe0, 0x85], [0xe5, 0x86], [0xe7, 0x87],
-    [0xea, 0x88], [0xeb, 0x89], [0xe8, 0x8a], [0xef, 0x8b], [0xee, 0x8c], [0xec, 0x8d], [0xc4, 0x8e], [0xc5, 0x8f],
-    [0xc9, 0x90], [0xe6, 0x91], [0xc6, 0x92], [0xf4, 0x93], [0xf6, 0x94], [0xf2, 0x95], [0xfb, 0x96], [0xf9, 0x97],
-    [0xff, 0x98], [0xd6, 0x99], [0xdc, 0x9a], [0xa2, 0x9b], [0xa3, 0x9c], [0xa5, 0x9d], [0xe1, 0xa0], [0xed, 0xa1],
-    [0xf3, 0xa2], [0xfa, 0xa3], [0xf1, 0xa4], [0xd1, 0xa5], [0xaa, 0xa6], [0xba, 0xa7], [0xbf, 0xa8], [0xac, 0xaa],
-    [0xbd, 0xab], [0xbc, 0xac], [0xa1, 0xad], [0xab, 0xae], [0xbb, 0xaf], [0xdf, 0xe1], [0xb5, 0xe6], [0xb1, 0xf1],
-    [0xf7, 0xf6], [0xb0, 0xf8], [0xb7, 0xfa], [0xb2, 0xfd], [0xa0, 0xff],
-]);
 /** Zeichen je Zeile fuer Papier und Schrift (`fontA`, wenn nichts gesetzt ist). */
 function escPosMaxCharsPerLine(paperSize, font) {
     const breiten = ZEICHEN_JE_ZEILE[paperSize];

package/dist/cjs/printing/index.d.ts

@@ -1,4 +1,5 @@
 export { type PosPaperSize, type PosAlign, type PosFont, type PosCutMode, type PosCodeTable, type PosTextSize, type QrSize, type QrCorrection, type QrMatrix, type PosStyles, type PosColumn, type EscPosOptions, type EscPosTextOptions, type EscPosHrOptions, type EscPosQrOptions, type EscPosQrRasterOptions, type EscPosDocument, createEscPosDocument, escPosBytes, escPosReset, escPosSetGlobalCodeTable, escPosSetGlobalFont, escPosSetStyles, escPosText, escPosEmptyLines, escPosFeed, escPosCut, escPosHr, escPosRow, escPosQrCode, escPosQrRaster, qrRasterDots, type RasterImage, rasterRowsBytes, rasterRowsBase64, escPosRasterImage, encodeEscPosText, qrCodeBytes, escPosMaxCharsPerLine, escPosWrapLines, wrapText, } from './escpos.js';
+export { type CodeTableId, type CodeTable, CODE_TABLES, codeTableById, codeTableFromSetting, encodeForCodeTable, } from './code-tables.js';
 export { type QrModuleSize, type QrSizing, QR_MODULE_SIZE_CAP, QR_QUIET_ZONE_MODULES, QR_MIN_MODULE_DOTS, QR_EXCEPTION_MODULE_DOTS, QR_MAX_MODULE_DOTS, QR_PRINT_WIDTH_DOTS, qrModuleCount, qrFitsInVersion, computeQrSizing, qrSizingFor, } from './qr-groesse.js';
 export { escPosPrintableText } from './printable.js';
 export { type UsbEndpointLike, type UsbAlternateLike, type UsbInterfaceLike, type UsbConfigurationLike, type UsbTransferOutResultLike, type UsbWriterLike, type UsbIdentityLike, type UsbDeviceLike, type UsbPrinterEndpoint, type UsbPrinterConnection, USB_VENDOR_EPSON, USB_CLASS_PRINTER, UsbTimeoutError, usbDeviceKey, usbFindPrinterEndpoint, usbWriteAll, usbConnectPrinter, usbPrint, usbDisconnect, } from './webusb.js';

package/dist/cjs/printing/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.usbDisconnect = exports.usbPrint = exports.usbConnectPrinter = exports.usbWriteAll = exports.usbFindPrinterEndpoint = exports.usbDeviceKey = exports.UsbTimeoutError = exports.USB_CLASS_PRINTER = exports.USB_VENDOR_EPSON = exports.escPosPrintableText = exports.qrSizingFor = exports.computeQrSizing = exports.qrFitsInVersion = exports.qrModuleCount = exports.QR_PRINT_WIDTH_DOTS = exports.QR_MAX_MODULE_DOTS = exports.QR_EXCEPTION_MODULE_DOTS = exports.QR_MIN_MODULE_DOTS = exports.QR_QUIET_ZONE_MODULES = exports.QR_MODULE_SIZE_CAP = exports.wrapText = exports.escPosWrapLines = exports.escPosMaxCharsPerLine = exports.qrCodeBytes = exports.encodeEscPosText = exports.escPosRasterImage = exports.rasterRowsBase64 = exports.rasterRowsBytes = exports.qrRasterDots = exports.escPosQrRaster = exports.escPosQrCode = exports.escPosRow = exports.escPosHr = exports.escPosCut = exports.escPosFeed = exports.escPosEmptyLines = exports.escPosText = exports.escPosSetStyles = exports.escPosSetGlobalFont = exports.escPosSetGlobalCodeTable = exports.escPosReset = exports.escPosBytes = exports.createEscPosDocument = void 0;
+exports.usbDisconnect = exports.usbPrint = exports.usbConnectPrinter = exports.usbWriteAll = exports.usbFindPrinterEndpoint = exports.usbDeviceKey = exports.UsbTimeoutError = exports.USB_CLASS_PRINTER = exports.USB_VENDOR_EPSON = exports.escPosPrintableText = exports.qrSizingFor = exports.computeQrSizing = exports.qrFitsInVersion = exports.qrModuleCount = exports.QR_PRINT_WIDTH_DOTS = exports.QR_MAX_MODULE_DOTS = exports.QR_EXCEPTION_MODULE_DOTS = exports.QR_MIN_MODULE_DOTS = exports.QR_QUIET_ZONE_MODULES = exports.QR_MODULE_SIZE_CAP = exports.encodeForCodeTable = exports.codeTableFromSetting = exports.codeTableById = exports.CODE_TABLES = exports.wrapText = exports.escPosWrapLines = exports.escPosMaxCharsPerLine = exports.qrCodeBytes = exports.encodeEscPosText = exports.escPosRasterImage = exports.rasterRowsBase64 = exports.rasterRowsBytes = exports.qrRasterDots = exports.escPosQrRaster = exports.escPosQrCode = exports.escPosRow = exports.escPosHr = exports.escPosCut = exports.escPosFeed = exports.escPosEmptyLines = exports.escPosText = exports.escPosSetStyles = exports.escPosSetGlobalFont = exports.escPosSetGlobalCodeTable = exports.escPosReset = exports.escPosBytes = exports.createEscPosDocument = void 0;
 var escpos_js_1 = require("./escpos.js");
 Object.defineProperty(exports, "createEscPosDocument", { enumerable: true, get: function () { return escpos_js_1.createEscPosDocument; } });
 Object.defineProperty(exports, "escPosBytes", { enumerable: true, get: function () { return escpos_js_1.escPosBytes; } });
@@ -25,6 +25,11 @@ Object.defineProperty(exports, "qrCodeBytes", { enumerable: true, get: function
 Object.defineProperty(exports, "escPosMaxCharsPerLine", { enumerable: true, get: function () { return escpos_js_1.escPosMaxCharsPerLine; } });
 Object.defineProperty(exports, "escPosWrapLines", { enumerable: true, get: function () { return escpos_js_1.escPosWrapLines; } });
 Object.defineProperty(exports, "wrapText", { enumerable: true, get: function () { return escpos_js_1.wrapText; } });
+var code_tables_js_1 = require("./code-tables.js");
+Object.defineProperty(exports, "CODE_TABLES", { enumerable: true, get: function () { return code_tables_js_1.CODE_TABLES; } });
+Object.defineProperty(exports, "codeTableById", { enumerable: true, get: function () { return code_tables_js_1.codeTableById; } });
+Object.defineProperty(exports, "codeTableFromSetting", { enumerable: true, get: function () { return code_tables_js_1.codeTableFromSetting; } });
+Object.defineProperty(exports, "encodeForCodeTable", { enumerable: true, get: function () { return code_tables_js_1.encodeForCodeTable; } });
 var qr_groesse_js_1 = require("./qr-groesse.js");
 Object.defineProperty(exports, "QR_MODULE_SIZE_CAP", { enumerable: true, get: function () { return qr_groesse_js_1.QR_MODULE_SIZE_CAP; } });
 Object.defineProperty(exports, "QR_QUIET_ZONE_MODULES", { enumerable: true, get: function () { return qr_groesse_js_1.QR_QUIET_ZONE_MODULES; } });

package/dist/cjs/printing/printable.d.ts

@@ -15,6 +15,7 @@
  * ersatzlos weg, alles Uebrige auf `?`. Ein Artikelname aus einer
  * ERP-Uebernahme mit Gedankenstrich soll den Beleg nicht verhindern.
  */
+import type { PosCodeTable } from './escpos.js';
 /**
  * Ersetzt alles, was der Bondrucker nicht darstellen kann, durch eine
  * druckbare Entsprechung. Reine Funktion, ohne Zustand und ohne Drucker.
@@ -22,6 +23,17 @@
  * Vor `escPosText`/`escPosRow` anwenden, wenn der Text aus fremder Hand kommt
  * (Artikelstamm, ERP-Uebernahme, Kundenname). `•` wird hier zu `*`, und der
  * Erzeuger sagt dasselbe — auch wer diese Funktion weglaesst, bekommt also
- * dasselbe Zeichen (siehe ZEICHEN_ERSATZ in escpos.ts).
+ * dasselbe Zeichen (siehe ZEICHEN_ERSATZ in code-tables.ts).
+ *
+ * Mit `codeTable` wird der Text fuer genau diese Tabelle fertig gemacht:
+ * - eine Tabelle des Katalogs (`CodeTableId`): `€` bleibt stehen, wenn die
+ *   Tabelle es hat (der Drucker bekommt das echte Byte), sonst `EUR`; jedes
+ *   der zehn Zeichen, das der Tabelle fehlt (`§` auf pc437, alle Umlaute auf
+ *   `replacement` ...), wird schon hier zu seinen Ersatzbuchstaben. Danach
+ *   ist jedes Zeichen genau ein Byte, und Spalten, die am Text gerechnet
+ *   werden, stimmen auch am Papier.
+ * - `CP437` (alter Name): wie `pc437`, also `§` -> `Par.`.
+ * - ohne Angabe, `null` oder `CP1252`: genau wie bisher (Bons ohne gewaehlte
+ *   Tabelle bleiben byte-gleich).
  */
-export declare function escPosPrintableText(text: string): string;
+export declare function escPosPrintableText(text: string, codeTable?: PosCodeTable | null): string;