@arraypress/covers 1.1.0 → 1.4.0

package/src/platform/bytes.d.ts

@@ -1,22 +0,0 @@
-// Byte helpers without Buffer.
-
-/** Bytes as a Uint8Array view. */
-export function u8(v: Uint8Array | ArrayBuffer | ArrayBufferView): Uint8Array;
-/** Whether a value is bytes. */
-export function isBytes(v: unknown): v is Uint8Array | ArrayBuffer;
-/** Base64-encode bytes. */
-export function toBase64(bytes: Uint8Array | ArrayBuffer): string;
-/** Decode base64. */
-export function fromBase64(s: string): Uint8Array;
-/** Each byte as one character. */
-export function latin1(b: Uint8Array): string;
-/** Decode UTF-8. */
-export function utf8(b: Uint8Array | ArrayBuffer): string;
-/** Encode UTF-8. */
-export function encodeUtf8(s: string): Uint8Array;
-/** Join byte arrays. */
-export function concat(parts: Uint8Array[]): Uint8Array;
-/** A `data:` URI's bytes, or undefined when it isn't one. */
-export function fromDataUri(uri: string): Uint8Array | undefined;
-/** A hex digest with Web Crypto. */
-export function hexDigest(algo: 'SHA-1' | 'SHA-256', data: Uint8Array | string): Promise<string>;

package/src/platform/bytes.js

@@ -1,103 +0,0 @@
-/**
- * Byte helpers that work the same in Node, browsers and Workers (no
- * `Buffer`). Where Node's `Buffer` is present it's used for speed; the
- * output is identical either way.
- *
- * @module bytes
- */
-
-const B = /** @type {any} */ (globalThis).Buffer;
-
-/**
- * Bytes as a `Uint8Array` view.
- *
- * @param {Uint8Array | ArrayBuffer | ArrayBufferView} v
- * @returns {Uint8Array}
- */
-export function u8(v) {
-  if (v instanceof Uint8Array) return v;
-  if (v instanceof ArrayBuffer) return new Uint8Array(v);
-  if (ArrayBuffer.isView(v)) return new Uint8Array(v.buffer, v.byteOffset, v.byteLength);
-  throw new TypeError('Expected bytes (Uint8Array or ArrayBuffer)');
-}
-
-/** @param {unknown} v @returns {v is Uint8Array | ArrayBuffer} */
-export const isBytes = (v) => v instanceof Uint8Array || v instanceof ArrayBuffer || ArrayBuffer.isView(v);
-
-/**
- * Base64-encode bytes.
- *
- * @param {Uint8Array | ArrayBuffer} bytes
- * @returns {string}
- */
-export function toBase64(bytes) {
-  const b = u8(bytes);
-  if (B) return B.from(b.buffer, b.byteOffset, b.byteLength).toString('base64');
-  let out = '';
-  for (let i = 0; i < b.length; i += 0x8000) out += String.fromCharCode.apply(null, /** @type {any} */ (b.subarray(i, i + 0x8000)));
-  return btoa(out);
-}
-
-/**
- * Decode base64.
- *
- * @param {string} s
- * @returns {Uint8Array}
- */
-export function fromBase64(s) {
-  if (B) return new Uint8Array(B.from(s, 'base64'));
-  const bin = atob(s.replace(/\s+/g, ''));
-  const out = new Uint8Array(bin.length);
-  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
-  return out;
-}
-
-/** @param {Uint8Array} b @returns {string} Each byte as one char. */
-export function latin1(b) {
-  let s = '';
-  for (let i = 0; i < b.length; i++) s += String.fromCharCode(b[i]);
-  return s;
-}
-
-/** @param {Uint8Array | ArrayBuffer} b @returns {string} */
-export const utf8 = (b) => new TextDecoder().decode(u8(b));
-
-/** @param {string} s @returns {Uint8Array} */
-export const encodeUtf8 = (s) => new TextEncoder().encode(s);
-
-/**
- * Join byte arrays.
- *
- * @param {Uint8Array[]} parts
- * @returns {Uint8Array}
- */
-export function concat(parts) {
-  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
-  let o = 0;
-  for (const p of parts) { out.set(p, o); o += p.length; }
-  return out;
-}
-
-/**
- * Decode a `data:` URI.
- *
- * @param {string} uri
- * @returns {Uint8Array | undefined} Its bytes, or undefined when it isn't one.
- */
-export function fromDataUri(uri) {
-  const m = /^data:([^,]*?),(.*)$/s.exec(uri);
-  if (!m) return undefined;
-  return /;base64$/i.test(m[1]) ? fromBase64(m[2]) : encodeUtf8(decodeURIComponent(m[2]));
-}
-
-/**
- * Hex digest with Web Crypto (Node 20+, browsers, Workers).
- *
- * @param {'SHA-1' | 'SHA-256'} algo
- * @param {Uint8Array | string} data
- * @returns {Promise<string>}
- */
-export async function hexDigest(algo, data) {
-  const buf = await globalThis.crypto.subtle.digest(algo, typeof data === 'string' ? encodeUtf8(data) : u8(data));
-  return Array.from(new Uint8Array(buf), (x) => x.toString(16).padStart(2, '0')).join('');
-}

