@arraypress/covers 0.0.0-stage → 1.0.0

package/src/extract.js

@@ -0,0 +1,90 @@
+/**
+ * A palette from a photo: k-means in OKLab over a small thumbnail.
+ *
+ * @module extract
+ */
+
+import { readFile } from 'node:fs/promises';
+import { toOklch, fromOklch, toHex } from './color.js';
+import { createRng } from './rng.js';
+
+/** @type {Map<string, Promise<string[]>>} */
+const cache = new Map();
+
+/**
+ * The dominant colours of an image, most common first.
+ *
+ * Decodes with sharp (an optional peer dependency) to a 64×64 thumbnail,
+ * clusters its pixels in OKLab (k-means, seeded so the result is stable),
+ * drops clusters too small to matter, prefers chromatic colours (a nearly
+ * grey cluster is kept only when there aren't enough others) and skips
+ * near-duplicate shades while distinct colours remain.
+ *
+ * @param {string | Uint8Array} src - A file path or image bytes.
+ * @param {{ count?: number }} [options] - How many colours (default 4).
+ * @returns {Promise<string[]>} `#rrggbb` colours.
+ * @throws {Error} Without sharp, or on an unreadable image.
+ *
+ * @example
+ * await extractPalette('cover.jpg'); // ['#2f5d8a', '#e0b25a', …]
+ */
+export function extractPalette(src, options = {}) {
+  const count = options.count ?? 4;
+  const key = typeof src === 'string' ? `${src}:${count}` : null;
+  if (key && cache.has(key)) return /** @type {Promise<string[]>} */ (cache.get(key));
+  const job = (async () => {
+    let sharp;
+    try {
+      sharp = (await import('sharp')).default;
+    } catch {
+      throw new Error('Extracting a palette from a photo needs sharp: npm install sharp');
+    }
+    const bytes = typeof src === 'string' ? await readFile(src) : src;
+    const { data } = await sharp(bytes).rotate().resize(64, 64, { fit: 'cover' }).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+    /** @type {[number, number, number][]} */
+    const pts = [];
+    for (let i = 0; i < data.length; i += 3) {
+      const hex = '#' + [data[i], data[i + 1], data[i + 2]].map((v) => v.toString(16).padStart(2, '0')).join('');
+      const { l, c, h } = toOklch(hex);
+      pts.push([l, c * Math.cos((h * Math.PI) / 180), c * Math.sin((h * Math.PI) / 180)]);
+    }
+    const k = Math.min(8, Math.max(count + 2, 5));
+    const rng = createRng('extract');
+    let centres = rng.shuffle(pts).slice(0, k).map((p) => p.slice());
+    const assign = new Int32Array(pts.length);
+    for (let it = 0; it < 18; it++) {
+      for (let i = 0; i < pts.length; i++) {
+        let best = 0;
+        let bd = Infinity;
+        for (let j = 0; j < centres.length; j++) {
+          const d = (pts[i][0] - centres[j][0]) ** 2 + (pts[i][1] - centres[j][1]) ** 2 + (pts[i][2] - centres[j][2]) ** 2;
+          if (d < bd) { bd = d; best = j; }
+        }
+        assign[i] = best;
+      }
+      centres = centres.map((c, j) => {
+        let n = 0;
+        const s = [0, 0, 0];
+        for (let i = 0; i < pts.length; i++) if (assign[i] === j) { n++; s[0] += pts[i][0]; s[1] += pts[i][1]; s[2] += pts[i][2]; }
+        return n ? s.map((v) => v / n) : c;
+      });
+    }
+    const sizes = centres.map((_, j) => assign.filter((a) => a === j).length);
+    const clusters = centres
+      .map((c, j) => ({ c, n: sizes[j], chroma: Math.hypot(c[1], c[2]) }))
+      .filter((x) => x.n > pts.length * 0.03)
+      .sort((a, b) => b.n - a.n);
+    const vivid = clusters.filter((x) => x.chroma > 0.035);
+    // Skip near-duplicates (shades of one colour) while others remain.
+    const ordered = [...vivid, ...clusters.filter((x) => x.chroma <= 0.035)];
+    const chosen = [];
+    for (const x of ordered) {
+      if (chosen.every((y) => Math.hypot(x.c[0] - y.c[0], x.c[1] - y.c[1], x.c[2] - y.c[2]) > 0.09)) chosen.push(x);
+    }
+    for (const x of ordered) if (chosen.length < count && !chosen.includes(x)) chosen.push(x);
+    chosen.length = Math.min(chosen.length, count);
+    return chosen.map(({ c }) => toHex(fromOklch({ l: c[0], c: Math.hypot(c[1], c[2]), h: ((Math.atan2(c[2], c[1]) * 180) / Math.PI + 360) % 360 })));
+  })();
+  if (key) cache.set(key, job);
+  return job;
+}

