thermalkit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NTag
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,184 @@
+# thermalkit
+
+Compose nicely-typeset images for thermal receipt printers (Epson TM-T88VI and friends).
+
+Designed for 80 mm thermal paper at 180 dpi — the canonical 504-pixel-wide vertical strip. Use it to build daily briefings, ticket lineups, schedules, weather forecasts, or anything that fits a single-column receipt layout.
+
+## Install
+
+```bash
+npm install thermalkit
+```
+
+If you want to print (not just generate images), install the printer dependency along with it:
+
+```bash
+npm install thermalkit node-thermal-printer
+```
+
+## Quick start
+
+```js
+import { Page } from 'thermalkit';
+import { EpsonPrinter } from 'thermalkit/printer';
+
+const page = new Page({
+  width: 504,                            // px (TM-T88VI printable area)
+  icons: ['sun', 'wind', 'drop'],        // Phosphor icons, pre-loaded
+});
+
+page.advance(60);
+page.title('BERLIN', { subtitle: 'morning briefing' });
+page.rule({ stroke: 1.5 });
+
+page.advance(36);
+page.section('MÉTÉO', { icon: 'sun' });
+
+page.text('21° / 14°', { family: 'georgia', size: 32 });
+page.advance(28);
+
+page.row(() => {
+  page.icon('wind', 16, { dy: -12 });
+  page.text('15 km/h SW', { x: 38 });
+});
+
+const png = await page.toPng();
+await new EpsonPrinter({ host: '192.168.0.225' }).print(png);
+```
+
+## API
+
+### `new Page(options)`
+
+Construct a vertical layout buffer.
+
+| option | type | default | meaning |
+|---|---|---|---|
+| `width` | `number` | `504` | Output width in pixels. Must be a multiple of 8 (ESC/POS bitmap requirement). |
+| `padding` | `number` | `22` | Horizontal padding around the content area. |
+| `icons` | `string[]` \| `Record<string,string>` | `{}` | Either a list of Phosphor icon names to pre-load, or a name→SVG-inner-content map. |
+| `defaultFontFamily` | `string` | `Helvetica, Arial, sans-serif` | Used by `page.text()` when no family is given. |
+
+### Cursor control
+
+| method | what it does |
+|---|---|
+| `page.y` | Read or write the current Y cursor (mutable property). |
+| `page.advance(delta)` | Move the cursor down by `delta` pixels. |
+| `page.spacer(amount = 12)` | Alias for `advance` with a documented default. |
+
+### Primitives (all chainable)
+
+| method | what it draws |
+|---|---|
+| `page.text(content, opts?)` | Text at the current baseline. Does **not** auto-advance. |
+| `page.icon(name, size?, opts?)` | Phosphor icon (must be pre-loaded). |
+| `page.rule(opts?)` | Horizontal line at the current Y. |
+| `page.image(pngBuffer, opts?)` | Embed a raster image (use `preparePoster` for halftone photos). |
+| `page.push(svgFragment)` | Append raw SVG (escape hatch for custom shapes). |
+| `page.row(fn, opts?)` | Run `fn` with the cursor preserved — multiple `text` / `icon` calls land on the same baseline. |
+
+### Higher-level helpers
+
+| method | what it draws |
+|---|---|
+| `page.title(text, { subtitle?, size?, family? })` | Big centered title + optional italic subtitle. |
+| `page.section(label, { icon?, size? })` | Caps-tracked section header, with optional icon on the left. |
+
+### Text-measurement
+
+```js
+page.approxWidth(text, size, opts?);
+page.wrapByWidth(text, maxWidth, size, opts?);
+```
+
+Naive but cheap. Good enough for word-wrapping decisions in the 10-24 px font-size range.
+
+### Output
+
+```js
+const svg = page.toSvg();                  // raw SVG string
+const png = await page.toPng();            // 1-bit-style PNG buffer
+const png = await page.toPng({             // override raster params
+  density: 240, width: 504, threshold: 140,
+});
+```
+
+For halftone photos (posters), use `toPngWithImages` to composite dithered rasters onto the thresholded base — that avoids the dither pattern getting smeared during the master rasterisation step:
+
+```js
+import { Page, preparePoster } from 'thermalkit';
+
+const page = new Page({ width: 504 });
+// ...
+const posterY = page.y;
+page.advance(150);  // reserve space
+
+const poster = await preparePoster('https://example.com/poster.jpg', {
+  width: 100,
+  dither: 'atkinson',
+});
+const png = await page.toPngWithImages([
+  { data: poster.data, x: 22, y: posterY },
+]);
+```
+
+## Printer
+
+```js
+import { EpsonPrinter } from 'thermalkit/printer';
+
+const printer = new EpsonPrinter({ host: '192.168.0.225', port: 9100 });
+
+await printer.print(png, {
+  density: 0,           // -50..+50, persistent in printer memory
+  cut: true,            // paper cut at end
+  align: 'center',
+});
+
+await printer.setDensity(20);              // change density without printing
+await printer.raw(Buffer.from([0x1b, 0x40])); // send arbitrary ESC/POS
+```
+
+## Dithering
+
+The poster pipeline uses Atkinson dither by default — cleaner contrast than Floyd-Steinberg, less speckle than ordered Bayer. You can call the algorithms directly too:
+
+```js
+import { atkinson, floydSteinberg, bayer, threshold } from 'thermalkit/dither';
+
+const out = atkinson(greyBytes, width, height);  // Uint8Array (0 or 255)
+```
+
+| algorithm | character | best for |
+|---|---|---|
+| `atkinson` | clean, high contrast, less speckle | posters, faces, illustrations |
+| `floydSteinberg` | photographic, more detail, more noise | photographs at large sizes |
+| `bayer` | regular cross-hatch pattern | when you want a "computer-print" aesthetic |
+| `threshold` | hard B&W, no halftone | text, line art, icons |
+
+## Icons
+
+The library ships with Phosphor icon loading out of the box. Pass icon names to the `Page` constructor:
+
+```js
+const page = new Page({
+  icons: ['sun', 'cloud-rain', 'wind', 'calendar-heart'],
+});
+```
+
+You can also load them yourself:
+
+```js
+import { loadIcon, loadIcons } from 'thermalkit/icons';
+
+const sun = loadIcon('sun');              // inner SVG content (string)
+const map = loadIcons(['sun', 'wind']);   // name → content
+const map2 = loadIcons(['sun'], 'bold');  // different Phosphor weight
+```
+
+If `@phosphor-icons/core` isn't installed, icon loading silently returns empty strings (and `page.icon()` becomes a no-op).
+
+## License
+
+MIT

