@johnmorrisdotca/dougu-sports 0.5.2 → 0.7.0

package/dist/emblems/emblem.ids.js

@@ -39,8 +39,8 @@ export const GEAR_IDS = [
     "gear:table-tennis-paddle", "gear:badminton-racket", "gear:tennis-racket", "gear:squash-racket", "gear:racquetball-racket", "gear:padel-racket", "gear:pickleball-paddle",
     "gear:roundnet-set", "gear:volleyball-net", "gear:basketball-hoop", "gear:baseball-bat", "gear:baseball-glove", "gear:football-helmet", "gear:goalposts", "gear:hurley",
     "gear:curling-broom", "gear:figure-skate", "gear:speed-skate", "gear:diving-board", "gear:swim-goggles", "gear:starting-blocks", "gear:relay-baton", "gear:javelin", "gear:hurdles",
-    "gear:gunbai", "gear:mawashi", "gear:shinai", "gear:kendo-men", "gear:judogi", "gear:judogi-blue", "gear:judogi-folded", "gear:judogi-blue-folded",
-    "gear:obi", "gear:obi-white", "gear:obi-yellow", "gear:obi-orange", "gear:obi-green", "gear:obi-blue", "gear:obi-brown", "gear:obi-kohaku", "gear:obi-red", "gear:obi-women", "gear:obi-white-yellow", "gear:obi-yellow-orange", "gear:obi-orange-green", "gear:obi-green-blue", "gear:obi-blue-brown",
+    "gear:gunbai", "gear:mawashi", "gear:shinai", "gear:kendo-men", "gear:judogi", "gear:judogi-blue", "gear:judogi-folded", "gear:judogi-blue-folded", "gear:judogi-back", "gear:judogi-blue-back",
+    "gear:obi", "gear:obi-white", "gear:obi-yellow", "gear:obi-orange", "gear:obi-green", "gear:obi-blue", "gear:obi-brown", "gear:obi-kohaku", "gear:obi-red", "gear:obi-women", "gear:obi-white-yellow", "gear:obi-yellow-orange", "gear:obi-orange-green", "gear:obi-green-blue", "gear:obi-blue-brown", "gear:obi-step-1", "gear:obi-step-2", "gear:obi-step-3", "gear:obi-step-4", "gear:obi-step-5", "gear:obi-step-6",
     "gear:yumi", "gear:ya", "gear:karate-gi"
 ];
 /** The Japanese sports and budo: sumo, kendo, judo, kyudo and karate, with the trophies and the gear that belong to them. Every one is also in its own group; this list is for showing them together. */
@@ -48,8 +48,8 @@ export const JAPANESE_IDS = [
     "sport:sumo", "trophy:sumo-cup", "gear:gunbai", "gear:mawashi",
     "trophy:championship-banner",
     "sport:kendo", "gear:shinai", "gear:kendo-men",
-    "sport:judo", "gear:judogi", "gear:judogi-blue", "gear:judogi-folded", "gear:judogi-blue-folded",
-    "gear:obi", "gear:obi-white", "gear:obi-yellow", "gear:obi-orange", "gear:obi-green", "gear:obi-blue", "gear:obi-brown", "gear:obi-kohaku", "gear:obi-red", "gear:obi-women", "gear:obi-white-yellow", "gear:obi-yellow-orange", "gear:obi-orange-green", "gear:obi-green-blue", "gear:obi-blue-brown",
+    "sport:judo", "gear:judogi", "gear:judogi-blue", "gear:judogi-folded", "gear:judogi-blue-folded", "gear:judogi-back", "gear:judogi-blue-back",
+    "gear:obi", "gear:obi-white", "gear:obi-yellow", "gear:obi-orange", "gear:obi-green", "gear:obi-blue", "gear:obi-brown", "gear:obi-kohaku", "gear:obi-red", "gear:obi-women", "gear:obi-white-yellow", "gear:obi-yellow-orange", "gear:obi-orange-green", "gear:obi-green-blue", "gear:obi-blue-brown", "gear:obi-step-1", "gear:obi-step-2", "gear:obi-step-3", "gear:obi-step-4", "gear:obi-step-5", "gear:obi-step-6",
     "sport:kyudo", "gear:yumi", "gear:ya",
     "sport:karate", "gear:karate-gi",
 ];

package/dist/emblems/gear/gear.budo.d.ts

@@ -1,4 +1,5 @@
 import type { PieceOptions } from "../ball/ball.core.ts";
+import { type Part } from "./gear.core.ts";
 /**
  * The colours of the judo belts, which `tint` takes: the six kyu colours in order, black (1st to 5th dan), `kohaku` (the red of the red-and-white belt of the 6th to 8th dan, whose white panels are the accent) and
  * `red` (9th and 10th dan). The Kodokan's own kyu belts are white and brown only; the colours between are a later, national addition, so a country's order may differ.
@@ -15,13 +16,75 @@ export declare const OBI_RANKS: {
     readonly red: "#c4202e";
 };
 export type ObiRank = keyof typeof OBI_RANKS;
+export type Pt = readonly [number, number];
 /** Judogi colours: the IJF white ("snow white") and blue (between Pantone 285M and 286M). */
 export declare const JUDOGI_WHITE = "#f6f4ee";
 export declare const JUDOGI_BLUE = "#1456b6";