package/src/flatten.js

@@ -0,0 +1,234 @@
+/**
+ * Flatten SVG shapes to polylines, so they can be redrawn by hand (jittered
+ * and stroked unevenly) by the `scribble` layer.
+ *
+ * Reads the elements an icon set uses: `path` (every command, including
+ * arcs, absolute and relative), `circle`, `ellipse`, `rect` (with `rx`),
+ * `line`, `polyline` and `polygon`.
+ *
+ * @module flatten
+ */
+
+/** @typedef {[number, number][]} Polyline */
+
+/**
+ * Flatten an icon body to polylines, in its own units.
+ *
+ * @param {string} body - SVG markup.
+ * @param {number} [step=0.6] - Target segment length, in the icon's units.
+ * @returns {{ lines: Polyline[], closed: boolean[] }}
+ */
+export function flattenBody(body, step = 0.6) {
+  /** @type {Polyline[]} */
+  const lines = [];
+  /** @type {boolean[]} */
+  const closed = [];
+  const attr = (/** @type {string} */ tag, /** @type {string} */ name) => {
+    const m = tag.match(new RegExp(`\\s${name}\\s*=\\s*["']([^"']*)["']`));
+    return m ? m[1] : undefined;
+  };
+  const numAttr = (/** @type {string} */ tag, /** @type {string} */ name, d = 0) => parseFloat(attr(tag, name) ?? `${d}`) || d;
+  for (const m of body.matchAll(/<(path|circle|ellipse|rect|line|polyline|polygon)\b[^>]*>/g)) {
+    const tag = m[0];
+    const kind = m[1];
+    if (kind === 'path') {
+      for (const sub of flattenPath(attr(tag, 'd') ?? '', step)) {
+        lines.push(sub.points);
+        closed.push(sub.closed);
+      }
+    } else if (kind === 'circle' || kind === 'ellipse') {
+      const cx = numAttr(tag, 'cx');
+      const cy = numAttr(tag, 'cy');
+      const rx = kind === 'circle' ? numAttr(tag, 'r') : numAttr(tag, 'rx');
+      const ry = kind === 'circle' ? rx : numAttr(tag, 'ry');
+      const n = Math.max(12, Math.ceil((2 * Math.PI * Math.max(rx, ry)) / step));
+      lines.push(Array.from({ length: n + 1 }, (_, i) => [cx + rx * Math.cos((i / n) * 2 * Math.PI), cy + ry * Math.sin((i / n) * 2 * Math.PI)]));
+      closed.push(true);
+    } else if (kind === 'rect') {
+      const x = numAttr(tag, 'x');
+      const y = numAttr(tag, 'y');
+      const w = numAttr(tag, 'width');
+      const h = numAttr(tag, 'height');
+      const r = Math.min(numAttr(tag, 'rx', numAttr(tag, 'ry')), w / 2, h / 2);
+      const d = r > 0
+        ? `M${x + r} ${y}H${x + w - r}A${r} ${r} 0 0 1 ${x + w} ${y + r}V${y + h - r}A${r} ${r} 0 0 1 ${x + w - r} ${y + h}H${x + r}A${r} ${r} 0 0 1 ${x} ${y + h - r}V${y + r}A${r} ${r} 0 0 1 ${x + r} ${y}Z`
+        : `M${x} ${y}H${x + w}V${y + h}H${x}Z`;
+      for (const sub of flattenPath(d, step)) {
+        lines.push(sub.points);
+        closed.push(true);
+      }
+    } else if (kind === 'line') {
+      lines.push(densify([[numAttr(tag, 'x1'), numAttr(tag, 'y1')], [numAttr(tag, 'x2'), numAttr(tag, 'y2')]], step));
+      closed.push(false);
+    } else {
+      const nums = (attr(tag, 'points') ?? '').split(/[\s,]+/).filter(Boolean).map(Number);
+      /** @type {Polyline} */
+      const pts = [];
+      for (let i = 0; i + 1 < nums.length; i += 2) pts.push([nums[i], nums[i + 1]]);
+      if (kind === 'polygon' && pts.length) pts.push(pts[0]);
+      lines.push(densify(pts, step));
+      closed.push(kind === 'polygon');
+    }
+  }
+  return { lines: lines.filter((l) => l.length > 1), closed };
+}
+
+/**
+ * Add points along straight segments so no segment is longer than `step`.
+ *
+ * @param {Polyline} pts
+ * @param {number} step
+ * @returns {Polyline}
+ */
+export function densify(pts, step) {
+  /** @type {Polyline} */
+  const out = [];
+  for (let i = 0; i < pts.length; i++) {
+    if (i === 0) { out.push(pts[0]); continue; }
+    const [ax, ay] = pts[i - 1];
+    const [bx, by] = pts[i];
+    const n = Math.max(1, Math.ceil(Math.hypot(bx - ax, by - ay) / step));
+    for (let k = 1; k <= n; k++) out.push([ax + ((bx - ax) * k) / n, ay + ((by - ay) * k) / n]);
+  }
+  return out;
+}
+
+/**
+ * Flatten path data into sub-paths.
+ *
+ * @param {string} d - Path data.
+ * @param {number} step - Target segment length.
+ * @returns {{ points: Polyline, closed: boolean }[]}
+ */
+export function flattenPath(d, step) {
+  const tokens = d.match(/[a-zA-Z]|-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?/g) ?? [];
+  /** @type {{ points: Polyline, closed: boolean }[]} */
+  const subs = [];
+  /** @type {Polyline} */
+  let cur = [];
+  let x = 0;
+  let y = 0;
+  let sx = 0;
+  let sy = 0;
+  let cmd = '';
+  let lastCtrl = /** @type {[number, number] | null} */ (null);
+  let lastQ = /** @type {[number, number] | null} */ (null);
+  let i = 0;
+  const next = () => parseFloat(tokens[i++]);
+  const isNum = () => i < tokens.length && !/^[a-zA-Z]$/.test(tokens[i]);
+  const flush = (closedPath = false) => {
+    if (cur.length > 1) subs.push({ points: cur, closed: closedPath });
+    cur = [];
+  };
+  const lineTo = (nx, ny) => {
+    const seg = densify([[x, y], [nx, ny]], step);
+    cur.push(...seg.slice(1));
+    x = nx; y = ny;
+  };
+  const cubic = (x1, y1, x2, y2, nx, ny) => {
+    const n = Math.max(4, Math.ceil((Math.hypot(x1 - x, y1 - y) + Math.hypot(x2 - x1, y2 - y1) + Math.hypot(nx - x2, ny - y2)) / step));
+    for (let k = 1; k <= n; k++) {
+      const t = k / n;
+      const u = 1 - t;
+      cur.push([u * u * u * x + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * nx, u * u * u * y + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * ny]);
+    }
+    lastCtrl = [x2, y2];
+    x = nx; y = ny;
+  };
+  const quad = (x1, y1, nx, ny) => {
+    const n = Math.max(4, Math.ceil((Math.hypot(x1 - x, y1 - y) + Math.hypot(nx - x1, ny - y1)) / step));
+    for (let k = 1; k <= n; k++) {
+      const t = k / n;
+      const u = 1 - t;
+      cur.push([u * u * x + 2 * u * t * x1 + t * t * nx, u * u * y + 2 * u * t * y1 + t * t * ny]);
+    }
+    lastQ = [x1, y1];
+    x = nx; y = ny;
+  };
+  const arc = (rx, ry, rot, large, sweep, nx, ny) => {
+    // Endpoint to centre parameterisation (SVG implementation notes, F.6.5).
+    if (rx === 0 || ry === 0) return lineTo(nx, ny);
+    rx = Math.abs(rx); ry = Math.abs(ry);
+    const phi = (rot * Math.PI) / 180;
+    const cos = Math.cos(phi);
+    const sin = Math.sin(phi);
+    const dx = (x - nx) / 2;
+    const dy = (y - ny) / 2;
+    const x1p = cos * dx + sin * dy;
+    const y1p = -sin * dx + cos * dy;
+    const lambda = (x1p * x1p) / (rx * rx) + (y1p * y1p) / (ry * ry);
+    if (lambda > 1) { rx *= Math.sqrt(lambda); ry *= Math.sqrt(lambda); }
+    const sign = large === sweep ? -1 : 1;
+    const num = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
+    const coef = sign * Math.sqrt(Math.max(0, num / (rx * rx * y1p * y1p + ry * ry * x1p * x1p)));
+    const cxp = (coef * rx * y1p) / ry;
+    const cyp = (-coef * ry * x1p) / rx;
+    const cx = cos * cxp - sin * cyp + (x + nx) / 2;
+    const cy = sin * cxp + cos * cyp + (y + ny) / 2;
+    const angle = (ux, uy, vx, vy) => {
+      const a = Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+      return a;
+    };
+    const t1 = angle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry);
+    let dt = angle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry);
+    if (!sweep && dt > 0) dt -= 2 * Math.PI;
+    if (sweep && dt < 0) dt += 2 * Math.PI;
+    const n = Math.max(4, Math.ceil((Math.abs(dt) * Math.max(rx, ry)) / step));
+    for (let k = 1; k <= n; k++) {
+      const t = t1 + (dt * k) / n;
+      cur.push([cx + rx * Math.cos(t) * cos - ry * Math.sin(t) * sin, cy + rx * Math.cos(t) * sin + ry * Math.sin(t) * cos]);
+    }
+    x = nx; y = ny;
+  };
+
+  while (i < tokens.length) {
+    if (!isNum()) cmd = tokens[i++];
+    const rel = cmd === cmd.toLowerCase();
+    const C = cmd.toUpperCase();
+    const ox = rel ? x : 0;
+    const oy = rel ? y : 0;
+    if (C !== 'C' && C !== 'S') lastCtrl = null;
+    if (C !== 'Q' && C !== 'T') lastQ = null;
+    switch (C) {
+      case 'M': {
+        flush();
+        x = ox + next(); y = oy + next();
+        sx = x; sy = y;
+        cur = [[x, y]];
+        cmd = rel ? 'l' : 'L';
+        break;
+      }
+      case 'L': lineTo(ox + next(), oy + next()); break;
+      case 'H': lineTo(ox + next(), y); break;
+      case 'V': lineTo(x, (rel ? y : 0) + next()); break;
+      case 'C': { const a = [ox + next(), oy + next(), ox + next(), oy + next(), ox + next(), oy + next()]; cubic(a[0], a[1], a[2], a[3], a[4], a[5]); break; }
+      case 'S': {
+        const [rx1, ry1] = lastCtrl ? [2 * x - lastCtrl[0], 2 * y - lastCtrl[1]] : [x, y];
+        const a = [ox + next(), oy + next(), ox + next(), oy + next()];
+        cubic(rx1, ry1, a[0], a[1], a[2], a[3]);
+        break;
+      }
+      case 'Q': { const a = [ox + next(), oy + next(), ox + next(), oy + next()]; quad(a[0], a[1], a[2], a[3]); break; }
+      case 'T': {
+        const [qx, qy] = lastQ ? [2 * x - lastQ[0], 2 * y - lastQ[1]] : [x, y];
+        quad(qx, qy, ox + next(), oy + next());
+        break;
+      }
+      case 'A': {
+        const a = [next(), next(), next(), next(), next()];
+        arc(a[0], a[1], a[2], a[3] ? 1 : 0, a[4] ? 1 : 0, ox + next(), oy + next());
+        break;
+      }
+      case 'Z': {
+        lineTo(sx, sy);
+        flush(true);
+        cur = [[sx, sy]];
+        break;
+      }
+      default:
+        i++;
+    }
+  }
+  flush();
+  return subs;
+}

