portakal 0.2.0 → 0.4.0

package/README.md

@@ -4,7 +4,7 @@
   <br><br>
   <b style="font-size: 2em;">portakal</b>
   <br><br>
-  Universal printer language SDK — TSC, ZPL, EPL, ESC/POS and more.
+  Universal printer language SDK — 9 languages, one API.
   <br>
   Text, barcodes, QR codes, images, shapes — anything you can print.
   <br>
@@ -14,6 +14,8 @@
   <a href="https://npmjs.com/package/portakal"><img src="https://img.shields.io/npm/dm/portakal?style=flat&colorA=18181B&colorB=F97316" alt="npm downloads"></a>
   <a href="https://bundlephobia.com/result?p=portakal"><img src="https://img.shields.io/bundlephobia/minzip/portakal?style=flat&colorA=18181B&colorB=F97316" alt="bundle size"></a>
   <a href="https://github.com/productdevbook/portakal/blob/main/LICENSE"><img src="https://img.shields.io/github/license/productdevbook/portakal?style=flat&colorA=18181B&colorB=F97316" alt="license"></a>
+  <br><br>
+  <a href="https://portakal.productdevbook.com">Playground</a> · <a href="https://github.com/productdevbook/portakal">GitHub</a> · <a href="https://npmjs.com/package/portakal">npm</a>
 </p>
 
 > [!NOTE]
@@ -28,37 +30,51 @@
 npm install portakal
 ```
 
-### Product label (text + barcode + QR + shapes)
+### Product label
 
 ```ts
-import { label } from "portakal";
+import { label } from "portakal/core";
+import { tsc } from "portakal/lang/tsc";
 
-const cmd = label({ width: 40, height: 30, unit: "mm" })
+const myLabel = label({ width: 40, height: 30, unit: "mm" })
   .text("ACME Corp", { x: 10, y: 10, size: 2 })
-  .text("SKU: PRD-00123", { x: 10, y: 35, font: "2" })
-  .barcode("123456789012", { type: "ean13", x: 10, y: 60, height: 50 })
-  .qrcode("https://acme.com/prd/123", { x: 220, y: 60, ecc: "M", size: 5 })
-  .line({ x1: 5, y1: 55, x2: 310, y2: 55, thickness: 1 })
-  .box({ x: 5, y: 5, width: 310, height: 230, thickness: 2 })
-  .toTSC();
+  .text("SKU: PRD-00123", { x: 10, y: 35 })
+  .line({ x1: 5, y1: 55, x2: 310, y2: 55 })
+  .box({ x: 5, y: 5, width: 310, height: 230, thickness: 2 });
+
+const code = tsc.compile(myLabel); // TSC/TSPL2 commands
+const svg = tsc.preview(myLabel); // SVG preview with TSC font metrics
 ```
 
-### Shipping label (multiple text fields + barcode)
+### Same label → any language
 
 ```ts
-const shipping = label({ width: 100, height: 150, unit: "mm" })
-  .text("FROM: Warehouse A", { x: 10, y: 10 })
-  .text("TO: John Doe", { x: 10, y: 30, size: 2 })
-  .text("123 Main St, New York, NY 10001", { x: 10, y: 55 })
-  .barcode("SSCC00012345678901234", { type: "code128", x: 10, y: 80, height: 80 })
-  .qrcode("https://track.example.com/PKG123", { x: 300, y: 80, size: 8 })
-  .line({ x1: 5, y1: 70, x2: 780, y2: 70, thickness: 2 })
-  .toZPL();
+import { label } from "portakal/core";
+import { tsc } from "portakal/lang/tsc";
+import { zpl } from "portakal/lang/zpl";
+import { epl } from "portakal/lang/epl";
+import { escpos } from "portakal/lang/escpos";
+
+const myLabel = label({ width: 40, height: 30, unit: "mm" }).text("Hello World", {
+  x: 10,
+  y: 10,
+  size: 2,
+});
+
+tsc.compile(myLabel); // TSC/TSPL2  — TSC, Gprinter, Xprinter, iDPRT
+zpl.compile(myLabel); // Zebra ZPL II — GK420, ZT410, ZD620
+epl.compile(myLabel); // Eltron EPL2 — LP/TLP 2824, GX420, ZD220
+escpos.compile(myLabel); // ESC/POS — Epson, Bixolon, Star, Citizen (Uint8Array)
 ```
 
-### Receipt (ESC/POS — text, barcode, QR)
+Only the imported languages enter your bundle — 100% tree-shakeable.
+
+### Receipt (ESC/POS)
 
 ```ts