package/dist/chunks/dither-DyIl72tE.js

@@ -0,0 +1,166 @@
+//#region src/dither.ts
+/**
+* 1-bit dithering algorithms.
+*
+* All three take a single-channel greyscale `Uint8Array` (one byte per pixel,
+* 0 = black, 255 = white) and return another `Uint8Array` of the same size
+* containing exclusively 0 or 255 values.
+*
+* Pick by use case:
+*   - **atkinson** — default; cleaner / higher contrast / less speckle. Loses
+*     detail in extreme dark/light. Best for posters, faces, illustrations.
+*   - **fs** (Floyd-Steinberg) — preserves the most photographic detail but
+*     produces visible noise at small sizes.
+*   - **bayer** — fastest, regular cross-hatch pattern. Good when you want a
+*     deliberate "computer-print" look.
+*
+* See the README for a side-by-side comparison.
+*/
+/**
+* Floyd-Steinberg error-diffusion dither.
+* Right 7/16, down-left 3/16, down 5/16, down-right 1/16.
+*/
+function floydSteinberg(grey, width, height) {
+	const work = new Float32Array(grey.length);
+	for (let i = 0; i < grey.length; i++) work[i] = grey[i];
+	const out = new Uint8Array(grey.length);
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+		const i = y * width + x;
+		const v = work[i];
+		const nv = v < 128 ? 0 : 255;
+		out[i] = nv;
+		const err = v - nv;
+		if (x + 1 < width) work[i + 1] += err * (7 / 16);
+		if (x > 0 && y + 1 < height) work[i + width - 1] += err * (3 / 16);
+		if (y + 1 < height) work[i + width] += err * (5 / 16);
+		if (x + 1 < width && y + 1 < height) work[i + width + 1] += err * (1 / 16);
+	}
+	return out;
+}
+/**
+* Atkinson dither — used by Apple's original Macintosh. Propagates only 6/8
+* of the error across 6 neighbours (the rest is discarded), giving higher
+* contrast and less speckle than Floyd-Steinberg.
+*/
+function atkinson(grey, width, height) {
+	const work = new Float32Array(grey.length);
+	for (let i = 0; i < grey.length; i++) work[i] = grey[i];
+	const out = new Uint8Array(grey.length);
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+		const i = y * width + x;
+		const v = work[i];
+		const nv = v < 128 ? 0 : 255;
+		out[i] = nv;
+		const err = (v - nv) / 8;
+		if (x + 1 < width) work[i + 1] += err;
+		if (x + 2 < width) work[i + 2] += err;
+		if (y + 1 < height) {
+			if (x > 0) work[i + width - 1] += err;
+			work[i + width] += err;
+			if (x + 1 < width) work[i + width + 1] += err;
+		}
+		if (y + 2 < height) work[i + 2 * width] += err;
+	}
+	return out;
+}
+const BAYER_8 = new Uint8Array([
+	0,
+	32,
+	8,
+	40,
+	2,
+	34,
+	10,
+	42,
+	48,
+	16,
+	56,
+	24,
+	50,
+	18,
+	58,
+	26,
+	12,
+	44,
+	4,
+	36,
+	14,
+	46,
+	6,
+	38,
+	60,
+	28,
+	52,
+	20,
+	62,
+	30,
+	54,
+	22,
+	3,
+	35,
+	11,
+	43,
+	1,
+	33,
+	9,
+	41,
+	51,
+	19,
+	59,
+	27,
+	49,
+	17,
+	57,
+	25,
+	15,
+	47,
+	7,
+	39,
+	13,
+	45,
+	5,
+	37,
+	63,
+	31,
+	55,
+	23,
+	61,
+	29,
+	53,
+	21
+]);
+/**
+* 8×8 Bayer ordered dither. Deterministic, fast, and produces a regular
+* cross-hatch pattern at low resolutions.
+*/
+function bayer(grey, width, height) {
+	const out = new Uint8Array(grey.length);
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+		const t = (BAYER_8[(y & 7) * 8 + (x & 7)] + .5) / 64 * 255;
+		out[y * width + x] = grey[y * width + x] < t ? 0 : 255;
+	}
+	return out;
+}
+/**
+* Threshold ("hard binarization") — no halftone, every pixel is either 0 or 255
+* based on whether it's above or below `threshold`. Use for line art / text,
+* not for photographs.
+*/
+function threshold(grey, width, height, cutoff = 128) {
+	const out = new Uint8Array(grey.length);
+	for (let i = 0; i < grey.length; i++) out[i] = grey[i] < cutoff ? 0 : 255;
+	return out;
+}
+function dither(algo, grey, width, height) {
+	switch (algo) {
+		case "fs": return floydSteinberg(grey, width, height);
+		case "bayer": return bayer(grey, width, height);
+		case "none": return threshold(grey, width, height);
+		case "atkinson":
+		default: return atkinson(grey, width, height);
+	}
+}
+
+//#endregion
+export { atkinson, bayer, dither, floydSteinberg, threshold };
+//# sourceMappingURL=dither-DyIl72tE.js.map

