@roobscoob/vibes 0.0.0-stage → 0.1.0

package/dist/here.js

@@ -0,0 +1,217 @@
+// Here: one light, now. Everything a sketch is made of (its functions, its
+// fields, and their parameters) takes a `here` and gives back what that
+// light should do. A field's transforms (rotate, kaleid, delay, ...) change
+// where and when it looks (x, y, t), never which light it is (light).
+//
+// Positions are in meters from the building's top-left wall corner (floors
+// share one frame), and u, v run 0 to 1 across the room the lights fill.
+//
+// What arclamp sends is read leniently: a light with no channels, coords that
+// aren't coords (older arclamps sent ""), or tags that aren't a list is taken
+// as having none.
+import { Color, off } from "./color.js";
+import { LUMENS_PER_BRIGHTNESS } from "./lemtone.js";
+import { hash } from "./shape.js";
+export class Light {
+    id;
+    /** "color" for color bulbs and panels; "switch" for old bulbs, which only go on and off. */
+    kind;
+    tags;
+    /** Whether it's on the plan; one that isn't sits at the room's center. */
+    placed;
+    floor;
+    /** Meters from the building's left wall. */
+    x;
+    /** Meters from the building's top wall. */
+    y;
+    /** The rail it hangs on, or null. */
+    rail = null;
+    /** A number from 0 to 1 of its own, the same every time: for giving each light its own beat or shade. */
+    random;
+    /** What the layers below this sketch are making it do. */
+    below = off;
+    /** Its own memory, kept from one tick to the next. */
+    state = {};
+    constructor(p, x, y) {
+        const coords = coordsOf(p);
+        this.id = p.id;
+        this.kind = isSwitch(p) ? "switch" : "color";
+        this.tags = Object.freeze([...tagsOf(p)]);
+        this.placed = !!coords;
+        this.floor = coords?.floor ?? null;
+        this.x = x;
+        this.y = y;
+        this.random = hash(p.id, 0x5eed);
+    }
+    has(tag) {
+        return this.tags.includes(tag);
+    }
+}
+export class Room {
+    /** Every light, in arclamp's order. */
+    lights;
+    rails;
+    /** The left and top edges of the room the lights fill, in meters. */
+    x0;
+    y0;
+    /** How wide (left to right) and deep (top to bottom) that room is, in meters. */
+    width;
+    depth;
+    center;
+    byId;
+    railsById;
+    constructor(lights, rails, bounds) {
+        this.lights = lights;
+        this.rails = rails;
+        this.x0 = bounds.x0;
+        this.y0 = bounds.y0;
+        this.width = bounds.width;
+        this.depth = bounds.depth;
+        this.center = Object.freeze({ x: bounds.x0 + bounds.width / 2, y: bounds.y0 + bounds.depth / 2 });
+        this.byId = new Map(lights.map((l) => [l.id, l]));
+        this.railsById = new Map(rails.map((r) => [r.id, r]));
+    }
+    light(id) {
+        return this.byId.get(id);
+    }
+    rail(id) {
+        return this.railsById.get(id);
+    }
+    /** The lights with this tag. */
+    tagged(tag) {
+        return this.lights.filter((l) => l.has(tag));
+    }
+}
+export class Here {
+    /** Where it's looking, in meters (the light's own place, unless a transform moved it). */
+    x;
+    y;
+    /** Seconds since the sketch started (unless a transform moved it). */
+    t;
+    /** Seconds since the last tick: about 0.01 in the room, 0.03 in the preview. */
+    dt;
+    /** The clock, in milliseconds since 1970: for things that follow the time of day. */
+    now;
+    light;
+    room;
+    constructor(x, y, t, dt, now, light, room) {
+        this.x = x;
+        this.y = y;
+        this.t = t;
+        this.dt = dt;
+        this.now = now;
+        this.light = light;
+        this.room = room;
+    }
+    /** 0 at the room's left edge, 1 at its right. */
+    get u() {
+        return (this.x - this.room.x0) / this.room.width;
+    }
+    /** 0 at the room's top edge, 1 at its bottom. */
+    get v() {
+        return (this.y - this.room.y0) / this.room.depth;
+    }
+    /** The same light, looking from somewhere else, or at another time. */
+    at(p) {
+        return new Here(p.x ?? this.x, p.y ?? this.y, p.t ?? this.t, this.dt, this.now, this.light, this.room);
+    }
+}
+// ---- reading arclamp's lights -------------------------------------------------------
+const NO_TAGS = Object.freeze([]);
+const finite = (v) => typeof v === "number" && Number.isFinite(v);
+/** A light's coords, if they are some. */
+function coordsOf(p) {
+    const c = p.coords;
+    return c && typeof c === "object" && finite(c.mm_x) && finite(c.mm_y) ? c : null;
+}
+/** A light's rail, if it has one. */
+function railOf(p) {
+    const r = p.rail;
+    return r && typeof r === "object" && (typeof r.id === "string" || typeof r.id === "number") && finite(r.mm_along)
+        ? { id: String(r.id), mm_along: r.mm_along }
+        : null;
+}
+function tagsOf(p) {
+    return Array.isArray(p.tags) ? p.tags.filter((t) => typeof t === "string") : NO_TAGS;
+}
+const channelsOf = (p) => (p.channels && typeof p.channels === "object" ? p.channels : {});
+const isSwitch = (p) => "on" in channelsOf(p);
+// The layout each room was made from, to tell when arclamp's has changed.
+const layouts = new WeakMap();
+const snapshot = (p) => {
+    const c = coordsOf(p);
+    return { id: p.id, switch: isSwitch(p), coords: c && { ...c }, rail: railOf(p), tags: [...tagsOf(p)] };
+};
+/** The room in `prev`, keeping each light's memory from `before` (lights move, and come and go). */
+export function roomOf(prev, before) {
+    const list = Array.isArray(prev?.lights) ? prev.lights : [];
+    const placed = list.map(coordsOf).filter((c) => !!c);
+    const xs = placed.map((c) => c.mm_x / 1000);
+    const ys = placed.map((c) => c.mm_y / 1000);
+    const x0 = xs.length ? Math.min(...xs) : 0;
+    const y0 = ys.length ? Math.min(...ys) : 0;
+    const width = Math.max(1, xs.length ? Math.max(...xs) - x0 : 0);
+    const depth = Math.max(1, ys.length ? Math.max(...ys) - y0 : 0);
+    const cx = x0 + width / 2;
+    const cy = y0 + depth / 2;
+    const lights = list.map((p) => {
+        const c = coordsOf(p);
+        const light = new Light(p, c ? c.mm_x / 1000 : cx, c ? c.mm_y / 1000 : cy);
+        const old = before?.light(p.id);
+        if (old)
+            light.state = old.state;
+        return light;
+    });
+    const onRails = new Map();
+    list.forEach((p, i) => {
+        const rail = railOf(p);
+        if (!rail)
+            return;
+        const entries = onRails.get(rail.id) ?? [];
+        entries.push({ light: lights[i], along: rail.mm_along / 1000 });
+        onRails.set(rail.id, entries);
+    });
+    const rails = [];
+    for (const [id, entries] of onRails) {
+        entries.sort((a, b) => a.along - b.along);
+        const length = entries[entries.length - 1].along;
+        entries.forEach(({ light, along }, index) => {
+            light.rail = { id, along, t: length > 0 ? along / length : 0, index, count: entries.length };
+        });
+        rails.push({ id, lights: entries.map((e) => e.light), length });
+    }
+    const room = new Room(lights, rails, { x0, y0, width, depth });
+    layouts.set(room, list.map(snapshot));
+    return room;
+}
+/** Whether `prev`'s lights are the ones `room` was made from, in the same places. */
+export function sameLayout(prev, room) {
+    const known = layouts.get(room);
+    const list = Array.isArray(prev?.lights) ? prev.lights : [];
+    if (!known || known.length !== list.length)
+        return false;
+    for (let i = 0; i < known.length; i++) {
+        const a = known[i];
+        const p = list[i];
+        if (a.id !== p.id || a.switch !== isSwitch(p))
+            return false;
+        const c = coordsOf(p);
+        if (!(a.coords === c || (a.coords && c && a.coords.mm_x === c.mm_x && a.coords.mm_y === c.mm_y && a.coords.floor === c.floor)))
+            return false;
+        const r = railOf(p);
+        if (!(a.rail === r || (a.rail && r && a.rail.id === r.id && a.rail.mm_along === r.mm_along)))
+            return false;
+        const tags = tagsOf(p);
+        if (a.tags.length !== tags.length || a.tags.some((t, k) => t !== tags[k]))
+            return false;
+    }
+    return true;
+}
+/** What a light's channels say it's making, as a color: an old bulb that's on is a warm 800 lm. */
+export function colorOf(p, kind) {
+    const ch = channelsOf(p);
+    const n = (k, d) => (finite(ch[k]) ? ch[k] : d);
+    if (kind === "switch")
+        return Color.from({ on: n("on", 0) });
+    return new Color(n("a", 0), n("b", 0), n("brightness", 0) * LUMENS_PER_BRIGHTNESS, n("fidelity", 1));
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export type { Coords, Out, Prev, PrevLight, Update } from "./arclamp.ts";
+export { br30, Color, color, hex, hsl, isPalette, lemtone, off, oklab, oklch, palette, palettes, rgb, toPalette, white, xy, type Bulb, type ColorChanges, type ColorInput, type ColorLike, type Palette, type Stop, } from "./color.ts";
+export { Here, Light, Room, type Rail, type RailSpot } from "./here.ts";
+export { delay, field, gradient, isField, kaleid, move, noise, osc, rings, rotate, scale, solid, speed, voronoi, warp, type ColorParam, type Field, type Param, } from "./field.ts";
+export { clock, type Clock, type Every } from "./signal.ts";
+export { chance, clamp, decay, ease, fract, hash, lerp, noiseAt, remap, saw, smoothstep, square, tri, wave } from "./shape.ts";
+export { sketch, type Look, type LookResult, type SketchOptions } from "./sketch.ts";
+//# 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":"AAGA,YAAY,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EACL,IAAI,EACJ,KAAK,EACL,KAAK,EACL,GAAG,EACH,GAAG,EACH,SAAS,EACT,OAAO,EACP,GAAG,EACH,KAAK,EACL,KAAK,EACL,OAAO,EACP,QAAQ,EACR,GAAG,EACH,SAAS,EACT,KAAK,EACL,EAAE,EACF,KAAK,IAAI,EACT,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,OAAO,EACZ,KAAK,IAAI,GACV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AACxE,OAAO,EACL,KAAK,EACL,KAAK,EACL,QAAQ,EACR,OAAO,EACP,MAAM,EACN,IAAI,EACJ,KAAK,EACL,GAAG,EACH,KAAK,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAK,EACL,OAAO,EACP,IAAI,EACJ,KAAK,UAAU,EACf,KAAK,KAAK,EACV,KAAK,KAAK,GACX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,KAAK,EAAE,KAAK,KAAK,EAAE,KAAK,KAAK,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC/H,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+// @roobscoob/vibes: color, light and time for sketches on the lights at the
+// Recurse Center. See README.md.
+export { br30, Color, color, hex, hsl, isPalette, lemtone, off, oklab, oklch, palette, palettes, rgb, toPalette, white, xy, } from "./color.js";
+export { Here, Light, Room } from "./here.js";
+export { delay, field, gradient, isField, kaleid, move, noise, osc, rings, rotate, scale, solid, speed, voronoi, warp, } from "./field.js";
+export { clock } from "./signal.js";
+export { chance, clamp, decay, ease, fract, hash, lerp, noiseAt, remap, saw, smoothstep, square, tri, wave } from "./shape.js";
+export { sketch } from "./sketch.js";

package/dist/lemtone.d.ts

@@ -0,0 +1,37 @@
+export type Vec3 = [number, number, number];
+export type XY = [number, number];
+/** What brightness 1.0 means (rclamp sink.LumensPerBrightness). */
+export declare const LUMENS_PER_BRIGHTNESS = 1000;
+export declare const mul3: (m: number[][], v: Vec3) => Vec3;
+export declare function xyzToOklab(X: Vec3): Vec3;
+/** XYZ as OKLab's LMS (before the cube root). */
+export declare const xyzToLms: (X: Vec3) => Vec3;
+/** OKLab's LMS (before the cube root) as XYZ. */
+export declare const lmsToXyz: (lms: Vec3) => Vec3;
+/** An OKLab color (L, a, b) as XYZ. */
+export declare function oklabToXyz(lab: Vec3): Vec3;
+/** A lemtone color's light as XYZ with Y = 1 (one lumen's worth, to add up), or null where there's no real color. */
+export declare function abToXyz(a: number, b: number): Vec3 | null;
+/** Light's color as a lemtone's a and b (its brightness doesn't matter). */
+export declare function xyzToAb(X: Vec3): [number, number];
+/** A chromaticity's OKLab a, b at L = 1 (OKLab scales with XYZ's cube root, so each chromaticity is one direction). */
+export declare function abOfXy(xy: XY): [number, number];
+/** The Planckian locus (Kim et al. cubic spline, 1667–25000 K), as the tool page has it. */
+export declare function cctToXy(kelvin: number): XY;
+/** A white of this color temperature, as a and b. */
+export declare const whiteAB: (kelvin: number) => [number, number];
+export declare const WHITE_K_MIN = 1700;
+export declare const WHITE_K_MAX = 10000;
+/**
+ * The color temperature of a white, or null for a color more than
+ * `tolerance` (in a/b) from the Planckian locus. Infinity finds the nearest
+ * white to any color.
+ */
+export declare function kelvinOf(a: number, b: number, tolerance?: number): number | null;
+/** Hue (degrees, 0–360) and chroma of a color: OKLCh at L = 1. */
+export declare function hueChroma(a: number, b: number): {
+    hue: number;
+    chroma: number;
+};
+export declare function abOf(hue: number, chroma: number): [number, number];
+//# sourceMappingURL=lemtone.d.ts.map

package/dist/lemtone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lemtone.d.ts","sourceRoot":"","sources":["../src/lemtone.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAC5C,MAAM,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAElC,mEAAmE;AACnE,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C,eAAO,MAAM,IAAI,MAAO,MAAM,EAAE,EAAE,KAAK,IAAI,KAAG,IAI7C,CAAC;AAUF,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAExC;AAED,iDAAiD;AACjD,eAAO,MAAM,QAAQ,MAAO,IAAI,KAAG,IAAwB,CAAC;AAuB5D,iDAAiD;AACjD,eAAO,MAAM,QAAQ,QAAS,IAAI,KAAG,IAA0B,CAAC;AAEhE,uCAAuC;AACvC,wBAAgB,UAAU,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,CAG1C;AAED,qHAAqH;AACrH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAIzD;AAED,4EAA4E;AAC5E,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAGjD;AAID,uHAAuH;AACvH,wBAAgB,MAAM,CAAC,EAAE,EAAE,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAG/C;AAED,4FAA4F;AAC5F,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,EAAE,CAiB1C;AAED,qDAAqD;AACrD,eAAO,MAAM,OAAO,WAAY,MAAM,KAAG,CAAC,MAAM,EAAE,MAAM,CAA4B,CAAC;AAErF,eAAO,MAAM,WAAW,OAAO,CAAC;AAChC,eAAO,MAAM,WAAW,QAAQ,CAAC;AAIjC;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,SAAkB,GAAG,MAAM,GAAG,IAAI,CAGzF;AA2CD,kEAAkE;AAClE,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAI/E;AAED,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAGlE"}

package/dist/lemtone.js

@@ -0,0 +1,158 @@
+// Lemtone: device-independent light, as arclamp's color channels carry it.
+// Walter's rc-bulb-firmware lemtone/ is canonical.
+//
+// A lemtone is a color as OKLab a and b at L = 1 (so color doesn't depend on
+// brightness), a brightness where 1.0 is 1000 lm (a fixed unit, not any
+// light's maximum), and a fidelity: 0 builds pale colors and whites from the
+// RGB LEDs, 1 from the white ones. Each bulb solves this into its own PWM.
+//
+// This is the color-space core: OKLab, whites by color temperature, and hue
+// and chroma. Sketches use it through color.ts; vibes uses it too
+// (src/shared/lemtone.ts), so a sketch, the picker and the map agree.
+/** What brightness 1.0 means (rclamp sink.LumensPerBrightness). */
+export const LUMENS_PER_BRIGHTNESS = 1000;
+export const mul3 = (m, v) => [
+    m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2],
+    m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2],
+    m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2],
+];
+// XYZ -> LMS and the LMS' -> OKLab step, as in Walter's Lemtone tool page
+// (Björn Ottosson's OKLab).
+const XYZ_LMS = [
+    [0.8189330101, 0.3618667424, -0.1288597137],
+    [0.0329845436, 0.9293118715, 0.0361456387],
+    [0.0482003018, 0.2643662691, 0.633851707],
+];
+export function xyzToOklab(X) {
+    return lmsToOklab(xyzToLms(X));
+}
+/** XYZ as OKLab's LMS (before the cube root). */
+export const xyzToLms = (X) => mul3(XYZ_LMS, X);
+function lmsToOklab(lms) {
+    const [l, m, s] = lms.map(Math.cbrt);
+    return [
+        0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+        1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+        0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
+    ];
+}
+// OKLab -> LMS' and LMS -> XYZ (Ottosson's inverses).
+const LAB_LMS = [
+    [1.0, 0.3963377774, 0.2158037573],
+    [1.0, -0.1055613458, -0.0638541728],
+    [1.0, -0.0894841775, -1.291485548],
+];
+const LMS_XYZ = [
+    [1.2270138511, -0.5577999807, 0.281256149],
+    [-0.0405801784, 1.1122568696, -0.0716766787],
+    [-0.0763812845, -0.4214819784, 1.5861632204],
+];
+/** OKLab's LMS (before the cube root) as XYZ. */
+export const lmsToXyz = (lms) => mul3(LMS_XYZ, lms);
+/** An OKLab color (L, a, b) as XYZ. */
+export function oklabToXyz(lab) {
+    const [l, m, s] = mul3(LAB_LMS, lab);
+    return lmsToXyz([l * l * l, m * m * m, s * s * s]);
+}
+/** A lemtone color's light as XYZ with Y = 1 (one lumen's worth, to add up), or null where there's no real color. */
+export function abToXyz(a, b) {
+    const X = oklabToXyz([1, a, b]);
+    if (!(X[1] > 1e-6))
+        return null;
+    return [X[0] / X[1], 1, X[2] / X[1]];
+}
+/** Light's color as a lemtone's a and b (its brightness doesn't matter). */
+export function xyzToAb(X) {
+    const [L, a, b] = xyzToOklab(X);
+    return L > 0 ? [a / L, b / L] : [0, 0];
+}
+const xyToXyz = ([x, y]) => [x / y, 1, (1 - x - y) / y];
+/** A chromaticity's OKLab a, b at L = 1 (OKLab scales with XYZ's cube root, so each chromaticity is one direction). */
+export function abOfXy(xy) {
+    const [L, a, b] = xyzToOklab(xyToXyz(xy));
+    return [a / L, b / L];
+}
+/** The Planckian locus (Kim et al. cubic spline, 1667–25000 K), as the tool page has it. */
+export function cctToXy(kelvin) {
+    const t = 1e3 / kelvin;
+    const t2 = t * t;
+    const t3 = t2 * t;
+    const x = kelvin <= 4000
+        ? -0.2661239 * t3 - 0.2343589 * t2 + 0.8776956 * t + 0.17991
+        : -3.0258469 * t3 + 2.1070379 * t2 + 0.2226347 * t + 0.24039;
+    const x2 = x * x;
+    const x3 = x2 * x;
+    const y = kelvin <= 2222
+        ? -1.1063814 * x3 - 1.3481102 * x2 + 2.18555832 * x - 0.20219683
+        : kelvin <= 4000
+            ? -0.9549476 * x3 - 1.37418593 * x2 + 2.09137015 * x - 0.16748867
+            : 3.081758 * x3 - 5.8733867 * x2 + 3.75112997 * x - 0.37001483;
+    return [x, y];
+}
+/** A white of this color temperature, as a and b. */
+export const whiteAB = (kelvin) => abOfXy(cctToXy(kelvin));
+export const WHITE_K_MIN = 1700;
+export const WHITE_K_MAX = 10000;
+// How far from the Planckian locus (in a/b) a color still counts as a white.
+const WHITE_TOLERANCE = 0.005;
+/**
+ * The color temperature of a white, or null for a color more than
+ * `tolerance` (in a/b) from the Planckian locus. Infinity finds the nearest
+ * white to any color.
+ */
+export function kelvinOf(a, b, tolerance = WHITE_TOLERANCE) {
+    const { mired, off } = nearestWhite(a, b);
+    return off <= tolerance ? 1e6 / mired : null;
+}
+// The coarse pass's whites, every 2 mired across the range, worked out once.
+let coarse = null;
+// Nearest whites found already: the same few colors are named over and over as things render.
+const nearest = new Map();
+/** The nearest white to a color (in mired) and how far off it the color is (in a/b). */
+function nearestWhite(a, b) {
+    const key = `${a} ${b}`;
+    const known = nearest.get(key);
+    if (known)
+        return known;
+    if (nearest.size > 4096)
+        nearest.clear();
+    if (!coarse) {
+        coarse = [];
+        for (let m = 1e6 / WHITE_K_MAX; m <= 1e6 / WHITE_K_MIN; m += 2) {
+            const [wa, wb] = whiteAB(1e6 / m);
+            coarse.push({ m, a: wa, b: wb });
+        }
+    }
+    // Coarse to fine, in mired: even steps in mired are even steps in look.
+    let best = 0;
+    let bestD = Infinity;
+    for (const w of coarse) {
+        const d = Math.hypot(w.a - a, w.b - b);
+        if (d < bestD) {
+            bestD = d;
+            best = w.m;
+        }
+    }
+    for (let m = best - 2; m <= best + 2; m += 0.02) {
+        const [wa, wb] = whiteAB(1e6 / m);
+        const d = Math.hypot(wa - a, wb - b);
+        if (d < bestD) {
+            bestD = d;
+            best = m;
+        }
+    }
+    const found = { mired: best, off: bestD };
+    nearest.set(key, found);
+    return found;
+}
+/** Hue (degrees, 0–360) and chroma of a color: OKLCh at L = 1. */
+export function hueChroma(a, b) {
+    let hue = (Math.atan2(b, a) * 180) / Math.PI;
+    if (hue < 0)
+        hue += 360;
+    return { hue, chroma: Math.hypot(a, b) };
+}
+export function abOf(hue, chroma) {
+    const r = (hue * Math.PI) / 180;
+    return [chroma * Math.cos(r), chroma * Math.sin(r)];
+}

