@johnmorrisdotca/kyogijo-stadiums 0.50.0 → 0.52.0

package/dist/catalogue.js

@@ -0,0 +1,74 @@
+// The catalogue: every venue the package draws today (supported), the ones being built (working on) and the ones wanted, with their facts, in one list. The same data is published as a static
+// file, `catalogue.json`, in the npm package and on the demo's site (`CATALOGUE_ADDRESS`). There is no server: a reader fetches the file or imports this entry.
+import { CATALOGUE_DATA } from "./catalogue.data.js";
+/** Every venue: the supported ones first, then those being built, then the wanted ones, each group in its order. */
+export const CATALOGUE = CATALOGUE_DATA.venues;
+/** The leagues (every venue of the season, NBA, MLB, NFL, CFL and NHL) and the collections of the Working on and Wanted sections, each with its venues in order and its name in both languages. */
+export const CATALOGUE_GROUPS = CATALOGUE_DATA.groups;
+/** The sports, with their names in both languages and the `sport` of `drawKyogijo` that draws each (`null`: not drawn yet). */
+export const CATALOGUE_SPORTS = CATALOGUE_DATA.sports;
+/** The countries of the catalogue by ISO code, with their names in English and Japanese (Wikidata's labels). */
+export const CATALOGUE_COUNTRIES = CATALOGUE_DATA.countries;
+/** Where `catalogue.json` is published: the same data as this entry, for a page or a program that does not install the package. */
+export const CATALOGUE_ADDRESS = CATALOGUE_DATA.address;
+/** The demo's address: a supported venue's `demo` is relative to it. */
+export const CATALOGUE_SITE = CATALOGUE_DATA.site;
+/** The counts, the day the sources were read and where they are kept, and the licence of the facts. */
+export const CATALOGUE_ABOUT = {
+    schemaVersion: CATALOGUE_DATA.schemaVersion,
+    generatedAt: CATALOGUE_DATA.generatedAt,
+    package: CATALOGUE_DATA.package,
+    licence: CATALOGUE_DATA.licence,
+    source: CATALOGUE_DATA.source,
+    counts: CATALOGUE_DATA.counts,
+};
+const BY_ID = new Map(CATALOGUE.map((entry) => [entry.id, entry]));
+/**
+ * A venue by its id, or `undefined`.
+ * @example
+ * ```ts
+ * import { catalogueById } from "@johnmorrisdotca/kyogijo-stadiums/catalogue";
+ * const ashe = catalogueById("arthur-ashe-stadium")!;
+ * console.log(ashe.status, ashe.ticket, ashe.wikidata);
+ * // working-on KYOGIJO-STADIUMS-22 Q609551
+ * ```
+ */
+export function catalogueById(id) {
+    return BY_ID.get(id);
+}
+/** The venues of a status, in the catalogue's order. */
+export function catalogueByStatus(status) {
+    return CATALOGUE.filter((entry) => entry.status === status);
+}
+/** The venues of a sport (any of a venue's sports), in the catalogue's order. */
+export function catalogueBySport(sport) {
+    return CATALOGUE.filter((entry) => entry.sports.includes(sport));
+}
+/** The venues of a group (a league or a collection), in the group's order; empty for a group that does not exist. */
+export function catalogueByGroup(group) {
+    return (CATALOGUE_GROUPS.find((one) => one.id === group)?.ids ?? []).map((id) => BY_ID.get(id)).filter((entry) => entry !== undefined);
+}
+/** Every venue whose building or whole venue is wanted: the venues of the Wanted section and the supported venues of a league or a collection that are drawn as a surface only. */
+export function catalogueWanted() {
+    return CATALOGUE.filter((entry) => entry.want !== undefined && entry.status !== "working-on");
+}
+/**
+ * How much of a league the package draws: its venues this season, how many in their buildings, how many as a field only, how many not yet.
+ * @example
+ * ```ts
+ * import { catalogueCoverage } from "@johnmorrisdotca/kyogijo-stadiums/catalogue";
+ * const nhl = catalogueCoverage("nhl");
+ * console.log(nhl.venues, nhl.outline, nhl.notYet);
+ * // 32 32 0
+ * ```
+ */
+export function catalogueCoverage(league) {
+    const venues = catalogueByGroup(league);
+    return {
+        league,
+        venues: venues.length,
+        outline: venues.filter((entry) => entry.drawn === "outline").length,
+        surface: venues.filter((entry) => entry.drawn === "surface").length,
+        notYet: venues.filter((entry) => entry.status !== "supported").length,
+    };
+}