package/dist/chunks/dither-DyIl72tE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dither-DyIl72tE.js","names":["grey: Uint8Array","width: number","height: number","algo: DitherAlgorithm"],"sources":["../../src/dither.ts"],"sourcesContent":["/**\n * 1-bit dithering algorithms.\n *\n * All three take a single-channel greyscale `Uint8Array` (one byte per pixel,\n * 0 = black, 255 = white) and return another `Uint8Array` of the same size\n * containing exclusively 0 or 255 values.\n *\n * Pick by use case:\n *   - **atkinson** — default; cleaner / higher contrast / less speckle. Loses\n *     detail in extreme dark/light. Best for posters, faces, illustrations.\n *   - **fs** (Floyd-Steinberg) — preserves the most photographic detail but\n *     produces visible noise at small sizes.\n *   - **bayer** — fastest, regular cross-hatch pattern. Good when you want a\n *     deliberate \"computer-print\" look.\n *\n * See the README for a side-by-side comparison.\n */\n\n/**\n * Floyd-Steinberg error-diffusion dither.\n * Right 7/16, down-left 3/16, down 5/16, down-right 1/16.\n */\nexport function floydSteinberg(\n  grey: Uint8Array,\n  width: number,\n  height: number,\n): Uint8Array {\n  const work = new Float32Array(grey.length);\n  for (let i = 0; i < grey.length; i++) work[i] = grey[i];\n  const out = new Uint8Array(grey.length);\n  for (let y = 0; y < height; y++) {\n    for (let x = 0; x < width; x++) {\n      const i = y * width + x;\n      const v = work[i];\n      const nv = v < 128 ? 0 : 255;\n      out[i] = nv;\n      const err = v - nv;\n      if (x + 1 < width)                   work[i + 1]         += err * (7 / 16);\n      if (x > 0 && y + 1 < height)         work[i + width - 1] += err * (3 / 16);\n      if (y + 1 < height)                  work[i + width]     += err * (5 / 16);\n      if (x + 1 < width && y + 1 < height) work[i + width + 1] += err * (1 / 16);\n    }\n  }\n  return out;\n}\n\n/**\n * Atkinson dither — used by Apple's original Macintosh. Propagates only 6/8\n * of the error across 6 neighbours (the rest is discarded), giving higher\n * contrast and less speckle than Floyd-Steinberg.\n */\nexport function atkinson(\n  grey: Uint8Array,\n  width: number,\n  height: number,\n): Uint8Array {\n  const work = new Float32Array(grey.length);\n  for (let i = 0; i < grey.length; i++) work[i] = grey[i];\n  const out = new Uint8Array(grey.length);\n  for (let y = 0; y < height; y++) {\n    for (let x = 0; x < width; x++) {\n      const i = y * width + x;\n      const v = work[i];\n      const nv = v < 128 ? 0 : 255;\n      out[i] = nv;\n      const err = (v - nv) / 8;\n      if (x + 1 < width)                   work[i + 1]              += err;\n      if (x + 2 < width)                   work[i + 2]              += err;\n      if (y + 1 < height) {\n        if (x > 0)                         work[i + width - 1]      += err;\n                                           work[i + width]          += err;\n        if (x + 1 < width)                 work[i + width + 1]      += err;\n      }\n      if (y + 2 < height)                  work[i + 2 * width]      += err;\n    }\n  }\n  return out;\n}\n\nconst BAYER_8 = new Uint8Array([\n   0, 32,  8, 40,  2, 34, 10, 42,\n  48, 16, 56, 24, 50, 18, 58, 26,\n  12, 44,  4, 36, 14, 46,  6, 38,\n  60, 28, 52, 20, 62, 30, 54, 22,\n   3, 35, 11, 43,  1, 33,  9, 41,\n  51, 19, 59, 27, 49, 17, 57, 25,\n  15, 47,  7, 39, 13, 45,  5, 37,\n  63, 31, 55, 23, 61, 29, 53, 21,\n]);\n\n/**\n * 8×8 Bayer ordered dither. Deterministic, fast, and produces a regular\n * cross-hatch pattern at low resolutions.\n */\nexport function bayer(\n  grey: Uint8Array,\n  width: number,\n  height: number,\n): Uint8Array {\n  const out = new Uint8Array(grey.length);\n  for (let y = 0; y < height; y++) {\n    for (let x = 0; x < width; x++) {\n      const t = ((BAYER_8[(y & 7) * 8 + (x & 7)] + 0.5) / 64) * 255;\n      out[y * width + x] = grey[y * width + x] < t ? 0 : 255;\n    }\n  }\n  return out;\n}\n\n/**\n * Threshold (\"hard binarization\") — no halftone, every pixel is either 0 or 255\n * based on whether it's above or below `threshold`. Use for line art / text,\n * not for photographs.\n */\nexport function threshold(\n  grey: Uint8Array,\n  width: number,\n  height: number,\n  cutoff = 128,\n): Uint8Array {\n  const out = new Uint8Array(grey.length);\n  for (let i = 0; i < grey.length; i++) out[i] = grey[i] < cutoff ? 0 : 255;\n  return out;\n}\n\nimport type { DitherAlgorithm } from './types.js';\n\nexport function dither(\n  algo: DitherAlgorithm,\n  grey: Uint8Array,\n  width: number,\n  height: number,\n): Uint8Array {\n  switch (algo) {\n    case 'fs':       return floydSteinberg(grey, width, height);\n    case 'bayer':    return bayer(grey, width, height);\n    case 'none':     return threshold(grey, width, height);\n    case 'atkinson':\n    default:         return atkinson(grey, width, height);\n  }\n}\n"],"mappings":"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"}