package/dist/names.d.ts

@@ -0,0 +1,5 @@
+/** A CSS named color's hex digits ("ffa500" for orange), or undefined. */
+export declare function cssNamed(name: string): string | undefined;
+/** Whites by what they're the light of, in kelvin. */
+export declare const LIGHT_NAMES: Readonly<Record<string, number>>;
+//# sourceMappingURL=names.d.ts.map

package/dist/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../src/names.ts"],"names":[],"mappings":"AAiCA,0EAA0E;AAC1E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOzD;AAED,sDAAsD;AACtD,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAKxD,CAAC"}

package/dist/names.js

@@ -0,0 +1,46 @@
+// Colors by name: CSS's named colors (as sRGB hex), and a few color
+// temperatures by what they're the light of.
+const CSS = "aliceblue f0f8ff antiquewhite faebd7 aqua 00ffff aquamarine 7fffd4 azure f0ffff beige f5f5dc bisque ffe4c4 " +
+    "black 000000 blanchedalmond ffebcd blue 0000ff blueviolet 8a2be2 brown a52a2a burlywood deb887 " +
+    "cadetblue 5f9ea0 chartreuse 7fff00 chocolate d2691e coral ff7f50 cornflowerblue 6495ed cornsilk fff8dc " +
+    "crimson dc143c cyan 00ffff darkblue 00008b darkcyan 008b8b darkgoldenrod b8860b darkgray a9a9a9 " +
+    "darkgreen 006400 darkgrey a9a9a9 darkkhaki bdb76b darkmagenta 8b008b darkolivegreen 556b2f " +
+    "darkorange ff8c00 darkorchid 9932cc darkred 8b0000 darksalmon e9967a darkseagreen 8fbc8f " +
+    "darkslateblue 483d8b darkslategray 2f4f4f darkslategrey 2f4f4f darkturquoise 00ced1 darkviolet 9400d3 " +
+    "deeppink ff1493 deepskyblue 00bfff dimgray 696969 dimgrey 696969 dodgerblue 1e90ff firebrick b22222 " +
+    "floralwhite fffaf0 forestgreen 228b22 fuchsia ff00ff gainsboro dcdcdc ghostwhite f8f8ff gold ffd700 " +
+    "goldenrod daa520 gray 808080 green 008000 greenyellow adff2f grey 808080 honeydew f0fff0 hotpink ff69b4 " +
+    "indianred cd5c5c indigo 4b0082 ivory fffff0 khaki f0e68c lavender e6e6fa lavenderblush fff0f5 " +
+    "lawngreen 7cfc00 lemonchiffon fffacd lightblue add8e6 lightcoral f08080 lightcyan e0ffff " +
+    "lightgoldenrodyellow fafad2 lightgray d3d3d3 lightgreen 90ee90 lightgrey d3d3d3 lightpink ffb6c1 " +
+    "lightsalmon ffa07a lightseagreen 20b2aa lightskyblue 87cefa lightslategray 778899 lightslategrey 778899 " +
+    "lightsteelblue b0c4de lightyellow ffffe0 lime 00ff00 limegreen 32cd32 linen faf0e6 magenta ff00ff " +
+    "maroon 800000 mediumaquamarine 66cdaa mediumblue 0000cd mediumorchid ba55d3 mediumpurple 9370db " +
+    "mediumseagreen 3cb371 mediumslateblue 7b68ee mediumspringgreen 00fa9a mediumturquoise 48d1cc " +
+    "mediumvioletred c71585 midnightblue 191970 mintcream f5fffa mistyrose ffe4e1 moccasin ffe4b5 " +
+    "navajowhite ffdead navy 000080 oldlace fdf5e6 olive 808000 olivedrab 6b8e23 orange ffa500 " +
+    "orangered ff4500 orchid da70d6 palegoldenrod eee8aa palegreen 98fb98 paleturquoise afeeee " +
+    "palevioletred db7093 papayawhip ffefd5 peachpuff ffdab9 peru cd853f pink ffc0cb plum dda0dd " +
+    "powderblue b0e0e6 purple 800080 rebeccapurple 663399 red ff0000 rosybrown bc8f8f royalblue 4169e1 " +
+    "saddlebrown 8b4513 salmon fa8072 sandybrown f4a460 seagreen 2e8b57 seashell fff5ee sienna a0522d " +
+    "silver c0c0c0 skyblue 87ceeb slateblue 6a5acd slategray 708090 slategrey 708090 snow fffafa " +
+    "springgreen 00ff7f steelblue 4682b4 tan d2b48c teal 008080 thistle d8bfd8 tomato ff6347 " +
+    "turquoise 40e0d0 violet ee82ee wheat f5deb3 white ffffff whitesmoke f5f5f5 yellow ffff00 yellowgreen 9acd32";
+let named = null;
+/** A CSS named color's hex digits ("ffa500" for orange), or undefined. */
+export function cssNamed(name) {
+    if (!named) {
+        named = new Map();
+        const words = CSS.split(" ");
+        for (let i = 0; i < words.length; i += 2)
+            named.set(words[i], words[i + 1]);
+    }
+    return named.get(name);
+}
+/** Whites by what they're the light of, in kelvin. */
+export const LIGHT_NAMES = {
+    candlelight: 1850,
+    incandescent: 2700,
+    halogen: 3000,
+    daylight: 6500,
+};