package/dist/catalogue.types.d.ts

@@ -0,0 +1,143 @@
+import type { PlaceSurface } from "./atlas.ts";
+/** Where a venue stands with the package: drawn today, being built (an open ticket), or wanted. */
+export type CatalogueStatus = "supported" | "working-on" | "wanted";
+/**
+ * How a supported venue is drawn: `outline`, inside the outline of its real building with a bowl of its seats (`STADIUMS` and the NHL's `VENUES`), or `surface`, its field, court, rink, park or
+ * floor only, at the venue's own size where the data gives one (a key of `PARKS`, `GROUNDS`, `ARENAS` or `HALLS`), or `circuit`, the lap as OpenStreetMap maps it with its pit lane and no stands
+ * (a key of `CIRCUITS`, drawn by `drawCircuit` of the `circuits` entry).
+ */
+export type CatalogueDrawn = "outline" | "surface" | "circuit";
+/** What is wanted of a venue: its building's `outline` (a venue drawn today as a surface only), or the `venue` itself (one the package does not draw at all). */
+export type CatalogueWant = "outline" | "venue";
+/** What has to exist before a wanted venue can be drawn: a `circuit-surface` for motor racing, which the package does not draw yet. */
+export type CatalogueNeed = "circuit-surface";
+/** The sports of the catalogue, in kebab case. Every one but `motor-racing` names a surface the package draws (`CATALOGUE_SPORTS[sport].surface`). */
+export type CatalogueSport = "baseball" | "basketball" | "hockey" | "american-football" | "canadian-football" | "soccer" | "cricket" | "rugby" | "australian-football" | "gaelic-games" | "tennis" | "budo" | "athletics" | "swimming" | "skating" | "curling" | "volleyball" | "badminton" | "handball" | "boxing" | "motor-racing";
+/** The leagues whose every venue of the season is in the catalogue. */
+export type CatalogueLeague = "nba" | "mlb" | "nfl" | "cfl" | "nhl";
+/** A club that plays its home games at a venue this season. */
+export interface CatalogueTeam {
+    name: string;
+    nameJa?: string;
+    league: CatalogueLeague;
+}
+/** The options that draw a supported venue with `drawKyogijo`: its surface (a park, a ground, an arena or a hall), or its real building (`stadium` or `arena` with `crowd: { real: true }`). */
+export type CatalogueDraw = PlaceSurface | {
+    sport: "nfl" | "cfl" | "soccer" | "mlb" | "boxing" | "nba" | "nhl";
+    stadium?: string;
+    park?: string;
+    arena?: string;
+    crowd: {
+        real: true;
+    };
+};
+/** One venue of the catalogue. */
+export interface CatalogueEntry {
+    /** Kebab case, unique: the package's own key for a venue it draws (`fenway-park`, `bc-place`), else one made from the venue's English name. */
+    id: string;
+    status: CatalogueStatus;
+    /** How a supported venue is drawn. */
+    drawn?: CatalogueDrawn;
+    /** What is wanted: the building's outline of a venue drawn as a surface that a league or a group lists, or the venue itself. */
+    want?: CatalogueWant;
+    /** What must be built first. */
+    needs?: CatalogueNeed;
+    /** Which of the package's lists a supported venue comes from: a real stadium or NHL venue (`stadium`, `venue`), or a `park`, `ground`, `arena` or `hall`. */
+    kind?: "stadium" | "venue" | "park" | "ground" | "arena" | "hall" | "circuit";
+    /** The everyday name in English. */
+    name: string;
+    /** The name in Japanese; absent where no source gives one (`missing.nameJa` says so). */
+    nameJa?: string;
+    /** Where the Japanese name was read: the package's own data, Wikidata's label, the title of the Japanese Wikipedia's article, or a name a reviewer checked. */
+    nameJaFrom?: "package" | "wikidata" | "jawiki" | "reviewed";
+    city?: string;
+    cityJa?: string;
+    /** ISO 3166-1 alpha-2. */
+    country?: string;
+    /** Wikidata's coordinates (P625), in degrees. */
+    lat?: number;
+    lon?: number;
+    sports: CatalogueSport[];
+    /** The Wikidata item. */
+    wikidata: string;
+    /** The seats, where Wikidata gives one figure (P1083), for a venue that is not drawn yet. */
+    capacity?: number;
+    /** `current` or `past`, for a supported venue. */
+    era?: "current" | "past";
+    /** The leagues that play there this season, and their clubs. */
+    leagues?: CatalogueLeague[];
+    teams?: CatalogueTeam[];
+    /** The groups the venue is listed in (a league, a collection of the Wanted section). */
+    groups: string[];
+    /** The ticket of a venue being built. */
+    ticket?: string;
+    /** The options that draw a supported venue with `drawKyogijo` (a circuit has none: `drawCircuit({ circuit: id })` of the `circuits` entry draws it). */
+    draw?: CatalogueDraw;
+    /** The demo page that shows a supported venue, relative to the demo's address (`CATALOGUE_SITE`). */
+    demo?: string;
+    /** The facts left out, each with why. */
+    missing?: Partial<Record<"nameJa" | "city" | "country" | "coordinates", string>>;
+}
+/** A group: a league (every venue of its season) or a collection of the Wanted or Working on section, in its order. */
+export interface CatalogueGroup {
+    id: string;
+    kind: "league" | "collection";
+    en: string;
+    ja: string;
+    /** For a league: its sport and its season. */
+    sport?: CatalogueSport;
+    season?: string;
+    /** For a collection that is being built. */
+    status?: "working-on";
+    needs?: CatalogueNeed;
+    ids: string[];
+}
+/** The whole catalogue, as `catalogue.json` holds it. */
+export interface CatalogueData {
+    /** The shape's version: a change that breaks a reader raises it. */
+    schemaVersion: 1;
+    /** The day the sources were read (not the day the file was written). */
+    generatedAt: string;
+    package: {
+        name: string;
+        version: string;
+    };
+    /** Where the JSON is published. */
+    address: string;
+    /** The demo's address, which `demo` is relative to. */
+    site: string;
+    licence: string;
+    source: {
+        read: string;
+        rawAnswers: string;
+        articles: Record<string, number>;
+    };
+    counts: {
+        supported: number;
+        outline: number;
+        surface: number;
+        circuit: number;
+        workingOn: number;
+        wanted: number;
+        outlineWanted: number;
+    };
+    sports: Record<CatalogueSport, {
+        en: string;
+        ja: string;
+        surface: string | null;
+    }>;
+    groups: CatalogueGroup[];
+    countries: Record<string, {
+        en: string;
+        ja?: string;
+    }>;
+    venues: CatalogueEntry[];
+}
+/** How many venues of a league the package draws in their buildings, as a surface only, or not at all. */
+export interface CatalogueCoverage {
+    league: CatalogueLeague;
+    venues: number;
+    outline: number;
+    surface: number;
+    notYet: number;
+}

