@kreiseck/kasseneck-api 1.0.0 → 1.1.0

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

@@ -0,0 +1,215 @@
+/**
+ * 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.
+ */
+/** 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).
+ */
+export 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). */
+export const 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. */
+export function codeTableById(id) {
+    const gefunden = 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`.
+ */
+export 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.
+ */
+export const 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 "?".
+ */
+export 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],
+]);
+/**
+ * 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 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.
+ */
+export function encodeForCodeTable(text, table) {
+    return encodeReplaced(replaceKnownCharacters(text), table);
+}
+/** Wendet `ZEICHEN_ERSATZ` an (paketintern, nicht exportiert ueber den Einstieg). */
+export function replaceKnownCharacters(text) {
+    let aufbereitet = text;
+    for (const [von, nach] of 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).
+ */
+export 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/esm/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/esm/printing/escpos.js

@@ -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 { CODE_TABLES, encodeForCodeTable, encodeReplaced, replaceKnownCharacters, } from './code-tables.js';
 import { QR_PRINT_WIDTH_DOTS, QR_MIN_MODULE_DOTS, QR_MODULE_SIZE_CAP, QR_QUIET_ZONE_MODULES, qrSizingFor, } from './qr-groesse.js';
 // -------------------------------------------------------------- Befehlsbytes
 // Wortwoertlich aus commands.dart. Die Zahlen sind ASCII-Codes der dortigen
@@ -61,8 +64,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.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. */
@@ -82,22 +92,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;
@@ -128,40 +122,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 `?`).
  */
 export 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 = replaceKnownCharacters(text);
+        const bytes = latin1(aufbereitet); // wirft ausserhalb Latin-1
+        return codeTable === 'CP1252' ? bytes : encodeReplaced(aufbereitet, 'pc437');
     }
-    return bytes;
+    return 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). */
 export function escPosMaxCharsPerLine(paperSize, font) {
     const breiten = ZEICHEN_JE_ZEILE[paperSize];

package/dist/esm/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/esm/printing/index.js

@@ -1,4 +1,5 @@
 export { createEscPosDocument, escPosBytes, escPosReset, escPosSetGlobalCodeTable, escPosSetGlobalFont, escPosSetStyles, escPosText, escPosEmptyLines, escPosFeed, escPosCut, escPosHr, escPosRow, escPosQrCode, escPosQrRaster, qrRasterDots, rasterRowsBytes, rasterRowsBase64, escPosRasterImage, encodeEscPosText, qrCodeBytes, escPosMaxCharsPerLine, escPosWrapLines, wrapText, } from './escpos.js';
+export { CODE_TABLES, codeTableById, codeTableFromSetting, encodeForCodeTable, } from './code-tables.js';
 export { 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 { USB_VENDOR_EPSON, USB_CLASS_PRINTER, UsbTimeoutError, usbDeviceKey, usbFindPrinterEndpoint, usbWriteAll, usbConnectPrinter, usbPrint, usbDisconnect, } from './webusb.js';

package/dist/esm/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;

package/dist/esm/printing/printable.js

@@ -15,6 +15,7 @@
  * ersatzlos weg, alles Uebrige auf `?`. Ein Artikelname aus einer
  * ERP-Uebernahme mit Gedankenstrich soll den Beleg nicht verhindern.
  */
+import { codeTableById, ersatzBuchstaben } from './code-tables.js';
 /** Ersetzungen aus print_paper.dart, Schluessel sind Unicode-Codepunkte. */
 const ERSETZUNGEN = new Map([
     [0x2013, '-'], // – Halbgeviertstrich
@@ -63,12 +64,34 @@ function istEmojiOderNullbreite(codepunkt) {
  * 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 function escPosPrintableText(text) {
+export function escPosPrintableText(text, codeTable) {
+    const tabelle = tabelleFuerErsatz(codeTable);
+    const fehlend = tabelle === null ? [] : codeTableById(tabelle).missing;
+    const echtesEuro = tabelle !== null && !fehlend.includes('€');
     let ergebnis = '';
     for (const zeichen of text) {
         const codepunkt = zeichen.codePointAt(0);
+        if (fehlend.includes(zeichen)) {
+            ergebnis += ersatzBuchstaben(zeichen);
+            continue;
+        }
+        if (codepunkt === 0x20ac && echtesEuro) {
+            ergebnis += zeichen;
+            continue;
+        }
         const ersatz = ERSETZUNGEN.get(codepunkt);
         if (ersatz !== undefined) {
             ergebnis += ersatz;
@@ -85,3 +108,14 @@ export function escPosPrintableText(text) {
     }
     return ergebnis;
 }
+/**
+ * Tabelle, deren fehlende Zeichen schon am Text ersetzt werden. `null` heisst
+ * alter Weg ohne Aenderung (keine Wahl, `null`, `CP1252`).
+ */
+function tabelleFuerErsatz(codeTable) {
+    if (codeTable === undefined || codeTable === null || codeTable === 'CP1252')
+        return null;
+    if (codeTable === 'CP437')
+        return 'pc437';
+    return codeTable;
+}

package/dist/esm/react/index.js

@@ -90,6 +90,13 @@ export function ReceiptSheetLines({ sheet: blatt, logoUrl, renderQr, qrHidden: q
     return (_jsx("div", { className: klasse, "data-zeichen": z, style: blattStil, children: blatt.blocks.map((b, i) => {
             switch (b.kind) {
                 case 'line':
+                    if (b.doubleSizeLead !== undefined && b.doubleSizeLead > 0) {
+                        // Wie am Papier (`GS !` doppelt): die Nummernzelle in doppelter
+                        // Schrift, die Zeile zwei Zeilen hoch, der Rest auf der Grundlinie.
+                        // `ch` im Span misst die doppelte Schrift, darum die halbe Zahl.
+                        const n = b.doubleSizeLead;
+                        return (_jsxs("div", { className: "keck-blatt-zeile keck-blatt-zeile--gross", style: { display: 'flex', alignItems: 'flex-end', whiteSpace: 'pre', height: '4ch', overflow: 'hidden', fontWeight: b.bold ? 'bold' : 'normal' }, children: [_jsx("span", { style: { fontSize: '2em', width: `${n / 2}ch`, lineHeight: '2ch', fontWeight: 'bold', textAlign: 'center', flex: 'none' }, children: b.text.slice(0, n).trim() }), _jsx("span", { style: { lineHeight: '2ch' }, children: b.text.slice(n) })] }, i));
+                    }
                     return (_jsx("div", { className: "keck-blatt-zeile", style: { whiteSpace: 'pre', height: '2ch', lineHeight: '2ch', overflow: 'hidden', fontWeight: b.bold ? 'bold' : 'normal' }, children: b.text }, i));
                 case 'logo':
                     return (_jsx("div", { className: "keck-blatt-logo", style: { height: `${b.heightLines * 2}ch`, display: 'flex', justifyContent: 'center' }, children: logoUrl === undefined ? null : (_jsx("img", { src: logoUrl, alt: "", "aria-hidden": "true", style: { width: `${b.widthFraction * z}ch`, height: `${b.heightLines * 2}ch`, objectFit: 'contain' } })) }, i));

package/dist/esm/receipt/blatt.d.ts

@@ -40,6 +40,15 @@ export type SheetBlock = {
     readonly text: string;
     readonly bold: boolean;
     readonly blank: boolean;
+    /**
+     * Die ersten n Spalten sind EINE Zelle, deren Inhalt (ohne Leerraum)
+     * doppelt breit und doppelt hoch steht -- die Zeile ist dann zwei
+     * Zeilen hoch. Nur das Testblatt des Zeichensatzes setzt das (Nummern
+     * links); fehlt es, ist alles einfach gross. Ein Zeichner, der das Feld
+     * nicht kennt, zeigt die Zeile in einfacher Groesse, die Spalten
+     * bleiben dieselben.
+     */
+    readonly doubleSizeLead?: number;
 } | {
     readonly kind: 'logo';
     readonly widthFraction: number;

package/dist/esm/receipt/code-table-reference-data.d.ts

@@ -0,0 +1,6 @@
+/** Die Vorlage-Zeile als Rasterbild: 384 x 24 Punkte, MSB zuerst, je Zeile auf volle Bytes aufgefuellt; base64. */
+export declare const CODE_TABLE_REFERENCE_RASTER: {
+    readonly width: number;
+    readonly height: number;
+    readonly bits: string;
+};

package/dist/esm/receipt/code-table-reference-data.js

@@ -0,0 +1,8 @@
+// Erzeugt von scripts/zeichensatz-vorlage.py -- nicht von Hand aendern.
+// Schrift: Menlo Regular 20 px (sha256 dc256e0b39c2a6fec947129d421fef41b8b429f58f9b6e5d1b148c87f775c1f6), Schwelle 160.
+/** Die Vorlage-Zeile als Rasterbild: 384 x 24 Punkte, MSB zuerst, je Zeile auf volle Bytes aufgefuellt; base64. */
+export const CODE_TABLE_REFERENCE_RASTER = {
+    width: 384,
+    height: 24,
+    bits: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYAAGYAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYAAGYAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGYAAGYAAGYAABgAADwAAIEAAH4AAB8AAD4AADwAAAAAAAAAAAAAAAAAAAAAAAAAAGYAAGYAAGYAADwAAH4AAcOAAOcAAD8AAH4AAH4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAMMAAcOAAMMAAHAAAGAAAEIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAMMAAcOAAMMAAOAAAGAAAEIAAAAAAAAAAAAAAAAAAAAAAAAAAP4AAH4AAMMAAGYAAcOAAcOAAMwAAMAAAHAAAGYAAAAAAAAAAAAAAAAAAAAAAAAAAOcAAOcAAMMAAGYAAYGAAcOAANgAAfwAAHgAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAMMAAMMAAGYAAYGAAcOAANgAAfwAAM4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAcOAAMMAAGcAAYGAAcOAANwAAMAAAMcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH8AAYGAAMMAAMMAAYGAAcOAAM4AAfgAAMMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAYGAAMMAAP8AAYGAAcOAAMcAA/gAAOMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcMAAYGAAMMAAP8AAcGAAcOAAMGAAMAAAHsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYMAAcOAAMMAAcOAAcOAAcOAAMGAAOAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYMAAMMAAMMAAYGAAMMAAMMAAMGAAGAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO8AAOcAAP8AAYGAAP8AAP8AAPOAAH8AAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8AAH4AAH8AA4HAAH4AAH4AAP8AAD8AAAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+};

package/dist/esm/receipt/code-table-test-sheet.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Das Testblatt fuer den Zeichensatz: welche Code-Tabelle druckt auf diesem
+ * Drucker die Umlaute richtig?
+ *
+ * Oben steht die Vorlage-Zeile als Rasterbild -- ein Bild druckt jeder
+ * Drucker gleich, egal welche Tabelle er gerade hat. Darunter je Tabelle des
+ * Katalogs eine Zeile mit ihrer Nummer (gross), umgeschaltet mit `ESC t n`
+ * und mit den Bytes dieser Tabelle. Die erste Zeile, die aussieht wie die
+ * Vorlage, ist die richtige; Zeile 6 (Ersatzbuchstaben) passt immer.
+ *
+ * Bildschirm und Papier zeigen dasselbe Blatt: `codeTableTestSheet` liefert
+ * es im Zeilenmodell des Beleg-Blatts (`ReceiptSheet`), `codeTableTestSheetBytes`
+ * druckt genau diese Zeilen. Das Blatt hat immer 32 Spalten (58 mm); auf
+ * 80 mm steht der Block ueber den linken Rand (`GS L`) mittig.
+ *
+ * Gemeinsamer Prueffall mit dem Dart-Zwilling:
+ * `fixtures/expected/code-table-test-sheet.{mm58,mm80}.hex` und `.lines.json`.
+ */
+import type { ReceiptSheet } from './blatt.js';
+import { type CodeTable, type CodeTableId } from '../printing/code-tables.js';
+import { type PosPaperSize, type RasterImage } from '../printing/escpos.js';
+/** Spalten des Testblatts -- immer 58-mm-Format. */
+export declare const CODE_TABLE_TEST_SHEET_CHARS = 32;
+export interface CodeTableTestSheetInput {
+    /** Kassen-Kennung fuer die Kopfzeile (keine Personendaten). */
+    cashregisterLabel: string;
+    /** Zeitpunkt des Drucks; die Kopfzeile zeigt ihn in Wiener Zeit. */
+    time: Date;
+    /** Papier des Druckers; das Blatt bleibt 32 Spalten, auf 80 mm mittig. */
+    paper: PosPaperSize;
+}
+/** Eine Testzeile: Nummer, Tabelle und die Zeichen, die ihr fehlen (fuer „ohne €“ am Bildschirm). */
+export interface CodeTableTestSheetRow {
+    readonly number: CodeTable['number'];
+    readonly codeTable: CodeTableId;
+    readonly missing: readonly string[];
+}
+/** Das Testblatt im Zeilenmodell des Beleg-Blatts, dazu die Testzeilen. */
+export interface CodeTableTestSheet extends ReceiptSheet {
+    readonly rows: readonly CodeTableTestSheetRow[];
+}
+/** Die Vorlage-Zeile als Rasterbild (384 x 24 Punkte), wie sie am Papier steht. */
+export declare function codeTableReferenceImage(): RasterImage;
+/** Das Testblatt im Zeilenmodell des Beleg-Blatts -- dieselben Zeilen wie am Papier. */
+export declare function codeTableTestSheet(options: CodeTableTestSheetInput): CodeTableTestSheet;
+/**
+ * Das Testblatt als ESC/POS-Bytes. Jede Testzeile schaltet nach ihrer
+ * Nummer einmal mit `FS .` + `ESC t n` auf ihre Tabelle und traegt deren Bytes (`encodeForCodeTable`,
+ * also das echte €-Byte, wo die Tabelle es hat). Die Nummer steht doppelt
+ * breit und hoch (`GS !`), die Vorlage als Rasterbild (`GS v 0`).
+ */
+export declare function codeTableTestSheetBytes(options: CodeTableTestSheetInput): Uint8Array;