@johnmorrisdotca/dougu-sports 0.8.0 → 0.10.0

package/dist/emblems/ball/ball.index.js

@@ -1,6 +1,5 @@
 import { escape, num, resolveOptions, PIECE_INK } from "./ball.core.js";
 import { BALL_AFL } from "./ball.afl.js";
-import { BALL_BASEBALL } from "./ball.baseball.js";
 import { BALL_BASKETBALL } from "./ball.basketball.js";
 import { BALL_BASKETBALL_3X3 } from "./ball.basketball3x3.js";
 import { BALL_BASKETBALL_6 } from "./ball.basketball6.js";
@@ -17,16 +16,15 @@ import { BALL_PADEL } from "./ball.padel.js";
 import { BALL_PICKLEBALL_OUTDOOR, BALL_PICKLEBALL_INDOOR } from "./ball.pickleball.js";
 import { BALL_PUCK } from "./ball.puck.js";
 import { PUCKS } from "./ball.puck.print.js";
+import { BALL_BASEBALL, BALL_SOCCER, BALL_SOCCER_COLOUR, BALL_SOCCER_ORANGE, BALL_SOCCER_YELLOW, BALL_SOFTBALL } from "./ball.printable.js";
 import { BALL_ROUNDNET } from "./ball.roundnet.js";
 import { BALL_RUGBY } from "./ball.rugby.js";
 import { BALL_SEPAK_TAKRAW } from "./ball.sepaktakraw.js";
 import { BALL_SHUTTLECOCK_FEATHER, BALL_SHUTTLECOCK_NYLON } from "./ball.shuttlecock.js";
 import { BALL_SLIOTAR } from "./ball.sliotar.js";
 import { BALL_LACROSSE, BALL_RACQUETBALL, BALL_TABLE_TENNIS, BALL_SHOT } from "./ball.smooth.js";
-import { BALL_SOCCER, BALL_SOCCER_COLOUR } from "./ball.soccer.js";
-import { BALL_SOCCER_26, BALL_SOCCER_18, BALL_SOCCER_14, BALL_SOCCER_12, BALL_SOCCER_6, BALL_SOCCER_ORANGE, BALL_SOCCER_26_ORANGE, BALL_SOCCER_18_ORANGE, BALL_SOCCER_14_ORANGE, BALL_SOCCER_12_ORANGE, BALL_SOCCER_6_ORANGE, BALL_SOCCER_YELLOW, BALL_SOCCER_26_YELLOW, BALL_SOCCER_18_YELLOW, BALL_SOCCER_14_YELLOW, BALL_SOCCER_12_YELLOW, BALL_SOCCER_6_YELLOW } from "./ball.soccer.panels.js";
+import { BALL_SOCCER_26, BALL_SOCCER_18, BALL_SOCCER_14, BALL_SOCCER_12, BALL_SOCCER_6, BALL_SOCCER_26_ORANGE, BALL_SOCCER_18_ORANGE, BALL_SOCCER_14_ORANGE, BALL_SOCCER_12_ORANGE, BALL_SOCCER_6_ORANGE, BALL_SOCCER_26_YELLOW, BALL_SOCCER_18_YELLOW, BALL_SOCCER_14_YELLOW, BALL_SOCCER_12_YELLOW, BALL_SOCCER_6_YELLOW } from "./ball.soccer.panels.js";
 import { BALL_FUTSAL, BALL_BEACH_SOCCER } from "./ball.soccer.indoor.js";
-import { BALL_SOFTBALL } from "./ball.softball.js";
 import { BALL_SOCCER_1870_HAND_STITCHED, BALL_SOCCER_1900_LACED, BALL_SOCCER_1930_18_PANEL, BALL_SOCCER_1950_12_PANEL, BALL_SOCCER_1960_32_PANEL_LEATHER } from "./ball.soccer.vintage.js";
 import { BALL_SOCCER_1970_BLACK_WHITE, BALL_SOCCER_1978_TRIAD, BALL_SOCCER_1986_DECORATED_TRIAD, BALL_SOCCER_1998_COLOURED_TRIAD, BALL_SOCCER_2002_TRIANGLE_SWEEP, BALL_SOCCER_2006_PROPELLER, BALL_SOCCER_2010_GROOVED, BALL_SOCCER_2014_RIBBON, BALL_SOCCER_2018_PIXEL, BALL_SOCCER_2022_SPEED_SHELL, BALL_SOCCER_TRAINING_HIGH_VIS } from "./ball.soccer.era.js";
 import { BALL_SOCCER_STARS_BLUE, BALL_SOCCER_STARS_RED, BALL_SOCCER_STARS_NIGHT, BALL_SOCCER_HEXAGONS_CYAN, BALL_SOCCER_HEXAGONS_MAGENTA, BALL_SOCCER_HEXAGONS_LIME, BALL_SOCCER_FLAMES_FIRE, BALL_SOCCER_FLAMES_ICE, BALL_SOCCER_FLAMES_TOXIC, BALL_SOCCER_CHEVRONS_RED, BALL_SOCCER_CHEVRONS_GREEN, BALL_SOCCER_CHEVRONS_BLUE, BALL_SOCCER_SWIRL_BLUE, BALL_SOCCER_SWIRL_RED, BALL_SOCCER_SWIRL_TEAL, BALL_SOCCER_METALLIC_GOLD, BALL_SOCCER_METALLIC_SILVER, BALL_SOCCER_METALLIC_COBALT } from "./ball.soccer.store.js";