package/dist/catalogue.types.js

@@ -0,0 +1 @@
+export {};

package/dist/element.d.ts

@@ -1,5 +1,6 @@
 import { type KyogijoReplay } from "./mount.ts";
 import { type KyogijoTurn } from "./turn.dom.ts";
+import "./turn.replay.dom.ts";
 import type { TurnSettings } from "./turn.model.ts";
 import type { ReplaySettings, ReplayTimeline } from "./replay.types.ts";
 import type { ScoreOptions, SurfaceOptions } from "./types.ts";

package/dist/element.js

@@ -9,13 +9,15 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _KyogijoField_instances, _KyogijoField_mount, _KyogijoField_host, _KyogijoField_options, _KyogijoField_theme, _KyogijoField_timeline, _KyogijoField_replaySettings, _KyogijoField_replay, _KyogijoField_replayOf, _KyogijoField_turn, _KyogijoField_turnSettings, _KyogijoField_attach, _KyogijoField_draw;
+var _KyogijoField_instances, _KyogijoField_mount, _KyogijoField_host, _KyogijoField_options, _KyogijoField_theme, _KyogijoField_timeline, _KyogijoField_replaySettings, _KyogijoField_replay, _KyogijoField_replayOf, _KyogijoField_turn, _KyogijoField_turnSettings, _KyogijoField_attach, _KyogijoField_draw, _KyogijoField_follow;
 import { SPORTS } from "./draw.js";
 import { leagueIds } from "./leagues.js";
 import { parseRange } from "./ranges.names.js";
 import { mountKyogijo } from "./mount.js";
 import { TURN_PRESET_NAMES } from "./turn.camera.js";
 import { mountKyogijoTurn } from "./turn.dom.js";
