@johnmorrisdotca/dougu-sports 0.7.2 → 0.9.0

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 {};

package/dist/emblems/ball/ball.script.js

@@ -0,0 +1,107 @@
+// An original cursive script, drawn for this package: a pen's centre line through hand-placed waypoints, joined letter to letter at the baseline, with the pen's thick down strokes and hairline up
+// strokes made by the caller from each segment's direction (`tier`). No font file, no licensed outline and no maker's lettering: every waypoint below was placed by hand, in a grid where the x-height is 10,
+// the ascender 20 and the descender -10, with y up. A glyph enters at (0, 0) and leaves at (adv, 0), so the next one starts where it stops. Imports nothing.
+const LOWER = {
+    a: { adv: 8.4, d: "0,0 1.6,2.6 3.6,6.2 5.2,8.6 6.4,9.6 4.6,10.4 2.4,9.2 1.2,6 1.5,2.4 3.4,0.5 5.2,1.4 6.3,4.4 6.7,9.4 6.7,5 6.8,1.4 7.6,0.2 8.4,0" },
+    b: { adv: 8.6, d: "0,0 1.6,3.5 3.4,9 4.6,15.5 4.6,19.5 3.8,20.8 2.8,19.4 2.9,15 3.6,9 4,3.5 4.2,0.8 4.8,3.2 6.5,6.6 7.8,5.6 7.6,2.2 5.8,0.4 3.8,1.4 3.3,3.4 4.3,0.3 7.2,0 8.6,0" },
+    c: { adv: 7.4, d: "0,0 1.8,2.8 3.8,7 5.8,9.4 4.8,10.2 2.6,9 1.2,5.8 1.6,2.2 3.4,0.3 5.4,0.8 6.6,1.8 7.4,0" },
+    d: { adv: 9, d: "0,0 1.6,2.6 3.6,6.2 5.2,8.6 6.4,9.6 4.6,10.4 2.4,9.2 1.2,6 1.5,2.4 3.4,0.5 5.2,1.4 6.4,4.4 7.2,11 8,17.5 8,20.2 7.1,20.8 6.5,19.3 6.7,13 7,6 7.1,1.4 8,0.2 9,0" },
+    e: { adv: 7.6, d: "0,0 0.9,2.4 1.7,5 3.2,5.8 4.9,5.7 5.4,8.2 4.2,10.1 2.6,9.8 1.2,7.6 1.1,3.8 2.1,1.2 3.8,0.2 5.6,0.9 7,0.2 7.6,0" },
+    f: { adv: 6.4, d: "0,0 1.4,3.5 3.2,9.5 4.8,16.5 5.4,19.6 4.4,20.8 3.2,19 3.5,14 3.6,6 3.4,-2.4 2.2,-8.4 1,-9.6 0,-8 1,-5.2 3.6,-3 5.4,0.4 6.4,0 ; 0.6,10.2 4.4,10.8 7.2,10.2" },
+    g: { adv: 8.6, d: "0,0 1.6,2.6 3.6,6.2 5.2,8.6 6.4,9.6 4.6,10.4 2.4,9.2 1.2,6 1.5,2.4 3.4,0.5 5.2,1.4 6.4,4.4 6.8,9.6 6.4,3 6.2,-4.6 4.8,-9 2.4,-9.8 1,-8.2 2,-6.8 5,-6 7,-3.6 8,-0.5 8.6,0" },
+    h: { adv: 8.6, d: "0,0 1.6,3.5 3.4,9 4.6,15.5 4.6,19.5 3.8,20.8 2.8,19.4 2.9,15 3.6,9 4,3.5 4.1,0.4 4.6,3.6 6,7.8 7.2,8 7.5,5 7.1,1.4 7.6,0.2 8.6,0" },
+    i: { adv: 4.8, d: "0,0 1.4,3.4 2.4,8.2 2.8,9.6 2.8,4.4 2.6,1 3.2,0.2 4.8,0 ; 3.2,12.8 3.2,13.4" },
+    j: { adv: 4.8, d: "0,0 1.4,3.4 2.4,8.2 3,9.6 3.2,3 3,-4.6 1.6,-9 0.2,-9.8 -0.8,-8.4 0.6,-6.8 2.6,-4 3.8,-0.5 4.8,0 ; 3.6,12.8 3.6,13.4" },
+    k: { adv: 8.2, d: "0,0 1.6,3.5 3.4,9 4.6,15.5 4.6,19.5 3.8,20.8 2.8,19.4 2.9,15 3.6,9 4,3.5 4.1,0.4 4.4,3.2 5,6.2 6.6,8 7,6.4 5.8,4.2 4.4,3.6 5.6,2.6 6.8,0.4 8.2,0" },
+    l: { adv: 4.8, d: "0,0 1.6,3.5 3.2,9.5 4.2,15.5 4.4,19.4 3.6,20.8 2.6,19.4 2.7,15 3.2,9 3.5,3.5 3.6,0.6 4.1,0.2 4.8,0" },
+    m: { adv: 12.8, d: "0,0 1.4,3.4 2.4,8.2 2.8,9.6 2.9,5.5 2.8,1 3.2,3.6 4.4,8 5.6,8.4 6.1,5.2 6,1 6.4,3.6 7.6,8 8.8,8.4 9.4,5.2 9.2,1.2 9.9,0.2 10.8,0.6 12.8,0" },
+    n: { adv: 8.4, d: "0,0 1.4,3.4 2.4,8.2 2.8,9.6 2.9,5.5 2.8,1 3.2,3.6 4.4,8 5.6,8.4 6.2,5.2 6,1.2 6.8,0.2 8.4,0" },
+    o: { adv: 7.6, d: "0,0 1.8,2.8 3.4,6.4 4.4,8.8 3.4,10.2 1.8,8.4 1.2,5.2 1.9,1.8 3.8,0.3 5.6,1.8 5.7,5.4 4.8,8.6 5.2,10 6.4,9.4 7.6,8.5" },
+    p: { adv: 8.6, d: "0,0 1.4,3.4 2.4,8.2 2.8,9.6 2.9,2 2.4,-4.6 1.8,-9.6 ; 2.8,5 3.4,8.6 5.2,10.2 7.2,9 7.6,5.4 6.4,2 4.2,0.4 2.8,1.4 2.5,3.4 4.4,0.4 6.8,0 8.6,0" },
+    q: { adv: 8.4, d: "0,0 1.6,2.6 3.6,6.2 5.2,8.6 6.4,9.6 4.6,10.4 2.4,9.2 1.2,6 1.5,2.4 3.4,0.5 5.2,1.4 6.4,4.4 6.8,9.6 6.6,2 6.2,-5 6.4,-9.4 7.2,-9.8 8.4,-8.4" },
+    r: { adv: 7, d: "0,0 1.4,3.4 2.4,8.2 2.8,9.6 2.9,5.5 2.8,1.6 3.4,4.6 4.6,8.4 5.8,9.6 6.4,8.4 5.4,7.6 6.2,8.4 7,8" },
+    s: { adv: 6.6, d: "0,0 1.2,2.4 2.8,6 4,8.6 4.6,9.8 3.6,9.8 3.5,7.6 4.8,5.8 5,3.6 4.2,1.4 2.8,0.4 1.5,0.8 1.6,1.8 3.2,1.4 5,0.5 6.6,0" },
+    t: { adv: 6.4, d: "0,0 1.4,3.4 2.6,8.5 3.2,13 3.4,16.8 3,16.4 3,10 2.8,3.2 3.4,0.6 4.6,0.4 6.4,0 ; 0.6,9.4 3,9.8 5.8,9.2" },
+    u: { adv: 8.4, d: "0,0 1.4,3.4 2.4,8.2 2.8,9.6 2.7,5.5 2.6,2.2 3.4,0.4 5,0.6 6.4,3.6 7,9.6 6.8,4.6 6.8,1.2 7.6,0.2 8.4,0" },
+    v: { adv: 7.6, d: "0,0 1.4,3.4 2.4,8.2 2.8,9.6 2.7,5.5 3,2.2 4,0.4 5.2,1.6 6.4,6 7,9 6.4,10 7.6,8.4" },
+    w: { adv: 10.4, d: "0,0 1.4,3.4 2.4,8.2 2.8,9.6 2.7,5.5 3,2.2 4,0.4 5,2.4 5.4,6 5.5,2.2 6.6,0.4 7.8,2.4 8.6,6 9.2,9 8.8,10 10.4,8.4" },
+    x: { adv: 7.4, d: "0,0 1.6,3 3.4,7 5,9.6 4.2,10.4 3,9 3.6,5.6 4.4,2.4 4,0.4 2.6,0.2 2,1.4 3.4,2.2 5.2,4.6 6.4,8.6 6.8,10 7.4,9" },
+    y: { adv: 8.2, d: "0,0 1.4,3.4 2.4,8.2 2.8,9.6 2.7,5.5 3,2.2 4,0.4 5.4,2.4 6.4,6 6.8,9.6 6.4,2.6 5.6,-4.6 4,-9 2,-9.8 0.8,-8.4 2,-7 4.6,-5.6 7,-3.4 8.2,0" },
+    z: { adv: 7, d: "0,0 1.4,2.6 2.6,6.6 3.4,9 4.4,10 5.8,9.4 3.8,6.4 2.2,3.4 2,0.4 3,-1.6 4.8,-3.6 4.2,-6 2.8,-6.6 2,-5.4 3.4,-4 5.6,-2.2 6.4,0 7,0" },
+};
+/** Capitals drawn for their own: the rest of the capitals are the small letter set tall (see `scriptStrokes`). */
+const UPPER = {
+    B: { adv: 14, d: "0,0 1.6,6 3.2,12 5,18 6.2,22.4 7,20 6.2,12 5.4,5 4.6,0.4 6,6.6 9.6,12 13,13.6 13.6,10.6 11,7.6 7,6.4 6,6.2 9,5.6 12.2,3.4 12.8,0.6 11,-1.4 7.8,-1.6 4,0.2 1.4,1 0,0" },
+    S: { adv: 11, d: "0,0 2.4,5 5,10 7.6,14.4 9.4,17 8.2,18.8 6,17.2 6.2,14 8.4,11 9.6,7.2 8.4,3 5.8,0.8 3,0.4 1.8,2 3.4,3 6.6,1.6 9,0.4 11,0" },
+};
+const SLANT = 0.3;
+/** A smooth curve through waypoints (a Catmull-Rom spline), as points about 0.8 apart. */
+function through(wp) {
+    const out = [];
+    for (let i = 0; i + 1 < wp.length; i++) {
+        const p0 = wp[Math.max(0, i - 1)], p1 = wp[i], p2 = wp[i + 1], p3 = wp[Math.min(wp.length - 1, i + 2)];
+        const n = Math.max(2, Math.ceil(Math.hypot(p2[0] - p1[0], p2[1] - p1[1]) / 0.8));
+        for (let j = 0; j < n; j++) {
+            const t = j / n, t2 = t * t, t3 = t2 * t;
+            out.push([
+                0.5 * (2 * p1[0] + (-p0[0] + p2[0]) * t + (2 * p0[0] - 5 * p1[0] + 4 * p2[0] - p3[0]) * t2 + (-p0[0] + 3 * p1[0] - 3 * p2[0] + p3[0]) * t3),
+                0.5 * (2 * p1[1] + (-p0[1] + p2[1]) * t + (2 * p0[1] - 5 * p1[1] + 4 * p2[1] - p3[1]) * t2 + (-p0[1] + 3 * p1[1] - 3 * p2[1] + p3[1]) * t3),
+            ]);
+        }
+    }
+    out.push(wp[wp.length - 1]);
+    return out;
+}
+/** The letter for a character: a drawn capital, a small letter (a capital with no drawing of its own is that letter set 1.7 times as tall), or `undefined`. */
+function letterOf(ch) {
+    if (Object.hasOwn(UPPER, ch))
+        return { letter: UPPER[ch], k: 1 };
+    const low = ch.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
+    if (low.length !== 1 || !Object.hasOwn(LOWER, low))
+        return undefined;
+    return { letter: LOWER[low], k: ch === ch.toUpperCase() && ch !== ch.toLowerCase() ? 1.7 : 1 };
+}
+/** The width of a word in the grid. */
+export function scriptWidth(text) {
+    let x = 0;
+    for (const ch of [...text]) {
+        if (ch === " ")
+            x += 5;
+        else {
+            const l = letterOf(ch);
+            if (l !== undefined)
+                x += l.letter.adv * l.k;
+        }
+    }
+    return x;
+}
+/**
+ * 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 function scriptRuns(text) {
+    const runs = [];
+    let x = 0;
+    for (const ch of [...text]) {
+        if (ch === " ") {
+            x += 5;
+            continue;
+        }
+        const l = letterOf(ch);
+        if (l === undefined)
+            continue;
+        for (const stroke of l.letter.d.split(";")) {
+            const wp = stroke.trim().split(/\s+/).map((p) => p.split(",").map(Number));
+            const pts = through(wp).map(([px, py]) => [x + px * l.k + SLANT * py * l.k, py * l.k]);
+            const tier = pts.slice(1).map((p, i) => {
+                const a = pts[i];
+                const dx = p[0] - a[0], dy = p[1] - a[1];
+                const down = Math.max(0, -dy / (Math.hypot(dx, dy) || 1));
+                return down > 0.62 ? 2 : down > 0.2 ? 1 : 0;
+            });
+            runs.push({ pts, tier });
+        }
+        x += l.letter.adv * l.k;
+    }
+    return runs;
+}

package/dist/emblems/ball/ball.soccer.js

@@ -4,7 +4,7 @@ import { defineBall } from "./ball.engine.js";
 import { truncatedIcosahedron } from "./ball.polyhedra.js";
 import { add, mul, norm } from "./ball.math.js";
 import { blend, mix } from "./ball.core.js";
-import { SOCCER_SIZE } from "./ball.soccer.size.js";
+import { CLASSIC_HOME, SOCCER_SIZE } from "./ball.soccer.size.js";
 const SEAM = "#6b7180";
 export const BALL_SOCCER = /* @__PURE__ */ defineBall({
     id: "ball:soccer",
@@ -16,11 +16,13 @@ export const BALL_SOCCER = /* @__PURE__ */ defineBall({
         base: "#1e2025",
         ground: "#f8f8f6",
         mat: { gloss: 0.8, shade: "#2a3450", grain: { f: 1.1, a: 0.16 } },
-        draw(s, base) {
+        home: CLASSIC_HOME,
+        draw(s, base, _accent, _colors, custom) {
             const t = truncatedIcosahedron();
             let out = "";
             for (const p of t.pentagons)
                 out += s.panel(p, base, { ink: true });
+            out += custom?.printer?.(s, custom.print, "soccer", [custom.paint?.body ?? "#f8f8f6"]) ?? "";
             out += s.strokes(t.edges, SEAM, 1.15);
             out += s.strokes(t.edges, "#fff", 0.45, { deco: true, opacity: 0.5, dx: 0.3, dy: 0.35 });
             return out;
@@ -37,7 +39,8 @@ export const BALL_SOCCER_COLOUR = /* @__PURE__ */ defineBall({
         base: "#d4283c",
         ground: "#f8f8f6",
         mat: { gloss: 0.8, shade: "#3a2030", grain: { f: 1.1, a: 0.16 } },
-        draw(s, base) {
+        home: CLASSIC_HOME,
+        draw(s, base, _accent, _colors, custom) {
             const t = truncatedIcosahedron();
             const light = blend(base, "#ffffff", 0.45);
             let out = "";
@@ -47,6 +50,7 @@ export const BALL_SOCCER_COLOUR = /* @__PURE__ */ defineBall({
             });
             for (const p of t.pentagons)
                 out += s.panel(p, base, { ink: true });
+            out += custom?.printer?.(s, custom.print, "soccer", [custom.paint?.body ?? "#f8f8f6", light]) ?? "";
             out += s.strokes(t.edges, mix(base, -0.35), 1.1);
             out += s.strokes(t.edges, "#fff", 0.45, { deco: true, opacity: 0.45, dx: 0.3, dy: 0.35 });
             return out;

package/dist/emblems/ball/ball.soccer.panels.d.ts

@@ -7,6 +7,8 @@ export interface Tones {
     /** A third tone between the light and the mid one, for a third kind of panel. */
     deep: string;
     seam: string;
+    /** What a layout lays between its panels and its seams (the print of a ball that has one), if it has any. */
+    under?: (s: Surface) => string;
 }
 export type Layout = (s: Surface, t: Tones) => string;
 export declare const classic: Layout;

package/dist/emblems/ball/ball.soccer.panels.js

@@ -5,7 +5,7 @@ import { blend, mix } from "./ball.core.js";
 import { strips18 } from "./ball.family.panelled.js";
 import { truncatedIcosahedron } from "./ball.polyhedra.js";
 import { dodecahedron, gores, propellers14, rhombicuboctahedron } from "./ball.tilings.js";
-import { SOCCER_SIZE } from "./ball.soccer.size.js";
+import { CLASSIC_HOME, SOCCER_SIZE } from "./ball.soccer.size.js";
 const INK = "#1e2025";
 const WHITE = "#f8f8f6";
 const SEAM = "#6b7180";
@@ -16,6 +16,7 @@ export const classic = (s, t) => {
     let out = "";
     for (const p of g.pentagons)
         out += s.panel(p, t.dark, { ink: true });
+    out += t.under?.(s) ?? "";
     out += s.strokes(g.edges, t.seam, 1.15);
     return out + lit(s, g.edges);
 };
@@ -94,7 +95,8 @@ function specOf(construction, way, view) {
             base: INK,
             ground: WHITE,
             mat: construction === 6 ? { ...gloss, gloss: 0.9, grain: { f: 0.7, a: 0.07 } } : gloss,
-            draw: (s, base, accent) => layout(s, { light: WHITE, dark: base, mid: accent ?? "#dfe2ea", deep: blend(accent ?? "#dfe2ea", base, 0.12), seam: SEAM }),
+            home: construction === "classic" ? CLASSIC_HOME : undefined,
+            draw: (s, base, accent, _colors, custom) => layout(s, { light: WHITE, dark: base, mid: accent ?? "#dfe2ea", deep: blend(accent ?? "#dfe2ea", base, 0.12), seam: SEAM, under: construction === "classic" ? (u) => custom?.printer?.(u, custom.print, "soccer", [custom.paint?.body ?? WHITE]) ?? "" : undefined }),
         };
     }
     const c = COLOURWAYS[way];
@@ -102,7 +104,8 @@ function specOf(construction, way, view) {
         view,
         base: c.base,
         mat: { ...(construction === 6 ? { ...gloss, gloss: 0.9, grain: { f: 0.7, a: 0.07 } } : gloss), shade: mix(c.base, -0.65) },
-        draw: (s, base, accent) => layout(s, { light: base, dark: accent ?? c.accent, mid: blend(base, "#ffffff", 0.4), deep: blend(base, "#ffffff", 0.18), seam: mix(base, -0.5) }),
+        home: construction === "classic" ? CLASSIC_HOME : undefined,
+        draw: (s, base, accent, _colors, custom) => layout(s, { light: base, dark: accent ?? c.accent, mid: blend(base, "#ffffff", 0.4), deep: blend(base, "#ffffff", 0.18), seam: mix(base, -0.5), under: construction === "classic" ? (u) => custom?.printer?.(u, custom.print, "soccer", [base]) ?? "" : undefined }),
     };
 }
 /** The id, and the English and Japanese names, of each construction in each colourway (short, because the name is the accessible name: 26 characters in English and 12 in Japanese at most). */

package/dist/emblems/ball/ball.soccer.size.d.ts

@@ -1,2 +1,4 @@
 import type { PieceSize } from "./ball.core.ts";
 export declare const SOCCER_SIZE: PieceSize;
+/** Where the classic 32-panel ball takes a logo and lettering: the middle of a white hexagon, the way up there, and the view that shows it (the hexagon on the far side is the same, so the label can go there). */
+export declare const CLASSIC_HOME: import("./ball.engine.ts").BallSpec["home"];

package/dist/emblems/ball/ball.soccer.size.js

@@ -6,3 +6,11 @@ export const SOCCER_SIZE = {
     rule: "IFAB Laws of the Game, Law 2 The Ball, section 2.1 Qualities and measurements",
     note: "Diameter worked out from the middle of the circumference range (68 to 70 cm).",
 };
+/** Where the classic 32-panel ball takes a logo and lettering: the middle of a white hexagon, the way up there, and the view that shows it (the hexagon on the far side is the same, so the label can go there). */
+export const CLASSIC_HOME = {
+    c: [-0.577, -0.577, -0.577],
+    up: [-0.408, 0.816, -0.408],
+    reach: 0.38,
+    view: { yaw: 124.5, pitch: -40.8, roll: -6.1 },
+    word: "soccer",
+};

package/dist/emblems/ball/ball.softball.js

@@ -1,5 +1,5 @@
 // Softball: an optic-yellow ball with red stitches along the seam (88 here, which the rule leaves free).
-import { seamedBall } from "./ball.family.seamed.js";
+import { SEAMED_HOME, seamedBall } from "./ball.family.seamed.js";
 export const BALL_SOFTBALL = /* @__PURE__ */ seamedBall({
     id: "ball:softball",
     en: "Softball",
@@ -9,6 +9,7 @@ export const BALL_SOFTBALL = /* @__PURE__ */ seamedBall({
     b: 0.4,
     view: { yaw: 18, pitch: 28, roll: -10 },
     mat: { gloss: 0.35, shade: "#4c5a10", grain: { f: 1.4, a: 0.12 } },
+    home: SEAMED_HOME("softball"),
     groove: "#8a9420",
     stitch: { colour: "#d0262c", count: 88, half: 0.085, width: 0.95, lean: 0.04 },
 });