@originkit/avatars 0.0.0-stage → 0.2.0

package/dist/knits/calming.d.ts

@@ -0,0 +1,7 @@
+/**
+ * What Possibilities calms on a knit. Low keeps the plainer hats, holes and clothes, and the
+ * eight calmest moods, one for each variant. Indices are into the lists in `index.ts`.
+ */
+import type { Calming } from "../possibilities.ts";
+export declare const CALMING: Calming;
+export declare const NOTES: [string, string, string];

package/dist/knits/calming.js

@@ -0,0 +1,19 @@
+/**
+ * What Possibilities calms on a knit. Low keeps the plainer hats, holes and clothes, and the
+ * eight calmest moods, one for each variant. Indices are into the lists in `index.ts`.
+ */
+export const CALMING = {
+    lists: {
+        // Bored, Calm, Sleepy, Wide, Side eye, Weary, Surprised, Suspicious, then Angry.
+        mood: [9, 8, [0, 6, 2, 1, 3, 8, 4, 5, 7]],
+        // Cuffed, Watch cap, Pompom, then Slouch and Bare.
+        hat: [5, 3, [0, 2, 1, 3, 4]],
+        // Goggles, Two holes, Slot, then Three holes and Open face.
+        opening: [5, 3, [0, 4, 2, 1, 3]],
+    },
+};
+export const NOTES = [
+    "beanies and goggle holes, calm and bored eyes.",
+    "more hats and holes, and more moods.",
+    "every hat, hole and mood, angry eyes and open faces too.",
+];

package/dist/knits/controls.d.ts

@@ -0,0 +1,2 @@
+import { type ControlBuilder } from "../controls.ts";
+export declare const controls: ControlBuilder;

package/dist/knits/controls.js

@@ -0,0 +1,32 @@
+import { choice, palette } from "../controls.js";
+import { narrowed, possibilitiesSlider } from "../possibilities.js";
+import { CALMING, NOTES } from "./calming.js";
+import { BEANIES, CLOTHES, CLOTHING, hatOf, HATS, knitTraits, MASKS, MOODS, OPENINGS, SKINS, TILES } from "./index.js";
+const named = (list) => list.map(({ name: label }) => ({ label }));
+export const controls = (name, overrides) => {
+    const t = knitTraits(name, overrides);
+    const list = (control) => narrowed(control, t, CALMING);
+    return [
+        {
+            title: "Knit",
+            controls: [
+                list(choice(t, "mood", "Mood", "list", named(MOODS))),
+                list(choice(t, "hat", "Hat", "list", named(HATS))),
+                list(choice(t, "opening", "Holes", "list", named(OPENINGS))),
+                possibilitiesSlider(t, NOTES),
+                choice(t, "clothing", "Clothes", "list", named(CLOTHING)),
+            ],
+        },
+        {
+            title: "Colour",
+            controls: [
+                // A bare head has no beanie to colour.
+                ...(hatOf(t) === "none" ? [] : [palette(t, "beanie", "Beanie", BEANIES)]),
+                palette(t, "mask", "Mask", MASKS),
+                palette(t, "clothes", "Clothes colour", CLOTHES),
+                palette(t, "skin", "Skin", SKINS),
+                palette(t, "tile", "Background", TILES),
+            ],
+        },
+    ];
+};

package/dist/knits/index.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Knits: a bust in a knitted balaclava and a ribbed beanie, after the reference's look. A soft
+ * studio grey behind, a coat over a white tee, the mask's knit running in fine ribs, and the eyes
+ * looking out through its holes from under heavy lids. It's drawn to feel modelled: every part is
+ * shaded as the form it is, a ball, a dome or a cylinder, under one soft light from up to the left,
+ * with soft shadows where parts meet, the beanie's ribs as tubes wrapping round it, and the yarn's
+ * edges fuzzy and its surface flecked. The eyes can blink and follow the pointer.
+ *
+ * It's drawn from numbers in the 100×100 frame, so the thumbnail is the very same picture.
+ */
+import { type Overrides, type Traits } from "../traits.ts";
+/** The reference's first. Neighbours are unlike. */
+export declare const BEANIES: string[];
+export declare const MASKS: string[];
+export declare const CLOTHES: string[];
+export declare const SKINS: string[];
+export declare const TILES: string[];
+type Hat = "cuffed" | "pompom" | "slouch" | "watch" | "none";
+type Opening = "goggles" | "slot" | "holes" | "three" | "open";
+type Clothing = "coat" | "hoodie" | "puffer" | "turtleneck" | "bomber";
+export declare const HATS: {
+    name: string;
+    hat: Hat;
+}[];
+export declare const OPENINGS: {
+    name: string;
+    opening: Opening;
+}[];
+export declare const CLOTHING: {
+    name: string;
+    clothing: Clothing;
+}[];
+/** A mood, as the eyes show it: how far down the lids are, their tilt, and where the eyes look. */
+interface Mood {
+    name: string;
+    lid: number;
+    /** Above 0 lowers the lids towards the nose, as in anger; below it, towards the ears, as in sorrow. */
+    tilt: number;
+    look: [number, number];
+    pupil: number;
+}
+/** The reference's bored glance first. Neighbours are unlike. */
+export declare const MOODS: Mood[];
+export declare const knitTraits: (name: string, overrides?: Overrides) => Traits;
+export declare const hatOf: (t: Traits) => Hat;
+export declare const openingOf: (t: Traits) => Opening;
+export declare const clothingOf: (t: Traits) => Clothing;
+export declare const moodOf: (t: Traits) => Mood;
+export declare function coloursOf(t: Traits): {
+    beanie: string;
+    mask: string;
+    clothes: string;
+    skin: string;
+    tile: string;
+};
+export interface Knit {
+    /** Gradients, patterns, filters and clips, which every layer uses. */
+    defs: string;
+    /** The studio behind, the clothes and the knitted head, which never move. */
+    back: string;
+    /** The eyes and a pompom, which blink, look and bounce. */
+    live: string;
+    /** The rims of the holes, the cuff's shadow and the hat, over the eyes, which never move. */
+    front: string;
+    blink: {
+        period: number;
+        delay: number;
+    };
+}
+/** `id` keeps each knit's patterns and clips its own where many share a page. */
+export declare function createKnit(name: string, overrides: Overrides | undefined, id?: string): Knit;
+/** The bust at rest, for thumbnails. */
+export declare function knitSvg(name: string, overrides?: Overrides): string;
+export {};