+// A timeline on the element's 3D view plays with the replay's code for the view.
+import "./turn.replay.dom.js";
 /** The tag of the element. */
 export const KYOGIJO_TAG = "kyogijo-field";
 /** The attributes the element reads. */
@@ -355,7 +357,8 @@ export class KyogijoField extends Base {
     }
 }
 _KyogijoField_mount = new WeakMap(), _KyogijoField_host = new WeakMap(), _KyogijoField_options = new WeakMap(), _KyogijoField_theme = new WeakMap(), _KyogijoField_timeline = new WeakMap(), _KyogijoField_replaySettings = new WeakMap(), _KyogijoField_replay = new WeakMap(), _KyogijoField_replayOf = new WeakMap(), _KyogijoField_turn = new WeakMap(), _KyogijoField_turnSettings = new WeakMap(), _KyogijoField_instances = new WeakSet(), _KyogijoField_attach = function _KyogijoField_attach(again) {
-    if (__classPrivateFieldGet(this, _KyogijoField_mount, "f") === undefined || __classPrivateFieldGet(this, _KyogijoField_timeline, "f") === undefined)
+    const on = __classPrivateFieldGet(this, _KyogijoField_turn, "f") ?? __classPrivateFieldGet(this, _KyogijoField_mount, "f");
+    if (on === undefined || __classPrivateFieldGet(this, _KyogijoField_timeline, "f") === undefined)
         return;
     const settings = replaySettingsFromAttributes((name) => this.getAttribute(name), __classPrivateFieldGet(this, _KyogijoField_replaySettings, "f"));
     if (__classPrivateFieldGet(this, _KyogijoField_replay, "f") !== undefined && __classPrivateFieldGet(this, _KyogijoField_replayOf, "f") === __classPrivateFieldGet(this, _KyogijoField_timeline, "f") && !again) {
@@ -368,7 +371,7 @@ _KyogijoField_mount = new WeakMap(), _KyogijoField_host = new WeakMap(), _Kyogij
     const from = __classPrivateFieldGet(this, _KyogijoField_replay, "f") === undefined || __classPrivateFieldGet(this, _KyogijoField_replayOf, "f") !== __classPrivateFieldGet(this, _KyogijoField_timeline, "f") ? undefined : __classPrivateFieldGet(this, _KyogijoField_replay, "f").state();
     __classPrivateFieldGet(this, _KyogijoField_replay, "f")?.destroy();
     __classPrivateFieldSet(this, _KyogijoField_replayOf, __classPrivateFieldGet(this, _KyogijoField_timeline, "f"), "f");
-    __classPrivateFieldSet(this, _KyogijoField_replay, __classPrivateFieldGet(this, _KyogijoField_mount, "f").replay(__classPrivateFieldGet(this, _KyogijoField_timeline, "f"), from === undefined ? settings : { ...settings, start: from.t - from.start }), "f");
+    __classPrivateFieldSet(this, _KyogijoField_replay, on.replay(__classPrivateFieldGet(this, _KyogijoField_timeline, "f"), from === undefined ? settings : { ...settings, start: from.t - from.start }), "f");
 }, _KyogijoField_draw = function _KyogijoField_draw() {
     if (__classPrivateFieldGet(this, _KyogijoField_host, "f") === undefined || !this.isConnected)
         return;
@@ -377,7 +380,7 @@ _KyogijoField_mount = new WeakMap(), _KyogijoField_host = new WeakMap(), _Kyogij
     if (options.theme === undefined && (page === "light" || page === "dark"))
         options.theme = page;
     if (turnWanted((name) => this.getAttribute(name))) {
-        // The 3D view takes the container over from the flat drawing; a replay does not play on it.
+        // The 3D view takes the container over from the flat drawing; a replay plays on it, the players standing up.
         if (__classPrivateFieldGet(this, _KyogijoField_mount, "f") !== undefined) {
             __classPrivateFieldGet(this, _KyogijoField_mount, "f").destroy();
             __classPrivateFieldSet(this, _KyogijoField_mount, undefined, "f");
@@ -385,20 +388,28 @@ _KyogijoField_mount = new WeakMap(), _KyogijoField_host = new WeakMap(), _Kyogij
             __classPrivateFieldSet(this, _KyogijoField_replayOf, undefined, "f");
         }
         const settings = turnSettingsFromAttributes((name) => this.getAttribute(name), __classPrivateFieldGet(this, _KyogijoField_turnSettings, "f"));
-        if (__classPrivateFieldGet(this, _KyogijoField_turn, "f") === undefined)
+        if (__classPrivateFieldGet(this, _KyogijoField_turn, "f") === undefined) {
             __classPrivateFieldSet(this, _KyogijoField_turn, mountKyogijoTurn(__classPrivateFieldGet(this, _KyogijoField_host, "f"), options, settings), "f");
+            __classPrivateFieldSet(this, _KyogijoField_replay, undefined, "f");
+            __classPrivateFieldSet(this, _KyogijoField_replayOf, undefined, "f");
+        }
         else
             __classPrivateFieldGet(this, _KyogijoField_turn, "f").update(options);
+        __classPrivateFieldGet(this, _KyogijoField_instances, "m", _KyogijoField_follow).call(this);
         return;
     }
     if (__classPrivateFieldGet(this, _KyogijoField_turn, "f") !== undefined) {
         __classPrivateFieldGet(this, _KyogijoField_turn, "f").destroy();
         __classPrivateFieldSet(this, _KyogijoField_turn, undefined, "f");
+        __classPrivateFieldSet(this, _KyogijoField_replay, undefined, "f");
+        __classPrivateFieldSet(this, _KyogijoField_replayOf, undefined, "f");
     }
     if (__classPrivateFieldGet(this, _KyogijoField_mount, "f") === undefined)
         __classPrivateFieldSet(this, _KyogijoField_mount, mountKyogijo(__classPrivateFieldGet(this, _KyogijoField_host, "f"), options), "f");
     else
         __classPrivateFieldGet(this, _KyogijoField_mount, "f").update(options);
+    __classPrivateFieldGet(this, _KyogijoField_instances, "m", _KyogijoField_follow).call(this);
+}, _KyogijoField_follow = function _KyogijoField_follow() {
     if (__classPrivateFieldGet(this, _KyogijoField_timeline, "f") === undefined) {
         __classPrivateFieldGet(this, _KyogijoField_replay, "f")?.destroy();
         __classPrivateFieldSet(this, _KyogijoField_replay, undefined, "f");

package/dist/judging.mount.js

@@ -62,6 +62,7 @@ export function mountJudgingBroadcast(host, options, settings = {}) {
         direction: () => turn.direction(),
         setDirection: (direction) => turn.setDirection(direction),
         togglePlay: () => turn.togglePlay(),
+        replay: (timeline, replaySettings) => turn.replay(timeline, replaySettings),
         get quality() {
             return turn.quality;
         },

package/dist/replay.d.ts

@@ -17,6 +17,8 @@ export declare function replayInfo(timeline: ReplayTimeline): {
     events: number;
     step: number;
 };
+/** Everything a timeline tracks, each as it first appears (its id, team, number and label), in that order. */
+export declare function replayCast(timeline: ReplayTimeline): readonly ReplayObject[];
 /** The times of the frames, and of the events, in order: the moments a step can land on. */
 export declare function replayTimes(timeline: ReplayTimeline): readonly number[];
 /** The events of a timeline, in time order. */
@@ -151,6 +153,8 @@ export declare function replayPlacer(options: SurfaceOptions | ScoreOptions, tim
  * ```
  */
 export declare function drawFrame(options: SurfaceOptions | ScoreOptions, timeline: ReplayTimeline, t: number, look?: ReplayLook): string;
+/** `drawFrame` with only the groups `keep` says yes to: a 3D view keeps the players off its floor, where they stand up instead. */
+export declare function drawFrameOf(options: SurfaceOptions | ScoreOptions, timeline: ReplayTimeline, t: number, look?: ReplayLook, keep?: (group: ReplayGroup) => boolean): string;
 /** The prefix of the ids in a replay's drawing when the options give none: a hash of the options and of the timeline's size, not of the time. */
 export declare const replayId: (options: SurfaceOptions | ScoreOptions, timeline: ReplayTimeline) => string;
 /**

package/dist/replay.dom.d.ts

@@ -1,6 +1,7 @@
 import { type ReplayController } from "./replay.control.ts";
-import type { ReplaySettings, ReplayTimeline } from "./replay.types.ts";
-import type { ScoreOptions, SurfaceOptions } from "./types.ts";
+import { type ReplayGroup } from "./replay.ts";
+import type { ReplayLook, ReplaySettings, ReplayTimeline } from "./replay.types.ts";
+import type { Language, ScoreOptions, SurfaceOptions } from "./types.ts";
 /** The controls' stylesheet: written once beside the controls, scoped to them, in the page's own colours. */
 export declare const REPLAY_STYLE: string;
 /** A replay attached to a container: the controller, the stage the drawing goes in, and how to draw it again. */
@@ -13,6 +14,70 @@ export interface ReplayView {
     /** Stop the clock and the listeners, and empty the container. */
     destroy(): void;
 }
+/** What a painter is given: where the drawing is, what it was drawn from, and how to draw it whole again. */
+export interface PainterSource {
+    doc: Document;
+    timeline: ReplayTimeline;
+    look: ReplayLook;
+    /** The drawing the replay's groups are in (`svg.kyogijo`), or `null` before it is written. */
+    svg(): SVGSVGElement | null;
+    /** The options it was drawn with, its `id` among them. */
+    options(): SurfaceOptions | ScoreOptions;
+    language(): Language;
+    /** Which groups of the replay are in this drawing: all when missing (a 3D view stands the players up and leaves the rest on the floor). */
+    keep?: (group: ReplayGroup) => boolean;
+    /** Write the drawing whole again at a time; the painter binds itself to it afterwards. */
+    redraw(t: number): void;
+}
+/** The painter of a replay's drawing: `paint` moves the marks to a time; `bind` matches the elements of a drawing just written at `t`. */
+export interface ReplayPainter {
+    paint(t: number): void;
+    bind(t: number): void;
+}
+/**
+ * The painter of a replay: it moves the marks that move and nothing else. A mark that comes or goes (an object that enters, an event that begins) draws the replay's own group
+ * again, never the surface; a group whose marks cannot be matched to elements one for one is drawn again each time.
+ */
+export declare function replayPainter(source: PainterSource): ReplayPainter;
+/** What a driver is given: how to paint a time, where its keys are heard, and what it labels. */
+export interface DriverSource {
+    /** Move the drawing to a time. Called on every change of the clock. */
+    paint(t: number): void;
+    language: Language;
+    /** The element whose keys play, step and seek (its descendants too): the stage and the bar in a flat replay, the bar alone over a 3D view. */
+    keysOn: HTMLElement;
+    /** The element that says what the replay is doing (`data-state`, `data-motion`). */
+    holder: HTMLElement;
+    /** The element that names the replay and points at its key help (the flat drawing's stage), if any. */
+    labelled?: HTMLElement;
+    /** The element whose being in sight lets the clock run: no frame is asked for while it is scrolled out of sight. */
+    seen?: Element;
+    /** The key help: `keys` and `keysStep` by default, `keysTurn` and `keysTurnStep` over a 3D view. */
+    help?: "flat" | "turn";
+    /** Where frames are asked for: the page's `requestAnimationFrame` by default; a 3D view lends its own, so that a turning view and its replay share one frame. */
+    frames?: {
+        request(callback: FrameRequestCallback): number;
+        cancel(id: number): void;
+    };
+}
+/** The page's side of a replay without its drawing: the clock on animation frames, the controls, the keys, the live region, a hidden page and reduced motion. */
+export interface ReplayDriver {
+    controller: ReplayController;
+    /** The style, the key help, the bar and the live region, in that order, for the caller to put in the page. */
+    parts: {
+        style: HTMLStyleElement;
+        hint: HTMLElement;
+        bar: HTMLElement;
+        live: HTMLElement;
+    };
+    /** The words changed: the controls are made again. */
+    setLanguage(language: Language): void;
+    /** The play, pause or step the keys of a 3D view's stage ask for, by the names of the keys: the same moves as the bar's keys. */
+    key(event: KeyboardEvent, scope: "stage" | "bar"): boolean;
+    destroy(): void;
+}
+/** Make the clock, the controls and the keys of a replay. Nothing runs until the reader (or `autoplay`) plays it, and nothing runs while it is paused, hidden or out of sight. */
+export declare function replayDriver(doc: Document, timeline: ReplayTimeline, settings: ReplaySettings, source: DriverSource): ReplayDriver;
 /**
  * Attach a replay to a container: the stage with the drawing, the controls under it, the keyboard and the live region. The drawing is written once
  * and then only the marks that move are moved, on `requestAnimationFrame`; a mark that comes or goes (an object that enters, an event that