package/src/platform/compress.d.ts

@@ -1,12 +0,0 @@
-// zlib on every platform.
-
-/** zlib-deflate synchronously (Node), else undefined. */
-export function deflateSync(data: Uint8Array): Uint8Array | undefined;
-/** zlib-deflate (Node's zlib, else CompressionStream). */
-export function deflate(data: Uint8Array): Promise<Uint8Array>;
-/** zlib-inflate. */
-export function inflate(data: Uint8Array): Promise<Uint8Array>;
-/** Brotli-decompress synchronously (Node), else undefined. */
-export function unbrotliSync(data: Uint8Array): Uint8Array | undefined;
-/** Brotli-decompress (Node's zlib, else DecompressionStream('brotli') where there is one), else undefined. */
-export function unbrotli(data: Uint8Array): Promise<Uint8Array | undefined>;

package/src/platform/compress.js

@@ -1,81 +0,0 @@
-/**
- * zlib deflate and inflate: Node's zlib, else `CompressionStream` and
- * `DecompressionStream` (browsers, Workers). For PNG textures and WOFF.
- *
- * @module platform/compress
- */
-
-import { node } from './node.js';
-
-/**
- * zlib-deflate synchronously, when the platform can (Node).
- *
- * @param {Uint8Array} data
- * @returns {Uint8Array | undefined}
- */
-export function deflateSync(data) {
-  const z = node('zlib');
-  return z ? z.deflateSync(data, { level: 9 }) : undefined;
-}
-
-/**
- * zlib-deflate: Node's zlib, else `CompressionStream` (browsers, Workers).
- * The two may differ in bytes but both are valid zlib streams.
- *
- * @param {Uint8Array} data
- * @returns {Promise<Uint8Array>}
- */
-export async function deflate(data) {
-  return deflateSync(data) ?? stream(data, new CompressionStream('deflate'));
-}
-
-/**
- * zlib-inflate (WOFF tables).
- *
- * @param {Uint8Array} data
- * @returns {Promise<Uint8Array>}
- */
-export async function inflate(data) {
-  const z = node('zlib');
-  return z ? z.inflateSync(data) : stream(data, new DecompressionStream('deflate'));
-}
-
-/**
- * @param {Uint8Array} data
- * @param {TransformStream} ts
- * @returns {Promise<Uint8Array>}
- */
-async function stream(data, ts) {
-  const out = new Response(new Blob([/** @type {any} */ (data)]).stream().pipeThrough(ts));
-  return new Uint8Array(await out.arrayBuffer());
-}
-
-/**
- * Brotli-decompress synchronously, when the platform can (Node's zlib).
- *
- * @param {Uint8Array} data
- * @returns {Uint8Array | undefined}
- */
-export function unbrotliSync(data) {
-  const z = node('zlib');
-  if (!z?.brotliDecompressSync) return undefined;
-  const out = z.brotliDecompressSync(data);
-  return new Uint8Array(out.buffer, out.byteOffset, out.byteLength);
-}
-
-/**
- * Brotli-decompress (WOFF2): Node's zlib, else `DecompressionStream('brotli')`
- * where the runtime has it. Undefined where neither can.
- *
- * @param {Uint8Array} data
- * @returns {Promise<Uint8Array | undefined>}
- */
-export async function unbrotli(data) {
-  const sync = unbrotliSync(data);
-  if (sync) return sync;
-  try {
-    return await stream(data, new DecompressionStream(/** @type {any} */ ('brotli')));
-  } catch {
-    return undefined;
-  }
-}