package/dist/chunks/icons-C1OFHE6u.js

@@ -0,0 +1,49 @@
+import { createRequire } from "node:module";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+//#region src/icons.ts
+const require_ = createRequire(import.meta.url);
+let phosphorAssetsDir = null;
+try {
+	const pkgPath = require_.resolve("@phosphor-icons/core/package.json");
+	phosphorAssetsDir = path.join(path.dirname(pkgPath), "assets");
+} catch {
+	phosphorAssetsDir = null;
+}
+const cache = new Map();
+function readInner(filePath) {
+	const raw = readFileSync(filePath, "utf8");
+	const m = raw.match(/<svg[^>]*>([\s\S]*?)<\/svg>/);
+	return m ? m[1].trim() : "";
+}
+/**
+* Load a single Phosphor icon's inner SVG.
+* Returns `''` if the icon (or Phosphor itself) is unavailable.
+*/
+function loadIcon(name, weight = "regular") {
+	const key = `${weight}/${name}`;
+	const cached = cache.get(key);
+	if (cached !== void 0) return cached;
+	let content = "";
+	if (phosphorAssetsDir) {
+		const file = path.join(phosphorAssetsDir, weight, `${name}.svg`);
+		if (existsSync(file)) try {
+			content = readInner(file);
+		} catch {}
+	}
+	cache.set(key, content);
+	return content;
+}
+/**
+* Load multiple icons into a `name → content` map suitable for `new Page({ icons })`.
+*/
+function loadIcons(names, weight = "regular") {
+	const out = {};
+	for (const n of names) out[n] = loadIcon(n, weight);
+	return out;
+}
+
+//#endregion
+export { loadIcon, loadIcons };
+//# sourceMappingURL=icons-C1OFHE6u.js.map