+import { label } from "portakal/core";
+import { escpos } from "portakal/lang/escpos";
+
 const receipt = label({ width: 80, unit: "mm" })
   .text("MY STORE", { align: "center", bold: true, size: 2 })
   .text("123 Market St", { align: "center" })
@@ -66,66 +82,50 @@ const receipt = label({ width: 80, unit: "mm" })
   .text("Hamburger           x2    $25.98")
   .text("Cola                x1     $3.50")
   .text("================================")
-  .text("TOTAL                     $29.48", { bold: true, size: 2 })
-  .barcode("INV-20260402-001", { type: "code128", height: 60 })
-  .qrcode("https://receipt.example.com/inv/001")
-  .toESCPOS(); // Uint8Array (binary)
+  .text("TOTAL                     $29.48", { bold: true, size: 2 });
+
+const bytes = escpos.compile(receipt); // Uint8Array
+const svg = escpos.preview(receipt); // Receipt-style SVG
 ```
 
-### Logo / image printing
+### Each module: compile + parse + preview + validate
 
 ```ts
-const cmd = label({ width: 40, height: 30, unit: "mm" })
-  .image(myLogoBitmap, { x: 10, y: 10, width: 100 })
-  .text("Company Name", { x: 120, y: 20, size: 2 })
-  .toTSC();
-```
+import { tsc } from "portakal/lang/tsc";
 
-### Same label → any printer language
+// Compile: label → printer commands
+tsc.compile(myLabel);
 
-```ts
-const myLabel = label({ width: 40, height: 30, unit: "mm" })
-  .text("Hello World", { x: 10, y: 10, size: 2 })
-  .barcode("123456789", { type: "code128", x: 10, y: 50, height: 60 });
+// Preview: label → SVG (per-language font metrics)
+tsc.preview(myLabel);
+
+// Parse: printer commands → structured data
+tsc.parse(tscCode); // { commands, elements, widthDots, ... }
 
-myLabel.toTSC(); // TSC/TSPL2  — TSC, Gprinter, Xprinter, iDPRT
-myLabel.toZPL(); // Zebra ZPL II — GK420, ZT410, ZD620
-myLabel.toEPL(); // Eltron EPL2 — LP/TLP 2824, GX420, ZD220
-myLabel.toESCPOS(); // ESC/POS — Epson, Bixolon, Star, Citizen
+// Validate: check for errors
+tsc.validate(tscCode); // { valid, errors, issues }
 ```
 
-### Software-rendered barcode/QR (with etiket)
+Available: `tsc`, `zpl`, `epl`, `cpcl`, `dpl`, `sbpl`, `escpos`, `starprnt`, `ipl`
 
-For pixel-perfect output, styled QR codes, or when the printer doesn't support a format natively:
+### Barcode/QR via etiket
 
-```sh
-npm install portakal etiket
-```
+Use [`etiket`](https://github.com/productdevbook/etiket) for barcode/QR generation, then embed as image:
 
 ```ts
-import { label } from "portakal";
+import { label } from "portakal/core";
+import { tsc } from "portakal/lang/tsc";
 import { barcodePNG, qrcodePNG } from "etiket";
 
-// etiket renders barcode/QR as PNG → portakal sends it as an image to the printer
-const cmd = label({ width: 40, height: 30, unit: "mm" })
+const myLabel = label({ width: 40, height: 30, unit: "mm" })
   .text("Product Label", { x: 10, y: 5 })
   .image(barcodePNG("123456789", { type: "code128" }), { x: 10, y: 40, width: 200 })
