@arraypress/covers 1.0.0 → 1.3.1

package/src/type/woff2.js

@@ -0,0 +1,301 @@
+/**
+ * WOFF2 to a bare sfnt, in JavaScript: the Brotli stream decompressed (by
+ * the platform: Node's zlib, or a `DecompressionStream('brotli')`), then
+ * the transformed `glyf`, `loca` and `hmtx` tables rebuilt (W3C WOFF2 §5).
+ * Font collections aren't supported.
+ *
+ * @module type/woff2
+ */
+
+/** The 63 known table tags, by index (WOFF2 §5.1). */
+const KNOWN = ['cmap', 'head', 'hhea', 'hmtx', 'maxp', 'name', 'OS/2', 'post', 'cvt ', 'fpgm', 'glyf', 'loca', 'prep', 'CFF ', 'VORG', 'EBDT', 'EBLC', 'gasp', 'hdmx', 'kern', 'LTSH', 'PCLT', 'VDMX', 'vhea', 'vmtx', 'BASE', 'GDEF', 'GPOS', 'GSUB', 'EBSC', 'JSTF', 'MATH', 'CBDT', 'CBLC', 'COLR', 'CPAL', 'SVG ', 'sbix', 'acnt', 'avar', 'bdat', 'bloc', 'bsln', 'cvar', 'fdsc', 'feat', 'fmtx', 'fvar', 'gvar', 'hsty', 'just', 'lcar', 'mort', 'morx', 'opbd', 'prop', 'trak', 'Zapf', 'Silf', 'Glat', 'Gloc', 'Feat', 'Sill'];
+
+/** A cursor over bytes. */
+class Reader {
+  /** @param {Uint8Array} b @param {number} [at=0] */
+  constructor(b, at = 0) { this.b = b; this.v = new DataView(b.buffer, b.byteOffset, b.byteLength); this.at = at; }
+  u8() { return this.b[this.at++]; }
+  u16() { const x = this.v.getUint16(this.at); this.at += 2; return x; }
+  i16() { const x = this.v.getInt16(this.at); this.at += 2; return x; }
+  u32() { const x = this.v.getUint32(this.at); this.at += 4; return x; }
+  /** UIntBase128. */
+  base128() { let x = 0; for (let i = 0; i < 5; i++) { const c = this.u8(); x = x * 128 + (c & 0x7f); if (!(c & 0x80)) return x; } throw new TypeError('WOFF2: bad UIntBase128'); }
+  /** 255UInt16. */
+  u255() { const c = this.u8(); return c === 253 ? this.u16() : c === 255 ? this.u8() + 253 : c === 254 ? this.u8() + 506 : c; }
+  /** @param {number} n */
+  bytes(n) { const out = this.b.subarray(this.at, this.at + n); this.at += n; return out; }
+}
+
+/**
+ * A WOFF2 file's header and table directory, and where its Brotli stream is.
+ *
+ * @param {Uint8Array} buf
+ * @returns {{ flavor: number, tables: { tag: string, origLength: number, length: number, transformed: boolean, data: Uint8Array }[], payload: Uint8Array }}
+ * @throws {TypeError} On a collection or damaged data.
+ */
+export function woff2Directory(buf) {
+  try {
+    return directory(buf);
+  } catch (err) {
+    if (err instanceof RangeError) throw new TypeError('WOFF2: the font data is damaged or cut short');
+    throw err;
+  }
+}
+
+/** @param {Uint8Array} buf @returns {ReturnType<typeof woff2Directory>} */
+function directory(buf) {
+  const r = new Reader(buf);
+  if (r.u32() !== 0x774f4632) throw new TypeError('Not a WOFF2 font');
+  const flavor = r.u32();
+  if (flavor === 0x74746366) throw new TypeError('WOFF2 font collections are not supported');
+  r.u32();
+  const count = r.u16();
+  r.u16(); r.u32();
+  const compressedSize = r.u32();
+  r.at = 48;
+  const tables = [];
+  for (let i = 0; i < count; i++) {
+    const flags = r.u8();
+    const tag = (flags & 0x3f) === 63 ? String.fromCharCode(...r.bytes(4)) : KNOWN[flags & 0x3f];
+    const version = flags >> 6;
+    const origLength = r.base128();
+    const transformed = tag === 'glyf' || tag === 'loca' ? version === 0 : version !== 0;
+    const length = transformed ? r.base128() : origLength;
+    tables.push({ tag, origLength, length, transformed, data: /** @type {Uint8Array} */ (new Uint8Array(0)) });
+  }
+  return { flavor, tables, payload: buf.subarray(r.at, r.at + compressedSize) };
+}
+
+/**
+ * WOFF2 bytes as sfnt.
+ *
+ * @param {Uint8Array} buf - WOFF2 bytes.
+ * @param {Uint8Array | undefined} stream - The decompressed Brotli stream (see {@link woff2Directory}'s `payload`); undefined where nothing could decompress it.
+ * @returns {Uint8Array}
+ * @throws {TypeError} On a collection, damaged data, or no Brotli decoder.
+ */
+export function woff2ToSfnt(buf, stream) {
+  const { flavor, tables } = woff2Directory(buf);
+  if (!stream) throw new TypeError('WOFF2 needs Brotli, which this runtime lacks: convert the font to .ttf (scripts/woff2-to-ttf.mjs) or use render: "live"');
+  let at = 0;
+  for (const t of tables) { t.data = stream.subarray(at, at + t.length); at += t.length; }
+  const byTag = new Map(tables.map((t) => [t.tag, t]));
+  const glyf = byTag.get('glyf');
+  if (glyf?.transformed) {
+    const { glyf: g, loca, long } = rebuildGlyf(glyf.data);
+    glyf.data = g;
+    const l = byTag.get('loca');
+    if (l) l.data = loca;
+    // The rebuilt glyf outgrew short offsets: the head says long ones now.
+    const head = byTag.get('head');
+    if (long && head) {
+      head.data = new Uint8Array(head.data);
+      new DataView(head.data.buffer).setInt16(50, 1);
+    }
+  }
+  const hmtx = byTag.get('hmtx');
+  if (hmtx?.transformed) hmtx.data = rebuildHmtx(hmtx.data, byTag);
+  return assemble(flavor, tables);
+}
+
+/**
+ * The transformed `glyf` table back to `glyf` and `loca` (WOFF2 §5.1–5.3).
+ * Glyphs are written plainly (a word a delta), so the table can outgrow
+ * the font's short `loca` (offsets to 128 KB): then `loca` is long, and
+ * `long` says so (the `head` must agree).
+ *
+ * @param {Uint8Array} data
+ * @returns {{ glyf: Uint8Array, loca: Uint8Array, long: boolean }}
+ */
+function rebuildGlyf(data) {
+  const h = new Reader(data);
+  h.u16();
+  const options = h.u16();
+  const numGlyphs = h.u16();
+  const indexFormat = h.u16();
+  const sizes = Array.from({ length: 7 }, () => h.u32());
+  let at = h.at;
+  const streams = sizes.map((n) => { const s = new Reader(data.subarray(at, at + n)); at += n; return s; });
+  const [nContours, nPoints, flagStream, glyphStream, composite, bboxStream, instructions] = streams;
+  const bitmapLength = ((numGlyphs + 31) >> 5) << 2;
+  const bboxBitmap = bboxStream.bytes(bitmapLength);
+  void options;
+
+  /** @type {Uint8Array[]} */
+  const out = [];
+  const offsets = [0];
+  let total = 0;
+  for (let i = 0; i < numGlyphs; i++) {
+    const n = nContours.i16();
+    const explicit = (bboxBitmap[i >> 3] >> (7 - (i & 7))) & 1;
+    let glyph = new Uint8Array(0);
+    if (n === -1) {
+      // A composite: its component records, as they are; an explicit bbox.
+      const start = composite.at;
+      let more = true;
+      let hasInstructions = false;
+      while (more) {
+        const flags = composite.u16();
+        composite.u16();
+        composite.at += (flags & 0x0001 ? 4 : 2) + (flags & 0x0008 ? 2 : flags & 0x0040 ? 4 : flags & 0x0080 ? 8 : 0);
+        more = Boolean(flags & 0x0020);
+        if (flags & 0x0100) hasInstructions = true;
+      }
+      const records = composite.b.subarray(start, composite.at);
+      const bbox = [bboxStream.i16(), bboxStream.i16(), bboxStream.i16(), bboxStream.i16()];
+      const ilen = hasInstructions ? glyphStream.u255() : 0;
+      const ins = instructions.bytes(ilen);
+      glyph = new Uint8Array(10 + records.length + (hasInstructions ? 2 + ilen : 0));
+      const v = new DataView(glyph.buffer);
+      v.setInt16(0, -1);
+      bbox.forEach((x, k) => v.setInt16(2 + k * 2, x));
+      glyph.set(records, 10);
+      if (hasInstructions) { v.setUint16(10 + records.length, ilen); glyph.set(ins, 12 + records.length); }
+    } else if (n > 0) {
+      const ends = [];
+      let points = 0;
+      for (let c = 0; c < n; c++) { points += nPoints.u255(); ends.push(points - 1); }
+      const flags = flagStream.bytes(points);
+      const xs = new Int32Array(points);
+      const ys = new Int32Array(points);
+      const on = new Uint8Array(points);
+      let x = 0;
+      let y = 0;
+      for (let p = 0; p < points; p++) {
+        const [dx, dy] = triplet(flags[p] & 0x7f, glyphStream);
+        on[p] = flags[p] >> 7 ? 0 : 1;
+        x += dx; y += dy;
+        xs[p] = x; ys[p] = y;
+      }
+      const ilen = glyphStream.u255();
+      const ins = instructions.bytes(ilen);
+      const bbox = explicit ? [bboxStream.i16(), bboxStream.i16(), bboxStream.i16(), bboxStream.i16()] : [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)];
+      // Written plainly: a flag a point, every delta a word.
+      glyph = new Uint8Array(10 + 2 * n + 2 + ilen + points + 4 * points);
+      const v = new DataView(glyph.buffer);
+      v.setInt16(0, n);
+      bbox.forEach((b, k) => v.setInt16(2 + k * 2, b));
+      let o = 10;
+      for (const e of ends) { v.setUint16(o, e); o += 2; }
+      v.setUint16(o, ilen); o += 2;
+      glyph.set(ins, o); o += ilen;
+      for (let p = 0; p < points; p++) glyph[o++] = on[p];
+      for (let p = 0; p < points; p++) { v.setInt16(o, xs[p] - (p ? xs[p - 1] : 0)); o += 2; }
+      for (let p = 0; p < points; p++) { v.setInt16(o, ys[p] - (p ? ys[p - 1] : 0)); o += 2; }
+    }
+    const padded = (glyph.length + 3) & ~3;
+    const g = new Uint8Array(padded);
+    g.set(glyph);
+    out.push(g);
+    total += padded;
+    offsets.push(total);
+  }
+  const glyf = new Uint8Array(total);
+  let o = 0;
+  for (const g of out) { glyf.set(g, o); o += g.length; }
+  const long = Boolean(indexFormat) || total > 0x1fffe;
+  const loca = new Uint8Array((numGlyphs + 1) * (long ? 4 : 2));
+  const lv = new DataView(loca.buffer);
+  offsets.forEach((off, k) => (long ? lv.setUint32(k * 4, off) : lv.setUint16(k * 2, off / 2)));
+  return { glyf, loca, long: long && !indexFormat };
+}
+
+/**
+ * One point's delta from the glyph stream (WOFF2 §5.2 triplet encoding).
+ *
+ * @param {number} flag - 0–127.
+ * @param {Reader} s
+ * @returns {[number, number]}
+ */
+function triplet(flag, s) {
+  const sign = (/** @type {number} */ f, /** @type {number} */ v) => (f & 1 ? v : -v);
+  if (flag < 10) return [0, sign(flag, ((flag & 14) << 7) + s.u8())];
+  if (flag < 20) return [sign(flag, (((flag - 10) & 14) << 7) + s.u8()), 0];
+  if (flag < 84) {
+    const b0 = flag - 20;
+    const b1 = s.u8();
+    return [sign(flag, 1 + (b0 & 0x30) + (b1 >> 4)), sign(flag >> 1, 1 + ((b0 & 0x0c) << 2) + (b1 & 0x0f))];
+  }
+  if (flag < 120) {
+    const b0 = flag - 84;
+    const a = s.u8();
+    const b = s.u8();
+    return [sign(flag, 1 + (Math.floor(b0 / 12) << 8) + a), sign(flag >> 1, 1 + (((b0 % 12) >> 2) << 8) + b)];
+  }
+  if (flag < 124) {
+    const a = s.u8();
+    const b2 = s.u8();
+    const c = s.u8();
+    return [sign(flag, (a << 4) + (b2 >> 4)), sign(flag >> 1, ((b2 & 0x0f) << 8) + c)];
+  }
+  const a = s.u16();
+  const b = s.u16();
+  return [sign(flag, a), sign(flag >> 1, b)];
+}
+
+/**
+ * The transformed `hmtx` table back (WOFF2 §5.4): left side bearings from
+ * the glyphs' xMin where they were left out.
+ *
+ * @param {Uint8Array} data
+ * @param {Map<string, { data: Uint8Array }>} byTag
+ * @returns {Uint8Array}
+ */
+function rebuildHmtx(data, byTag) {
+  const r = new Reader(data);
+  const flags = r.u8();
+  const hhea = /** @type {any} */ (byTag.get('hhea')).data;
+  const maxp = /** @type {any} */ (byTag.get('maxp')).data;
+  const head = /** @type {any} */ (byTag.get('head')).data;
+  const metrics = new DataView(hhea.buffer, hhea.byteOffset).getUint16(34);
+  const numGlyphs = new DataView(maxp.buffer, maxp.byteOffset).getUint16(4);
+  const longLoca = new DataView(head.buffer, head.byteOffset).getInt16(50) === 1;
+  const glyf = /** @type {any} */ (byTag.get('glyf')).data;
+  const loca = /** @type {any} */ (byTag.get('loca')).data;
+  const lv = new DataView(loca.buffer, loca.byteOffset, loca.byteLength);
+  const gv = new DataView(glyf.buffer, glyf.byteOffset, glyf.byteLength);
+  const xMin = (/** @type {number} */ g) => {
+    const a = longLoca ? lv.getUint32(g * 4) : lv.getUint16(g * 2) * 2;
+    const b = longLoca ? lv.getUint32(g * 4 + 4) : lv.getUint16(g * 2 + 2) * 2;
+    return b > a ? gv.getInt16(a + 2) : 0;
+  };
+  const adv = Array.from({ length: metrics }, () => r.u16());
+  const lsb = Array.from({ length: numGlyphs }, (_, g) => (g < metrics ? (flags & 1 ? xMin(g) : r.i16()) : 0));
+  for (let g = metrics; g < numGlyphs; g++) lsb[g] = flags & 2 ? xMin(g) : r.i16();
+  const out = new Uint8Array(metrics * 4 + (numGlyphs - metrics) * 2);
+  const v = new DataView(out.buffer);
+  for (let g = 0; g < metrics; g++) { v.setUint16(g * 4, adv[g]); v.setInt16(g * 4 + 2, lsb[g]); }
+  for (let g = metrics; g < numGlyphs; g++) v.setInt16(metrics * 4 + (g - metrics) * 2, lsb[g]);
+  return out;
+}
+
+/**
+ * Tables into an sfnt file (sorted directory, checksums, 4-byte alignment).
+ *
+ * @param {number} flavor
+ * @param {{ tag: string, data: Uint8Array }[]} tables
+ * @returns {Uint8Array}
+ */
+function assemble(flavor, tables) {
+  const sorted = [...tables].sort((a, b) => (a.tag < b.tag ? -1 : a.tag > b.tag ? 1 : 0));
+  const n = sorted.length;
+  let pow = 1;
+  let log = 0;
+  while (pow * 2 <= n) { pow *= 2; log++; }
+  const header = 12 + 16 * n;
+  const total = sorted.reduce((s, t) => s + ((t.data.length + 3) & ~3), header);
+  const out = new Uint8Array(total);
+  const v = new DataView(out.buffer);
+  v.setUint32(0, flavor); v.setUint16(4, n); v.setUint16(6, pow * 16); v.setUint16(8, log); v.setUint16(10, n * 16 - pow * 16);
+  let at = header;
+  sorted.forEach((t, i) => {
+    out.set(t.data, at);
+    let sum = 0;
+    for (let k = 0; k < t.data.length; k += 4) sum = (sum + (((out[at + k] << 24) | (out[at + k + 1] << 16) | (out[at + k + 2] << 8) | out[at + k + 3]) >>> 0)) >>> 0;
+    const rec = 12 + i * 16;
+    for (let k = 0; k < 4; k++) out[rec + k] = t.tag.charCodeAt(k);
+    v.setUint32(rec + 4, sum); v.setUint32(rec + 8, at); v.setUint32(rec + 12, t.data.length);
+    at += (t.data.length + 3) & ~3;
+  });
+  return out;
+}