+export declare const f: (n: number) => string;
+export declare const path: (pts: readonly Pt[], close?: boolean) => string;
+/** A rectangle of width `w` along the segment from `a` to `b`, as a polygon. */
+export declare const strip: (a: Pt, b: Pt, w: number) => Pt[];
+export declare const lerp: (a: Pt, b: Pt, t: number) => Pt;
+/** A line parallel to the segment from `a` to `b`, `off` to its side, between the fractions `t0` and `t1` of its length. */
+export declare const along: (a: Pt, b: Pt, off: number, t0: number, t1: number) => string;
+export declare const INK = "#0d1522";
+/** The edge of a black belt: light enough to show on a dark page. */
+export declare const BELT_EDGE = "#5d6672";
+export declare const dark: (d: string, w?: number, op?: number) => Part;
+export declare const light: (d: string, w?: number, op?: number) => Part;
+export interface BeltSpec {
+    /** The colour of the belt, and of its second colour (the other half of a split belt, or the white of the kohaku panels). */
+    main: string;
+    alt?: string;
+    /** Centre and ends of the two wraps, the top of the first one, the width of the belt and how far its wraps sag at the middle (the belt is round). */
+    cx: number;
+    x0: number;
+    x1: number;
+    y: number;
+    w: number;
+    sag: number;
+    /** The knot's width, the length of the ends and how far they hang apart (degrees). */
+    knot: number;
+    tail: number;
+    splay: number;
+    /** The length of the end on the right as the wearer is seen (the left end of the wearer), where it is not `tail`: a knot just tied has one end longer than the other. */
+    tail2?: number;
+    /** Panels of the red-and-white belt: the x where the panel colour changes along the first and the second wrap, and the colour of the ends. */
+    panels?: {
+        upper: readonly number[];
+        lower: readonly number[];
+        tail: string;
+    };
+    /** A split belt: the second colour fills the lower half of the belt's width, lengthwise. */
+    half?: boolean;
+    /** The white stripe of a women's black belt, down the middle of the belt. */
+    stripe?: boolean;
+    /** A bar across each end. */
+    bars?: boolean;
+    /** The edge of the belt, where a darker tone of the belt itself would vanish (a black belt on a dark page). */
+    edge?: string;
+}
+/** A belt tied at the front: two wraps, a flat square knot and two equal ends hanging a little apart. Parts, back to front. */
+export declare function belt(s: BeltSpec): Part[];
+/**
+ * The judogi laid flat: jacket (sleeves out to the sides, lapels crossed left over right, thick stitched collar, quilted upper body, vented skirt), the belt tied over it and the trousers below with a drawstring
+ * waist and reinforced knees. `$main` is the cloth, `$accent` the belt.
+ */
+export declare function judogiFlat(torso?: boolean): Part[];
 export declare const GEAR_JUDOGI: import("./gear.index.ts").Piece<import("./gear.core.ts").GearSpec>;
 export declare const GEAR_JUDOGI_BLUE: import("./gear.index.ts").Piece<import("./gear.core.ts").GearSpec>;
 export declare const GEAR_JUDOGI_FOLDED: import("./gear.index.ts").Piece<import("./gear.core.ts").GearSpec>;
 export declare const GEAR_JUDOGI_BLUE_FOLDED: import("./gear.index.ts").Piece<import("./gear.core.ts").GearSpec>;
+export declare const GEAR_JUDOGI_BACK: import("./gear.index.ts").Piece<{
+    main: string;
+    accent: "#1f2228";
+    parts: Part[];
+}>;
+export declare const GEAR_JUDOGI_BLUE_BACK: import("./gear.index.ts").Piece<{
+    main: string;
+    accent: "#1f2228";
+    parts: Part[];
+}>;
 export declare const GEAR_KARATE_GI: import("./gear.index.ts").Piece<import("./gear.core.ts").GearSpec>;
 export declare const GEAR_OBI: import("./gear.index.ts").Piece<import("./gear.core.ts").GearSpec>;
 export declare const GEAR_OBI_WHITE: import("./gear.index.ts").Piece<import("./gear.core.ts").GearSpec>;

package/dist/emblems/gear/gear.budo.js

@@ -1,4 +1,5 @@
-import { drawn, rect } from "./gear.core.js";
+import { fitSize, linePath } from "../ball/ball.letters.js";
+import { defineGear, drawGear, drawn, rect } from "./gear.core.js";
 /**
  * The colours of the judo belts, which `tint` takes: the six kyu colours in order, black (1st to 5th dan), `kohaku` (the red of the red-and-white belt of the 6th to 8th dan, whose white panels are the accent) and
  * `red` (9th and 10th dan). The Kodokan's own kyu belts are white and brown only; the colours between are a later, national addition, so a country's order may differ.
@@ -17,25 +18,55 @@ export const OBI_RANKS = {
 /** Judogi colours: the IJF white ("snow white") and blue (between Pantone 285M and 286M). */
 export const JUDOGI_WHITE = "#f6f4ee";
 export const JUDOGI_BLUE = "#1456b6";
-const f = (n) => String(Math.round(n * 10) / 10);
-const path = (pts, close = true) => `M${pts.map((p) => `${f(p[0])} ${f(p[1])}`).join("L")}${close ? "z" : ""}`;
+export const f = (n) => String(Math.round(n * 10) / 10);
+export const path = (pts, close = true) => `M${pts.map((p) => `${f(p[0])} ${f(p[1])}`).join("L")}${close ? "z" : ""}`;
 const mirror = (pts) => pts.map((p) => [64 - p[0], p[1]]);
 /** A rectangle of width `w` along the segment from `a` to `b`, as a polygon. */