package/src/platform/node.d.ts

@@ -1,26 +0,0 @@
-// Node's built-ins, without importing node:.
-
-/** Node modules covers uses. */
-export interface NodeModules {
-  fs?: typeof import('node:fs');
-  fsp?: typeof import('node:fs/promises');
-  zlib?: typeof import('node:zlib');
-  path?: typeof import('node:path');
-  module?: typeof import('node:module');
-  url?: typeof import('node:url');
-}
-
-/** The global `process`, where there is one. */
-export const proc: NodeJS.Process | undefined;
-/** This module was loaded from disk. */
-export const FROM_DISK: boolean;
-/** A Node built-in, when there is one. */
-export function node<K extends 'fs' | 'fs/promises' | 'zlib' | 'path' | 'module' | 'url'>(name: K): K extends 'fs' ? typeof import('node:fs') : K extends 'fs/promises' ? typeof import('node:fs/promises') : K extends 'zlib' ? typeof import('node:zlib') : K extends 'path' ? typeof import('node:path') : K extends 'module' ? typeof import('node:module') : typeof import('node:url') | undefined;
-/** Install Node's modules (what `@arraypress/covers/node` does). */
-export function installNode(mods: NodeModules): void;
-/** Whether this is Node with a file system. */
-export function isNode(): boolean;
-/** Read a text file synchronously (Node). */
-export function readTextSync(path: string | URL): string;
-/** A file shipped with the package, from disk (Node), or undefined. */
-export function packageFileSync(rel: string): Uint8Array | undefined;

package/src/platform/node.js