package/dist/chunks/icons-C1OFHE6u.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"icons-C1OFHE6u.js","names":["phosphorAssetsDir: string | null","filePath: string","name: string","weight: PhosphorWeight","names: string[]","out: Record<string, string>"],"sources":["../../src/icons.ts"],"sourcesContent":["/**\n * Thin loader for Phosphor icons (`@phosphor-icons/core`).\n *\n * The package ships per-icon `.svg` files at:\n *   assets/<weight>/<name>.svg\n *\n * We read each file once, extract the inner SVG content (everything between\n * `<svg …>` and `</svg>`), and cache it so subsequent loads are free.\n *\n * The Page builder embeds this content via:\n *   <g transform=\"translate(x, y) scale(s)\" fill=\"#000\">{content}</g>\n */\nimport { readFileSync, existsSync } from 'node:fs';\nimport path from 'node:path';\nimport { createRequire } from 'node:module';\n\nconst require_ = createRequire(import.meta.url);\n\nexport type PhosphorWeight =\n  | 'thin' | 'light' | 'regular' | 'bold' | 'fill' | 'duotone';\n\n// Resolve the package once. Fall back gracefully if Phosphor isn't installed.\nlet phosphorAssetsDir: string | null = null;\ntry {\n  const pkgPath = require_.resolve('@phosphor-icons/core/package.json');\n  phosphorAssetsDir = path.join(path.dirname(pkgPath), 'assets');\n} catch {\n  phosphorAssetsDir = null;\n}\n\nconst cache = new Map<string, string>();\n\nfunction readInner(filePath: string): string {\n  const raw = readFileSync(filePath, 'utf8');\n  const m = raw.match(/<svg[^>]*>([\\s\\S]*?)<\\/svg>/);\n  return m ? m[1].trim() : '';\n}\n\n/**\n * Load a single Phosphor icon's inner SVG.\n * Returns `''` if the icon (or Phosphor itself) is unavailable.\n */\nexport function loadIcon(name: string, weight: PhosphorWeight = 'regular'): string {\n  const key = `${weight}/${name}`;\n  const cached = cache.get(key);\n  if (cached !== undefined) return cached;\n  let content = '';\n  if (phosphorAssetsDir) {\n    const file = path.join(phosphorAssetsDir, weight, `${name}.svg`);\n    if (existsSync(file)) {\n      try { content = readInner(file); } catch { /* swallow */ }\n    }\n  }\n  cache.set(key, content);\n  return content;\n}\n\n/**\n * Load multiple icons into a `name → content` map suitable for `new Page({ icons })`.\n */\nexport function loadIcons(\n  names: string[],\n  weight: PhosphorWeight = 'regular',\n): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const n of names) out[n] = loadIcon(n, weight);\n  return out;\n}\n"],"mappings":";;;;;AAgBA,MAAM,WAAW,cAAc,OAAO,KAAK,IAAI;AAM/C,IAAIA,oBAAmC;AACvC,IAAI;CACF,MAAM,UAAU,SAAS,QAAQ,oCAAoC;AACrE,qBAAoB,KAAK,KAAK,KAAK,QAAQ,QAAQ,EAAE,SAAS;AAC/D,QAAO;AACN,qBAAoB;AACrB;AAED,MAAM,QAAQ,IAAI;AAElB,SAAS,UAAUC,UAA0B;CAC3C,MAAM,MAAM,aAAa,UAAU,OAAO;CAC1C,MAAM,IAAI,IAAI,MAAM,8BAA8B;AAClD,QAAO,IAAI,EAAE,GAAG,MAAM,GAAG;AAC1B;;;;;AAMD,SAAgB,SAASC,MAAcC,SAAyB,WAAmB;CACjF,MAAM,OAAO,EAAE,OAAO,GAAG,KAAK;CAC9B,MAAM,SAAS,MAAM,IAAI,IAAI;AAC7B,KAAI,kBAAsB,QAAO;CACjC,IAAI,UAAU;AACd,KAAI,mBAAmB;EACrB,MAAM,OAAO,KAAK,KAAK,mBAAmB,SAAS,EAAE,KAAK,MAAM;AAChE,MAAI,WAAW,KAAK,CAClB,KAAI;AAAE,aAAU,UAAU,KAAK;EAAG,QAAO,CAAiB;CAE7D;AACD,OAAM,IAAI,KAAK,QAAQ;AACvB,QAAO;AACR;;;;AAKD,SAAgB,UACdC,OACAD,SAAyB,WACD;CACxB,MAAME,MAA8B,CAAE;AACtC,MAAK,MAAM,KAAK,MAAO,KAAI,KAAK,SAAS,GAAG,OAAO;AACnD,QAAO;AACR"}

