@johnmorrisdotca/kyogijo-stadiums 0.57.0 → 0.59.0

package/dist/landmarks.js

@@ -0,0 +1,160 @@
+import { FEET_PER_METRE } from "./geometry.js";
+import { bar, n, plane } from "./turn.kit.js";
+import { hullOf, inside, metresFrom, smallestBox } from "./venues.geo.js";
+export const LANDMARK_SHAPES = ["dome", "wheel", "fountains", "named"];
+const RAD = Math.PI / 180;
+const rotate = ([x, y], degrees) => [x * Math.cos(degrees * RAD) - y * Math.sin(degrees * RAD), x * Math.sin(degrees * RAD) + y * Math.cos(degrees * RAD)];
+const middleOf = (ring) => [ring.reduce((s, p) => s + p[0], 0) / ring.length, ring.reduce((s, p) => s + p[1], 0) / ring.length];
+/** The landmarks of some areas placed in a district: turned as the plan is and kept where they stand in the frame (`frame` is the plan's box in feet). */
+export function placeLandmarks(areas, origin, turn, frame) {
+    const placed = [];
+    for (const area of areas) {
+        const [east, north] = metresFrom(origin, [area.origin])[0];
+        for (const l of area.landmarks ?? []) {
+            const ring = l.ring.map(([e, nn]) => rotate([(e + east) * FEET_PER_METRE, -(nn + north) * FEET_PER_METRE], turn));
+            const at = middleOf(ring);
+            if (at[0] < frame.x || at[0] > frame.x + frame.w || at[1] < frame.y || at[1] > frame.y + frame.h)
+                continue;
+            // The long way of the outline, on the page: `smallestBox` reads east and north, and the page's y runs down.
+            const heading = smallestBox(ring.map(([x, y]) => [x, -y])).heading;
+            const along = [Math.sin(heading * RAD), -Math.cos(heading * RAD)];
+            const label = l.top === undefined ? at : rotate([(l.top[0] + east) * FEET_PER_METRE, -(l.top[1] + north) * FEET_PER_METRE], turn);
+            placed.push({ key: l.key, name: l.name, shape: l.shape, ring, at, label, height: l.height * FEET_PER_METRE, ...(l.width === undefined ? {} : { width: l.width * FEET_PER_METRE }), along });
+        }
+    }
+    return placed;
+}
+/** Whether a building's outline is a landmark's own (most of it inside a dome's footprint): the dome draws it, and the block is left out. */
+export const ownedByLandmark = (landmarks, ring) => landmarks.some((l) => l.shape === "dome" && (inside(hullOf([...l.ring]), middleOf(ring)) || ring.filter((p) => inside(l.ring, p)).length * 10 >= ring.length * 7));
+/** Whether a building stands under a named landmark (its middle inside the landmark's outline): it is raised in the 3D view whatever the count of blocks. */
+export const underLandmark = (landmarks, ring) => landmarks.some((l) => l.shape === "named" && inside(l.ring, middleOf(ring)));
+const num = (value) => String(Math.round(value * 10) / 10);
+/** The jets of fountains, in feet: where each stands along the long way of the water (from its middle) and how high it reaches, as a share of the most. Ours: the published figure is the most they reach, the row is a pattern. */
+export const FOUNTAIN_JETS = [[-0.36, 0.3], [-0.27, 0.48], [-0.18, 0.66], [-0.09, 0.84], [0, 1], [0.09, 0.84], [0.18, 0.66], [0.27, 0.48], [0.36, 0.3]];
+/** The extent of an outline along a unit direction from its middle: the least and the most. */
+const extent = (ring, at, along) => {
+    const t = ring.map((p) => (p[0] - at[0]) * along[0] + (p[1] - at[1]) * along[1]);
+    return [Math.min(...t), Math.max(...t)];
+};
+/** What the floor has of the landmarks: a dome's footprint and a wheel's line on the ground, in the tone of the tallest buildings, and the jets' feet as dots on the water. Empty for none. */
+export function landmarksFloor(landmarks) {
+    const parts = [];
+    for (const l of landmarks) {
+        if (l.shape === "dome")
+            parts.push(`<path class="ky-dist-block ky-dist-b3 ky-dist-landmark" data-landmark="${l.key}" d="M${l.ring.map(([x, y]) => `${num(x)} ${num(y)}`).join("L")}Z"/>`);
+        if (l.shape === "wheel") {
+            const r = (l.width ?? 0) / 2;
+            parts.push(`<path class="ky-dist-ink ky-dist-landmark" data-landmark="${l.key}" stroke-width="${num(Math.max(r * 0.06, 3))}" d="M${num(l.at[0] - l.along[0] * r)} ${num(l.at[1] - l.along[1] * r)}L${num(l.at[0] + l.along[0] * r)} ${num(l.at[1] + l.along[1] * r)}"/>`);
+        }
+        if (l.shape === "fountains") {
+            // The water the jets stand in, as the land cover draws water (an area's lake mapped as the fountains' own outline is not in its land cover).
+            parts.push(`<path class="ky-dist-land ky-dist-water" data-landmark="${l.key}" d="M${l.ring.map(([x, y]) => `${num(x)} ${num(y)}`).join("L")}Z"/>`);
+            const [t0, t1] = extent(l.ring, l.at, l.along);
+            const long = t1 - t0;
+            const d = FOUNTAIN_JETS.map(([s]) => `M${num(l.at[0] + l.along[0] * (t0 + long * (0.5 + s)))} ${num(l.at[1] + l.along[1] * (t0 + long * (0.5 + s)))}h0`).join("");
+            parts.push(`<path class="ky-dist-jet ky-dist-landmark" data-landmark="${l.key}" stroke-width="${num(Math.max(long * 0.02, 6))}" d="${d}"/>`);
+        }
+    }
+    return parts.length === 0 ? "" : `<g class="ky-dist-landmarks" aria-hidden="true">${parts.join("")}</g>`;
+}
+/** A plane through three or more points of one flat polygon in 3D, painted with `cls`, and `cull` set so that its face away from `inward` is the one drawn (it is hidden from inside). */
+function facet(id, points, cls, inward) {
+    const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+    const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+    const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+    const unit = (a) => {
+        const l = Math.hypot(...a);
+        return l < 1e-9 ? [0, 0, 0] : [a[0] / l, a[1] / l, a[2] / l];
+    };
+    const [p0, p1] = points;
+    const u = unit(sub(p1, p0));
+    const normal = unit(cross(sub(p1, p0), sub(points[points.length - 1], p0)));
+    if (Math.hypot(...normal) < 0.5)
+        return undefined;
+    const v = unit(cross(normal, u));
+    const local = points.map((p) => [dot(sub(p, p0), u), dot(sub(p, p0), v)]);
+    const [a0, a1] = [Math.min(...local.map((p) => p[0])), Math.max(...local.map((p) => p[0]))];
+    const [b0, b1] = [Math.min(...local.map((p) => p[1])), Math.max(...local.map((p) => p[1]))];
+    const o = [p0[0] + u[0] * a0 + v[0] * b0, p0[1] + u[1] * a0 + v[1] * b0, p0[2] + u[2] * a0 + v[2] * b0];
+    const svg = `<polygon class="${cls}" points="${local.map(([a, b]) => `${n(a - a0)},${n(b - b0)}`).join(" ")}"/>`;
+    const out = sub(points[0], inward);
+    // `u` x `v` is the normal; the face that is drawn is the one the normal points out of.
+    return { ...plane(id, "block", o, [u[0] * (a1 - a0), u[1] * (a1 - a0), u[2] * (a1 - a0)], [v[0] * (b1 - b0), v[1] * (b1 - b0), v[2] * (b1 - b0)], svg), cull: dot(normal, out) >= 0 ? 1 : -1 };
+}
+/** The tone of a facet by the way it faces the light (from up the page, to the left, and above): three tones, as a building's walls have. */
+const toneOf = (normal) => {
+    const lit = normal[0] * -0.4 + normal[1] * -0.5 + normal[2] * 0.75;
+    return lit > 0.45 ? "u-block-a" : lit > 0 ? "u-block-b" : "u-block-c";
+};
+/** How finely a dome is cut: sides round it and bands up it. Fewer in the lower tiers. */
+export const DOME_CUT = Object.freeze({ high: { sides: 16, bands: 6 }, simple: { sides: 10, bands: 4 } });
+/** The planes of a dome: a sphere `width` across whose top is `height` over the ground, cut by the ground, as bands of flat facets, each lit by the way it faces. */
+export function domePlanes(prefix, at, height, width, cut) {
+    const r = width / 2;
+    const zc = height - r;
+    const low = Math.asin(Math.max(-1, Math.min(1, -zc / r)));
+    const centre = [at[0], at[1], zc];
+    const point = (side, band) => {
+        const lat = low + ((Math.PI / 2 - low) * band) / cut.bands;
+        const lon = (2 * Math.PI * side) / cut.sides;
+        return [at[0] + r * Math.cos(lat) * Math.cos(lon), at[1] + r * Math.cos(lat) * Math.sin(lon), zc + r * Math.sin(lat)];
+    };
+    const planes = [];
+    for (let band = 0; band < cut.bands; band += 1) {
+        for (let side = 0; side < cut.sides; side += 1) {
+            const top = band + 1 === cut.bands;
+            const pts = top ? [point(side, band), point(side + 1, band), point(side, band + 1)] : [point(side, band), point(side + 1, band), point(side + 1, band + 1), point(side, band + 1)];
+            const mid = [pts.reduce((s, p) => s + p[0], 0) / pts.length - centre[0], pts.reduce((s, p) => s + p[1], 0) / pts.length - centre[1], pts.reduce((s, p) => s + p[2], 0) / pts.length - centre[2]];
+            const l = Math.hypot(...mid);
+            const f = facet(`${prefix}d${band}-${side}`, pts, `u-block ${toneOf([mid[0] / l, mid[1] / l, mid[2] / l])}`, centre);
+            if (f !== undefined)
+                planes.push(f);
+        }
+    }
+    return planes;
+}
+/** How a wheel is drawn: segments round its rim and spokes to its hub. */
+export const WHEEL_CUT = Object.freeze({ high: { rim: 24, spokes: 12 }, simple: { rim: 12, spokes: 6 } });
+/** The planes of a big wheel standing upright along `along`: its rim, its spokes and the two legs from its hub to the ground, each a thin bar seen from every side. */
+export function wheelPlanes(prefix, at, along, height, width, cut) {
+    const r = width / 2;
+    const hub = [at[0], at[1], height - r];
+    const on = (angle, radius = r) => [at[0] + along[0] * radius * Math.cos(angle), at[1] + along[1] * radius * Math.cos(angle), hub[2] + radius * Math.sin(angle)];
+    const thick = Math.max(width * 0.025, 2);
+    const planes = [];
+    for (let i = 0; i < cut.rim; i += 1)
+        planes.push(...bar(`${prefix}rim${i}`, "pole", on((2 * Math.PI * i) / cut.rim), on((2 * Math.PI * (i + 1)) / cut.rim), thick, "u-leg"));
+    for (let i = 0; i < cut.spokes; i += 1)
+        planes.push(...bar(`${prefix}spoke${i}`, "pole", hub, on((2 * Math.PI * i) / cut.spokes), thick * 0.35, "u-leg"));
+    // Two legs, leaning out across the wheel's plane to the ground.
+    const across = [-along[1], along[0]];
+    for (const [i, side] of [[0, 1], [1, -1]])
+        planes.push(...bar(`${prefix}leg${i}`, "pole", hub, [at[0] + across[0] * side * r * 0.3, at[1] + across[1] * side * r * 0.3, 0], thick * 1.4, "u-leg"));
+    return planes;
+}
+/** The planes of fountains: a row of jets along the long way of the water, each a thin upright strip reaching to its share of `height`. */
+export function fountainPlanes(prefix, l) {
+    const [t0, t1] = extent(l.ring, l.at, l.along);
+    const long = t1 - t0;
+    const planes = [];
+    FOUNTAIN_JETS.forEach(([s, share], i) => {
+        const t = t0 + long * (0.5 + s);
+        const [x, y] = [l.at[0] + l.along[0] * t, l.at[1] + l.along[1] * t];
+        planes.push(...bar(`${prefix}jet${i}`, "pole", [x, y, 0], [x, y, l.height * share], Math.max(long * 0.012, 3), "u-jet"));
+    });
+    return planes;
+}
+/** The 3D view's landmarks: each one's shape standing where it is, cut more coarsely in a simple tier. A named landmark has no shape of its own: its buildings are the area's. */
+export function landmarkUprights(landmarks, simple) {
+    const items = [];
+    for (const l of landmarks) {
+        const prefix = `lm-${l.key}-`;
+        if (l.shape === "dome" && l.width !== undefined)
+            items.push({ id: `lm-${l.key}`, kind: "blocks", at: l.at, height: l.height, planes: domePlanes(prefix, l.at, l.height, l.width, simple ? DOME_CUT.simple : DOME_CUT.high) });
+        if (l.shape === "wheel" && l.width !== undefined)
+            items.push({ id: `lm-${l.key}`, kind: "flags", at: l.at, height: l.height, planes: wheelPlanes(prefix, l.at, l.along, l.height, l.width, simple ? WHEEL_CUT.simple : WHEEL_CUT.high) });
+        if (l.shape === "fountains" && !simple)
+            items.push({ id: `lm-${l.key}`, kind: "flags", at: l.at, height: l.height, planes: fountainPlanes(prefix, l) });
+    }
+    return items;
+}