-const strip = (a, b, w) => {
+export const strip = (a, b, w) => {
     const dx = b[0] - a[0], dy = b[1] - a[1];
     const l = Math.hypot(dx, dy) || 1;
     const nx = (-dy / l) * (w / 2), ny = (dx / l) * (w / 2);
     return [[a[0] + nx, a[1] + ny], [b[0] + nx, b[1] + ny], [b[0] - nx, b[1] - ny], [a[0] - nx, a[1] - ny]];
 };
-const lerp = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+export const lerp = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
 /** A line parallel to the segment from `a` to `b`, `off` to its side, between the fractions `t0` and `t1` of its length. */
-const along = (a, b, off, t0, t1) => {
+export const along = (a, b, off, t0, t1) => {
     const dx = b[0] - a[0], dy = b[1] - a[1];
     const l = Math.hypot(dx, dy) || 1;
     const nx = (-dy / l) * off, ny = (dx / l) * off;
     const p0 = lerp(a, b, t0), p1 = lerp(a, b, t1);
     return `M${f(p0[0] + nx)} ${f(p0[1] + ny)}L${f(p1[0] + nx)} ${f(p1[1] + ny)}`;
 };
+/**
+ * A sleeve of the jacket's left side, hanging out and down from the armhole: its axis `deg` below the horizontal, `len` long from the middle of the armhole to the middle of the cuff, and the cuff `cuff` wide. The
+ * corners, in order: the top of the shoulder, the outer corner of the cuff, its inner corner and the underarm. Everything is measured from this shape (test/judo.test.ts).
+ */
+function hangingSleeve(top, under, deg, len, cuff) {
+    const a = (deg * Math.PI) / 180;
+    const mid = lerp(top, under, 0.5);
+    const tip = [mid[0] - Math.cos(a) * len, mid[1] + Math.sin(a) * len];
+    const hx = (Math.sin(a) * cuff) / 2, hy = (Math.cos(a) * cuff) / 2;
+    return [top, [tip[0] - hx, tip[1] - hy], [tip[0] + hx, tip[1] + hy], under];
+}
+/** The judogi's sleeve (IJF C1.10): to the wrist bone, about four fifths as long as the jacket, and wide at the cuff so that the forearm has room all the way. */
+const JUDOGI_SLEEVE = hangingSleeve([19.8, 6.4], [18.6, 22.4], 60, 26, 8.8);
+/** The karate-gi's sleeve (WKF 2.2.1 j): three-quarter length, between half the forearm and the bend of the wrist. */
+const KARATE_SLEEVE = hangingSleeve([20.6, 8], [19.4, 22], 56, 23.6, 8.8);
+/** Rows of quilting across a sleeve, from its top edge to its underside, leaving the ends of each row a little short of the seams. */
+function sleeveRows(pts) {
+    let d = "";
+    for (let t = 0.1; t <= 0.9; t += 0.08) {
+        const a = lerp(pts[0], pts[1], t), b = lerp(pts[3], pts[2], t);
+        const a2 = lerp(a, b, 0.07), b2 = lerp(a, b, 0.93);
+        d += `M${f(a2[0])} ${f(a2[1])}L${f(b2[0])} ${f(b2[1])}`;
+    }
+    return d;
+}
+/** The hem of a sleeve's cuff, stitched across at the fraction `t` of the way from the shoulder. */
+const cuffHem = (sleeve, t = 0.9) => {
+    const a = lerp(sleeve[0], sleeve[1], t), b = lerp(sleeve[3], sleeve[2], t);
+    return `M${f(a[0])} ${f(a[1])}L${f(b[0])} ${f(b[1])}`;
+};
 /** Horizontal rows (every `step`, from `y0` to `y1`) clipped to a convex polygon, as one path. */
 function rows(poly, y0, y1, step, inset = 0) {
     let d = "";
@@ -55,13 +86,13 @@ function rows(poly, y0, y1, step, inset = 0) {
     return d;
 }
 // Cloth lines are laid over the cloth as ink at low opacity (dark rows) or as light rows, so they follow any tint.
-const INK = "#0d1522";
+export const INK = "#0d1522";
 /** The edge of a black belt: light enough to show on a dark page. */
-const BELT_EDGE = "#5d6672";
-const dark = (d, w = 0.3, op = 0.2) => ({ d, fill: "none", stroke: INK, w, op, line: "none" });
-const light = (d, w = 0.3, op = 0.3) => ({ d, fill: "none", stroke: "#ffffff", w, op, line: "none" });
+export const BELT_EDGE = "#5d6672";
+export const dark = (d, w = 0.3, op = 0.2) => ({ d, fill: "none", stroke: INK, w, op, line: "none" });
+export const light = (d, w = 0.3, op = 0.3) => ({ d, fill: "none", stroke: "#ffffff", w, op, line: "none" });
 /** A belt tied at the front: two wraps, a flat square knot and two equal ends hanging a little apart. Parts, back to front. */
-function belt(s) {
+export function belt(s) {
     const parts = [];
     const hw = (s.x1 - s.x0) / 2;
     const w = s.w;
@@ -109,7 +140,8 @@ function belt(s) {
     const tailFill = s.panels?.tail ?? s.main;
     for (const side of [-1, 1]) {
         const a = [s.cx + side * kw * 0.2, yc + hh * 0.2];
-        const b = [a[0] + side * Math.sin(rad) * s.tail, a[1] + Math.cos(rad) * s.tail];
+        const length = side === 1 ? (s.tail2 ?? s.tail) : s.tail;
+        const b = [a[0] + side * Math.sin(rad) * length, a[1] + Math.cos(rad) * length];
         parts.push({ d: path(strip(a, b, tw)), fill: tailFill, stroke: s.edge, cyl: 0.55, shade: 0.25 });
         if (s.half === true) {
             const q = strip(a, b, tw);
@@ -120,7 +152,7 @@ function belt(s) {
         if (s.stripe === true)
             parts.push({ d: path(strip(lerp(a, b, 0.25), lerp(a, b, 1), tw * 0.15)), fill: "#f6f4ee", stroke: "none", line: "none" });
         if (s.bars === true)
-            parts.push({ d: path(strip(lerp(a, b, 1 - 3.4 / s.tail), lerp(a, b, 1 - 2.2 / s.tail), tw)), fill: "$accent", stroke: "none", op: 0.9, line: "none" });
+            parts.push({ d: path(strip(lerp(a, b, 1 - 3.4 / length), lerp(a, b, 1 - 2.2 / length), tw)), fill: "$accent", stroke: "none", op: 0.9, line: "none" });
     }
     const kfill = s.panels === undefined ? s.main : alt;
     const blob = rect(s.cx - kw / 2, yt, kw, hh * 2, Math.min(2.4, kw * 0.22));
@@ -141,13 +173,9 @@ function belt(s) {
     return parts;
 }
 // ───────────────────────────── the judogi ─────────────────────────────
-/**
- * The judogi laid flat: jacket (sleeves out to the sides, lapels crossed left over right, thick stitched collar, quilted upper body, vented skirt), the belt tied over it and the trousers below with a drawstring
- * waist and reinforced knees. `$main` is the cloth, `$accent` the belt.
- */
-function judogiFlat() {
+/** The judogi's trousers laid flat: straight legs, a waistband with its drawstring, reinforced knees. */
+function judogiTrousers() {
     const parts = [];
-    // Trousers, behind everything: straight legs, a waistband with its drawstring, reinforced knees.
     const trousers = [[18.4, 37], [45.6, 37], [46.6, 62], [34.6, 62], [32, 43.6], [29.4, 62], [17.4, 62]];
     parts.push({ d: path(trousers), fill: "$main", shade: 0.3, cyl: 0.25 });
     parts.push({ d: path([[18.4, 37], [45.6, 37], [45.7, 39.8], [18.3, 39.8]]), fill: "$main", shade: 0.2 });
@@ -159,9 +187,20 @@ function judogiFlat() {
         parts.push(dark(path(k) + rows(k, 51.4, 56.4, 1.6, 0.3), 0.28, 0.35));
     }
     parts.push(dark("M17.6 60.2H29.6M34.4 60.2H46.4", 0.3, 0.3));
-    // Sleeves: long, wide, ending past the wrist, laid out and down.
-    const sleeve = [[19.8, 6.4], [1.4, 20.2], [4.6, 27.6], [18.6, 22.4]];
-    for (const pts of [sleeve, mirror(sleeve)])
+    return parts;
+}
+/**
+ * The judogi laid flat: jacket (sleeves out to the sides, lapels crossed left over right, thick stitched collar, quilted upper body, vented skirt), the belt tied over it and the trousers below with a drawstring
+ * waist and reinforced knees. `$main` is the cloth, `$accent` the belt.
+ */
+export function judogiFlat(torso = false) {
+    const parts = [];
+    // Trousers, behind everything: straight legs, a waistband with its drawstring, reinforced knees. A torso (the jacket alone, for the close-ups of the belt) has no trousers, no sleeves and no belt.
+    if (!torso)
+        parts.push(...judogiTrousers());
+    // Sleeves: to the wrist, the arms hanging out and down (IJF C1.10: the sleeve covers the wrist bone, at most 5 cm short of it, and is loose all along the forearm).
+    const sleeves = torso ? [] : [JUDOGI_SLEEVE, mirror(JUDOGI_SLEEVE)];
+    for (const pts of sleeves)
         parts.push({ d: path(pts), fill: "$main", cyl: 0.15, shade: 0.35 });
     const jacket = [[19.4, 6.6], [26.2, 4], [32, 3.2], [37.8, 4], [44.6, 6.6], [45.6, 8], [45.6, 36], [18.4, 36], [18.4, 8]];
     parts.push({ d: path(jacket), fill: "$main", shade: 0.35, cyl: 0.18 });
@@ -169,15 +208,11 @@ function judogiFlat() {
     const body = [[19, 7], [45, 7], [45.6, 26], [18.4, 26]];
     parts.push(dark(rows(body, 8, 25, 1.4, 0.5), 0.28, 0.1));
     parts.push(light(rows(body, 8.5, 25.5, 1.4, 0.5), 0.24, 0.2));
-    for (const pts of [sleeve, mirror(sleeve)]) {
-        let d = "";
-        for (let t = 0.1; t <= 0.9; t += 0.08) {
-            const a = lerp(pts[0], pts[1], t), b = lerp(pts[3], pts[2], t);
-            const a2 = lerp(a, b, 0.07), b2 = lerp(a, b, 0.93);
-            d += `M${f(a2[0])} ${f(a2[1])}L${f(b2[0])} ${f(b2[1])}`;
-        }
-        parts.push(dark(d, 0.28, 0.1));
-    }
+    for (const pts of sleeves)
+        parts.push(dark(sleeveRows(pts), 0.28, 0.1));
+    // The loose cuff: a hem stitched a little in from the open end, on both sleeves.
+    for (const pts of sleeves)
+        parts.push(dark(cuffHem(pts), 0.3, 0.38));
     // The neck: the collar goes round the back of the neck, and the opening is a V that ends under 10 cm below the sternum.
     parts.push({ d: path([[26.4, 4.2], [37.6, 4.2], [33.4, 14]]), fill: INK, stroke: INK, w: 0.3, op: 0.62, line: "none" });
     parts.push({ d: "M25.4 5.4Q32 2 38.6 5.4L37.6 8.2Q32 5.4 26.4 8.2Z", fill: "$main", cyl: 0.4, shade: 0.3 });
@@ -202,7 +237,8 @@ function judogiFlat() {
     parts.push(dark("M18.8 34.4H44.8", 0.3, 0.32));
     parts.push(dark("M20.2 31.4V36M43.8 31.4V36", 0.4, 0.45));
     // The belt, over the jacket, wrapped twice.
-    parts.push(...belt({ edge: BELT_EDGE, main: "$accent", cx: 32, x0: 18.2, x1: 45.8, y: 25.2, w: 2.5, sag: 0, knot: 6.4, tail: 11.4, splay: 6 }));
+    if (!torso)
+        parts.push(...belt({ edge: BELT_EDGE, main: "$accent", cx: 32, x0: 18.2, x1: 45.8, y: 25.2, w: 2.5, sag: 0, knot: 6.4, tail: 11.4, splay: 6 }));
     return parts;
 }
 /** The judogi folded into a neat rectangle: collar and lapel stitching on top, the belt tied round it. */
@@ -241,6 +277,109 @@ export const GEAR_JUDOGI = /* @__PURE__ */ drawn("gear:judogi", "Judo suit", "
 export const GEAR_JUDOGI_BLUE = /* @__PURE__ */ drawn("gear:judogi-blue", "Blue judo suit", "青い柔道衣", { main: JUDOGI_BLUE, accent: OBI_RANKS.black, parts: judogiFlat() });
 export const GEAR_JUDOGI_FOLDED = /* @__PURE__ */ drawn("gear:judogi-folded", "Folded judo suit", "畳んだ柔道衣", { main: JUDOGI_WHITE, accent: OBI_RANKS.black, parts: judogiFolded() });
 export const GEAR_JUDOGI_BLUE_FOLDED = /* @__PURE__ */ drawn("gear:judogi-blue-folded", "Folded blue judo suit", "畳んだ青い柔道衣", { main: JUDOGI_BLUE, accent: OBI_RANKS.black, parts: judogiFolded() });
+// ───────────────────────────── the judogi from behind, with its back number ─────────────────────────────
+/** The bands of the back number (IJF C1.8): blue for everyone, gold for an Olympic champion and red for a world champion while the title is held. Each with the ink of the family name and the ink of the country code. */
+const BAND = {
+    blue: { band: "#26318f", name: "#fefefe", code: "#26318f" },
+    gold: { band: "#d8a31a", name: "#1b2430", code: "#1b2430" },
+    red: { band: "#c4202e", name: "#fefefe", code: "#c4202e" },
+};
+/** The white of the patch. */
+const PATCH_WHITE = "#fcfcf9";
+/** The back number's size and place, in this drawing's units: the large one is 38 cm wide and 39 cm high (the manual of the IJF's partner, docs/references.md), and the jacket's 27.2 units across stand for about 60 cm. */
+const BACKNUMBER = { x0: 23.4, x1: 40.6, y0: 8.4, y1: 26.1 };
+const cleanName = (value) => typeof value === "string" ? value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toUpperCase().replace(/[^A-Z0-9 '-]/g, "").replace(/\s+/g, " ").trim().slice(0, 16) : "";
+const cleanCode = (value) => (typeof value === "string" ? value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toUpperCase().replace(/[^A-Z]/g, "").slice(0, 3) : "");
+/** A dashed line round the edge of a rectangle, `inset` in from it: the stitching that holds the patch on. */
+function stitches(x0, y0, x1, y1, inset, dash = 0.9, gap = 0.75) {
+    let d = "";
+    const run = (xa, ya, xb, yb) => {
+        const len = Math.hypot(xb - xa, yb - ya);
+        for (let t = 0; t < len - 0.2; t += dash + gap) {
+            const e = Math.min(t + dash, len);
+            d += `M${f(xa + ((xb - xa) * t) / len)} ${f(ya + ((yb - ya) * t) / len)}L${f(xa + ((xb - xa) * e) / len)} ${f(ya + ((yb - ya) * e) / len)}`;
+        }
+    };
+    const a = x0 + inset, b = x1 - inset, c = y0 + inset, e = y1 - inset;
+    run(a, c, b, c);
+    run(b, c, b, e);
+    run(b, e, a, e);
+    run(a, e, a, c);
+    return d;
+}
+/**
+ * The back number as parts: a white patch with the family name in white capitals on a band across the top (the band arched), the three letters of the National Olympic Committee in capitals under it, and the rest
+ * of the patch blank, where the event's sponsor goes. A small square at the left edge stands for the label that makes it authentic. No flag (the IJF's patch has none), no logo, no mark of the IJF or of the maker.
+ */
+function backnumberParts(back) {
+    const parts = [];
+    const { x0, x1, y0, y1 } = BACKNUMBER;
+    const w = x1 - x0, cx = (x0 + x1) / 2;
+    const colours = BAND[back?.band === "gold" || back?.band === "red" ? back.band : "blue"];
+    const name = back?.name === undefined ? "TANAKA" : cleanName(back.name);
+    const code = back?.code === undefined ? "JPN" : cleanCode(back.code);
+    parts.push({ d: rect(x0, y0, w, y1 - y0, 0.3), fill: PATCH_WHITE, stroke: "#7d8594", w: 0.45, shade: 0.12 });
+    parts.push(dark(stitches(x0, y0, x1, y1, 0.5), 0.26, 0.45));
+    parts.push({ d: `M${x0} ${f(y0 + 0.9)}Q${f(cx)} ${f(y0 - 0.5)} ${x1} ${f(y0 + 0.9)}L${x1} ${f(y0 + 4.6)}Q${f(cx)} ${f(y0 + 3.4)} ${x0} ${f(y0 + 4.6)}Z`, fill: colours.band, stroke: colours.band, w: 0.3, shade: 0 });
+    const letters = { weight: 0.2, wide: 0.78 };
+    const nameSize = fitSize(name, letters, w - 3, 2.8);
+    if (name !== "")
+        parts.push({ d: linePath(name, { ...letters, size: nameSize }, cx, y0 + 2.4), fill: "none", stroke: colours.name, w: letters.weight * nameSize });
+    const codeLetters = { weight: 0.24, wide: 1.05 };
+    const codeSize = fitSize(code, codeLetters, 10, 3.2);
+    if (code !== "")
+        parts.push({ d: linePath(code, { ...codeLetters, size: codeSize }, cx, y0 + 8.4), fill: "none", stroke: colours.code, w: codeLetters.weight * codeSize });
+    parts.push({ d: rect(x0 + 0.9, y0 + 7.6, 1.3, 1.3), fill: "#1b2430", stroke: "none", shade: 0, line: "ink" });
+    return parts;
+}
+/** The judogi laid flat and seen from behind: collar, the back of the jacket with the back number sewn on it (its top 3 cm under the collar), the belt crossed behind the waist and the trousers. `$main` is the cloth, `$accent` the belt. */
+function judogiBack(back) {
+    const parts = [];
+    const trousers = [[18.4, 37], [45.6, 37], [46.6, 62], [34.6, 62], [32, 43.6], [29.4, 62], [17.4, 62]];
+    parts.push({ d: path(trousers), fill: "$main", shade: 0.3, cyl: 0.25 });
+    parts.push({ d: path([[18.4, 37], [45.6, 37], [45.7, 39.8], [18.3, 39.8]]), fill: "$main", shade: 0.2 });
+    parts.push(dark("M18.6 38.9H45.4", 0.3, 0.35));
+    parts.push(dark("M17.6 60.2H29.6M34.4 60.2H46.4M32 39.8V43.4", 0.3, 0.3));
+    const sleeve = JUDOGI_SLEEVE;
+    for (const pts of [sleeve, mirror(sleeve)])
+        parts.push({ d: path(pts), fill: "$main", cyl: 0.15, shade: 0.35 });
+    const jacket = [[19.4, 6.6], [26.2, 4], [32, 3.2], [37.8, 4], [44.6, 6.6], [45.6, 8], [45.6, 36], [18.4, 36], [18.4, 8]];
+    parts.push({ d: path(jacket), fill: "$main", shade: 0.35, cyl: 0.18 });
+    parts.push(dark(rows([[19, 7], [45, 7], [45.6, 35], [18.4, 35]], 9, 34, 1.4, 0.5), 0.28, 0.1));
+    parts.push(light(rows([[19, 7], [45, 7], [45.6, 35], [18.4, 35]], 9.5, 34.5, 1.4, 0.5), 0.24, 0.2));
+    for (const pts of [sleeve, mirror(sleeve)])
+        parts.push(dark(sleeveRows(pts), 0.28, 0.1));
+    for (const pts of [sleeve, mirror(sleeve)])
+        parts.push(dark(cuffHem(pts), 0.3, 0.38));
+    parts.push(dark("M18.8 34.4H44.8", 0.3, 0.32));
+    parts.push(dark("M20.2 31.4V36M43.8 31.4V36", 0.4, 0.45));
+    parts.push(...backnumberParts(back));
+    // The collar goes round the back of the neck: a thick, stitched band.
+    parts.push({ d: "M24.6 5.4Q32 2 39.4 5.4L38.8 8.2Q32 5.6 25.2 8.2Z", fill: "$main", cyl: 0.4, shade: 0.3 });
+    parts.push(dark("M25.2 6.9Q32 4.2 38.8 6.9", 0.28, 0.4));
+    // The belt, crossed behind the waist: two wraps, and the two turns that cross in the middle of the back.
+    const edge = { stroke: BELT_EDGE, cyl: 0.5, shade: 0.25 };
+    parts.push({ d: path([[18.2, 27.2], [45.8, 27.2], [45.8, 29.7], [18.2, 29.7]]), fill: "$accent", ...edge });
+    parts.push({ d: path([[18.2, 29.4], [45.8, 29.4], [45.8, 31.9], [18.2, 31.9]]), fill: "$accent", ...edge });
+    parts.push({ d: path(strip([28.4, 27.2], [35.6, 31.9], 2.5)), fill: "$accent", ...edge });
+    parts.push({ d: path(strip([35.6, 27.2], [28.4, 31.9], 2.5)), fill: "$accent", ...edge });
+    parts.push(dark("M18.6 28.4H27M37 28.4H45.4M18.6 30.6H27M37 30.6H45.4", 0.26, 0.3));
+    return parts;
+}
+/** The title of a back view: its name, then (when the call gave a back number) the family name and the country code that are on it. */
+const backTitle = (en, back) => {
+    if (back === undefined)
+        return en;
+    const name = back.name === undefined ? "TANAKA" : cleanName(back.name);
+    const code = back.code === undefined ? "JPN" : cleanCode(back.code);
+    return [en, `${name} ${code}`.trim()].filter((t) => t !== "").join(", ");
+};
+const backPiece = (id, en, ja, main) => {
+    const spec = { main, accent: OBI_RANKS.black, parts: judogiBack(undefined) };
+    return defineGear({ id, en, ja, source: "drawn", model: spec, draw: (o) => drawGear(id, backTitle(en, o?.backnumber), { ...spec, parts: o?.backnumber === undefined ? spec.parts : judogiBack(o.backnumber) }, o) });
+};
+export const GEAR_JUDOGI_BACK = /* @__PURE__ */ backPiece("gear:judogi-back", "Judo suit, back view", "柔道衣の背面", JUDOGI_WHITE);
+export const GEAR_JUDOGI_BLUE_BACK = /* @__PURE__ */ backPiece("gear:judogi-blue-back", "Blue judo suit, back view", "青い柔道衣の背面", JUDOGI_BLUE);
 // ───────────────────────────── the karate-gi ─────────────────────────────
 /** The karate-gi laid flat: lighter cloth (no quilting), a plain narrow collar, shorter jacket and sleeves than the judogi, tie strings, ankle-length trousers and the belt. `$main` is the cloth, `$accent` the belt. */
 function karateFlat() {
@@ -251,10 +390,12 @@ function karateFlat() {
     parts.push(dark("M19.6 41.4H44.4", 0.3, 0.3));
     parts.push({ d: "M26 41.8Q24.4 44.6 25.4 47M27.6 41.8Q28.4 44.4 27.4 46.8", fill: "none", stroke: INK, w: 0.35, op: 0.45, line: "none" });
     parts.push(dark("M18.8 60H29.6M34.4 60H45.2", 0.3, 0.25));
-    // Sleeves reach the bend of the wrist at most (WKF 2.2.1 j), so they are shorter than a judogi's, with a wide cuff.
-    const sleeve = [[20.6, 8], [8.6, 16.6], [11.8, 23], [19.4, 22]];
+    // Sleeves reach the bend of the wrist at most and halfway down the forearm at least (WKF 2.2.1 j): three-quarter length, a little shorter than a judogi's, with a wide cuff.
+    const sleeve = KARATE_SLEEVE;
     for (const pts of [sleeve, mirror(sleeve)])
         parts.push({ d: path(pts), fill: "$main", shade: 0.3, cyl: 0.12 });
+    for (const pts of [sleeve, mirror(sleeve)])
+        parts.push(dark(cuffHem(pts, 0.88), 0.3, 0.3));
     const jacket = [[20.2, 8], [26.6, 5.2], [32, 4.4], [37.4, 5.2], [43.8, 8], [44.8, 38.6], [19.2, 38.6]];
     parts.push({ d: path(jacket), fill: "$main", shade: 0.3, cyl: 0.15 });
     // Neck: a wide V that ends lower than the judogi's, a plain thin collar.

package/dist/emblems/gear/gear.budo.steps.d.ts

@@ -0,0 +1,35 @@
+import { type Part } from "./gear.core.ts";
+import type { PieceOptions } from "../ball/ball.core.ts";
+export type ObiStep = 1 | 2 | 3 | 4 | 5 | 6;
+export declare const GEAR_OBI_STEP_1: import("./gear.index.ts").Piece<{
+    main: string;
+    accent: string;
+    parts: Part[];
+}>;
+export declare const GEAR_OBI_STEP_2: import("./gear.index.ts").Piece<{
+    main: string;
+    accent: string;
+    parts: Part[];
+}>;
+export declare const GEAR_OBI_STEP_3: import("./gear.index.ts").Piece<{
+    main: string;
+    accent: string;
+    parts: Part[];
+}>;
+export declare const GEAR_OBI_STEP_4: import("./gear.index.ts").Piece<{
+    main: string;
+    accent: string;
+    parts: Part[];
+}>;
+export declare const GEAR_OBI_STEP_5: import("./gear.index.ts").Piece<{
+    main: string;
+    accent: string;
+    parts: Part[];
+}>;
+export declare const GEAR_OBI_STEP_6: import("./gear.index.ts").Piece<{
+    main: string;
+    accent: string;
+    parts: Part[];
+}>;
+/** One step of tying the belt, 1 to 6, with the usual options (`tint` is the jacket's colour, `accent` the belt's). A number that is not a step from 1 to 6 draws the last one. */
+export declare const obiStep: (step: ObiStep, options?: PieceOptions) => string;

package/dist/emblems/gear/gear.budo.steps.js

@@ -0,0 +1,146 @@
+// How a judo belt is tied, in six pictures: the torso of the judogi (the same jacket as `gear:judogi`, lapels crossed left over right, so the wearer's left panel lies on top and the funeral wrap's opposite is
+// avoided) in close-up, and the belt (`$accent`, black by default) at each stage. The belt is the one `gear:judogi` and the belts are drawn with, so a step's belt takes `accent` like theirs.
+//
+//   1. the middle of the belt against the belly;  2. wrapped twice round the waist, both ends back in front;  3. the ends crossed in front;  4. one end brought up under both layers;
+//   5. the flat square knot (hon-musubi, 本結び);  6. both ends hanging even.
+//
+// The close-up is the jacket alone, drawn 1.55 times as big, so that the belt's width and the knot read at small sizes; a red number says which step it is, and a few small red marks (the middle, the way an end
+// travels, the equal lengths) say what to look at. The marks and the number are not the suit's, so they ignore `tint` and `accent`.
+import { circle, defineGear, drawGear, rect } from "./gear.core.js";
+import { fitSize, linePath } from "../ball/ball.letters.js";
+import { BELT_EDGE, belt, dark, f, judogiFlat, light, lerp, path, strip } from "./gear.budo.js";
+/** The belt's width in the jacket's own units (the judogi's), the two wraps' tops, and the middle of the belly. */
+const W = 2.5;
+const Y_UPPER = 25.2;
+const Y_LOWER = 27.4;
+const X0 = 18.2;
+const X1 = 45.8;
+const MID = 32;
+/** The length of the two ends in these pictures: a little shorter than the judogi's, so that they stay inside the picture. */
+const TAIL = 9.5;
+/** The red of the marks. */
+const MARK = "#d8342c";
+const MARK_EDGE = "#8f1d17";
+/** The close-up: the jacket, 1.55 times as big, with the belt about at the middle of the picture. */
+const ZOOM = "translate(32 32) scale(1.55) translate(-32 -21.6)";
+/** One wrap of the belt across the front, its top at `y`, drawn as the judogi's belt is: the band, two rows of stitching and their highlights. */
+function wrap(y, x0 = X0, x1 = X1) {
+    const row = (off) => `M${f(x0 + 0.8)} ${f(y + W * off)}H${f(x1 - 0.8)}`;
+    return [
+        { d: rect(x0, y, Math.round((x1 - x0) * 10) / 10, W), fill: "$accent", stroke: BELT_EDGE, cyl: 0.5, shade: 0.25 },
+        dark(row(0.3) + row(0.7), 0.28, 0.3),
+        light(`M${f(x0 + 0.8)} ${f(y + W * 0.3 + 0.35)}H${f(x1 - 0.8)}M${f(x0 + 0.8)} ${f(y + W * 0.7 + 0.35)}H${f(x1 - 0.8)}`, 0.25, 0.2),
+    ];
+}
+/** One end of the belt, from `a` to `b`: a strip with its two rows of stitching. */
+function end(a, b, width = W * 1.02) {
+    const dx = b[0] - a[0], dy = b[1] - a[1];
+    const l = Math.hypot(dx, dy) || 1;
+    const stitch = (off, t0, t1) => {
+        const p = lerp(a, b, t0), q = lerp(a, b, t1);
+        const nx = (-dy / l) * off, ny = (dx / l) * off;
+        return `M${f(p[0] + nx)} ${f(p[1] + ny)}L${f(q[0] + nx)} ${f(q[1] + ny)}`;
+    };
+    return [
+        { d: path(strip(a, b, width)), fill: "$accent", stroke: BELT_EDGE, cyl: 0.55, shade: 0.25 },
+        dark(stitch(-width * 0.18, 0.15, 0.97) + stitch(width * 0.18, 0.15, 0.97), 0.28, 0.3),
+        light(stitch(-width * 0.18 + 0.35, 0.15, 0.97) + stitch(width * 0.18 + 0.35, 0.15, 0.97), 0.25, 0.2),
+    ];
+}
+/** A small red mark: a line or a filled shape in the colour of the marks, drawn as ink in the line style too. */
+const mark = (d, w = 0.6) => ({ d, fill: "none", stroke: MARK, w });
+/** An arrow from `a` to `b`, with its head. */
+function arrow(a, b, head = 1.7) {
+    const dx = b[0] - a[0], dy = b[1] - a[1];
+    const l = Math.hypot(dx, dy) || 1;
+    const ux = dx / l, uy = dy / l;
+    const h = (s) => `${f(b[0] - ux * head + -uy * head * s * 0.6)} ${f(b[1] - uy * head + ux * head * s * 0.6)}`;
+    return mark(`M${f(a[0])} ${f(a[1])}L${f(b[0])} ${f(b[1])}M${h(1)}L${f(b[0])} ${f(b[1])}L${h(-1)}`, 0.7);
+}
+/** The belt at each step, in the jacket's units, back to front. */
+function beltAt(step) {
+    const ends = (cx) => [cx - 3.2, cx + 3.2];
+    switch (step) {
+        case 1: {
+            // One layer across the belly, a notch marking the middle of the belt, and a red arrow down to it.
+            const y = 26.3;
+            return [...wrap(y), mark(`M${MID} ${f(y + 0.3)}V${f(y + W - 0.3)}`, 0.5), arrow([MID, y - 5.6], [MID, y - 0.8])];
+        }
+        case 2: {
+            // Two wraps, and the ends that came round the back hanging free in front, apart.
+            const [l, r] = ends(MID);
+            return [...wrap(Y_LOWER), ...wrap(Y_UPPER), ...end([l, Y_LOWER + 0.8], [l - 0.4, Y_LOWER + 0.8 + TAIL]), ...end([r, Y_LOWER + 0.8], [r + 0.4, Y_LOWER + 0.8 + TAIL])];
+        }
+        case 3: {
+            // The ends cross: the one on the wearer's left (the right of the picture) lies over the other.
+            const top = Y_LOWER + 0.8;
+            return [...wrap(Y_LOWER), ...wrap(Y_UPPER), ...end([MID - 2.4, top], [MID + 3.6, top + TAIL - 0.6]), ...end([MID + 2.4, top], [MID - 3.6, top + TAIL - 0.6])];
+        }
+        case 4: {
+            // One end goes up under both wraps: it shows below the belt and again above it, the wraps hiding the middle of it, and a red arrow follows its way.
+            const x = MID - 1.8;
+            const under = end([x, Y_UPPER - 4.2], [x, Y_LOWER + 6.8]);
+            const hanging = end([MID + 3.4, Y_LOWER + 0.8], [MID + 3.8, Y_LOWER + 0.8 + TAIL]);
+            return [...under, ...wrap(Y_LOWER), ...wrap(Y_UPPER), ...hanging, arrow([MID - 5.8, Y_LOWER + 8.4], [MID - 5.8, Y_UPPER - 5.2])];
+        }
+        case 5: {
+            // The knot: two half knots, the second laid the other way (the flat square knot), so the ends are not yet even, and a red turn over it for each half.
+            const y = Y_UPPER + (Y_LOWER + W - Y_UPPER) / 2;
+            return [
+                ...belt({ edge: BELT_EDGE, main: "$accent", cx: MID, x0: X0, x1: X1, y: Y_UPPER, w: W, sag: 0, knot: 6.4, tail: TAIL + 1.2, tail2: TAIL - 2.6, splay: 14 }),
+                mark(`M${MID - 4.4} ${f(y - 4.2)}Q${MID} ${f(y - 7.4)} ${MID + 4.4} ${f(y - 4.2)}`, 0.6),
+                arrow([MID + 3.6, y - 6.4], [MID + 4.6, y - 4]),
+            ];
+        }
+        case 6: {
+            // Tied: both ends hang even, and a red mark under them shows their tips on one line.
+            const yc = (Y_UPPER + Y_LOWER - 0.3 + W) / 2 + 0.2 * 3;
+            const tip = yc + Math.cos((6 * Math.PI) / 180) * TAIL;
+            const y = tip + 2;
+            return [
+                ...belt({ edge: BELT_EDGE, main: "$accent", cx: MID, x0: X0, x1: X1, y: Y_UPPER, w: W, sag: 0, knot: 6.4, tail: TAIL, splay: 6 }),
+                mark(`M${MID - 4.6} ${f(y)}H${MID + 4.6}M${MID - 4.6} ${f(y - 1)}V${f(y + 1)}M${MID + 4.6} ${f(y - 1)}V${f(y + 1)}`, 0.5),
+            ];
+        }
+    }
+}
+/** The step's number in a red disc at the top left, in the picture's own units (not zoomed). */
+function badge(step) {
+    const text = String(step);
+    const letters = { weight: 0.2, wide: 1 };
+    const size = fitSize(text, letters, 5, 5.2);
+    return [
+        { d: circle(7.4, 7.4, 5), fill: MARK, stroke: MARK_EDGE, w: 0.7, shade: 0.4 },
+        { d: linePath(text, { ...letters, size }, 7.4, 7.4), fill: "none", stroke: "#ffffff", w: letters.weight * size, line: "stroke" },
+    ];
+}
+/** The parts of a step: the jacket in close-up, the belt at that stage and the number. */
+function stepParts(step) {
+    const zoomed = [...judogiFlat(true), ...beltAt(step)].map((p) => ({ ...p, t: ZOOM }));
+    return [...zoomed, ...badge(step)];
+}
+const STEPS = [
+    { en: "Belt step 1: centre", ja: "帯の結び方（1）中心" },
+    { en: "Belt step 2: two wraps", ja: "帯の結び方（2）二重巻き" },
+    { en: "Belt step 3: cross", ja: "帯の結び方（3）交差" },
+    { en: "Belt step 4: tuck under", ja: "帯の結び方（4）下に通す" },
+    { en: "Belt step 5: square knot", ja: "帯の結び方（5）本結び" },
+    { en: "Belt step 6: even ends", ja: "帯の結び方（6）仕上げ" },
+];
+const SUIT = "#f6f4ee";
+const BLACK = "#1f2228";
+const stepPiece = (step) => {
+    const id = `gear:obi-step-${step}`;
+    const { en, ja } = STEPS[step - 1];
+    const spec = { main: SUIT, accent: BLACK, parts: stepParts(step) };
+    return defineGear({ id, en, ja, source: "drawn", model: spec, draw: (o) => drawGear(id, en, spec, o) });
+};
+export const GEAR_OBI_STEP_1 = /* @__PURE__ */ stepPiece(1);
+export const GEAR_OBI_STEP_2 = /* @__PURE__ */ stepPiece(2);
+export const GEAR_OBI_STEP_3 = /* @__PURE__ */ stepPiece(3);
+export const GEAR_OBI_STEP_4 = /* @__PURE__ */ stepPiece(4);
+export const GEAR_OBI_STEP_5 = /* @__PURE__ */ stepPiece(5);
+export const GEAR_OBI_STEP_6 = /* @__PURE__ */ stepPiece(6);
+const BY_STEP = [GEAR_OBI_STEP_1, GEAR_OBI_STEP_2, GEAR_OBI_STEP_3, GEAR_OBI_STEP_4, GEAR_OBI_STEP_5, GEAR_OBI_STEP_6];
+/** One step of tying the belt, 1 to 6, with the usual options (`tint` is the jacket's colour, `accent` the belt's). A number that is not a step from 1 to 6 draws the last one. */
+export const obiStep = (step, options) => BY_STEP[Number.isInteger(step) && step >= 1 && step <= 6 ? step - 1 : 5].svg(options);