package/dist/parse.d.ts

@@ -0,0 +1,43 @@
+import type { Vec3 } from "./lemtone.ts";
+/** What some text says a color is. */
+export type Spec = {
+    alpha?: number;
+    lm?: number;
+    fidelity?: number;
+} & ({
+    space: "off";
+} | {
+    space: "srgb" | "srgb-linear" | "display-p3";
+    rgb: Vec3;
+} | {
+    space: "xyz" | "xyz-d50";
+    xyz: Vec3;
+} | {
+    space: "hsl";
+    h: number;
+    s: number;
+    l: number;
+} | {
+    space: "hwb";
+    h: number;
+    w: number;
+    b: number;
+} | {
+    space: "oklab" | "lab";
+    lab: Vec3;
+} | {
+    space: "oklch" | "lch";
+    l: number;
+    c: number;
+    h: number;
+} | {
+    space: "kelvin";
+    kelvin: number;
+} | {
+    space: "lemtone";
+    hue: number;
+    chroma: number;
+});
+/** What `text` says a color is, or null if it can't be read. */
+export declare function parseColor(text: string): Spec | null;
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAGzC,sCAAsC;AACtC,MAAM,MAAM,IAAI,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,CACpE;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,GAChB;IAAE,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,YAAY,CAAC;IAAC,GAAG,EAAE,IAAI,CAAA;CAAE,GAC3D;IAAE,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;IAAC,GAAG,EAAE,IAAI,CAAA;CAAE,GACvC;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GACjD;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GACjD;IAAE,KAAK,EAAE,OAAO,GAAG,KAAK,CAAC;IAAC,GAAG,EAAE,IAAI,CAAA;CAAE,GACrC;IAAE,KAAK,EAAE,OAAO,GAAG,KAAK,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,KAAK,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CACpD,CAAC;AAiCF,gEAAgE;AAChE,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAqBpD"}