package/dist/surfaces/artistic.js

@@ -59,7 +59,9 @@ export function artistic(o, plan, ctx = {}) {
     }
     const top = -jy + 0.4;
     const bottom = sy + start.depth + 0.4 - W;
-    const view0 = { x: -m, y: -feet(top) - m * 0.4, w: feet(L) + 2 * m, h: feet(W) + feet(top + bottom) + m * 0.8 };
+    // The deck is narrower along the sides than at the ends; a margin that is asked for (the ground the stands of a crowd stand on) is the same all round.
+    const across = o.margin === undefined ? m * 0.4 : m;
+    const view0 = { x: -m, y: -feet(top) - across, w: feet(L) + 2 * m, h: feet(W) + feet(top + bottom) + 2 * across };
     base = (ctx.bare === true ? "" : deckMarkup(o, ids, plan.deck, view0.x, view0.y, view0.w, view0.h)) + base + deck;
     const Lf = feet(L);
     const Wf = feet(W);

package/dist/surfaces/athletics.js

@@ -96,6 +96,8 @@ export function athleticsSurface(o, plan, embedded, margin) {
         onColour: false,
     };
     surface.box = { x: 0, y: 0, w: W, h: H };
+    if (plan.outline !== undefined && sv === undefined)
+        surface.floor = plan.outline.map(([x, y]) => [(x - ox) * K, (y - oy) * K]);
     surface.lineRef = { width: thick, feet: K };
     const ranges = {};
     for (const [name, r] of Object.entries(plan.ranges))