package/src/fonts.js

@@ -0,0 +1,200 @@
+/**
+ * Fonts: loading, decoding and picking a face for a text layer.
+ *
+ * Text is shaped by HarfBuzz (`harfbuzzjs`, WebAssembly) and drawn as
+ * outlines, so the rendered cover never depends on fonts installed on the
+ * build machine. Inter (Latin, 400/500/600/700, about 120 KB of WOFF) ships
+ * in `fonts/` and is always available as the family `Inter`.
+ *
+ * Accepted formats: TrueType/OpenType (`.ttf`/`.otf`) and WOFF (`.woff`).
+ * WOFF2 is rejected with a clear error: it needs Brotli plus glyph-table
+ * reconstruction, which isn't worth carrying for a build tool.
+ *
+ * @module fonts
+ */
+
+import { readFileSync } from 'node:fs';
+import { inflateSync } from 'node:zlib';
+
+/** @type {Promise<typeof import('harfbuzzjs')> | undefined} */
+let hbPromise;
+
+/**
+ * Load HarfBuzz once (its WebAssembly initialises on import, so it's
+ * imported lazily: covers with no text never pay for it).
+ *
+ * @returns {Promise<typeof import('harfbuzzjs')>} The harfbuzzjs module.
+ */
+export function harfbuzz() {
+  hbPromise ??= import('harfbuzzjs');
+  return hbPromise;
+}
+
+/** Bundled weights of Inter. */
+const BUNDLED = [400, 500, 600, 700];
+
+/** @type {import('./index.js').FontSource[] | undefined} */
+let bundled;
+
+/**
+ * The bundled Inter faces, read from disk once per process.
+ *
+ * @returns {import('./index.js').FontSource[]} Inter 400/500/600/700.
+ */
+export function bundledFonts() {
+  bundled ??= BUNDLED.map((weight) => ({
+    name: 'Inter',
+    weight,
+    style: 'normal',
+    // A URL, not `.pathname`: a path with a space would be percent-encoded.
+    data: readFileSync(new URL(`../fonts/inter-latin-${weight}.woff`, import.meta.url)),
+  }));
+  return bundled;
+}
+
+/**
+ * Turn font bytes into a bare sfnt (TrueType/OpenType) HarfBuzz can read.
+ *
+ * @param {Uint8Array | ArrayBuffer} input - `.ttf`, `.otf` or `.woff` bytes.
+ * @returns {Uint8Array} sfnt bytes.
+ * @throws {TypeError} On WOFF2 or bytes that aren't a font.
+ */
+export function decodeFont(input) {
+  const buf = input instanceof Uint8Array ? input : new Uint8Array(input);
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  if (buf.byteLength < 12) throw new TypeError('Font data is too short to be a font');
+  const tag = view.getUint32(0);
+  if (tag === 0x774f4632) throw new TypeError('WOFF2 fonts are not supported: pass a .woff, .ttf or .otf');
+  if (tag !== 0x774f4646) {
+    // 0x00010000 TrueType, 'OTTO' CFF, 'true' old Apple TrueType.
+    if (tag === 0x00010000 || tag === 0x4f54544f || tag === 0x74727565) return buf;
+    throw new TypeError('Font data is not TrueType, OpenType or WOFF');
+  }
+
+  const flavor = view.getUint32(4);
+  const count = view.getUint16(12);
+  const tables = [];
+  for (let i = 0; i < count; i++) {
+    const o = 44 + i * 20;
+    tables.push({
+      tag: view.getUint32(o),
+      offset: view.getUint32(o + 4),
+      compLength: view.getUint32(o + 8),
+      origLength: view.getUint32(o + 12),
+      checksum: view.getUint32(o + 16),
+    });
+  }
+  let pow = 1;
+  let log = 0;
+  while (pow * 2 <= count) { pow *= 2; log++; }
+
+  const headerSize = 12 + 16 * count;
+  const pad = (n) => (n + 3) & ~3;
+  const total = tables.reduce((sum, t) => sum + pad(t.origLength), headerSize);
+  const out = new Uint8Array(total);
+  const ov = new DataView(out.buffer);
+  ov.setUint32(0, flavor);
+  ov.setUint16(4, count);
+  ov.setUint16(6, pow * 16);
+  ov.setUint16(8, log);
+  ov.setUint16(10, count * 16 - pow * 16);
+
+  let offset = headerSize;
+  tables.forEach((t, i) => {
+    const src = buf.subarray(t.offset, t.offset + t.compLength);
+    const data = t.compLength < t.origLength ? inflateSync(src) : src;
+    out.set(data, offset);
+    const rec = 12 + i * 16;
+    ov.setUint32(rec, t.tag);
+    ov.setUint32(rec + 4, t.checksum);
+    ov.setUint32(rec + 8, offset);
+    ov.setUint32(rec + 12, t.origLength);
+    offset += pad(t.origLength);
+  });
+  return out;
+}
+
+/**
+ * A loaded face, ready to shape with.
+ *
+ * @typedef {object} LoadedFont
+ * @property {string} name - Family name.
+ * @property {number} weight - Weight.
+ * @property {string} style - `'normal'` or `'italic'`.
+ * @property {any} font - The harfbuzzjs `Font`.
+ * @property {number} upem - Units per em.
+ * @property {number} ascender - In font units.
+ * @property {number} descender - In font units (negative).
+ * @property {number} capHeight - In font units.
+ * @property {Map<number, (string | number)[]>} paths - Glyph outline cache.
+ */
+
+/** @type {WeakMap<object, Promise<LoadedFont>>} */
+const loaded = new WeakMap();
+
+/**
+ * Load one font source (cached per data buffer, so the bundled faces and a
+ * caller's reused buffers are decoded once per process).
+ *
+ * @param {import('./index.js').FontSource} source - The font.
+ * @returns {Promise<LoadedFont>} The loaded face.
+ */
+export function loadFont(source) {
+  const key = /** @type {object} */ (source.data);
+  let p = loaded.get(key);
+  if (!p) {
+    p = (async () => {
+      const hb = await harfbuzz();
+      const face = new hb.Face(new hb.Blob(decodeFont(source.data)));
+      const font = new hb.Font(face);
+      const ext = font.hExtents();
+      const cap = font.getMetricPosition?.(hb.MetricsTag.CAP_HEIGHT);
+      const upem = face.upem;
+      return {
+        name: source.name,
+        weight: source.weight ?? 400,
+        style: source.style ?? 'normal',
+        font,
+        upem,
+        ascender: ext.ascender,
+        descender: ext.descender,
+        capHeight: cap || capFromGlyph(font) || upem * 0.7,
+        paths: new Map(),
+      };
+    })();
+    loaded.set(key, p);
+  }
+  // The same bytes can be registered under another name or weight.
+  return p.then((f) => ({ ...f, name: source.name, weight: source.weight ?? 400, style: source.style ?? 'normal' }));
+}
+
+/**
+ * The height of `H` when the font has no OS/2 cap height.
+ *
+ * @param {any} font - A harfbuzzjs Font.
+ * @returns {number | undefined} Cap height in font units.
+ */
+function capFromGlyph(font) {
+  const gid = font.nominalGlyph?.(0x48);
+  const ext = gid != null ? font.glyphExtents?.(gid) : undefined;
+  return ext ? ext.yBearing : undefined;
+}
+
+/**
+ * Pick the face for a family, weight and style: the closest weight within
+ * the family (CSS's matching rule, simplified), falling back to Inter.
+ *
+ * @param {import('./index.js').FontSource[]} sources - The available fonts.
+ * @param {string} family - Wanted family.
+ * @param {number} weight - Wanted weight.
+ * @param {string} [style='normal'] - Wanted style.
+ * @returns {import('./index.js').FontSource} The chosen source.
+ */
+export function pickFont(sources, family, weight, style = 'normal') {
+  let pool = sources.filter((s) => s.name.toLowerCase() === family.toLowerCase());
+  if (!pool.length) pool = sources.filter((s) => s.name === 'Inter');
+  if (!pool.length) pool = sources;
+  const styled = pool.filter((s) => (s.style ?? 'normal') === style);
+  if (styled.length) pool = styled;
+  return pool.reduce((best, s) => (Math.abs((s.weight ?? 400) - weight) < Math.abs((best.weight ?? 400) - weight) ? s : best));
+}