package/src/version.js

@@ -0,0 +1,4 @@
+// Generated by scripts/generate.mjs from package.json. Do not edit.
+
+/** The package version, part of every cache key. */
+export const VERSION = '1.3.1';

package/src/color.js

@@ -1,246 +0,0 @@
-/**
- * Colour parsing and the few colour-space moves palettes need.
- *
- * Everything inside the library is a lowercase `#rrggbb` string. Input can
- * be hex (3, 4, 6 or 8 digits), `rgb()`/`rgba()` or `hsl()`/`hsla()`; alpha
- * is dropped, since a cover's layers carry their own `opacity`.
- *
- * Mixing and contrast come from `@arraypress/color-utils`; this module adds
- * OKLCH, so derived palettes can rotate hue and set lightness perceptually
- * instead of in sRGB (where "the same lightness" means very different
- * things for yellow and blue).
- *
- * @module color
- */
-
-import { hexToRgb, rgbToHex, contrastRatio } from '@arraypress/color-utils';
-
-/**
- * Parse a CSS colour to `#rrggbb`.
- *
- * @param {string} input - `#abc`, `#aabbcc`, `#aabbccdd`, `rgb(…)`, `rgba(…)`, `hsl(…)` or `hsla(…)`.
- * @returns {string} Lowercase `#rrggbb`.
- * @throws {TypeError} When the string isn't a colour this function understands.
- *
- * @example
- * toHex('rgb(37 99 235)');   // '#2563eb'
- * toHex('#FA0');             // '#ffaa00'
- * toHex('hsl(220 80% 50%)'); // '#1a5ee6'
- */
-export function toHex(input) {
-  if (typeof input !== 'string') throw new TypeError(`Expected a colour string, got ${typeof input}`);
-  const s = input.trim().toLowerCase();
-
-  const hex = s.match(/^#?([0-9a-f]{3,8})$/);
-  if (hex && [3, 4, 6, 8].includes(hex[1].length)) {
-    let h = hex[1];
-    if (h.length <= 4) h = h.split('').map((c) => c + c).join('');
-    return '#' + h.slice(0, 6);
-  }
-
-  const fn = s.match(/^(rgba?|hsla?)\(([^)]*)\)$/);
-  if (fn) {
-    const parts = fn[2].split(/[\s,/]+/).filter(Boolean);
-    if (parts.length >= 3) {
-      if (fn[1].startsWith('rgb')) {
-        const [r, g, b] = parts.slice(0, 3).map((p) => (p.endsWith('%') ? parseFloat(p) * 2.55 : parseFloat(p)));
-        if ([r, g, b].every(Number.isFinite)) return rgbToHex(r, g, b);
-      } else {
-        const h = parseFloat(parts[0]);
-        const sat = parseFloat(parts[1]) / 100;
-        const l = parseFloat(parts[2]) / 100;
-        if ([h, sat, l].every(Number.isFinite)) return hslToHex(h, sat, l);
-      }
-    }
-  }
-  throw new TypeError(`Unrecognised colour: "${input}"`);
-}
-
-/**
- * HSL to `#rrggbb`.
- *
- * @param {number} h - Hue in degrees.
- * @param {number} s - Saturation, 0–1.
- * @param {number} l - Lightness, 0–1.
- * @returns {string} `#rrggbb`.
- */
-function hslToHex(h, s, l) {
-  const k = (n) => (n + h / 30) % 12;
-  const a = s * Math.min(l, 1 - l);
-  const f = (n) => l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
-  return rgbToHex(f(0) * 255, f(8) * 255, f(4) * 255);
-}
-
-/** @param {number} c - sRGB channel 0–1. @returns {number} Linear channel. */
-const toLinear = (c) => (c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4);
-/** @param {number} c - Linear channel. @returns {number} sRGB channel 0–1. */
-const toGamma = (c) => (c <= 0.0031308 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - 0.055);
-
-/**
- * `#rrggbb` to OKLCH.
- *
- * @param {string} color - Any colour {@link toHex} accepts.
- * @returns {{ l: number, c: number, h: number }} Lightness 0–1, chroma (~0–0.37), hue in degrees.
- *
- * @example
- * toOklch('#2563eb'); // { l: 0.546, c: 0.215, h: 262.9 }
- */
-export function toOklch(color) {
-  const { r, g, b } = hexToRgb(toHex(color));
-  const [lr, lg, lb] = [r, g, b].map((v) => toLinear(v / 255));
-  const l = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
-  const m = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
-  const s = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
-  const L = 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s;
-  const A = 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s;
-  const B = 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s;
-  const h = (Math.atan2(B, A) * 180) / Math.PI;
-  return { l: L, c: Math.hypot(A, B), h: h < 0 ? h + 360 : h };
-}
-
-/**
- * OKLCH to `#rrggbb`. Out-of-gamut colours are brought in by reducing
- * chroma (keeping lightness and hue), not by clipping channels, so a
- * derived colour keeps the hue it was asked for.
- *
- * @param {{ l: number, c: number, h: number }} lch - Lightness 0–1, chroma, hue in degrees.
- * @returns {string} `#rrggbb`.
- *
- * @example
- * fromOklch({ l: 0.7, c: 0.12, h: 30 }); // a soft coral
- */
-export function fromOklch({ l, c, h }) {
-  const L = Math.max(0, Math.min(1, l));
-  let chroma = Math.max(0, c);
-  for (let i = 0; i < 24; i++) {
-    const rgb = oklabToRgb(L, chroma * Math.cos((h * Math.PI) / 180), chroma * Math.sin((h * Math.PI) / 180));
-    if (rgb.every((v) => v >= -0.0005 && v <= 1.0005) || chroma < 0.001) {
-      return toRgbHex(rgb);
-    }
-    chroma *= 0.9;
-  }
-  return toRgbHex(oklabToRgb(L, 0, 0));
-}
-
-/**
- * Clamp 0–1 sRGB channels and write them as `#rrggbb`.
- *
- * @param {[number, number, number]} rgb
- * @returns {string}
- */
-function toRgbHex([r, g, b]) {
-  const c = (/** @type {number} */ v) => Math.max(0, Math.min(1, v)) * 255;
-  return rgbToHex(c(r), c(g), c(b));
-}
-
-/**
- * OKLab to gamma-encoded sRGB channels (0–1, possibly out of range).
- *
- * @param {number} L @param {number} A @param {number} B
- * @returns {[number, number, number]} sRGB channels.
- */
-function oklabToRgb(L, A, B) {
-  const l = (L + 0.3963377774 * A + 0.2158037573 * B) ** 3;
-  const m = (L - 0.1055613458 * A - 0.0638541728 * B) ** 3;
-  const s = (L - 0.0894841775 * A - 1.291485548 * B) ** 3;
-  return [
-    toGamma(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s),
-    toGamma(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s),
-    toGamma(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s),
-  ];
-}
-
-/**
- * Mix two colours in OKLab (perceptually even, no muddy midpoints).
- *
- * @param {string} a - First colour.
- * @param {string} b - Second colour.
- * @param {number} t - 0 gives `a`, 1 gives `b`.
- * @returns {string} `#rrggbb`.
- *
- * @example
- * mixOklab('#ffffff', '#2563eb', 0.1); // a pale blue tint
- */
-export function mixOklab(a, b, t) {
-  const p = toLab(a);
-  const q = toLab(b);
-  const rgb = oklabToRgb(p[0] + (q[0] - p[0]) * t, p[1] + (q[1] - p[1]) * t, p[2] + (q[2] - p[2]) * t);
-  return toRgbHex(rgb);
-}
-
-/** @param {string} color @returns {[number, number, number]} OKLab. */
-function toLab(color) {
-  const { l, c, h } = toOklch(color);
-  return [l, c * Math.cos((h * Math.PI) / 180), c * Math.sin((h * Math.PI) / 180)];
-}
-
-/**
- * Mix two colours in OKLCH: lightness and chroma linearly, hue the short
- * way round. Unlike OKLab, a mix of two far-apart hues stays vivid instead
- * of passing through grey (orange → blue goes by way of pink, not mud).
- *
- * @param {string} a - First colour.
- * @param {string} b - Second colour.
- * @param {number} t - 0 gives `a`, 1 gives `b`.
- * @returns {string} `#rrggbb`.
- *
- * @example
- * mixOklch('#c9502a', '#a9bdf2', 0.5); // a clear rose, not a muddy mauve
- */
-export function mixOklch(a, b, t) {
-  const p = toOklch(a);
-  const q = toOklch(b);
-  // A near-grey has no meaningful hue: take the other colour's.
-  const ph = p.c < 0.02 ? q.h : p.h;
-  const qh = q.c < 0.02 ? p.h : q.h;
-  const dh = ((qh - ph + 540) % 360) - 180;
-  return fromOklch({ l: p.l + (q.l - p.l) * t, c: p.c + (q.c - p.c) * t, h: (ph + dh * t + 360) % 360 });
-}
-
-/** Near-black used wherever white doesn't read. */
-export const NEAR_BLACK = '#111111';
-
-/**
- * A colour for a mark on one or more backgrounds: `prefer` when it clears
- * `ratio` against every one of them, else whichever of white and
- * near-black has the better worst case.
- *
- * For icons and other non-text marks WCAG 1.4.11 asks 3:1 (text needs
- * 4.5:1), so `onBackground(bg, 3, 'white')` keeps white on mid-tone fills
- * where a text rule would flip to black.
- *
- * @param {string | string[]} backgrounds - The colour(s) under the mark.
- * @param {number} [ratio=3] - Contrast to clear.
- * @param {'white' | 'black' | string} [prefer='white'] - The colour to use when it clears `ratio`.
- * @returns {string} `#rrggbb`.
- *
- * @example
- * onBackground('#e0533d', 3, 'white'); // '#ffffff' (3.6:1)
- * onBackground('#ffe14d', 3, 'white'); // '#111111'
- */
-export function onBackground(backgrounds, ratio = 3, prefer = 'white') {
-  const bgs = [].concat(/** @type {any} */ (backgrounds)).map(toHex);
-  const want = prefer === 'white' ? '#ffffff' : prefer === 'black' ? NEAR_BLACK : toHex(prefer);
-  const worst = (/** @type {string} */ c) => Math.min(...bgs.map((b) => contrastRatio(c, b)));
-  if (worst(want) >= ratio) return want;
-  return worst('#ffffff') >= worst(NEAR_BLACK) ? '#ffffff' : NEAR_BLACK;
-}
-
-/**
- * The colour of an eased multi-stop gradient at `t` (0–1), the way the
- * `linear` and `radial` layers draw it (smoothstep between stops, in OKLab).
- *
- * @param {string[]} colors - Two or more stops, evenly spaced.
- * @param {number} t - Position along the gradient.
- * @param {boolean} [ease=true] - Ease between stops.
- * @returns {string} `#rrggbb`.
- */
-export function gradientAt(colors, t, ease = true) {
-  const list = colors.map(toHex);
-  if (list.length === 1) return list[0];
-  const n = list.length - 1;
-  const x = Math.max(0, Math.min(1, t)) * n;
-  const i = Math.min(n - 1, Math.floor(x));
-  const f = x - i;
-  return mixOklab(list[i], list[i + 1], ease ? f * f * (3 - 2 * f) : f);
-}