@@ -1,86 +0,0 @@
-/**
- * Node's built-ins, found without importing `node:` (so bundles for
- * browsers and Workers never see them): `process.getBuiltinModule` on Node
- * 20.16+, or the modules `@arraypress/covers/node` installs.
- *
- * @module platform/node
- */
-
-/**
- * @typedef {object} NodeModules
- * @property {any} [fs] - `node:fs`.
- * @property {any} [fsp] - `node:fs/promises`.
- * @property {any} [zlib] - `node:zlib`.
- * @property {any} [path] - `node:path`.
- * @property {any} [module] - `node:module`.
- * @property {any} [url] - `node:url`.
- */
-
-/** @type {NodeModules} */
-let nodeModules = {};
-
-/** The global `process`, where there is one. */
-export const proc = /** @type {any} */ (globalThis).process;
-/** Built-in lookup without a static import (Node 20.16+, Deno, Bun). */
-const builtin = typeof proc?.getBuiltinModule === 'function' && proc.versions?.node ? proc.getBuiltinModule.bind(proc) : undefined;
-/** This module was loaded from disk (Node, Deno, Bun), not a bundle or a page. */
-export const FROM_DISK = String(import.meta.url).startsWith('file:');
-
-/**
- * A Node built-in, when there is one.
- *
- * @param {'fs' | 'fs/promises' | 'zlib' | 'path' | 'module' | 'url'} name
- * @returns {any}
- */
-export function node(name) {
-  const key = name === 'fs/promises' ? 'fsp' : name;
-  const have = /** @type {any} */ (nodeModules)[key];
-  if (have) return have;
-  if (!builtin) return undefined;
-  try {
-    return (/** @type {any} */ (nodeModules)[key] = builtin(`node:${name}`));
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Install Node's modules (what `@arraypress/covers/node` does).
- *
- * @param {NodeModules} mods
- * @returns {void}
- */
-export function installNode(mods) {
-  nodeModules = { ...nodeModules, ...mods };
-}
-
-/** Whether this looks like Node with a file system we can read. */
-export const isNode = () => Boolean(node('fs')) && Boolean(proc?.versions?.node);
-
-/**
- * Read a text file synchronously (Node only; `loadRecipe`).
- *
- * @param {string | URL} path
- * @returns {string}
- */
-export function readTextSync(path) {
-  const fs = node('fs');
-  if (!fs) throw new Error('Reading a file synchronously needs Node. In a browser or Worker, fetch the JSON and pass it to defineRecipe().');
-  return fs.readFileSync(path, 'utf8');
-}
-
-/**
- * Read a file that ships with this package (Node, from disk), or undefined.
- *
- * @param {string} rel - Relative to the package root (`'fonts/inter-latin-400.woff'`).
- * @returns {Uint8Array | undefined}
- */
-export function packageFileSync(rel) {
-  const fs = node('fs');
-  if (!fs || !FROM_DISK) return undefined;
-  try {
-    return fs.readFileSync(new URL(`../../${rel}`, import.meta.url));
-  } catch {
-    return undefined;
-  }
-}

package/src/png.js

@@ -1,126 +0,0 @@
-/**
- * A minimal PNG encoder (8-bit greyscale, RGB or RGBA; no filtering), so
- * layers that are pixels by nature (dithers, print textures) can embed
- * themselves in an SVG without sharp.
- *
- * @module png
- */
-
-import { deflateSync, deflate } from './platform/index.js';
-import { concat, toBase64 } from './platform/bytes.js';
-
-/** CRC-32 table (PNG's polynomial). */
-const CRC = (() => {
-  const t = new Uint32Array(256);
-  for (let n = 0; n < 256; n++) {
-    let c = n;
-    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
-    t[n] = c >>> 0;
-  }
-  return t;
-})();
-
-/** @param {Uint8Array} bytes @returns {number} */
-function crc32(bytes) {
-  let c = 0xffffffff;
-  for (const b of bytes) c = CRC[(c ^ b) & 0xff] ^ (c >>> 8);
-  return (c ^ 0xffffffff) >>> 0;
-}
-
-/** @param {string} type @param {Uint8Array} data @returns {Uint8Array} */
-function chunk(type, data) {
-  const out = new Uint8Array(12 + data.length);
-  const v = new DataView(out.buffer);
-  v.setUint32(0, data.length);
-  for (let i = 0; i < 4; i++) out[4 + i] = type.charCodeAt(i);
-  out.set(data, 8);
-  v.setUint32(8 + data.length, crc32(out.subarray(4, 8 + data.length)));
-  return out;
-}
-
-/**
- * The filtered scanlines and header of a PNG.
- *
- * @param {Uint8Array} pixels @param {number} width @param {number} height @param {1 | 3 | 4} channels
- * @returns {{ raw: Uint8Array, ihdr: Uint8Array }}
- */
-function scanlines(pixels, width, height, channels) {
-  const stride = width * channels;
-  const raw = new Uint8Array((stride + 1) * height);
-  for (let y = 0; y < height; y++) {
-    raw[y * (stride + 1)] = 0;
-    raw.set(pixels.subarray(y * stride, y * stride + stride), y * (stride + 1) + 1);
-  }
-  const ihdr = new Uint8Array(13);
-  const v = new DataView(ihdr.buffer);
-  v.setUint32(0, width);
-  v.setUint32(4, height);
-  ihdr[8] = 8;
-  ihdr[9] = /** @type {Record<number, number>} */ ({ 1: 0, 3: 2, 4: 6 })[channels];
-  return { raw, ihdr };
-}
-
-const SIGNATURE = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-
-/**
- * zlib "stored" blocks: valid, uncompressed. The synchronous fallback where
- * the platform has no synchronous deflate (browsers, Workers).
- *
- * @param {Uint8Array} data
- * @returns {Uint8Array}
- */
-function stored(data) {
-  const parts = [new Uint8Array([0x78, 0x01])];
-  for (let i = 0; i < data.length || i === 0; i += 65535) {
-    const block = data.subarray(i, i + 65535);
-    const last = i + 65535 >= data.length ? 1 : 0;
-    parts.push(new Uint8Array([last, block.length & 255, block.length >> 8, ~block.length & 255, (~block.length >> 8) & 255]), block);
-    if (last) break;
-  }
-  let a = 1;
-  let b = 0;
-  for (const x of data) { a = (a + x) % 65521; b = (b + a) % 65521; }
-  const adler = new Uint8Array(4);
-  new DataView(adler.buffer).setUint32(0, ((b << 16) | a) >>> 0);
-  parts.push(adler);
-  return concat(parts);
-}
-
-/**
- * Encode pixels as a PNG (synchronously: zlib in Node, stored blocks where
- * there's no synchronous deflate; {@link encodePngAsync} compresses
- * everywhere).
- *
- * @param {Uint8Array} pixels - Row-major samples.
- * @param {number} width
- * @param {number} height
- * @param {1 | 3 | 4} [channels=4] - Grey, RGB or RGBA.
- * @returns {Uint8Array} PNG bytes.
- *
- * @example
- * encodePng(new Uint8Array([0, 255]), 2, 1, 1); // a black and a white pixel
- */
-export function encodePng(pixels, width, height, channels = 4) {
-  const { raw, ihdr } = scanlines(pixels, width, height, channels);
-  return concat([SIGNATURE, chunk('IHDR', ihdr), chunk('IDAT', deflateSync(raw) ?? stored(raw)), chunk('IEND', new Uint8Array(0))]);
-}
-
-/**
- * Encode pixels as a PNG, compressed on every platform (Node's zlib, else
- * `CompressionStream`).
- *
- * @param {Uint8Array} pixels @param {number} width @param {number} height @param {1 | 3 | 4} [channels=4]
- * @returns {Promise<Uint8Array>}
- */
-export async function encodePngAsync(pixels, width, height, channels = 4) {
-  const { raw, ihdr } = scanlines(pixels, width, height, channels);
-  return concat([SIGNATURE, chunk('IHDR', ihdr), chunk('IDAT', await deflate(raw)), chunk('IEND', new Uint8Array(0))]);
-}
-
-/**
- * A PNG as a data URI.
- *
- * @param {Uint8Array} png
- * @returns {string}
- */
-export const pngUri = (png) => `data:image/png;base64,${toBase64(png)}`;

package/src/raster/index.d.ts

@@ -1,24 +0,0 @@
-// Rasterising in the browser.
-
-/** Browser raster options. */
-export interface RasterizeOptions {
-  /** Default `'png'`. */
-  format?: 'png' | 'jpeg' | 'webp';
-  /** 0–1 (JPEG, WebP). Default 0.9. */
-  quality?: number;
-  /** Output width or height, px (the other follows), or a `scale`. */
-  width?: number;
-  height?: number;
-  scale?: number;
-  /** A colour under the art (JPEG defaults to the page colour). */
-  background?: string;
-}
-
-/** Rasterise an SVG string in a browser page. */
-export function rasterize(svg: string, options?: RasterizeOptions): Promise<Blob>;
-/** RGBA pixels of an SVG at a size: sharp in Node, a canvas in a page, undefined elsewhere. */
-export function pixelsOf(svg: string, w: number, h: number, sharp?: unknown): Promise<Uint8Array | undefined>;
-/** Encode RGBA pixels for embedding: JPEG where opaque (unless `lossless`), else PNG. */
-export function encodePixels(data: Uint8Array | Uint8ClampedArray, w: number, h: number, o?: { opaque?: boolean; lossless?: boolean; quality?: number }, sharp?: unknown): Promise<{ mime: 'image/jpeg' | 'image/png'; bytes: Uint8Array }>;
-/** Pixels through a real JPEG encoder and back; undefined where none is available. */
-export function jpegRoundTrip(data: Uint8ClampedArray, w: number, h: number, quality: number, subsample: boolean, sharp?: unknown): Promise<Uint8ClampedArray | undefined>;

package/src/raster/index.js

@@ -1,171 +0,0 @@
-/**
- * Rasterising without sharp: an SVG drawn into a canvas in the browser,
- * encoded as PNG, JPEG or WebP. `renderImage()` stays the Node path (sharp,
- * with its grain and padded-blur handling); this is the browser one.
- *
- * The SVG is decoded by the browser as an `<img>` (so it needs a page:
- * `document` and `Image`), drawn onto an `OffscreenCanvas` when there is
- * one (else a `<canvas>`), and encoded with `convertToBlob` / `toBlob`.
- *
- * @module raster
- */
-
-const MIMES = /** @type {const} */ ({ png: 'image/png', jpeg: 'image/jpeg', webp: 'image/webp' });
-
-/**
- * Decode an SVG string into a drawable image (browser).
- *
- * @param {string} svg
- * @returns {Promise<HTMLImageElement>}
- */
-async function decodeSvg(svg) {
-  const g = /** @type {any} */ (globalThis);
-  if (typeof g.Image !== 'function' || typeof g.document === 'undefined') {
-    throw new Error('rasterize() needs a browser page (Image and canvas). In Node use renderImage(); in a Worker return the SVG, or rasterise it with a wasm renderer.');
-  }
-  const url = URL.createObjectURL(new Blob([svg], { type: 'image/svg+xml' }));
-  try {
-    const img = new g.Image();
-    img.decoding = 'sync';
-    img.src = url;
-    await img.decode();
-    return img;
-  } finally {
-    // Revoked after decode: the decoded image keeps its pixels.
-    setTimeout(() => URL.revokeObjectURL(url), 0);
-  }
-}
-
-/**
- * A 2D canvas of a size.
- *
- * @param {number} w @param {number} h
- * @returns {{ canvas: any, ctx: CanvasRenderingContext2D }}
- */
-function canvasOf(w, h) {
-  const g = /** @type {any} */ (globalThis);
-  const canvas = typeof g.OffscreenCanvas === 'function' ? new g.OffscreenCanvas(w, h) : Object.assign(g.document.createElement('canvas'), { width: w, height: h });
-  return { canvas, ctx: canvas.getContext('2d') };
-}
-
-/**
- * Rasterise an SVG in the browser.
- *
- * @param {string} svg - An SVG document (from `renderSvg`).
- * @param {{ format?: 'png' | 'jpeg' | 'webp', quality?: number, width?: number, height?: number, scale?: number, background?: string }} [options]
- * @returns {Promise<Blob>}
- *
- * @example
- * const blob = await rasterize(await renderSvg(cover), { format: 'webp', quality: 0.9 });
- * img.src = URL.createObjectURL(blob);
- */
-export async function rasterize(svg, options = {}) {
-  const format = options.format ?? 'png';
-  if (!Object.hasOwn(MIMES, format)) throw new TypeError(`Unknown format "${format}" (png, jpeg, webp)`);
-  const vw = Number(/\bwidth="([\d.]+)"/.exec(svg)?.[1] ?? 1200);
-  const vh = Number(/\bheight="([\d.]+)"/.exec(svg)?.[1] ?? 1200);
-  const scale = options.scale ?? (options.width ? options.width / vw : options.height ? options.height / vh : 1);
-  const w = Math.max(1, Math.round(vw * scale));
-  const h = Math.max(1, Math.round(vh * scale));
-  const img = await decodeSvg(svg);
-  const { canvas, ctx } = canvasOf(w, h);
-  if (format === 'jpeg' || options.background) {
-    ctx.fillStyle = options.background ?? /fill="(#[0-9a-f]{6})"/i.exec(svg)?.[1] ?? '#ffffff';
-    ctx.fillRect(0, 0, w, h);
-  }
-  ctx.drawImage(img, 0, 0, w, h);
-  const type = MIMES[format];
-  const quality = options.quality ?? (format === 'png' ? undefined : 0.9);
-  if (typeof canvas.convertToBlob === 'function') return canvas.convertToBlob({ type, quality });
-  return new Promise((resolve, reject) => canvas.toBlob((/** @type {Blob | null} */ b) => (b ? resolve(b) : reject(new Error('Canvas encoding failed'))), type, quality));
-}
-
-/**
- * RGBA pixels of an SVG at a size: sharp in Node, a canvas in a page.
- * Undefined where neither is available (a Worker).
- *
- * @param {string} svg
- * @param {number} w
- * @param {number} h
- * @param {any} [sharp] - The sharp module, when loaded.
- * @returns {Promise<Uint8Array | undefined>}
- */
-export async function pixelsOf(svg, w, h, sharp) {
-  if (sharp) {
-    const out = await sharp(new TextEncoder().encode(svg)).resize(w, h, { fit: 'fill' }).ensureAlpha().raw().toBuffer();
-    return new Uint8Array(out.buffer, out.byteOffset, out.byteLength);
-  }
-  const g = /** @type {any} */ (globalThis);
-  if (typeof g.Image !== 'function' || typeof g.document === 'undefined') return undefined;
-  const img = await decodeSvg(svg);
-  const { ctx } = canvasOf(w, h);
-  ctx.drawImage(img, 0, 0, w, h);
-  return new Uint8Array(ctx.getImageData(0, 0, w, h).data.buffer);
-}
-
-/**
- * Encode RGBA pixels for embedding: JPEG where they're opaque (smaller),
- * PNG where they aren't or where `lossless` (flat colour, crisp cells).
- * sharp in Node, a canvas in a page, else the in-library PNG encoder.
- *
- * @param {Uint8Array | Uint8ClampedArray} data - RGBA, unpremultiplied.
- * @param {number} w
- * @param {number} h
- * @param {{ opaque?: boolean, lossless?: boolean, quality?: number }} [o]
- * @param {any} [sharp]
- * @returns {Promise<{ mime: 'image/jpeg' | 'image/png', bytes: Uint8Array }>}
- */
-export async function encodePixels(data, w, h, o = {}, sharp) {
-  const jpeg = Boolean(o.opaque) && !o.lossless;
-  const quality = o.quality ?? 92;
-  if (sharp) {
-    let img = sharp(data, { raw: { width: w, height: h, channels: 4 } });
-    if (o.opaque) img = img.removeAlpha();
-    const out = jpeg ? await img.jpeg({ quality, chromaSubsampling: '4:4:4' }).toBuffer() : await img.png({ compressionLevel: 6 }).toBuffer();
-    return { mime: jpeg ? 'image/jpeg' : 'image/png', bytes: new Uint8Array(out.buffer, out.byteOffset, out.byteLength) };
-  }
-  const g = /** @type {any} */ (globalThis);
-  if (typeof g.OffscreenCanvas === 'function' || typeof g.document !== 'undefined') {
-    const { canvas, ctx } = canvasOf(w, h);
-    ctx.putImageData(new g.ImageData(new Uint8ClampedArray(data.buffer, data.byteOffset, data.byteLength), w, h), 0, 0);
-    const type = jpeg ? 'image/jpeg' : 'image/png';
-    const blob = typeof canvas.convertToBlob === 'function'
-      ? await canvas.convertToBlob({ type, quality: quality / 100 })
-      : await new Promise((resolve, reject) => canvas.toBlob((/** @type {Blob | null} */ b) => (b ? resolve(b) : reject(new Error('Canvas encoding failed'))), type, quality / 100));
-    return { mime: type, bytes: new Uint8Array(await blob.arrayBuffer()) };
-  }
-  const { encodePngAsync } = await import('../png.js');
-  return { mime: 'image/png', bytes: await encodePngAsync(new Uint8Array(data.buffer, data.byteOffset, data.byteLength), w, h, 4) };
-}
-
-/**
- * Pixels through a real JPEG encoder and back (compression artefacts):
- * libjpeg through sharp in Node, the browser's own encoder in a page.
- * Undefined where neither is available.
- *
- * @param {Uint8ClampedArray} data - RGBA (alpha ignored).
- * @param {number} w
- * @param {number} h
- * @param {number} quality - 1–100.
- * @param {boolean} subsample - 4:2:0 chroma (blocky colour).
- * @param {any} [sharp]
- * @returns {Promise<Uint8ClampedArray | undefined>} RGBA, opaque.
- */
-export async function jpegRoundTrip(data, w, h, quality, subsample, sharp) {
-  if (sharp) {
-    const jpg = await sharp(data, { raw: { width: w, height: h, channels: 4 } }).removeAlpha().jpeg({ quality, chromaSubsampling: subsample ? '4:2:0' : '4:4:4' }).toBuffer();
-    const out = await sharp(jpg).ensureAlpha().raw().toBuffer();
-    return new Uint8ClampedArray(out.buffer, out.byteOffset, out.byteLength);
-  }
-  const g = /** @type {any} */ (globalThis);
-  if (typeof g.createImageBitmap !== 'function' || (typeof g.OffscreenCanvas !== 'function' && typeof g.document === 'undefined')) return undefined;
-  const { canvas, ctx } = canvasOf(w, h);
-  ctx.putImageData(new g.ImageData(new Uint8ClampedArray(data), w, h), 0, 0);
-  const blob = typeof canvas.convertToBlob === 'function'
-    ? await canvas.convertToBlob({ type: 'image/jpeg', quality: quality / 100 })
-    : await new Promise((resolve) => canvas.toBlob(resolve, 'image/jpeg', quality / 100));
-  const bitmap = await g.createImageBitmap(blob);
-  ctx.clearRect(0, 0, w, h);
-  ctx.drawImage(bitmap, 0, 0);
-  return new Uint8ClampedArray(ctx.getImageData(0, 0, w, h).data.buffer);
-}

package/src/render/content.d.ts

@@ -1,5 +0,0 @@
-// Where a layer paints, for content-sized filter regions.
-import type { Markup, RenderContext } from './context.js';
-
-/** The box a layer's markup paints, in its units (drawn small with sharp); undefined when it can't be probed. */
-export function contentBox(m: Markup, ctx: RenderContext): Promise<{ x: number; y: number; width: number; height: number } | undefined>;