package/dist/dither.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 1-bit dithering algorithms.
+ *
+ * All three take a single-channel greyscale `Uint8Array` (one byte per pixel,
+ * 0 = black, 255 = white) and return another `Uint8Array` of the same size
+ * containing exclusively 0 or 255 values.
+ *
+ * Pick by use case:
+ *   - **atkinson** — default; cleaner / higher contrast / less speckle. Loses
+ *     detail in extreme dark/light. Best for posters, faces, illustrations.
+ *   - **fs** (Floyd-Steinberg) — preserves the most photographic detail but
+ *     produces visible noise at small sizes.
+ *   - **bayer** — fastest, regular cross-hatch pattern. Good when you want a
+ *     deliberate "computer-print" look.
+ *
+ * See the README for a side-by-side comparison.
+ */
+/**
+ * Floyd-Steinberg error-diffusion dither.
+ * Right 7/16, down-left 3/16, down 5/16, down-right 1/16.
+ */
+export declare function floydSteinberg(grey: Uint8Array, width: number, height: number): Uint8Array;
+/**
+ * Atkinson dither — used by Apple's original Macintosh. Propagates only 6/8
+ * of the error across 6 neighbours (the rest is discarded), giving higher
+ * contrast and less speckle than Floyd-Steinberg.
+ */
+export declare function atkinson(grey: Uint8Array, width: number, height: number): Uint8Array;
+/**
+ * 8×8 Bayer ordered dither. Deterministic, fast, and produces a regular
+ * cross-hatch pattern at low resolutions.
+ */
+export declare function bayer(grey: Uint8Array, width: number, height: number): Uint8Array;
+/**
+ * Threshold ("hard binarization") — no halftone, every pixel is either 0 or 255
+ * based on whether it's above or below `threshold`. Use for line art / text,
+ * not for photographs.
+ */
+export declare function threshold(grey: Uint8Array, width: number, height: number, cutoff?: number): Uint8Array;
+import type { DitherAlgorithm } from './types.js';
+export declare function dither(algo: DitherAlgorithm, grey: Uint8Array, width: number, height: number): Uint8Array;
+//# sourceMappingURL=dither.d.ts.map