package/src/png.js

@@ -1,77 +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 } from 'node:zlib';
-
-/** 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 {Buffer} */
-function chunk(type, data) {
-  const out = Buffer.alloc(12 + data.length);
-  out.writeUInt32BE(data.length, 0);
-  out.write(type, 4, 'latin1');
-  Buffer.from(data).copy(out, 8);
-  out.writeUInt32BE(crc32(out.subarray(4, 8 + data.length)), 8 + data.length);
-  return out;
-}
-
-/**
- * Encode pixels as a PNG.
- *
- * @param {Uint8Array} pixels - Row-major samples.
- * @param {number} width
- * @param {number} height
- * @param {1 | 3 | 4} [channels=4] - Grey, RGB or RGBA.
- * @returns {Buffer} 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 stride = width * channels;
-  const raw = Buffer.alloc((stride + 1) * height);
-  for (let y = 0; y < height; y++) {
-    raw[y * (stride + 1)] = 0;
-    Buffer.from(pixels.buffer, pixels.byteOffset + y * stride, stride).copy(raw, y * (stride + 1) + 1);
-  }
-  const ihdr = Buffer.alloc(13);
-  ihdr.writeUInt32BE(width, 0);
-  ihdr.writeUInt32BE(height, 4);
-  ihdr[8] = 8;
-  ihdr[9] = { 1: 0, 3: 2, 4: 6 }[channels];
-  return Buffer.concat([
-    Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
-    chunk('IHDR', ihdr),
-    chunk('IDAT', deflateSync(raw, { level: 9 })),
-    chunk('IEND', new Uint8Array(0)),
-  ]);
-}
-
-/**
- * A PNG as a data URI.
- *
- * @param {Buffer} png
- * @returns {string}
- */
-export const pngUri = (png) => `data:image/png;base64,${png.toString('base64')}`;