package/dist/surfaces/hockey.js

@@ -2,7 +2,7 @@ import { el, num } from "../format.js";
 import { rulesFor } from "../eras.js";
 import { NHL } from "../geometry.js";
 import { NHL_RINK } from "../leagues/hockey.js";
-import { atEnds, edges, ft, quarterTurn, roundedRect } from "./surface.js";
+import { atEnds, edges, ft, quarterTurn, roundedOutline, roundedRect } from "./surface.js";
 /** Where the boards' curve is at a distance x from the end: the y at which it meets a line across the rink. The corner's radius is the NHL's unless given. */
 export function boardsY(x, radius = NHL.cornerRadius) {
     const r = radius;
@@ -128,6 +128,8 @@ export function hockey(o, era, rink = NHL_RINK) {
     };
     surface.lineRef = { width: thin, feet: 1 };
     surface.box = { x: 0, y: 0, w: L, h: W };
+    // The floor the stands of a crowd clear: the boards round the rounded corners, not the apron's square corners.
+    surface.floor = roundedOutline(-bw, -bw, L + 2 * bw, W + 2 * bw, r + bw);
     surface.centreRadius = rink.circleRadius;
     surface.anchors = { kind: "hockey", length: L, width: W, blueLine, goalLine: g, cornerRadius: r, net: net_ };
     // The zones of the ice: from the end boards to a blue line, and between the blue lines.

package/dist/surfaces/surface.d.ts

@@ -153,6 +153,11 @@ export interface Surface {
         width: number;
         feet: number;
     };
+    /**
+     * For a surface whose floor is not the rectangle of its view (an athletics track, its sprint straight and runways): the outline of everything it draws round its playing area, as points in the wide frame
+     * in feet. The stands of a crowd clear it.
+     */
+    floor?: (readonly [number, number])[];
     /** For a surface with a crowd: the margin it was drawn with, which holds the stands. */
     crowdMargin?: number;
     /** A real stadium of more than one configuration laid out in the venue's own frame: where the middle of its field is in the surface's frame (the surface is shifted to lie there), and the ground, building, stands and crowd under it, in the venue's frame. */
@@ -254,6 +259,8 @@ export declare function quarterTurn(view: {
 };
 /** A box from its edges: the left, the top, the right and the bottom. */
 export declare const edges: (x0: number, y0: number, x1: number, y1: number) => Box;
+/** A rounded rectangle's outline as points (each corner in 12 steps), for a surface's `floor`. */
+export declare function roundedOutline(x: number, y: number, w: number, h: number, r: number): [number, number][];
 /** A range that has an end: its box at the left end and at the right, made by a function of the end. */
 export declare const atEnds: (box: (end: "left" | "right") => Box) => {
     left: Box;

package/dist/surfaces/surface.js

@@ -45,5 +45,14 @@ export function quarterTurn(view) {
 }
 /** A box from its edges: the left, the top, the right and the bottom. */
 export const edges = (x0, y0, x1, y1) => ({ x: Math.min(x0, x1), y: Math.min(y0, y1), w: Math.abs(x1 - x0), h: Math.abs(y1 - y0) });
+/** A rounded rectangle's outline as points (each corner in 12 steps), for a surface's `floor`. */
+export function roundedOutline(x, y, w, h, r) {
+    const rr = Math.max(0, Math.min(r, w / 2, h / 2));
+    const out = [];
+    for (const [cx, cy, a0] of [[x + w - rr, y + rr, -90], [x + w - rr, y + h - rr, 0], [x + rr, y + h - rr, 90], [x + rr, y + rr, 180]])
+        for (let i = 0; i <= 12; i += 1)
+            out.push([cx + rr * Math.cos(((a0 + i * 7.5) * Math.PI) / 180), cy + rr * Math.sin(((a0 + i * 7.5) * Math.PI) / 180)]);
+    return out;
+}
 /** A range that has an end: its box at the left end and at the right, made by a function of the end. */
 export const atEnds = (box) => ({ left: box("left"), right: box("right") });

package/dist/turn.dom.js

@@ -212,6 +212,8 @@ export function mountTurn(host, options, settings, build, replayable = false, le
     root.dataset.quality = quality;
     root.dataset.tier = tier;
     root.dataset.share = String(ceiling);
+    // ---- One frame request a frame: the auto-turn, a replay or a race on the view, and the quality's timing of the frames ask through this, and share one animation frame when they run together. ----
+    const frames = frameBatch(win);
     // ---- Quality: in `auto`, the frames the view makes while it turns decide the tier. ----
     let governor = quality === "auto" && win !== null && model.tiered === true ? createGovernor(tier, settings.qualityTuning) : undefined;
     let meterFrame;
@@ -230,7 +232,7 @@ export function mountTurn(host, options, settings, build, replayable = false, le
     };
     const stopMeter = () => {
         if (meterFrame !== undefined)
-            win?.cancelAnimationFrame(meterFrame);
+            frames.cancel(meterFrame);
         meterFrame = undefined;
         lastStamp = undefined;
     };
@@ -252,7 +254,7 @@ export function mountTurn(host, options, settings, build, replayable = false, le
         if (next !== undefined)
             retier(next);
         if (meterFrame === undefined)
-            meterFrame = win.requestAnimationFrame(meterTick);
+            meterFrame = frames.request(meterTick);
     };
     /** The view was painted: the frames are timed from now until it is still. */
     const touched = () => {
@@ -260,7 +262,7 @@ export function mountTurn(host, options, settings, build, replayable = false, le
             return;
         lastPaint = win.performance.now();
         if (meterFrame === undefined)
-            meterFrame = win.requestAnimationFrame(meterTick);
+            meterFrame = frames.request(meterTick);
     };
     /** Draw the world again, from the model of the tier and the options now: the camera, the auto-turn and the pointer are not touched (the elements are the only thing replaced). */
     const renderWorld = () => {
@@ -447,8 +449,6 @@ export function mountTurn(host, options, settings, build, replayable = false, le
         go(opening, 560, "none");
         say(turnWords(model).reset);
     };
-    // ---- One frame request a frame: the auto-turn and a replay on the view ask through this, and share one animation frame when both run. ----
-    const frames = frameBatch(win);
     const requestFrame = (callback) => frames.request(callback);
     const cancelFrame = (id) => frames.cancel(id);
     // ---- The auto-turn: a trophy case's slow turn. It runs only when asked, holds while the pointer holds the view, and does nothing while the page is hidden. ----

package/dist/turn.markup.js

@@ -56,6 +56,8 @@ export function groupRanks(groups, yaw) {
     return rank;
 }
 const RAD = Math.PI / 180;
+/** The things of a venue's bowl: they stand on the ground round the surface, never under a raised floor. */
+const BOWL = new Set(["stands", "wall-seats", "gallery", "roof", "ribbon-boards", "hung-board"]);
 const prepared = new WeakMap();
 function prepare(model) {
     const known = prepared.get(model.planes);
@@ -79,7 +81,8 @@ function prepare(model) {
         const zs = [p.o[2], p.o[2] + p.u[2], p.o[2] + p.v[2], p.o[2] + p.u[2] + p.v[2]];
         mid.push([(p.o[0] + (p.u[0] + p.v[0]) / 2 - centre[0]) * s, (p.o[1] + (p.u[1] + p.v[1]) / 2 - centre[1]) * s, (p.o[2] + (p.u[2] + p.v[2]) / 2) * s, Math.min(...zs) * s, Math.max(...zs) * s]);
     }
-    const made = { planes: model.planes, scale: s, centre, base, mid };
+    const ofBowl = new Set(model.uprights.items.filter((item) => BOWL.has(item.kind)).flatMap((item) => item.planes));
+    const made = { planes: model.planes, scale: s, centre, base, mid, bowl: model.planes.map((p) => ofBowl.has(p)) };
     prepared.set(model.planes, made);
     return made;
 }
@@ -159,6 +162,14 @@ export function layoutOf(model, view, width, height, lens, cull = false, raster
     order.length = 0;
     for (let i = 0, j = 0; i < own.length || j < apart.length;)
         order.push(j >= apart.length || (i < own.length && own[i].depth <= apart[j].depth) ? own[i++] : apart[j++]);
+    // A raised floor (a table's top) carries the ground the bowl stands on, so it is sorted by its middle among the surface's own things only: the parts of the bowl that are farther than its middle
+    // come after it, still in their own order, or the floor would be drawn over the far stands.
+    if (raised) {
+        const at = order.findIndex((one) => one.i === 0);
+        const far = order.slice(0, at).filter((one) => known.bowl[one.i - 1]);
+        if (far.length > 0)
+            order.splice(0, at + 1, ...order.slice(0, at).filter((one) => !known.bowl[one.i - 1]), order[at], ...far);
+    }
     const stack = new Array(count + 1).fill(0);
     stack[0] = 1;
     order.forEach((one, rank) => {

package/dist/turn.style.js

@@ -28,6 +28,7 @@ export const KYOGIJO_TURN_STYLE = `
 .ky-turn .u-orange{fill:var(--ky-up-orange)}
 .ky-turn .u-wood{fill:var(--ky-up-wood)}
 .ky-turn .u-leg{fill:var(--ky-up-leg)}
+.ky-turn .u-jet{fill:var(--ky-up-jet,rgba(222,240,252,.82))}
 .ky-turn .u-pad{fill:var(--ky-up-pad)}
 .ky-turn .u-table{fill:var(--ky-up-table)}
 .ky-turn .u-foot{fill:var(--ky-up-foot)}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export declare const VERSION = "0.57.0";
+export declare const VERSION = "0.59.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export const VERSION = "0.57.0";
+export const VERSION = "0.59.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnmorrisdotca/kyogijo-stadiums",
-  "version": "0.57.0",
+  "version": "0.59.0",
   "description": "Kyogijo Stadiums 競技場, 40 sports' surfaces as SVG, drawn to scale from the rulebooks: NFL, CFL and IFAF football fields, an NHL rink, an NBA court, MLB ballparks, soccer pitches, curling sheets, athletics stadiums, speed skating, short track and figure skating rinks, swimming pools, water polo fields, diving wells, artistic swimming areas, and the courts and fields of tennis, volleyball (indoor, beach and sitting), badminton, pickleball, table tennis, padel, squash, racquetball, sepak takraw, teqball, roundnet, netball, lacrosse, rugby, Australian football, Gaelic games, cricket, field hockey and handball, and the budo of judo, karate, kendo, sumo and kyudo with a dojo of tatami laid as real units, the MMA cage, with each team's name and logo on its side and the score in the middle, stands and a crowd, a pageant of flags, and a 3D view. Light and dark, accessible, a compact badge for lists, a helper for React and a custom element. Zero dependencies.",
   "keywords": [
     "sports",
@@ -75,6 +75,7 @@
     "./dist/grounds.js",
     "./dist/venues.all.js",
     "./dist/walk.full.js",
+    "./dist/circuits.held.js",
     "./dist/strings.js",
     "./dist/strings.en.js",
     "./dist/strings.ja.js"