package/dist/emblems/ball/ball.letters.d.ts

@@ -22,6 +22,7 @@ export interface Lettering {
 export declare function textWidth(text: string, o: Lettering): number;
 /** The size at which a text is as wide as `width` at most and as tall as `height` at most. */
 export declare function fitSize(text: string, o: Omit<Lettering, "size">, width: number, height: number): number;
+type Pt = readonly [number, number];
 /** A line of text on a straight line, centred on (`x`, `y`), as one path: draw it with a stroke of `weight * size`. */
 export declare function linePath(text: string, o: Lettering, x: number, y: number): string;
 /**
@@ -29,4 +30,6 @@ export declare function linePath(text: string, o: Lettering, x: number, y: numbe
  * clockwise (the top of the ring); with `inside` true they stand inward and read left to right (the bottom of the ring, `centre` 180). One path.
  */
 export declare function arcPath(text: string, o: Lettering, r: number, centre: number, inside?: boolean): string;
+/** The centre lines of a text on a straight line, centred on (`x`, `y`), as lists of points (curves sampled `steps` to a segment), for a caller that carries them onto a surface; draw them with a stroke of `weight * size`. */
+export declare function lineStrokes(text: string, o: Lettering, x: number, y: number, steps?: number): Pt[][];
 export {};

package/dist/emblems/ball/ball.letters.js

@@ -140,3 +140,54 @@ export function arcPath(text, o, r, centre, inside = false) {
         });
     }).join("");
 }
+/** The centre lines of a text on a straight line, centred on (`x`, `y`), as lists of points (curves sampled `steps` to a segment), for a caller that carries them onto a surface; draw them with a stroke of `weight * size`. */
+export function lineStrokes(text, o, x, y, steps = 6) {
+    const glyphs = glyphsOf(text);
+    const s = setting(glyphs, o);
+    const k = o.size / GLYPH_H;
+    const left = x - (s.total * k) / 2;
+    const top = y - o.size / 2;
+    const shape = shaped(o);
+    const out = [];
+    glyphs.forEach((g, i) => {
+        let cur = [];
+        let at = [0, 0];
+        let start = [0, 0];
+        const put = (p) => {
+            const q = shape(p);
+            cur.push([left + (s.at[i] + q[0]) * k, top + q[1] * k]);
+        };
+        const flush = () => {
+            if (cur.length > 1)
+                out.push(cur);
+            cur = [];
+        };
+        for (const part of g.d.match(/[MLCZ][^MLCZ]*/g) ?? []) {
+            const n = (part.slice(1).match(/-?\d+(?:\.\d+)?/g) ?? []).map(Number);
+            if (part[0] === "M") {
+                flush();
+                at = start = [n[0], n[1]];
+                put(at);
+            }
+            else if (part[0] === "L") {
+                at = [n[0], n[1]];
+                put(at);
+            }
+            else if (part[0] === "C") {
+                const [x1, y1, x2, y2, x3, y3] = n;
+                const [x0, y0] = at;
+                for (let j = 1; j <= steps; j++) {
+                    const t = j / steps, u = 1 - t;
+                    put([u * u * u * x0 + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * x3, u * u * u * y0 + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * y3]);
+                }
+                at = [x3, y3];
+            }
+            else {
+                at = start;
+                put(at);
+            }
+        }
+        flush();
+    });
+    return out;
+}

package/dist/emblems/ball/ball.print.d.ts