package/dist/knits/index.js

@@ -0,0 +1,445 @@
+/**
+ * Knits: a bust in a knitted balaclava and a ribbed beanie, after the reference's look. A soft
+ * studio grey behind, a coat over a white tee, the mask's knit running in fine ribs, and the eyes
+ * looking out through its holes from under heavy lids. It's drawn to feel modelled: every part is
+ * shaded as the form it is, a ball, a dome or a cylinder, under one soft light from up to the left,
+ * with soft shadows where parts meet, the beanie's ribs as tubes wrapping round it, and the yarn's
+ * edges fuzzy and its surface flecked. The eyes can blink and follow the pointer.
+ *
+ * It's drawn from numbers in the 100×100 frame, so the thumbnail is the very same picture.
+ */
+import { BLACK, mix, WHITE } from "../colors.js";
+import { calmed } from "../possibilities.js";
+import { createTraits } from "../traits.js";
+import { CALMING } from "./calming.js";
+const r2 = (value) => Math.round(value * 100) / 100;
+/** The reference's first. Neighbours are unlike. */
+export const BEANIES = ["#1b1b1f", "#c23a2e", "#d9a43a", "#20324f", "#3f5f3a", "#e9e4d8", "#6b3a5a", "#2f7f86"];
+export const MASKS = ["#a9aaac", "#26262b", "#d8d2c4", "#6c7558", "#d98fa0", "#8fa3b8", "#4a5a7a", "#efe7d2"];
+export const CLOTHES = ["#1c1c20", "#7b5a3c", "#2b3a55", "#5b6b4a", "#a8322d", "#cfcac0", "#3b3b42", "#c99a3e"];
+export const SKINS = ["#e3a980", "#f2c7a5", "#c98b5f", "#9c6340", "#6e4329", "#f5d6bf"];
+export const TILES = ["#d9dadd", "#e4ddd3", "#d3dbe3", "#e2d6dd", "#d6ded3", "#cfcfd4"];
+export const HATS = [
+    { name: "Cuffed", hat: "cuffed" },
+    { name: "Pompom", hat: "pompom" },
+    { name: "Watch cap", hat: "watch" },
+    { name: "Slouch", hat: "slouch" },
+    { name: "Bare", hat: "none" },
+];
+export const OPENINGS = [
+    { name: "Goggles", opening: "goggles" },
+    { name: "Three holes", opening: "three" },
+    { name: "Slot", opening: "slot" },
+    { name: "Open face", opening: "open" },
+    { name: "Two holes", opening: "holes" },
+];
+export const CLOTHING = [
+    { name: "Coat", clothing: "coat" },
+    { name: "Puffer", clothing: "puffer" },
+    { name: "Hoodie", clothing: "hoodie" },
+    { name: "Bomber", clothing: "bomber" },
+    { name: "Turtleneck", clothing: "turtleneck" },
+];
+/** The reference's bored glance first. Neighbours are unlike. */
+export const MOODS = [
+    { name: "Bored", lid: 0.5, tilt: 0, look: [-0.55, 0.35], pupil: 1 },
+    { name: "Wide", lid: 0.08, tilt: 0, look: [0, 0], pupil: 0.85 },
+    { name: "Sleepy", lid: 0.68, tilt: -4, look: [0, 0.5], pupil: 1 },
+    { name: "Side eye", lid: 0.38, tilt: 6, look: [0.8, 0.1], pupil: 1 },
+    { name: "Surprised", lid: 0, tilt: 0, look: [0, -0.2], pupil: 0.7 },
+    { name: "Suspicious", lid: 0.46, tilt: 14, look: [-0.7, 0], pupil: 0.95 },
+    { name: "Calm", lid: 0.3, tilt: -2, look: [0, 0.15], pupil: 1 },
+    { name: "Angry", lid: 0.36, tilt: 24, look: [0, 0], pupil: 0.9 },
+    { name: "Weary", lid: 0.58, tilt: -12, look: [0.3, 0.4], pupil: 1 },
+];
+export const knitTraits = (name, overrides) => calmed(createTraits(name, overrides), CALMING);
+export const hatOf = (t) => t.pick("hat", HATS).hat;
+export const openingOf = (t) => t.pick("opening", OPENINGS).opening;
+export const clothingOf = (t) => t.pick("clothing", CLOTHING).clothing;
+export const moodOf = (t) => t.pick("mood", MOODS);
+export function coloursOf(t) {
+    return {
+        beanie: t.color("beanie") ?? t.pick("beanie", BEANIES),
+        mask: t.color("mask") ?? t.pick("mask", MASKS),
+        clothes: t.color("clothes") ?? t.pick("clothes", CLOTHES),
+        skin: t.color("skin") ?? t.pick("skin", SKINS),
+        tile: t.color("tile") ?? t.pick("tile", TILES),
+    };
+}
+/** Points along `curve` from `x0` to `x1`, a unit or so apart, for a smooth edge. */
+function along(curve, x0, x1, lift = 0) {
+    const steps = Math.ceil(Math.abs(x1 - x0));
+    return Array.from({ length: steps + 1 }, (_, i) => {
+        const x = x0 + ((x1 - x0) * i) / steps;
+        return `${r2(x)} ${r2(curve(x) + lift)}`;
+    }).join("L");
+}
+/** A knit as a pattern of ribs `pitch` apart, each a light and a dark line on the yarn's colour. */
+function ribs(id, colour, pitch, depth = 1) {
+    const light = mix(colour, WHITE, 0.12 * depth);
+    const dark = mix(colour, BLACK, 0.16 * depth);
+    return (`<pattern id="${id}" patternUnits="userSpaceOnUse" width="${pitch}" height="${pitch * 3}">` +
+        `<rect width="${pitch}" height="${pitch * 3}" fill="${colour}"/>` +
+        `<rect x="${r2(pitch * 0.08)}" width="${r2(pitch * 0.38)}" height="${pitch * 3}" fill="${light}"/>` +
+        `<rect x="${r2(pitch * 0.62)}" width="${r2(pitch * 0.16)}" height="${pitch * 3}" fill="${dark}"/>` +
+        // The stitches: a small vee down each rib, which is what makes it read as knitted.
+        `<path d="M${r2(pitch * 0.08)} 0L${r2(pitch * 0.27)} ${r2(pitch * 0.5)}L${r2(pitch * 0.46)} 0M${r2(pitch * 0.08)} ${r2(pitch * 1.5)}L${r2(pitch * 0.27)} ${r2(pitch * 2)}L${r2(pitch * 0.46)} ${r2(pitch * 1.5)}" fill="none" stroke="${mix(colour, BLACK, 0.1)}" stroke-width="${r2(pitch * 0.07)}"/>` +
+        `</pattern>`);
+}
+/** Stops for a gradient, each `[offset, colour, opacity]`. */
+const stops = (list) => list.map(([offset, colour, opacity]) => `<stop offset="${offset}" stop-color="${colour}" stop-opacity="${opacity}"/>`).join("");
+/** Blurs `std` units wide, by name, with room round each part for the blur to spread. */
+const BLURS = { b4: 0.4, b8: 0.8, b14: 1.4, b24: 2.4 };
+const ROOM = `filterUnits="userSpaceOnUse" x="-10" y="-10" width="120" height="120"`;
+/** A soft stroke, a shadow or a gleam, along `d`. */
+const soft = (id, d, colour, opacity, width, blur) => `<path d="${d}" fill="none" stroke="${colour}" stroke-opacity="${opacity}" stroke-width="${width}" stroke-linecap="round" filter="url(#${id}-${blur})"/>`;
+/** The holes and the eyes in them, drawn larger than their numbers, as the reference's eyes are big. */
+const OPEN = `transform="translate(50 46) scale(1.22) translate(-50 -46)"`;
+/** The head in its mask: round on top, the knit bunched in folds over the cheeks, and a soft chin. */
+const HEAD = "M50 15.5C66.5 15.5 78.5 26 79.2 41.5C79.4 44 79.6 46 79.8 47.5Q82.6 50 80.2 52.6Q83 55.6 79.8 58.6Q82 61.8 77.8 64" +
+    "C73.5 68.6 62.5 71 50 71C37.5 71 26.5 68.6 22.2 64Q18 61.8 20.2 58.6Q17 55.6 19.8 52.6Q17.4 50 20.2 47.5" +
+    "C20.4 46 20.6 44 20.8 41.5C21.5 26 33.5 15.5 50 15.5Z";
+const NECK = "M39 61H61Q61.2 70 62.6 75.2Q50 78.6 37.4 75.2Q38.8 70 39 61Z";
+const BODY = "M19 104C19.5 90 24 80.5 35 75.6Q38.5 74.2 42 74H58Q61.5 74.2 65 75.6C76 80.5 80.5 90 81 104Z";
+const TEE = "M41.5 74H58.5L57 104H43Z";
+/** A pill from corner to corner, for the goggles' tall windows. */
+function pill(x0, y0, x1, y1) {
+    const r = (x1 - x0) / 2;
+    return `M${r2(x0 + r)} ${y0}A${r2(r)} ${r2(r)} 0 0 1 ${x1} ${r2(y0 + r)}V${r2(y1 - r)}A${r2(r)} ${r2(r)} 0 0 1 ${r2(x0 + r)} ${y1}A${r2(r)} ${r2(r)} 0 0 1 ${x0} ${r2(y1 - r)}V${r2(y0 + r)}A${r2(r)} ${r2(r)} 0 0 1 ${r2(x0 + r)} ${y0}Z`;
+}
+/** The holes in the mask, as paths, and the eyes in them. */
+function openingShape(opening) {
+    const eyes = (xs, y, rx, ry, open = 0, drop = 0, iris = 0.64) => xs.map((x) => ({ x, y, rx, ry, open, drop, iris }));
+    switch (opening) {
+        case "goggles":
+            // Two tall windows with a knitted bridge between them over the nose, as the reference's.
+            return { d: pill(36.9, 33.3, 47.95, 51.7) + pill(52.05, 33.3, 63.1, 51.7), eyes: eyes([42.43, 57.57], 42.5, 4.42, 8.1, 0.24, 0.2, 0.82) };
+        case "slot":
+            return { d: "M38 38.5H62Q69 38.5 69 45.5Q69 52 62 52H38Q31 52 31 45.5Q31 38.5 38 38.5Z", eyes: eyes([41.5, 58.5], 45.2, 5.2, 4.8) };
+        case "holes":
+            return { d: "M34.5 45.5A7 6.8 0 1 0 48.5 45.5A7 6.8 0 1 0 34.5 45.5ZM51.5 45.5A7 6.8 0 1 0 65.5 45.5A7 6.8 0 1 0 51.5 45.5Z", eyes: eyes([41.5, 58.5], 45.5, 5.6, 5.4) };
+        case "three":
+            return {
+                d: "M34.5 45A7 6.6 0 1 0 48.5 45A7 6.6 0 1 0 34.5 45ZM51.5 45A7 6.6 0 1 0 65.5 45A7 6.6 0 1 0 51.5 45ZM43.5 61.5A6.5 4 0 1 0 56.5 61.5A6.5 4 0 1 0 43.5 61.5Z",
+                eyes: eyes([41.5, 58.5], 45, 5.6, 5.2),
+                mouth: true,
+            };
+        case "open":
+            return { d: "M50 36Q67 36 67 50Q67 66 50 66Q33 66 33 50Q33 36 50 36Z", eyes: eyes([42, 58], 46, 5, 4.2), mouth: true, nose: true };
+    }
+}
+/** The eye as a rect with rounded ends, which is an ellipse or a pill as its shape asks. */
+const eyeRect = (e, grow = 0) => `x="${r2(e.x - e.rx - grow)}" y="${r2(e.y - e.ry - grow)}" width="${r2(2 * (e.rx + grow))}" height="${r2(2 * (e.ry + grow))}" rx="${r2(e.rx + grow)}" ry="${r2(Math.min(e.rx, e.ry) + grow)}"`;
+/** The eyes: shaded whites, big dark pupils that can look about, and heavy skin lids that set the mood and blink. */
+function eyesMarkup(id, m, eyes) {
+    return eyes
+        .map((e, i) => {
+        const side = i === 0 ? -1 : 1;
+        const clip = `${id}-eye${i}`;
+        const radius = e.rx * e.iris * m.pupil;
+        const [px, py] = [e.x + m.look[0] * e.rx * 0.36, e.y + e.ry * e.drop + m.look[1] * e.ry * 0.3];
+        // The lid's rect runs from above the eye down past it; scaling it from its top drops its edge.
+        const top = e.y - e.ry - 0.4;
+        const height = 2 * e.ry + 0.8;
+        const edge = e.y - e.ry + 2 * e.ry * (e.open + (1 - e.open) * m.lid);
+        const scale = (edge - top) / height;
+        const layer = (fill, stretch, opacity = 1) => `<rect class="lid" x="${r2(e.x - e.rx * 2.2)}" y="${r2(top)}" width="${r2(e.rx * 4.4)}" height="${r2(height * stretch)}" fill="${fill}"${opacity < 1 ? ` fill-opacity="${opacity}"` : ""} style="--lid:${r2(scale)}" transform="translate(0 ${r2(top)}) scale(1 ${r2(scale)}) translate(0 ${r2(-top)})"/>`;
+        return (`<g class="eye" data-eye="${i}">` +
+            `<clipPath id="${clip}"><rect ${eyeRect(e)}/></clipPath>` +
+            `<rect ${eyeRect(e)} fill="url(#${id}-white)"/>` +
+            `<g clip-path="url(#${clip})">` +
+            `<g class="pupil"><circle cx="${r2(px)}" cy="${r2(py)}" r="${r2(radius)}" fill="url(#${id}-pupil)"/>` +
+            `<circle cx="${r2(px + radius * 0.38)}" cy="${r2(py - radius * 0.4)}" r="${r2(radius * 0.17)}" fill="#ffffff" fill-opacity="0.9"/>` +
+            `<circle cx="${r2(px - radius * 0.35)}" cy="${r2(py + radius * 0.45)}" r="${r2(radius * 0.22)}" fill="#ffffff" fill-opacity="0.12"/></g>` +
+            // The eyeball turns away into shadow round its edge.
+            `<rect ${eyeRect(e)} fill="url(#${id}-eyeball)"/>` +
+            // The lid's shadow across the white, soft and then deeper, its dark edge, and the lid itself.
+            `<g transform="rotate(${r2(-side * m.tilt)} ${r2(e.x)} ${r2(e.y)})"><g class="lids">` +
+            `${layer("#2a1810", 1.14, 0.1)}${layer("#2a1810", 1.06, 0.16)}${layer(`url(#${id}-lash)`, 1.02)}${layer(`url(#${id}-lid)`, 1)}` +
+            `</g></g>` +
+            `</g></g>`);
+    })
+        .join("");
+}
+function bandOf(hat) {
+    // The top arches up in the middle; the bottom wraps down round the sides of the head.
+    const arch = (x0, x1, sides, middle) => (x) => {
+        const t = (x - x0) / (x1 - x0);
+        return sides - 4 * (sides - middle) * t * (1 - t);
+    };
+    const wrap = (middle, sides, half) => (x) => middle + (sides - middle) * Math.abs((x - 50) / half) ** 2.6;
+    switch (hat) {
+        case "none":
+            return undefined;
+        case "watch":
+            return { x0: 22, x1: 78, top: arch(22, 78, 23, 18.5), bottom: wrap(30.5, 40, 28), peak: [50, 11.5] };
+        case "slouch": {
+            const bottom = wrap(35, 47, 29);
+            return { x0: 20.5, x1: 79.5, top: (x) => bottom(x) - 6.5, bottom, peak: [56, 2.5] };
+        }
+        default:
+            return { x0: 20.5, x1: 79.5, top: arch(20.5, 79.5, 24.5, 19.5), bottom: wrap(35, 47, 29), peak: [50, hat === "pompom" ? 9.5 : 8] };
+    }
+}
+/** Ribs round a cylinder, `count` of them: where each groove falls across the front, and how square on it is. */
+const around = (count) => Array.from({ length: count - 1 }, (_, k) => {
+    const angle = -Math.PI / 2 + ((k + 1) * Math.PI) / count;
+    return { sin: Math.sin(angle), cos: Math.cos(angle), angle };
+});
+/** The light comes from up to the left, so a rib facing that way catches it. */
+const lit = (angle) => Math.max(0, Math.cos(angle + 0.45));
+/** The beanie: a ribbed crown and a thick turned-up cuff, each rib a soft tube, round the head. */
+function hatMarkup(id, hat, band) {
+    const { x0, x1, top, bottom, peak } = band;
+    const [px, py] = peak;
+    const half = (x1 - x0) / 2;
+    const inset = hat === "slouch" ? 1.5 : 4.5;
+    const [l, r] = [x0 + inset, x1 - inset];
+    const [ly, ry] = [top(l), top(r)];
+    const crown = hat === "slouch"
+        ? `M${l} ${r2(ly + 1)}C${l - 2} ${py + 12} ${px - 20} ${py} ${px} ${py}C${px + 16} ${py} ${r + 5} ${py + 8} ${r + 1.5} ${py + 16}C${r + 0.5} ${r2(ry - 6)} ${r} ${r2(ry - 2)} ${r} ${r2(ry + 1)}Z`
+        : `M${l} ${r2(ly + 2)}C${l - 1} ${r2(py + (ly - py) * 0.5)} ${px - 12.5} ${py} ${px} ${py}C${px + 12.5} ${py} ${r + 1} ${r2(py + (ry - py) * 0.5)} ${r} ${r2(ry + 2)}Z`;
+    const bandPath = 
+    // Its top corners round over into its sides.
+    `M${x0} ${r2(top(x0) + 3)}Q${x0} ${r2(top(x0))} ${x0 + 3} ${r2(top(x0 + 3))}L${along(top, x0 + 3, x1 - 3)}Q${x1} ${r2(top(x1))} ${x1} ${r2(top(x1) + 3)}` +
+        `Q${x1 + 2.6} ${r2((top(x1) + bottom(x1)) / 2 + 1.5)} ${x1 - 0.6} ${r2(bottom(x1 - 0.6))}` +
+        `L${along(bottom, x1 - 0.6, x0 + 0.6)}Q${x0 - 2.6} ${r2((top(x0) + bottom(x0)) / 2 + 1.5)} ${x0} ${r2(top(x0) + 3)}Z`;
+    // The crown's ribs run up to its peak like lines of longitude.
+    const crownRibs = around(12)
+        .map(({ sin, cos, angle }) => {
+        const xb = 50 + (half - inset) * sin;
+        const yb = top(xb) + 1;
+        const start = `M${r2(px + (xb - 50) * 0.08)} ${py + 1}`;
+        const bend = `Q${r2(xb + (xb - 50) * 0.08 + (px - 50) * 0.4)} ${r2(py + (yb - py) * 0.45)} ${r2(xb)} ${r2(yb)}`;
+        const gleam = 50 + (half - inset) * Math.sin(angle + Math.PI / 24 - 0.05);
+        const gb = top(gleam) + 1;
+        return (soft(id, start + bend, "#000000", 0.5, r2(0.35 + 0.8 * cos), "b4") +
+            soft(id, `M${r2(px + (gleam - 50) * 0.08)} ${py + 2}Q${r2(gleam + (gleam - 50) * 0.08 + (px - 50) * 0.4)} ${r2(py + (gb - py) * 0.45)} ${r2(gleam)} ${r2(gb)}`, "#ffffff", r2(0.03 + 0.12 * lit(angle)), r2(0.5 + 1.2 * cos), "b8"));
+    })
+        .join("");
+    // The cuff's ribs are bigger and plumper, packed closer towards the sides as it turns away.
+    const step = Math.PI / 14;
+    const cuffRibs = around(14)
+        .map(({ sin, cos, angle }) => {
+        const xt = 50 + half * sin;
+        const xb = 50 + (half - 0.8) * sin;
+        const mid = (top(xt) + bottom(xt)) / 2;
+        const groove = `M${r2(xt)} ${r2(top(xt) + 0.2)}Q${r2(50 + (half + 0.6) * sin)} ${r2(mid)} ${r2(xb)} ${r2(bottom(xb) - 0.2)}`;
+        // The rib to the left of this groove, lit on its upper left.
+        const g = Math.sin(angle - step * 0.62);
+        const gt = 50 + half * g;
+        const gb = 50 + (half - 0.8) * g;
+        const gleam = `M${r2(gt)} ${r2(top(gt) + 1.2)}Q${r2(50 + (half + 0.6) * g)} ${r2((top(gt) + bottom(gt)) / 2)} ${r2(gb)} ${r2(bottom(gb) - 1.4)}`;
+        return soft(id, groove, "#000000", 0.55, r2(0.4 + 0.9 * cos), "b4") + soft(id, gleam, "#ffffff", r2(0.05 + 0.2 * lit(angle - step)), r2(0.6 + 2 * cos), "b8");
+    })
+        .join("");
+    return (`<g filter="url(#${id}-fuzz)">` +
+        `<clipPath id="${id}-crown"><path d="${crown}"/></clipPath>` +
+        `<path d="${crown}" fill="url(#${id}-beanie)"/>` +
+        `<g clip-path="url(#${id}-crown)">${crownRibs}<path d="${crown}" fill="url(#${id}-dome)"/></g>` +
+        `<clipPath id="${id}-band"><path d="${bandPath}"/></clipPath>` +
+        `<path d="${bandPath}" fill="url(#${id}-beanie)"/>` +
+        `<g clip-path="url(#${id}-band)">${cuffRibs}` +
+        `<path d="${bandPath}" fill="url(#${id}-round)"/>` +
+        // The crown's shadow where it meets the cuff, the cuff's fold catching the light, and its edge curling under.
+        soft(id, `M${along(top, x0, x1, -0.3)}`, "#000000", 0.6, 1.6, "b8") +
+        soft(id, `M${along(top, x0 + 3, x1 - 3, 1.8)}`, "#ffffff", 0.14, 2, "b14") +
+        soft(id, `M${along(bottom, x0, x1, -0.4)}`, "#000000", 0.45, 2.6, "b14") +
+        `</g></g>`);
+}
+/** The pompom: a fluffy ball of yarn on the crown, drawn live so a tap can bounce it. */
+function pompomMarkup(id, band) {
+    const [cx, cy] = [band.peak[0], band.peak[1] - 3.4];
+    const tufts = Array.from({ length: 18 }, (_, i) => {
+        const a = (i / 18) * Math.PI * 2;
+        const reach = 4.3 + (i % 3) * 0.35;
+        return `<circle cx="${r2(cx + Math.cos(a) * reach)}" cy="${r2(cy + Math.sin(a) * reach * 0.9)}" r="${r2(2.1 + (i % 2) * 0.3)}" fill="url(#${id}-pom)"/>`;
+    }).join("");
+    return `<g class="pompom">${tufts}<circle cx="${cx}" cy="${r2(cy)}" r="4.9" fill="url(#${id}-pom)"/></g>`;
+}
+/** The clothes, from the shoulders down, in two parts: what's behind the mask's neck, and what wraps in front of it. */
+function clothesMarkup(id, clothing, c) {
+    const cloth = c.clothes;
+    const dark = mix(cloth, BLACK, 0.4);
+    const body = `<path d="${BODY}" fill="${cloth}"/>`;
+    const tee = `<path d="${TEE}" fill="#ecebe7"/><path d="${TEE}" fill="url(#${id}-tee)"/>`;
+    // Light on the shoulders, more on the left, and the body rounding away at its sides.
+    const form = soft(id, "M21.5 96C22.8 86 27 80 35.5 76.2", "#ffffff", 0.16, 2.4, "b14") +
+        soft(id, "M78.5 96C77.2 86 73 80 64.5 76.2", "#ffffff", 0.07, 2.4, "b14") +
+        `<path d="${BODY}" fill="url(#${id}-round)"/>`;
+    switch (clothing) {
+        case "coat": {
+            const lapel = mix(cloth, WHITE, 0.05);
+            return {
+                under: body + tee +
+                    // The lapels' shadows on the tee and on the coat.
+                    soft(id, "M42.6 74.6Q45.3 88 47.6 104", "#000000", 0.3, 1.8, "b8") + soft(id, "M57.4 74.6Q54.7 88 52.4 104", "#000000", 0.3, 1.8, "b8") +
+                    soft(id, "M33.6 84.6Q38 93.5 41.2 104", "#000000", 0.5, 1.6, "b8") + soft(id, "M66.4 84.6Q62 93.5 58.8 104", "#000000", 0.5, 1.6, "b8") +
+                    `<path d="M35.2 75.4L41.6 74.2Q44.4 88 46.6 104H41Q37.8 93 33.2 84L36.9 81.6Z" fill="${lapel}"/>` +
+                    `<path d="M64.8 75.4L58.4 74.2Q55.6 88 53.4 104H59Q62.2 93 66.8 84L63.1 81.6Z" fill="${lapel}"/>` +
+                    soft(id, "M41.2 75Q44 88 46.2 104", "#ffffff", 0.16, 0.7, "b4") + soft(id, "M58.8 75Q56 88 53.8 104", "#ffffff", 0.08, 0.7, "b4") +
+                    soft(id, "M33.6 84.2L36.9 81.6", "#000000", 0.45, 0.6, "b4") + soft(id, "M66.4 84.2L63.1 81.6", "#000000", 0.45, 0.6, "b4") +
+                    form,
+                over: "",
+            };
+        }
+        case "hoodie":
+            // The hood gathered round the neck behind, and its strings hanging in front.
+            return {
+                under: body +
+                    `<path d="M29 77.5Q31 70.5 40 69.5H60Q69 70.5 71 77.5Q66 83.5 50 84Q34 83.5 29 77.5Z" fill="${mix(cloth, WHITE, 0.04)}"/>` +
+                    `<path d="M35.5 75Q50 70 64.5 75Q60.5 81 50 81.5Q39.5 81 35.5 75Z" fill="${dark}"/>` +
+                    soft(id, "M30 78Q36 84 50 84.2Q64 84 70 78", "#000000", 0.45, 1.6, "b8") +
+                    soft(id, "M31.5 75.5Q33 71.5 39 70.8", "#ffffff", 0.18, 1.4, "b8") +
+                    soft(id, "M33 79.5Q37 76.5 36.5 73M67 79.5Q63 76.5 63.5 73", "#000000", 0.3, 0.8, "b4") +
+                    form,
+                over: soft(id, "M45.3 80Q44.8 88 45.4 95.5M56.3 80Q56.8 88 56.2 95.5", "#000000", 0.35, 1.4, "b8") +
+                    `<path d="M44.5 79.5Q44 88 44.6 95M55.5 79.5Q56 88 55.4 95" fill="none" stroke="#efece6" stroke-width="1.1" stroke-linecap="round"/>` +
+                    `<rect x="43.8" y="94.4" width="1.6" height="3" rx="0.6" fill="#c9c5bd"/><rect x="54.6" y="94.4" width="1.6" height="3" rx="0.6" fill="#c9c5bd"/>`,
+            };
+        case "puffer":
+            return {
+                under: body +
+                    `<clipPath id="${id}-body"><path d="${BODY}"/></clipPath><g clip-path="url(#${id}-body)">` +
+                    [82, 89, 96, 103]
+                        .map((y) => soft(id, `M18 ${y - 3.6}Q50 ${y - 0.6} 82 ${y - 3.6}`, "#ffffff", 0.16, 3, "b14") + soft(id, `M14 ${y}Q50 ${y + 3} 86 ${y}`, "#000000", 0.55, 1, "b4"))
+                        .join("") +
+                    `</g>` +
+                    soft(id, "M50 77V104", "#000000", 0.5, 0.9, "b4") +
+                    form,
+                // A standing collar, zipped up round the neck.
+                over: `<path d="M36.5 72.5Q50 76.5 63.5 72.5L64 79.5Q50 83.5 36 79.5Z" fill="${cloth}"/><path d="M36.5 72.5Q50 76.5 63.5 72.5L64 79.5Q50 83.5 36 79.5Z" fill="url(#${id}-round)"/>` +
+                    soft(id, "M37.5 74.5Q50 78.2 62.5 74.5", "#ffffff", 0.2, 1.4, "b8") +
+                    soft(id, "M36.5 80Q50 84 63.5 80", "#000000", 0.45, 1.4, "b8") +
+                    soft(id, "M50 77.5V83", "#000000", 0.5, 0.7, "b4"),
+            };
+        case "turtleneck":
+            return {
+                under: `<path d="${BODY}" fill="url(#${id}-cloth)"/>` + form,
+                // The rolled collar, folded over the mask's neck.
+                over: `<path d="M36 72.5Q50 70.5 64 72.5Q65.5 76.5 63.5 80Q50 83 36.5 80Q34.5 76.5 36 72.5Z" fill="url(#${id}-cloth)"/>` +
+                    `<path d="M36 72.5Q50 70.5 64 72.5Q65.5 76.5 63.5 80Q50 83 36.5 80Q34.5 76.5 36 72.5Z" fill="url(#${id}-round)"/>` +
+                    soft(id, "M37 74Q50 72.4 63 74", "#ffffff", 0.18, 1.6, "b8") +
+                    soft(id, "M36.5 80.4Q50 83.6 63.5 80.4", "#000000", 0.5, 1.6, "b8"),
+            };
+        case "bomber":
+            return {
+                under: body + tee +
+                    soft(id, "M42.5 86Q43.3 95 44 104M57.5 86Q56.7 95 56 104", "#000000", 0.35, 1.8, "b8") +
+                    // The open front, its zip tapes, and the knitted collar.
+                    `<path d="M41.5 86L43 104H39.5L37.5 86.5Z" fill="${cloth}"/><path d="M58.5 86L57 104H60.5L62.5 86.5Z" fill="${cloth}"/>` +
+                    soft(id, "M41.6 86.5L43 103.5M58.4 86.5L57 103.5", "#000000", 0.6, 0.6, "b4") +
+                    `<path d="M34.5 75.5Q41 78.5 41.5 86L39.5 86.5Q38.6 80.5 32.5 77.5Z" fill="url(#${id}-cloth)"/>` +
+                    `<path d="M65.5 75.5Q59 78.5 58.5 86L60.5 86.5Q61.4 80.5 67.5 77.5Z" fill="url(#${id}-cloth)"/>` +
+                    form,
+                over: "",
+            };
+    }
+}
+/** `id` keeps each knit's patterns and clips its own where many share a page. */
+export function createKnit(name, overrides, id = "knit") {
+    const t = knitTraits(name, overrides);
+    const c = coloursOf(t);
+    const hat = hatOf(t);
+    const band = bandOf(hat);
+    const opening = openingShape(openingOf(t));
+    const mood = moodOf(t);
+    const clothes = clothesMarkup(id, clothingOf(t), c);
+    const knit = `url(#${id}-mask)`;
+    const skinDark = mix(c.skin, BLACK, 0.32);
+    const blurs = Object.entries(BLURS)
+        .map(([key, std]) => `<filter id="${id}-${key}" ${ROOM}><feGaussianBlur stdDeviation="${std}"/></filter>`)
+        .join("");
+    const defs = `<defs>` +
+        // The mask's knit is fine and soft, the beanie's a fine stitch under its big ribs, as in the reference.
+        ribs(`${id}-mask`, c.mask, 1, 0.65) +
+        ribs(`${id}-beanie`, c.beanie, 0.9, 0.55) +
+        ribs(`${id}-cloth`, c.clothes, 2.4) +
+        blurs +
+        // Yarn: its edges a little fuzzy, and its surface flecked.
+        `<filter id="${id}-fuzz" ${ROOM}>` +
+        `<feTurbulence type="fractalNoise" baseFrequency="1.6" numOctaves="2" seed="3" result="wobble"/>` +
+        `<feDisplacementMap in="SourceGraphic" in2="wobble" scale="0.32" xChannelSelector="R" yChannelSelector="G" result="fuzzy"/>` +
+        `<feTurbulence type="fractalNoise" baseFrequency="3.2" numOctaves="1" seed="7" result="fleck"/>` +
+        `<feColorMatrix in="fleck" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.5 0 0 0 -0.18" result="specks"/>` +
+        `<feComposite in="specks" in2="fuzzy" operator="in" result="flecked"/>` +
+        `<feMerge><feMergeNode in="fuzzy"/><feMergeNode in="flecked"/></feMerge></filter>` +
+        // The light, up to the left: a ball for the head, a dome for the crown, a cylinder for the rest.
+        `<radialGradient id="${id}-ball" cx="0.42" cy="0.36" r="0.66">${stops([[0, WHITE, 0.26], [0.45, WHITE, 0.04], [0.8, BLACK, 0.1], [1, BLACK, 0.3]])}</radialGradient>` +
+        `<linearGradient id="${id}-under" x1="0" y1="0" x2="0" y2="1">${stops([[0.7, BLACK, 0], [1, BLACK, 0.26]])}</linearGradient>` +
+        `<radialGradient id="${id}-dome" cx="0.4" cy="0.3" r="0.8">${stops([[0, WHITE, 0.16], [0.4, WHITE, 0], [0.8, BLACK, 0.3], [1, BLACK, 0.5]])}</radialGradient>` +
+        `<linearGradient id="${id}-round" x1="0" y1="0" x2="1" y2="0">${stops([[0, BLACK, 0.5], [0.12, BLACK, 0.16], [0.3, WHITE, 0.1], [0.46, WHITE, 0.03], [0.7, BLACK, 0.08], [0.88, BLACK, 0.3], [1, BLACK, 0.55]])}</linearGradient>` +
+        `<linearGradient id="${id}-tee" x1="0" y1="0" x2="1" y2="0">${stops([[0, BLACK, 0.2], [0.3, BLACK, 0], [0.7, BLACK, 0.02], [1, BLACK, 0.26]])}</linearGradient>` +
+        `<radialGradient id="${id}-pom" cx="0.38" cy="0.32" r="0.7">${stops([[0, mix(c.beanie, WHITE, 0.3), 1], [0.55, c.beanie, 1], [1, mix(c.beanie, BLACK, 0.4), 1]])}</radialGradient>` +
+        // The skin in the holes, and the eyes: their whites in the lids' shade, dark pupils, lids lit from above.
+        `<linearGradient id="${id}-skin" x1="0" y1="0" x2="0" y2="1">${stops([[0, mix(c.skin, BLACK, 0.18), 1], [0.5, c.skin, 1], [1, mix(c.skin, WHITE, 0.12), 1]])}</linearGradient>` +
+        `<linearGradient id="${id}-white" x1="0" y1="0" x2="0" y2="1">${stops([[0, "#c9c3be", 1], [0.4, "#eae6e2", 1], [0.78, "#f8f6f3", 1], [1, "#ddd8d3", 1]])}</linearGradient>` +
+        `<radialGradient id="${id}-eyeball" cx="0.5" cy="0.6" r="0.62">${stops([[0, BLACK, 0], [0.72, BLACK, 0], [1, BLACK, 0.24]])}</radialGradient>` +
+        `<radialGradient id="${id}-pupil" cx="0.42" cy="0.38" r="0.65">${stops([[0, "#2b1a12", 1], [0.7, "#120a07", 1], [1, "#070403", 1]])}</radialGradient>` +
+        `<linearGradient id="${id}-lid" x1="0" y1="0" x2="0" y2="1">${stops([[0, mix(c.skin, WHITE, 0.14), 1], [0.55, c.skin, 1], [0.9, mix(c.skin, BLACK, 0.14), 1], [0.97, mix(c.skin, WHITE, 0.06), 1], [1, mix(c.skin, BLACK, 0.2), 1]])}</linearGradient>` +
+        `<linearGradient id="${id}-lash" x1="0" y1="0" x2="0" y2="1">${stops([[0, mix(c.skin, BLACK, 0.5), 1], [1, mix(c.skin, BLACK, 0.62), 1]])}</linearGradient>` +
+        `<linearGradient id="${id}-studio" x1="0" y1="0" x2="0" y2="1">${stops([[0, mix(c.tile, WHITE, 0.3), 1], [0.55, c.tile, 1], [1, mix(c.tile, BLACK, 0.1), 1]])}</linearGradient>` +
+        `<radialGradient id="${id}-light" cx="0.45" cy="0.35" r="0.7">${stops([[0, WHITE, 0.22], [1, WHITE, 0]])}</radialGradient>` +
+        `<clipPath id="${id}-tile"><rect width="100" height="100" rx="22.22"/></clipPath>` +
+        `<clipPath id="${id}-head"><path d="${HEAD}"/></clipPath>` +
+        // Used inside the holes' own enlarging group, so it isn't enlarged again here.
+        `<clipPath id="${id}-holes"><path d="${opening.d}"/></clipPath>` +
+        `</defs>`;
+    // The knit bunches in folds over the cheeks: a crease under each fold, and light on its top.
+    const folds = [52.6, 58.6, 64]
+        .map((y, i) => soft(id, `M19.5 ${y}Q23.5 ${y - 0.6} ${27 - i} ${y + 0.8}`, "#000000", 0.32, 1, "b8") +
+        soft(id, `M80.5 ${y}Q76.5 ${y - 0.6} ${73 + i} ${y + 0.8}`, "#000000", 0.38, 1, "b8") +
+        soft(id, `M18.6 ${y - 3}Q21.5 ${y - 3.6} 24.5 ${y - 2.6}`, "#ffffff", 0.2, 1.2, "b8") +
+        soft(id, `M81.4 ${y - 3}Q78.5 ${y - 3.6} 75.5 ${y - 2.6}`, "#ffffff", 0.1, 1.2, "b8"))
+        .join("");
+    // Bare, the mask's knit gathers to a point on top of the head.
+    const gather = band
+        ? ""
+        : [-1, -0.4, 0.4, 1].map((s) => soft(id, `M50 16.4Q${r2(50 + s * 6)} 18.5 ${r2(50 + s * 11)} ${r2(24 + Math.abs(s) * 2)}`, "#000000", 0.28, 0.7, "b4")).join("");
+    const head = `<g filter="url(#${id}-fuzz)">` +
+        `<path d="${NECK}" fill="${knit}"/><path d="${NECK}" fill="url(#${id}-round)"/>` +
+        soft(id, "M39.4 72.8Q50 75 60.6 72.8", "#ffffff", 0.14, 1.4, "b8") +
+        soft(id, "M39 75.2Q50 77.6 61 75.2", "#000000", 0.35, 1.2, "b4") +
+        `</g>` +
+        clothes.over +
+        // The chin's shadow on the neck.
+        `<ellipse cx="50" cy="70" rx="15" ry="3" fill="#000000" fill-opacity="0.42" filter="url(#${id}-b14)"/>` +
+        `<g filter="url(#${id}-fuzz)">` +
+        `<path d="${HEAD}" fill="${knit}"/><path d="${HEAD}" fill="url(#${id}-ball)"/><path d="${HEAD}" fill="url(#${id}-under)"/>` +
+        `<g clip-path="url(#${id}-head)">${folds}${gather}</g>` +
+        `</g>`;
+    // The skin seen through the holes, shaded where the knit's edge overhangs it, and round each eye's socket.
+    const skin = `<g ${OPEN}><path d="${opening.d}" fill="url(#${id}-skin)"/>` +
+        `<g clip-path="url(#${id}-holes)">` +
+        opening.eyes.map((e) => `<rect ${eyeRect(e, 0.3)} fill="none" stroke="${skinDark}" stroke-opacity="0.5" stroke-width="1.2" filter="url(#${id}-b4)"/>`).join("") +
+        opening.eyes.map((e) => `<rect ${eyeRect(e, 0.5)} transform="translate(0 0.6)" fill="none" stroke="#ffffff" stroke-opacity="0.22" stroke-width="0.8" filter="url(#${id}-b4)"/>`).join("") +
+        (opening.nose ? soft(id, "M48.5 52Q50 57 47.5 58.5Q50 59.8 52.5 58.5Q50 57 51.5 52", skinDark, 0.8, 0.7, "b4") : "") +
+        (opening.mouth ? `<path d="M45.5 ${opening.nose ? 61.5 : 61.8}Q50 ${opening.nose ? 63.4 : 63.2} 54.5 ${opening.nose ? 61.5 : 61.8}" fill="none" stroke="${mix(c.skin, "#7a2d2d", 0.55)}" stroke-width="0.9" stroke-linecap="round"/>` : "") +
+        `<path d="${opening.d}" fill="none" stroke="#000000" stroke-opacity="0.45" stroke-width="2.6" filter="url(#${id}-b8)"/>` +
+        `</g></g>`;
+    return {
+        defs,
+        back: `<g clip-path="url(#${id}-tile)"><rect width="100" height="100" fill="url(#${id}-studio)"/><rect width="100" height="100" fill="url(#${id}-light)"/>` +
+            clothes.under +
+            // The neck's shadow on the clothes.
+            `<ellipse cx="50" cy="76.6" rx="12.5" ry="2.6" fill="#000000" fill-opacity="0.4" filter="url(#${id}-b14)"/>` +
+            head +
+            skin +
+            `</g>`,
+        live: (band && hat === "pompom" ? pompomMarkup(id, band) : "") + `<g ${OPEN}>${eyesMarkup(id, mood, opening.eyes)}</g>`,
+        front: `<g clip-path="url(#${id}-tile)">` +
+            // The knit's cut edge, rolled a little thick round each hole.
+            `<g filter="url(#${id}-fuzz)"><g ${OPEN}><path d="${opening.d}" fill="none" stroke="${mix(c.mask, WHITE, 0.06)}" stroke-width="0.9"/>` +
+            `<path d="${opening.d}" fill="none" stroke="${mix(c.mask, BLACK, 0.35)}" stroke-width="0.35" stroke-opacity="0.5"/></g></g>` +
+            // The cuff's shadow, cast down over the face and the tops of the eyes.
+            (band ? `<g clip-path="url(#${id}-head)">${soft(id, `M${along(band.bottom, band.x0, band.x1, 1.2)}`, "#000000", 0.5, 3.6, "b14")}</g>` : "") +
+            (band ? hatMarkup(id, hat, band) : "") +
+            `</g>`,
+        blink: { period: r2(t.num("blink.period", 3.6, 6.2)), delay: r2(t.num("blink.delay", 0, 3)) },
+    };
+}
+/** The bust at rest, for thumbnails. */
+export function knitSvg(name, overrides) {
+    const k = createKnit(name, overrides);
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">${k.defs}${k.back}${k.live}${k.front}</svg>`;
+}

package/dist/mallows/calming.d.ts

@@ -0,0 +1,8 @@
+/**
+ * What Possibilities calms on a mallow. Each type is its reference, so it calms the feeling,
+ * keeping the eight gentlest at the lowest, one for each variant, and the pose and the blush.
+ * Indices are into each type's lists, which are in the same order.
+ */
+import type { Calming } from "../possibilities.ts";
+export declare const CALMING: Calming;
+export declare const NOTES: [string, string, string];

package/dist/mallows/calming.js

@@ -0,0 +1,19 @@
+/**
+ * What Possibilities calms on a mallow. Each type is its reference, so it calms the feeling,
+ * keeping the eight gentlest at the lowest, one for each variant, and the pose and the blush.
+ * Indices are into each type's lists, which are in the same order.
+ */
+export const CALMING = {
+    lists: {
+        // Content, Bliss, Shy, Joy, Wink, Sleepy, Wow, Cheeky, then Laugh, Sad, Worried and Grumpy.
+        face: [12, 8, [0, 9, 8, 5, 7, 4, 3, 11, 1, 2, 10, 6]],
+        // Each type's reference pose and its quietest, then the raised ones.
+        pose: [4, 2],
+    },
+    rarer: ["blush"],
+};
+export const NOTES = [
+    "only gentle, happy feelings, each type's own eyes, its arms or hands at rest, and no blush.",
+    "more feelings, cheeky ones too, other types' eyes, and the odd wave.",
+    "every feeling, sad, worried and grumpy too, every eye and every pose.",
+];

package/dist/mallows/controls.d.ts

@@ -0,0 +1,2 @@
+import { type ControlBuilder } from "../controls.ts";
+export declare const controls: ControlBuilder;