package/dist/dither.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dither.d.ts","sourceRoot":"","sources":["../src/dither.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,UAAU,CAkBZ;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,UAAU,CAsBZ;AAaD;;;GAGG;AACH,wBAAgB,KAAK,CACnB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,UAAU,CASZ;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,SAAM,GACX,UAAU,CAIZ;AAED,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,wBAAgB,MAAM,CACpB,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,UAAU,CAQZ"}

package/dist/dither.js

@@ -0,0 +1,3 @@
+import { atkinson, bayer, dither, floydSteinberg, threshold } from "./chunks/dither-DyIl72tE.js";
+
+export { atkinson, bayer, dither, floydSteinberg, threshold };

package/dist/icons.d.ts

@@ -0,0 +1,11 @@
+export type PhosphorWeight = 'thin' | 'light' | 'regular' | 'bold' | 'fill' | 'duotone';
+/**
+ * Load a single Phosphor icon's inner SVG.
+ * Returns `''` if the icon (or Phosphor itself) is unavailable.
+ */
+export declare function loadIcon(name: string, weight?: PhosphorWeight): string;
+/**
+ * Load multiple icons into a `name → content` map suitable for `new Page({ icons })`.
+ */
+export declare function loadIcons(names: string[], weight?: PhosphorWeight): Record<string, string>;
+//# sourceMappingURL=icons.d.ts.map

package/dist/icons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icons.d.ts","sourceRoot":"","sources":["../src/icons.ts"],"names":[],"mappings":"AAkBA,MAAM,MAAM,cAAc,GACtB,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAmB/D;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,cAA0B,GAAG,MAAM,CAajF;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,GAAE,cAA0B,GACjC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAIxB"}

package/dist/icons.js

@@ -0,0 +1,3 @@
+import { loadIcon, loadIcons } from "./chunks/icons-C1OFHE6u.js";
+
+export { loadIcon, loadIcons };

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * thermalkit — compose 1-bit images for thermal receipt printers.
+ *
+ * Quick start:
+ *
+ *   import { Page } from 'thermalkit';
+ *   import { EpsonPrinter } from 'thermalkit/printer';
+ *
+ *   const page = new Page({ width: 504, icons: ['sun', 'wind'] });
+ *   page.title('BERLIN', { subtitle: 'morning briefing' });
+ *   page.rule();
+ *   page.section('MÉTÉO', { icon: 'sun' });
+ *   page.text('21° / 14°', { size: 32, family: 'georgia' });
+ *
+ *   const png = await page.toPng();
+ *   await new EpsonPrinter({ host: '192.168.0.225' }).print(png);
+ */
+export { Page } from './page.js';
+export { preparePoster } from './poster.js';
+export { loadIcon, loadIcons } from './icons.js';
+export { escapeXml, approxWidth, wrapByWidth, } from './svg.js';
+export type { PageOptions, TextOptions, IconOptions, RuleOptions, RowOptions, ImageOptions, RenderOptions, PosterOptions, PreparedImage, DitherAlgorithm, FontFamily, Align, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EACL,SAAS,EACT,WAAW,EACX,WAAW,GACZ,MAAM,UAAU,CAAC;AAElB,YAAY,EACV,WAAW,EACX,WAAW,EACX,WAAW,EACX,WAAW,EACX,UAAU,EACV,YAAY,EACZ,aAAa,EACb,aAAa,EACb,aAAa,EACb,eAAe,EACf,UAAU,EACV,KAAK,GACN,MAAM,YAAY,CAAC"}