@@ -0,0 +1,81 @@
+import { type Piece } from "./ball.core.ts";
+import { type PrintOptions } from "./ball.core.ts";
+import type { BallSpec, Surface } from "./ball.engine.ts";
+/** The colours of a painted ball: `body` is the ball (or a soccer ball's hexagons), `second` the other half of a two-tone ball (or a soccer ball's pentagons). */
+export interface BallPaint {
+    /** The ball's colour: `#rgb`, `#rrggbb` or `rgb()`; anything else is ignored. */
+    body?: string;
+    /** The second colour. A baseball or a softball becomes two-tone, split along its seam or in halves; a soccer ball's pentagons take it. */
+    second?: string;
+    /** How a two-tone baseball or softball is divided: `"seam"` (the default: the figure-eight seam parts the two colours, as a commemorative ball is) or `"half"` (a flat cut through the middle). */
+    split?: "seam" | "half";
+    /** For `split: "half"`: the turn of the cut in degrees about the label's middle (0 is a vertical cut, body on the left). */
+    angle?: number;
+    /** The colour of the stitches. By default one that shows against the ball (red, cream or navy; on a two-tone ball each stitch's legs are the colour that shows on their own side). */
+    stitch?: string;
+}
+/** A place on the ball in degrees from the middle of its default view: `lon` toward the right, `lat` toward the top, in the ball's own frame (it turns with the ball). */
+export interface Spot {
+    lon?: number;
+    lat?: number;
+}
+/** Where the logo and the lettering go, as a place on the ball in degrees from the middle of its default view. By default the logo is there and so is the lettering, or the lettering is on the far side of the ball (`lon: 180`) when there is a logo. */
+export interface BallSpots {
+    decal?: Spot;
+    label?: Spot;
+}
+/** A logo printed on the ball. */
+export interface BallDecal {
+    /** An SVG string. It is made safe first (only shapes, gradients and groups survive; no script, text, image, style or address), a gradient is its mean colour, and it is wrapped exactly onto the sphere. */
+    svg?: string;
+    /** Or a `data:` URI of an image: an SVG is read as `svg` is, a PNG, JPEG, GIF or WebP is laid on in small triangles (close, not exact). An address on the network is refused. */
+    href?: string;
+    /** How wide the logo is, in degrees of the sphere (about 55 by default). */
+    size?: number;
+    /** A turn of the logo on the ball, in degrees. */
+    turn?: number;
+}
+/** The stamp: lines of bold block lettering, the first with a small star on each side, and an optional signature-style line under them. */
+export interface BallStamp {
+    /** The lines (up to three, 24 letters each, any letter, digit or `- . , ' / : &`; the ball's own default is `UNOFFICIAL` and `DIGITAL BASEBALL`). */
+    lines?: readonly string[];
+    /** Stars on each side of the first line (on by default). */
+    stars?: boolean;
+    /** A made-up signature under the lines: `true`, a seed (text or a number), or `{ seed, caption }` with a small line of words under it. The same seed always draws the same squiggle, and no seed is anyone's real hand. */
+    sign?: boolean | string | number | {
+        seed?: string | number;
+        caption?: string;
+    };
+    /** The ink, `#rgb`, `#rrggbb` or `rgb()`. Navy by default, or white or black where navy would not show on the ball. */
+    colour?: string;
+}
+/** The cursive word where a maker's mark would sit. */
+export interface BallScript {
+    /** The word (up to 16 letters; a-z and a space; a capital without a drawing of its own is a tall small letter). By default the ball's own: `Baseball`, `Softball` or `Soccer`. */
+    text?: string;
+    colour?: string;
+}
+/** The small mark under the script: a letter in a circle, or a mark of your own. */
+export interface BallMark {
+    /** The letter in the circle (one letter or digit). By default the first letter of the script. */
+    letter?: string;
+    /** A mark of your own as an SVG string (made safe first, as a decal is), fitted in the circle's place. It replaces the circled letter. */
+    svg?: string;
+    /** Or a `data:` URI of an SVG (a raster picture is not taken for a mark). */
+    href?: string;
+    colour?: string;
+}
+/** The ink for a print on the given grounds: the wanted colour if it shows on all of them (3 to 1), else the first of navy, white and near-black that does. */
+export declare function inkFor(grounds: readonly string[], wanted?: string): string;
+/**
+ * The print of a ball as layers for its surface: the logo, then the label (the script, the circled letter, the stamp), each at its own place. `grounds` are the colours the print lies on, for the ink (the label's far side is the same colour as the front on every ball that has one). A ball
+ * in the line style has none. Returns an empty string when nothing was asked for.
+ */
+export declare function printLayers(s: Surface, p: PrintOptions | undefined, word: string, grounds: readonly string[]): string;
+/** What `printLayers` was given, for the id of a drawing (so two prints of one ball have their own definitions). */
+export declare const printKey: (p: PrintOptions | undefined) => string;
+/**
+ * A ball that can be printed. The balls themselves carry no printing code (a ball bundled alone stays small): `renderEmblem` and the registry use this, and so can you for one ball taken from its own module:
+ * `const ball = printed(BALL_BASEBALL); ball.svg({ stamp: true })`. The same ball with the printer in its options; options that ask for no print draw exactly what the plain ball draws.
+ */
+export declare const printed: <P extends Piece<BallSpec>>(piece: P) => P;

package/dist/emblems/ball/ball.print.js