-  .image(qrcodePNG("https://example.com"), { x: 220, y: 40, width: 80 })
-  .toZPL();
-```
+  .image(qrcodePNG("https://example.com"), { x: 220, y: 40, width: 80 });
 
-### When to use which?
+const code = tsc.compile(myLabel);
+```
 
-|                                       | Printer-native (`.barcode()` / `.qrcode()`) | Software-rendered (`.image()` + `etiket`) |
-| :------------------------------------ | :------------------------------------------ | :---------------------------------------- |
-| **Dependencies**                      | None                                        | `etiket` (you install it)                 |
-| **Speed**                             | Fast (only sends command text)              | Slower (sends pixel data)                 |
-| **Data size**                         | Small (~50 bytes)                           | Larger (bitmap data)                      |
-| **Consistency**                       | Varies by printer model                     | Identical on every printer                |
-| **Format support**                    | Depends on printer (10-20 types)            | 40+ barcode types, styled QR              |
-| **Styled QR** (dots, gradients, logo) | Not possible                                | Full support via etiket                   |
-| **Works on cheap printers**           | May not support QR/PDF417                   | Always works (it's just an image)         |
-| **Best for**                          | Simple labels, fast printing                | Pixel-perfect, guaranteed output          |
+| **Best for** | Simple labels, fast printing | Pixel-perfect, guaranteed output |
 
 ## API
 
@@ -163,56 +163,6 @@ builder.text("Hello", {
 });
 ```
 
-### `.barcode(data, options)`
-
-Printer-native barcode (uses the printer's built-in encoder):
-
-```ts
-builder.barcode("123456789", {
-  type: "code128", // Symbology (see table below)
-  x: 10,
-  y: 50, // Position
-  height: 80, // Bar height in dots
-  narrowWidth: 2, // Narrow bar width
-  wideWidth: 4, // Wide bar width
-  readable: true, // Show human-readable text
-  readablePosition: "below", // "none" | "above" | "below" | "both"
-  rotation: 0, // 0 | 90 | 180 | 270
-});
-```
-
-**Supported barcode types:**
-
-| Type                                 | Description            |
-| :----------------------------------- | :--------------------- |
-| `code128`                            | Code 128 (auto subset) |
-| `code128a` / `code128b` / `code128c` | Code 128 subsets       |
-| `code39`                             | Code 39                |
-| `code93`                             | Code 93                |
-| `ean13` / `ean8`                     | EAN-13 / EAN-8         |
-| `upca` / `upce`                      | UPC-A / UPC-E          |
-| `itf` / `itf14`                      | Interleaved 2 of 5     |
-| `codabar`                            | Codabar                |
-| `msi`                                | MSI Plessey            |
-| `plessey`                            | Plessey                |
-| `code11`                             | Code 11                |
-| `postnet` / `planet`                 | USPS Postnet / Planet  |
-| `gs1_128`                            | GS1-128                |
-| `gs1_databar`                        | GS1 DataBar            |
-
-### `.qrcode(data, options?)`
-
-```ts
-builder.qrcode("https://example.com", {
-  x: 10,
-  y: 100, // Position
-  ecc: "M", // "L" | "M" | "Q" | "H"
-  size: 6, // Module size 1-10
-  model: 2, // QR model 1 | 2
-  rotation: 0, // 0 | 90 | 180 | 270
-});
-```
-
 ### `.image(bitmap, options?)`
 
 ```ts
@@ -253,20 +203,16 @@ builder.raw("^FO10,10^FDCustom^FS"); // ZPL
 builder.raw(new Uint8Array([0x1b, 0x70, 0x00, 0x32, 0x32])); // ESC/POS cash drawer
 ```
 
-### Output Methods
-
-| Method          | Output       | Target                          |
-| :-------------- | :----------- | :------------------------------ |
-| `.toTSC()`      | `string`     | TSC/TSPL2 label printers        |
-| `.toZPL()`      | `string`     | Zebra ZPL II printers           |
-| `.toEPL()`      | `string`     | Eltron EPL2 printers            |
-| `.toCPCL()`     | `string`     | Zebra mobile printers           |
-| `.toDPL()`      | `string`     | Honeywell/Datamax printers      |
-| `.toSBPL()`     | `string`     | SATO printers                   |
-| `.toESCPOS()`   | `Uint8Array` | ESC/POS receipt printers        |
-| `.toStarPRNT()` | `Uint8Array` | Star Micronics printers         |
-| `.toIPL()`      | `string`     | Intermec/Honeywell printers     |
-| `.toPreview()`  | `string`     | SVG preview (no printer needed) |
+### Language Module Methods
+
+Each language module (`tsc`, `zpl`, `epl`, `cpcl`, `dpl`, `sbpl`, `escpos`, `starprnt`, `ipl`) has:
+
+| Method                | Output                   | Description                              |
+| :-------------------- | :----------------------- | :--------------------------------------- |
+| `lang.compile(label)` | `string` or `Uint8Array` | Compile to printer commands              |
+| `lang.preview(label)` | `string`                 | SVG preview with language-specific fonts |
+| `lang.parse(code)`    | `object`                 | Parse printer commands → structured data |
+| `lang.validate(code)` | `object`                 | Validate commands for errors/warnings    |
 
 ### Image Processing
 
@@ -279,7 +225,7 @@ const bitmap = imageToMonochrome(rgbaPixels, width, height, {
   dither: "floyd-steinberg", // "threshold" | "floyd-steinberg" | "atkinson" | "ordered"
 });
 
-label({ width: 40, height: 30 }).image(bitmap, { x: 10, y: 10 }).toTSC();
+tsc.compile(label({ width: 40, height: 30 }).image(bitmap, { x: 10, y: 10 }));
 ```
 
 ### Receipt Layout
@@ -310,6 +256,60 @@ formatTable(
 );
 ```
 
+### Cross-Compiler
+
+Convert between any printer languages — world's first thermal printer translator:
+
+```ts
+import { convert } from "portakal";
+
+// TSC → ZPL
+const { output } = convert(tscCode, "tsc", "zpl");
+
+// ZPL → ESC/POS
+const { output } = convert(zplCode, "zpl", "escpos");
+
+// EPL → CPCL
+const { output } = convert(eplCode, "epl", "cpcl");
+```
+
+7 source × 9 target = **63 conversion paths**.
+
+### Validation
+
+Check printer commands for errors before sending to printer:
+
+```ts
+import { validate } from "portakal";
+
+const result = validate(code, "tsc");
+// { valid: false, errors: 1, warnings: 2, issues: [
+//   { level: "error", message: "CLS must appear before label elements" },
+//   { level: "warning", message: "No PRINT command found" },
+// ]}
+```
+
+TSC validation: SIZE order, CLS before elements, PRINT required, DENSITY 0-15, SPEED 1-18.
+ZPL validation: ^XA/^XZ required, ^FD without ^FO, ^PW range.
+
+### Printer Profiles
+
+Auto-configure DPI, paper width, and capabilities based on printer model:
+
+```ts
+import { label, getProfile, findByVendorId } from "portakal";
+
+// Auto-DPI from profile
+label({ width: 40, height: 30, printer: "tsc-te310" }); // 300 DPI
+label({ width: 80, printer: "epson-tm-t88vi" }); // 203 DPI
+
+// Lookup profiles
+getProfile("zebra-zd420"); // { name, dpi, paperWidth, ... }
+findByVendorId(0x04b8); // All Epson printers
+```
+
+20 built-in profiles: Epson, Star, Bixolon, Citizen, TSC, Zebra, SATO, Honeywell, Generic.
+
 ## Supported Printer Languages
 
 | Language        | Printers                                       | Status             |
@@ -331,24 +331,23 @@ formatTable(
 portakal generates commands only — it does **not** handle printer connections. Send the output over any transport you choose:
 
 ```ts
-import { label } from "portakal";
+import { label } from "portakal/core";
+import { tsc } from "portakal/lang/tsc";
+import { escpos } from "portakal/lang/escpos";
 import net from "node:net";
 
-const commands = label({ width: 40, height: 30 }).text("Hello", { x: 10, y: 10 }).toTSC();
+const myLabel = label({ width: 40, height: 30 }).text("Hello", { x: 10, y: 10 });
+const commands = tsc.compile(myLabel);
 
 // TCP (port 9100)
 const socket = net.createConnection({ host: "192.168.1.100", port: 9100 });
 socket.write(commands);
 socket.end();
 
-// USB (via serialport)
-import { SerialPort } from "serialport";
-const port = new SerialPort({ path: "/dev/usb/lp0", baudRate: 9600 });
-port.write(commands);
-
 // ESC/POS (binary) over WebUSB
-const escpos = label({ width: 80 }).text("Receipt").toESCPOS();
-await usbDevice.transferOut(endpointNumber, escpos);
+const receipt = label({ width: 80 }).text("Receipt");
+const bytes = escpos.compile(receipt);
+await usbDevice.transferOut(endpointNumber, bytes);
 ```
 
 ## Comparison
@@ -366,6 +365,10 @@ await usbDevice.transferOut(endpointNumber, escpos);
 | Image dithering              |       :white_check_mark:       |                                    :x:                                     |                       :x:                       |                       :x:                       |
 | Receipt layout engine        |       :white_check_mark:       |                                  Partial                                   |                       :x:                       |                       :x:                       |
 | SVG preview                  |       :white_check_mark:       |                                    :x:                                     |                       :x:                       |                       :x:                       |
+| Command parser (reverse)     |  :white_check_mark: 9 parsers  |                                    :x:                                     |                       :x:                       |                       :x:                       |
+| Cross-compiler (translate)   |  :white_check_mark: 63 paths   |                                    :x:                                     |                       :x:                       |                       :x:                       |
+| Command validation           |       :white_check_mark:       |                                    :x:                                     |                       :x:                       |                       :x:                       |
+| Printer profiles             |     :white_check_mark: 20      |                                    :x:                                     |                       :x:                       |                       :x:                       |
 | Works in browser             |       :white_check_mark:       |                                    :x:                                     |                       :x:                       |               :white_check_mark:                |
 | No native modules (no gyp)   |       :white_check_mark:       |                                    :x:                                     |                       :x:                       |               :white_check_mark:                |
 | Pure ESM                     |       :white_check_mark:       |                                 :x: (CJS)                                  |                    :x: (CJS)                    |                    :x: (CJS)                    |
@@ -376,30 +379,39 @@ await usbDevice.transferOut(endpointNumber, escpos);
 
 - Zero dependencies — pure computation, no native modules, no node-gyp
 - **9 printer languages** — TSC, ZPL, EPL, CPCL, DPL, SBPL, ESC/POS, Star PRNT, IPL
+- **Tree-shakeable** — sub-path exports for every module (`portakal/tsc`, `portakal/image`, etc.)
 - Pure ESM, edge-runtime compatible (Cloudflare Workers, Deno, Bun)
 - TypeScript-first with strict types (tsgo)
 - Transport-agnostic — generates commands, you handle the connection
 - Fluent builder API — one label definition compiles to any language
 - **Image processing** — RGBA → monochrome with 4 dithering algorithms (Floyd-Steinberg, Atkinson, ordered, threshold)
 - **Receipt layout engine** — same-line left+right alignment, tables, word-wrap, separators
-- **SVG preview** — `.toPreview()` renders labels without a physical printer
+- **SVG preview** — `lang.preview(label)` renders labels without a physical printer
+- **9 parsers** — reverse-parse printer commands back to structured data (TSC, ZPL, EPL, CPCL, ESC/POS, DPL, SBPL, Star PRNT, IPL)
 - Drawing primitives — box, line, circle, diagonal
 - Raw command passthrough for advanced/unsupported features
 - Optional [`etiket`](https://github.com/productdevbook/etiket) integration for barcode/QR images (40+ formats)
 - Works in browser, Node.js, Deno, Bun, Electron
 - **UTF-8 encoding engine** — auto code page selection (CP437, CP858, CP1252, CP866, CP857)
-- 184 tests across 15 test files
+- **Cross-compiler** — convert between any languages (63 paths: TSC↔ZPL↔EPL↔CPCL↔DPL↔SBPL↔IPL↔ESC/POS↔Star)
+- **Real validation** — parameter ranges, command order, structure checks
+- **20 printer profiles** — auto-DPI, auto-width by model (Epson, Star, Zebra, TSC, SATO, etc.)
+- **Language modules** — each language is a standalone module (compile + parse + preview + validate)
+- **Per-language SVG preview** — TSC fonts differ from ZPL fonts, ESC/POS renders receipt-style
+- 447 tests across 28 test files
 
 ## Contributing
 
 Contributions are welcome! Here are areas where help is especially appreciated:
 
-- **IPL, Fingerprint, Argox PPLA/PPLB** compiler implementations
-- UTF-8 encoding engine (auto code page selection)
-- Arabic/Hebrew RTL support (bidi + shaping)
-- Printer capability profiles (auto-detect features per model)
-- Transport layer implementations (WebUSB, WebSerial, Web Bluetooth)
-- Star TSP100 raster-only mode
+- **Arabic/Hebrew RTL** support (bidi algorithm + Arabic shaping)
+- **GS1/UDI label standards** (SSCC, GTIN, FMD, DSCSA templates)
+- **Star TSP100** raster-only text rendering
+- **CJK encoding** (GB18030, Shift_JIS, Big5, EUC-KR)
+- **Fingerprint** (Honeywell BASIC-like) compiler
+- **WebUSB/WebSerial/Web Bluetooth** transport adapters
+- Additional printer profiles
+- Parser validation rules for more languages
 
 ```bash
 pnpm install    # Install dependencies

package/dist/_chunks/types.d.mts

@@ -0,0 +1,202 @@
+//#region src/types.d.ts
+/** Unit of measurement for label dimensions */
+type Unit = "mm" | "inch" | "dot";
+/** Print orientation / rotation */
+type Rotation = 0 | 90 | 180 | 270;
+/** Text alignment */
+type Alignment = "left" | "center" | "right";
+/** Dithering algorithm for image processing */
+type DitherAlgorithm = "threshold" | "floyd-steinberg" | "atkinson" | "ordered";
+/** Label configuration */
+interface LabelConfig {
+  /** Printer profile ID (e.g., "epson-tm-t88vi", "zebra-zd420"). Overrides width, dpi, etc. */
+  printer?: string;
+  /** Label width */
+  width: number;
+  /** Label height (optional for receipt/continuous mode) */
+  height?: number;
+  /** Unit of measurement (default: "mm") */
+  unit?: Unit;
+  /** Printer DPI (default: 203) */
+  dpi?: number;
+  /** Gap between labels in mm (label printers only) */
+  gap?: number;
+  /** Print speed (1-10, printer-dependent) */
+  speed?: number;
+  /** Print darkness/density (0-15) */
+  density?: number;
+  /** Print direction */
+  direction?: 0 | 1;
+  /** Number of copies */
+  copies?: number;
+}
+/** Text element options */
+interface TextOptions {
+  /** X position */
+  x?: number;
+  /** Y position */
+  y?: number;
+  /** Font name or ID */
+  font?: string;
+  /** Font size or magnification */
+  size?: number;
+  /** Horizontal magnification (1-10) */
+  xScale?: number;
+  /** Vertical magnification (1-10) */
+  yScale?: number;
+  /** Rotation */
+  rotation?: Rotation;
+  /** Bold */
+  bold?: boolean;
+  /** Underline */
+  underline?: boolean;
+  /** Reverse (white on black) */
+  reverse?: boolean;
+  /** Alignment */
+  align?: Alignment;
+  /** Max width for word-wrap (in dots) */
+  maxWidth?: number;
+  /** Line spacing (in dots) */
+  lineSpacing?: number;
+}
+/** Image element options */
+interface ImageOptions {
+  /** X position */
+  x?: number;
+  /** Y position */
+  y?: number;
+  /** Target width in dots (auto-scale if set) */
+  width?: number;
+  /** Target height in dots (auto-scale if set) */
+  height?: number;
+  /** Dithering algorithm (default: "threshold") */
+  dither?: DitherAlgorithm;
+  /** Threshold for monochrome conversion (0-255, default: 128) */
+  threshold?: number;
+}
+/** Box/rectangle element options */
+interface BoxOptions {
+  /** X position */
+  x: number;
+  /** Y position */
+  y: number;
+  /** Width */
+  width: number;
+  /** Height */
+  height: number;
+  /** Border thickness in dots (default: 1) */
+  thickness?: number;
+  /** Corner radius in dots */
+  radius?: number;
+}
+/** Line element options */
+interface LineOptions {
+  /** Start X */
+  x1: number;
+  /** Start Y */
+  y1: number;
+  /** End X */
+  x2: number;
+  /** End Y */
+  y2: number;
+  /** Line thickness in dots (default: 1) */
+  thickness?: number;
+}
+/** Circle element options */
+interface CircleOptions {
+  /** Center X */
+  x: number;
+  /** Center Y */
+  y: number;
+  /** Diameter in dots */
+  diameter: number;
+  /** Border thickness in dots (default: 1) */
+  thickness?: number;
+}
+/** 1-bit monochrome bitmap (universal intermediate format for images) */
+interface MonochromeBitmap {
+  /** Packed 1-bit pixel data, row-major, MSB-first */
+  data: Uint8Array;
+  /** Width in pixels */
+  width: number;
+  /** Height in pixels */
+  height: number;
+  /** Bytes per row = ceil(width / 8) */
+  bytesPerRow: number;
+}
+/** Ellipse element options */
+interface EllipseOptions {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  thickness?: number;
+}
+/** Reverse region options (invert black/white) */
+interface ReverseOptions {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+/** Erase region options (clear to white) */
+interface EraseOptions {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+/** Internal label element union type */
+type LabelElement = {
+  type: "text";
+  content: string;
+  options: TextOptions;
+} | {
+  type: "image";
+  bitmap: MonochromeBitmap;
+  options: ImageOptions;
+} | {
+  type: "box";
+  options: BoxOptions;
+} | {
+  type: "line";
+  options: LineOptions;
+} | {
+  type: "circle";
+  options: CircleOptions;
+} | {
+  type: "ellipse";
+  options: EllipseOptions;
+} | {
+  type: "reverse";
+  options: ReverseOptions;
+} | {
+  type: "erase";
+  options: EraseOptions;
+} | {
+  type: "raw";
+  content: string | Uint8Array;
+};
+/** Resolved label configuration with computed values */
+interface ResolvedLabel {
+  /** Width in dots */
+  widthDots: number;
+  /** Height in dots (0 for continuous/receipt) */
+  heightDots: number;
+  /** DPI */
+  dpi: number;
+  /** Gap in dots */
+  gapDots: number;
+  /** Speed */
+  speed: number;
+  /** Density */
+  density: number;
+  /** Direction */
+  direction: 0 | 1;
+  /** Copies */
+  copies: number;
+  /** All elements to render */
+  elements: LabelElement[];
+}
+//#endregion
+export { EllipseOptions as a, LabelConfig as c, MonochromeBitmap as d, ResolvedLabel as f, Unit as g, TextOptions as h, DitherAlgorithm as i, LabelElement as l, Rotation as m, BoxOptions as n, EraseOptions as o, ReverseOptions as p, CircleOptions as r, ImageOptions as s, Alignment as t, LineOptions as u };