@@ -0,0 +1,268 @@
+// What a ball is printed with: a logo wrapped onto the side of the ball, a stamp of text, a cursive maker's word and a small mark, laid out as a label on a flat plane that touches the ball at one point and
+// carried onto the sphere with an equal-distance map, so every line of it curves with the ball and turns with it. Everything is our own drawing: our own cursive script (ball.script.ts), our own block
+// lettering (ball.letters.ts), our own stars and circled letter, and no maker's, league's or team's name or mark; a logo and a mark of the caller's own are drawn from the SVG they give, made safe first.
+// Imports only this folder's helpers.
+import { escape, hashOf, hexOf, readColour } from "./ball.core.js";
+import { contrast } from "./ball.contrast.js";
+import { hasPrint } from "./ball.core.js";
+import { safeImage } from "./ball.image.js";
+import { lineStrokes, textWidth } from "./ball.letters.js";
+import { add, mul, norm } from "./ball.math.js";
+import { scriptRuns, scriptWidth } from "./ball.script.js";
+import { signaturePath } from "./ball.signature.js";
+import { drawPicture, drawShapes, flattenPath, shapesOf } from "./ball.warp.js";
+const NAVY = "#1b2a5c";
+const MAX_SVG = 60000;
+/** The ink for a print on the given grounds: the wanted colour if it shows on all of them (3 to 1), else the first of navy, white and near-black that does. */
+export function inkFor(grounds, wanted) {
+    const w = wanted === undefined ? undefined : readColour(wanted);
+    const list = [...(w === undefined ? [] : [hexOf(w)]), NAVY, "#ffffff", "#101418"];
+    return list.find((c) => grounds.every((g) => contrast(c, g) >= 3)) ?? list[list.length - 1];
+}
+const clean = (v, max) => {
+    if (typeof v !== "string" && typeof v !== "number")
+        return undefined;
+    const t = [...String(v).replace(/\p{Cc}/gu, " ").replace(/\s+/g, " ").trim()].slice(0, max).join("");
+    return t === "" ? undefined : t;
+};
+const degrees = (v, d, lo, hi) => (typeof v === "number" && Number.isFinite(v) ? Math.max(lo, Math.min(hi, v)) : d);
+/** An SVG from a data URI, if the URI is one of an SVG: base64 or percent-encoded. */
+function svgOfUri(uri) {
+    const m = /^data:image\/svg\+xml(?:;charset=[\w-]+)?(;base64)?,([\s\S]*)$/i.exec(uri.trim());
+    if (m === null || m[2].length > MAX_SVG * 1.4)
+        return undefined;
+    try {
+        const decode = globalThis.atob;
+        return m[1] === undefined ? decodeURIComponent(m[2]) : decode === undefined ? undefined : decode(m[2]);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A raster data URI that is safe to write into an attribute: PNG, JPEG, GIF or WebP, base64 only, of a size that fits in a document. */
+const RASTER = /^data:image\/(?:png|jpe?g|gif|webp);base64,[A-Za-z0-9+/]+={0,2}$/;
+const MAX_RASTER = 400000;
+/** A logo or mark from a string and a URI, made safe; `undefined` when nothing drawable is left. A picture is taken only when `pictures` is true. */
+function artOf(svg, href, prefix, pictures) {
+    let source = typeof svg === "string" ? svg : undefined;
+    let uri = typeof href === "string" ? href.trim() : undefined;
+    if (source !== undefined && /^\s*data:/i.test(source)) {
+        uri = source.trim();
+        source = undefined;
+    }
+    if (source === undefined && uri !== undefined) {
+        source = svgOfUri(uri);
+        if (source === undefined && pictures && uri.length <= MAX_RASTER && RASTER.test(uri))
+            return { kind: "picture", href: uri };
+    }
+    const img = safeImage(source, prefix);
+    return img === undefined ? undefined : { kind: "vector", img };
+}
+/** The frame a plane is laid on the ball in: at `spot` degrees from the label's middle, turned `turn` degrees. The map is equal-distance, so a length from the middle is the same on the ball in radians. */
+function planeOf(home, spot, turn = 0) {
+    const lon = (degrees(spot?.lon, 0, -360, 360) * Math.PI) / 180, lat = (degrees(spot?.lat, 0, -90, 90) * Math.PI) / 180;
+    const c1 = add(mul(home.c, Math.cos(lon)), mul(home.ex, Math.sin(lon)));
+    const ex1 = add(mul(home.ex, Math.cos(lon)), mul(home.c, -Math.sin(lon)));
+    const c = add(mul(c1, Math.cos(lat)), mul(home.up, Math.sin(lat)));
+    const up = add(mul(home.up, Math.cos(lat)), mul(c1, -Math.sin(lat)));
+    const t = (turn * Math.PI) / 180, ct = Math.cos(t), st = Math.sin(t);
+    return (x, y) => {
+        const px = x * ct - y * st, py = x * st + y * ct;
+        const r = Math.min(Math.hypot(px, py), Math.PI);
+        if (r < 1e-9)
+            return c;
+        return norm(add(mul(c, Math.cos(r)), mul(add(mul(ex1, px), mul(up, -py)), Math.sin(r) / Math.hypot(px, py))));
+    };
+}
+const ringOf = (cx, cy, r, n = 28) => Array.from({ length: n }, (_, i) => [cx + r * Math.cos((i * 2 * Math.PI) / n), cy + r * Math.sin((i * 2 * Math.PI) / n)]);
+const starOf = (cx, cy, r) => Array.from({ length: 10 }, (_, i) => [cx + (i % 2 === 0 ? r : r * 0.42) * Math.cos(-Math.PI / 2 + (i * Math.PI) / 5), cy + (i % 2 === 0 ? r : r * 0.42) * Math.sin(-Math.PI / 2 + (i * Math.PI) / 5)]);
+/** The print asked for, made safe. `word` is the ball's own word, the default of the script and of the stamp's second line. */
+function partsOf(p, word) {
+    const out = {};
+    const d = typeof p.decal === "string" ? { svg: p.decal } : typeof p.decal === "object" && p.decal !== null ? p.decal : undefined;
+    if (d !== undefined) {
+        const art = artOf(d.svg, d.href, "d", true);
+        if (art !== undefined)
+            out.decal = { art, size: (degrees(d.size, 0, 5, 170) * Math.PI) / 180, turn: degrees(d.turn, 0, -360, 360) };
+    }
+    const sc = p.script === true ? {} : typeof p.script === "string" ? { text: p.script } : typeof p.script === "object" && p.script !== null ? p.script : undefined;
+    if (sc !== undefined) {
+        const t = clean(sc.text, 16) ?? `${word[0]?.toUpperCase()}${word.slice(1)}`;
+        if (scriptWidth(t) > 0)
+            out.script = { text: t, colour: typeof sc.colour === "string" ? sc.colour : undefined };
+    }
+    const mk = p.mark === true ? {} : typeof p.mark === "string" ? (/^\s*(<|data:)/i.test(p.mark) ? { svg: p.mark } : { letter: p.mark }) : typeof p.mark === "object" && p.mark !== null ? p.mark : undefined;
+    // The script brings its circled letter with it, unless the mark is switched off.
+    const mark = mk ?? (out.script !== undefined && p.mark !== false ? {} : undefined);
+    if (mark !== undefined) {
+        const art = artOf(mark.svg, mark.href, "m", false);
+        const letter = [...(clean(mark.letter, 1) ?? out.script?.text.trim()[0] ?? word[0] ?? "B")][0];
+        out.mark = { letter: letter.toUpperCase(), colour: typeof mark.colour === "string" ? mark.colour : undefined, art };
+    }
+    const st = p.stamp === true ? {} : typeof p.stamp === "string" ? { lines: [p.stamp] } : Array.isArray(p.stamp) ? { lines: p.stamp } : typeof p.stamp === "object" && p.stamp !== null ? p.stamp : undefined;
+    if (st !== undefined) {
+        const given = Array.isArray(st.lines) ? st.lines.slice(0, 3).flatMap((l) => clean(l, 24) ?? []) : [];
+        const lines = given.length > 0 ? given : ["UNOFFICIAL", `DIGITAL ${word.toUpperCase()}`];
+        const sg = st.sign;
+        const sign = sg === true ? { seed: "dougu" } : typeof sg === "string" || typeof sg === "number" ? { seed: sg } : typeof sg === "object" && sg !== null ? { seed: sg.seed ?? "dougu", caption: clean(sg.caption, 24) } : undefined;
+        out.stamp = { lines, stars: st.stars !== false, colour: typeof st.colour === "string" ? st.colour : undefined, sign };
+    }
+    return out;
+}
+/** The ink of one part: its own colour if it is one, else the label's. */
+const pen = (own, label) => {
+    const c = own === undefined ? undefined : readColour(own);
+    return c === undefined ? label : hexOf(c);
+};
+/** Points of a flat curve onto the ball, each given as `[x, y]` in the plane's units. */
+const lay = (map, pts) => pts.map((p) => map(p[0], p[1]));
+/** The size of the label's full width, in radians, for a ball that reaches `reach` from the middle of its label area. */
+const labelWidth = (reach) => Math.min(1.7, reach * 1.4);
+/** The id of a drawing's definitions: from its own text, so that two logos in a page do not share. */
+const idOf = (text) => `p${hashOf(text)}`;
+/**
+ * The print of a ball as layers for its surface: the logo, then the label (the script, the circled letter, the stamp), each at its own place. `grounds` are the colours the print lies on, for the ink (the label's far side is the same colour as the front on every ball that has one). A ball
+ * in the line style has none. Returns an empty string when nothing was asked for.
+ */
+export function printLayers(s, p, word, grounds) {
+    const home = s.home;
+    if (p === undefined || home === undefined || s.line)
+        return "";
+    const parts = partsOf(p, word);
+    let out = "";
+    const labelled = parts.script !== undefined || parts.mark !== undefined || parts.stamp !== undefined;
+    if (parts.decal !== undefined) {
+        const d = parts.decal;
+        const ink = inkFor(grounds);
+        const map = planeOf(home, p.spots?.decal, d.turn);
+        const size = d.size > 0 ? d.size : Math.min(1.3, home.reach * 1.25);
+        if (d.art.kind === "picture")
+            out += drawPicture(s, d.art.href, map, size, idOf(d.art.href.slice(0, 64) + d.art.href.length));
+        else
+            out += drawShapes(s, shapesOf(d.art.img, ink), d.art.img.box, map, size);
+    }
+    if (labelled) {
+        const spot = p.spots?.label ?? (parts.decal !== undefined ? { lon: 180 } : undefined);
+        out += labelLayers(s, parts, planeOf(home, spot), labelWidth(home.reach), inkFor(grounds, parts.stamp?.colour));
+    }
+    return out;
+}
+/** The label: its items from the top down, centred on the plane's origin. */
+function labelLayers(s, parts, map, W, ink) {
+    const items = [];
+    const gap = W * 0.085;
+    const digits = 2;
+    const stroke = (curves, colour, width, extra) => s.strokes(curves.map((c) => lay(map, c)), colour, width * s.radius, { digits, ...extra });
+    if (parts.script !== undefined) {
+        const sc = parts.script;
+        const runs = scriptRuns(sc.text);
+        const wide = scriptWidth(sc.text);
+        const k = Math.min((W * 0.82) / wide, W * 0.03);
+        const high = 22 * k;
+        const colour = pen(sc.colour, ink);
+        items.push({
+            h: high,
+            draw: (cy) => {
+                const ox = (-wide * k) / 2 + wide * k * 0.02, oy = cy + high / 2 - k * 0.5;
+                const tiers = [[], [], []];
+                for (const run of runs) {
+                    let cur = [];
+                    let tier = -1;
+                    run.pts.forEach((pt, i) => {
+                        const q = [ox + pt[0] * k, oy - pt[1] * k];
+                        if (i === 0) {
+                            cur = [q];
+                            return;
+                        }
+                        const t = run.tier[i - 1];
+                        if (t !== tier && cur.length > 1) {
+                            tiers[tier]?.push(cur);
+                            cur = [cur[cur.length - 1]];
+                        }
+                        tier = t;
+                        cur.push(q);
+                    });
+                    if (cur.length > 1)
+                        tiers[tier]?.push(cur);
+                }
+                const w = [0.34, 0.7, 1.2];
+                return stroke(tiers[0], colour, w[0] * k) + stroke(tiers[1], colour, w[1] * k) + stroke(tiers[2], colour, w[2] * k);
+            },
+        });
+    }
+    if (parts.mark !== undefined) {
+        const mk = parts.mark;
+        const r = W * 0.062;
+        const colour = pen(mk.colour, ink);
+        items.push({
+            h: r * 2,
+            draw: (cy) => {
+                if (mk.art !== undefined && mk.art.kind === "vector")
+                    return drawShapes(s, shapesOf(mk.art.img, colour), mk.art.img.box, (x, y) => map(x, y + cy), r * 2.6);
+                const L = { size: r * 1.15, weight: 0.2, wide: 0.9 };
+                return stroke([ringOf(0, cy, r)], colour, r * 0.2, { closed: true }) + stroke(lineStrokes(mk.letter, L, 0, cy, 5), colour, L.size * L.weight);
+            },
+        });
+    }
+    if (parts.stamp !== undefined) {
+        const st = parts.stamp;
+        const colour = pen(st.colour, ink);
+        st.lines.forEach((text, i) => {
+            const want = i === 0 ? { weight: 0.22, wide: 0.78 } : { weight: 0.22, wide: 0.78 };
+            const room = W * (i === 0 ? 0.62 : 0.98);
+            const base = i === 0 ? W * 0.075 : W * 0.105;
+            const w1 = textWidth(text, { ...want, size: 1 });
+            const size = Math.min(base, room / w1);
+            const L = { ...want, size };
+            items.push({
+                h: size * 1.1,
+                draw: (cy) => {
+                    let o = stroke(lineStrokes(text, L, 0, cy, 5), colour, size * L.weight);
+                    if (i === 0 && st.stars) {
+                        const half = textWidth(text, L) / 2;
+                        const r = size * 0.62;
+                        for (const sx of [-1, 1])
+                            o += s.panel(lay(map, starOf(sx * (half + r * 1.5), cy, r)), colour, { n: 1, ink: true });
+                    }
+                    return o;
+                },
+            });
+        });
+        if (st.sign !== undefined) {
+            const sg = st.sign;
+            const seed = sg.seed;
+            const width = W * 0.52;
+            items.push({
+                h: width * 0.34,
+                draw: (cy) => {
+                    const subs = flattenPath(signaturePath(seed), 8);
+                    return stroke(subs.map((q) => q.pts.map((pt) => [pt[0] * width, pt[1] * width + cy])), colour, width * 0.014);
+                },
+            });
+            if (sg.caption !== undefined) {
+                const size = W * 0.036;
+                const L = { size, weight: 0.16, wide: 0.8, track: 0.12 };
+                items.push({ h: size * 1.4, draw: (cy) => stroke(lineStrokes(sg.caption, L, 0, cy, 4), colour, size * L.weight) });
+            }
+        }
+    }
+    const total = items.reduce((a, it) => a + it.h, 0) + gap * Math.max(0, items.length - 1);
+    let y = -total / 2;
+    let out = "";
+    for (const it of items) {
+        out += it.draw(y + it.h / 2);
+        y += it.h + gap;
+    }
+    return out;
+}
+/** What `printLayers` was given, for the id of a drawing (so two prints of one ball have their own definitions). */
+export const printKey = (p) => (p === undefined ? "" : escape(hashOf(JSON.stringify(p))));
+/**
+ * A ball that can be printed. The balls themselves carry no printing code (a ball bundled alone stays small): `renderEmblem` and the registry use this, and so can you for one ball taken from its own module:
+ * `const ball = printed(BALL_BASEBALL); ball.svg({ stamp: true })`. The same ball with the printer in its options; options that ask for no print draw exactly what the plain ball draws.
+ */
+export const printed = (piece) => ({
+    ...piece,
+    svg: (o) => piece.svg(hasPrint(o) ? { ...o, printer: printLayers } : o),
+    frame: (o) => piece.frame(hasPrint(o) ? { ...o, printer: printLayers } : o),
+});

package/dist/emblems/ball/ball.printable.d.ts

@@ -0,0 +1,6 @@
+export declare const BALL_BASEBALL: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;
+export declare const BALL_SOFTBALL: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;
+export declare const BALL_SOCCER: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;
+export declare const BALL_SOCCER_COLOUR: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;
+export declare const BALL_SOCCER_ORANGE: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;
+export declare const BALL_SOCCER_YELLOW: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;

package/dist/emblems/ball/ball.printable.js

@@ -0,0 +1,13 @@
+// The balls that take a logo, lettering and a mark, with the printer in hand: the same balls as `ball.baseball.ts`, `ball.softball.ts` and `ball.soccer.ts` and the classic soccer balls of `ball.soccer.panels.ts`, made
+// with `printed()`. The balls' own modules carry no printing code (so one bundled alone stays small); the registry and the main entry take these.
+import { BALL_BASEBALL as PLAIN_BASEBALL } from "./ball.baseball.js";
+import { printed } from "./ball.print.js";
+import { BALL_SOCCER_ORANGE as PLAIN_SOCCER_ORANGE, BALL_SOCCER_YELLOW as PLAIN_SOCCER_YELLOW } from "./ball.soccer.panels.js";
+import { BALL_SOCCER as PLAIN_SOCCER, BALL_SOCCER_COLOUR as PLAIN_SOCCER_COLOUR } from "./ball.soccer.js";
+import { BALL_SOFTBALL as PLAIN_SOFTBALL } from "./ball.softball.js";
+export const BALL_BASEBALL = /* @__PURE__ */ printed(PLAIN_BASEBALL);
+export const BALL_SOFTBALL = /* @__PURE__ */ printed(PLAIN_SOFTBALL);
+export const BALL_SOCCER = /* @__PURE__ */ printed(PLAIN_SOCCER);
+export const BALL_SOCCER_COLOUR = /* @__PURE__ */ printed(PLAIN_SOCCER_COLOUR);
+export const BALL_SOCCER_ORANGE = /* @__PURE__ */ printed(PLAIN_SOCCER_ORANGE);
+export const BALL_SOCCER_YELLOW = /* @__PURE__ */ printed(PLAIN_SOCCER_YELLOW);

package/dist/emblems/ball/ball.region.d.ts

@@ -0,0 +1,12 @@
+import { type Geometry, type Surface } from "./ball.engine.ts";
+import { type V3 } from "./ball.math.ts";
+/**
+ * The visible part of the surface on the left of a closed curve on a sphere, as the path of its outline: the curve's visible runs, joined along the limb. Walking a run with the region on your left, the limb is
+ * followed counterclockwise (as the eye sees it) from where the run leaves the disc to the next place a run comes in, so the outline closes on the correct side even for a region that is not convex.
+ */
+export declare function regionPath(g: Geometry, ring: readonly V3[]): string;
+/**
+ * The part of the surface on the left of a closed curve (looking at the sphere from outside, walking along the curve in the order given), filled with a colour: what you see of it, bounded by the curve and the
+ * limb. For spheres only. In the line style nothing is drawn.
+ */
+export declare function region(s: Surface, ring: readonly V3[], fill: string): string;

package/dist/emblems/ball/ball.region.js

@@ -0,0 +1,94 @@
+// A region of a sphere on the left of a closed curve, drawn as the outline it has on the screen. Kept out of the engine so that a ball with no two-tone colouring does not carry it: the seamed balls import it.
+import { num } from "./ball.core.js";
+import { EPS, pathOf, project, visOf, visibleRuns } from "./ball.engine.js";
+import { cross, dot, norm, sub } from "./ball.math.js";
+/** The signed area of a polygon of screen points, y up (positive when it runs counterclockwise as you see it). */
+function areaOf(pts) {
+    let a = 0;
+    for (let i = 0; i < pts.length; i++) {
+        const p = pts[i], q = pts[(i + 1) % pts.length];
+        a += p[0] * -q[1] - q[0] * -p[1];
+    }
+    return a / 2;
+}
+/** Whether a point of the sphere is on the left of a closed curve, by the nearest sample's side. */
+function leftOf(ring, p) {
+    let best = Infinity, left = false;
+    const n = ring.length;
+    for (let i = 0; i < n; i++) {
+        const q = ring[i];
+        const d = 1 - dot(p, q);
+        if (d < best) {
+            best = d;
+            left = dot(p, cross(q, norm(sub(ring[(i + 1) % n], ring[(i + n - 1) % n])))) > 0;
+        }
+    }
+    return left;
+}
+/**
+ * The visible part of the surface on the left of a closed curve on a sphere, as the path of its outline: the curve's visible runs, joined along the limb. Walking a run with the region on your left, the limb is
+ * followed counterclockwise (as the eye sees it) from where the run leaves the disc to the next place a run comes in, so the outline closes on the correct side even for a region that is not convex.
+ */
+export function regionPath(g, ring) {
+    const R = g.k;
+    const vis = ring.map((p) => visOf(g, p));
+    const disc = () => `M${num(g.cx - R, 2)} ${num(g.cy, 2)}A${num(R, 2)} ${num(R, 2)} 0 1 0 ${num(g.cx + R, 2)} ${num(g.cy, 2)}A${num(R, 2)} ${num(R, 2)} 0 1 0 ${num(g.cx - R, 2)} ${num(g.cy, 2)}Z`;
+    if (!vis.some((v) => v > EPS))
+        return leftOf(ring, norm(g.w)) ? disc() : "";
+    if (vis.every((v) => v > EPS)) {
+        const pts = ring.map((p) => {
+            const [x, y] = project(g, p);
+            return [x, y, 1];
+        });
+        const poly = `${pathOf(pts, 2)}Z`;
+        return areaOf(pts) > 0 ? poly : disc() + poly;
+    }
+    const runs = visibleRuns(g, ring, true).filter((r) => r.pts.length > 1);
+    if (runs.length === 0)
+        return "";
+    const angle = (p) => Math.atan2(-(p[1] - g.cy), p[0] - g.cx);
+    const first = (r) => r.pts[0];
+    const last = (r) => r.pts[r.pts.length - 1];
+    const next = runs.map((r) => {
+        const out = angle(last(r));
+        let best = 0, gap = Infinity;
+        runs.forEach((q, j) => {
+            let d = angle(first(q)) - out;
+            d -= Math.floor(d / (2 * Math.PI)) * 2 * Math.PI;
+            if (d < gap) {
+                gap = d;
+                best = j;
+            }
+        });
+        return { to: best, gap };
+    });
+    const seen = new Set();
+    let d = "";
+    runs.forEach((_, start) => {
+        if (seen.has(start))
+            return;
+        let at = start;
+        d += `M${num(first(runs[at])[0], 2)} ${num(first(runs[at])[1], 2)}`;
+        while (!seen.has(at)) {
+            seen.add(at);
+            const r = runs[at];
+            d += pathOf(r.pts.slice(1), 2).replace(/^M/, "L");
+            const n = next[at];
+            const e = first(runs[n.to]);
+            d += n.gap < 1e-4 ? `L${num(e[0], 2)} ${num(e[1], 2)}` : `A${num(R, 2)} ${num(R, 2)} 0 ${n.gap > Math.PI ? 1 : 0} 0 ${num(e[0], 2)} ${num(e[1], 2)}`;
+            at = n.to;
+        }
+        d += "Z";
+    });
+    return d;
+}
+/**
+ * The part of the surface on the left of a closed curve (looking at the sphere from outside, walking along the curve in the order given), filled with a colour: what you see of it, bounded by the curve and the
+ * limb. For spheres only. In the line style nothing is drawn.
+ */
+export function region(s, ring, fill) {
+    if (s.line)
+        return "";
+    const d = regionPath(s.view, ring);
+    return d === "" ? "" : `<path d="${d}" fill="${fill}" fill-rule="evenodd"/>`;
+}

package/dist/emblems/ball/ball.script.d.ts

@@ -0,0 +1,15 @@
+type Pt = readonly [number, number];
+/** One piece of a word's centre line: its points in the grid, and `tier` 0 (hairline), 1 (medium) or 2 (down stroke), for each segment. */
+export interface ScriptRun {
+    pts: Pt[];
+    /** One entry per segment (`pts.length - 1`). */
+    tier: number[];
+}
+/** The width of a word in the grid. */
+export declare function scriptWidth(text: string): number;
+/**
+ * A word as pen runs in the grid (y up, the baseline at 0, the left end of the first letter at 0), leaning right, each run with the thickness tier of its segments. Characters with no letter are left out;
+ * a space is a gap.
+ */
+export declare function scriptRuns(text: string): ScriptRun[];
+export {};