@restless-dreams/orbit 0.0.0-stage → 0.1.0

package/dist/core/svg-renderer.d.ts

@@ -0,0 +1,729 @@
+/**
+ * OrbitSVGRenderer draws a map into a container element and makes it
+ * explorable.
+ *
+ * Each view (a node in focus, or the overview) is a scene in world
+ * coordinates (engine/scene.ts), seen through one camera. Moving between
+ * views flies the camera along a smooth zoom path while the nodes both views
+ * share move into place; when the flight lands, the world is re-rooted on
+ * the new scene. In focus mode the orbit spins with momentum when flicked,
+ * zooming far enough into a planet enters it, and zooming out leaves.
+ *
+ * Nodes, rings and links are SVG under one camera transform. Labels, badges,
+ * controls and the detail sheet are HTML on top, so text stays sharp and
+ * readable at any zoom.
+ */
+import type { OrbitDocument, OrbitEventMap, OrbitEventName, OrbitMediaOptions, OrbitNode, OrbitNewNode, OrbitNodeInput, RendererOptions, ViewMode } from './types.js';
+export declare class OrbitSVGRenderer {
+    private static registry;
+    private static instanceCounter;
+    /** Destroys the renderer drawing into `target`, if there is one. Returns whether there was. */
+    static unmount(target: HTMLElement): boolean;
+    private readonly container;
+    private readonly root;
+    private readonly svg;
+    private readonly world;
+    private readonly definitions;
+    /** The camera as last written to the world: a spin repaints every frame without moving it. */
+    private worldTransform;
+    /** The orbit's turn as last written to the layers of its planets and moons (see `paintTurn`). */
+    private turnTransform;
+    /** The theme the shading was last placed for (see `placeShading`). */
+    private shadingTheme;
+    /** The turn the shading of specks is turned back by (see `turnShading`). */
+    private speckLighting;
+    /** The on-screen radius (px) below which bodies were last drawn as specks (see `speckRadius`). */
+    private specksBelow;
+    /**
+     * The nodes as last painted at rest, with what they were drawn for: while
+     * only the camera or the orbit's turn changes, they hold still, all but
+     * the bodies turned back upright (see `paintNodes`).
+     */
+    private stillNodes;
+    private readonly layers;
+    private readonly labelLayer;
+    /** The fonts the labels are drawn with, which names are measured and fitted in. */
+    private readonly labelFonts;
+    /** Stops listening for fonts that finish loading. */
+    private readonly stopWatchingFonts;
+    /** What node types draw inside their nodes, between the nodes and the labels. */
+    private readonly contentLayer;
+    private readonly contents;
+    /** This map's node types, actions and status words, then the registered ones. */
+    private extensions;
+    /** The words the map speaks, in its language, and the language and words they were made for. */
+    private words;
+    private requestedLanguage;
+    private requestedStrings;
+    private readonly overlayLayer;
+    private readonly emptyState;
+    private readonly actionBar;
+    private readonly tooltip;
+    private readonly controls;
+    private readonly outline;
+    private readonly sheet;
+    private readonly viewer;
+    private readonly input;
+    private readonly clock;
+    private readonly spinPhysics;
+    private readonly spinTracker;
+    private readonly panTracker;
+    private readonly glide;
+    private readonly ids;
+    private resizeObserver;
+    private visibilityObserver;
+    /** Every node's color, from `getNodeColor`'s first call until the map or its options change. */
+    private nodeColors;
+    private taskTokens;
+    /** Whether any of the map is on screen; off screen, the drift rests. */
+    private onScreen;
+    /** The reduced-motion query, asked once: the drift checks it every frame. */
+    private reducedMotionQuery;
+    private options;
+    /** Options from the caller (constructor and setOptions); they win over the document's. */
+    private userOptions;
+    /** Options from the rendered document's frontmatter or YAML keys. */
+    private documentOptions;
+    /** Those options as the document wrote them, for `getDocument()` and `toMarkdown()`. */
+    private sourceOptions;
+    /** The document's keys Orbit doesn't read, written back on save. */
+    private sourceExtra;
+    private themeProperties;
+    private tree;
+    private focusPath;
+    private viewMode;
+    private viewport;
+    /** The size the views were last laid out for: resizes close to it keep the layout. */
+    private layoutSize;
+    /** The map was resized while flying: lay the view out again once it lands. */
+    private relayoutOnArrival;
+    /** The page's controls moved while flying (see `insets`): fit the view again once it lands. */
+    private refitOnArrival;
+    private scene;
+    private camera;
+    private transition;
+    /** Where a flight between two branches goes after passing through their common ancestor. */
+    private nextScene;
+    /** The camera a flight ends on, when it isn't the scene's fitted view. */
+    private landingCamera;
+    private cameraFlight;
+    private wheelZoom;
+    private display;
+    private restingDisplay;
+    /**
+     * Nodes in the order their labels are placed, for one display, and their
+     * ids for a scene at rest: the order holds while the orbit spins, only the
+     * entries are new each frame.
+     */
+    private labelOrder;
+    private readonly nodeViews;
+    /** The family group each node's element is in (see `Family`). */
+    private readonly nodeGroups;
+    private readonly families;
+    /** Counts flights, so each one's arrivals get groups of their own. */
+    private flightCount;
+    private familyCount;
+    private readonly labels;
+    private readonly ringViews;
+    /** Each view keeps what it last wrote, so the elements of a map that didn't move aren't touched. */
+    private readonly linkViews;
+    private readonly counts;
+    /** The camera labels and counts were last placed for, and the nodes they were placed for. */
+    private labelsPlaced;
+    /** Names planned to show that wait for a later frame (see `LABELS_SHOWN_PER_FRAME`), placed for `labelsPlaced`'s camera, and whether the map moved then. */
+    private waitingLabels;
+    private labelLayerTransform;
+    private readonly lightText;
+    /** The theme's label colors, resolved when first needed after each theme change. */
+    private textColors;
+    /** The node that holds the map's single tab stop. */
+    private activeId;
+    private tabStopsChanged;
+    private hoveredId;
+    private keyboardFocusId;
+    private topPlanetId;
+    private userSpun;
+    /** Put keyboard focus back on the map when a flight lands (its node may have left). */
+    private returnFocusToMap;
+    private dragging;
+    /** The last node a long press, right click or context menu key reported, and whether someone took it. */
+    private lastContext;
+    /** Nodes whose ids an edit changed, old to new, so the next redraw moves them rather than replacing them. */
+    private renamedIds;
+    /** Nodes an edit changed in place (the node itself, or a parent's children): the next paint draws them again. */
+    private readonly changedIds;
+    /** The + in the orbit, and the field for typing on the map. */
+    private readonly addSlotView;
+    /** The place held in the orbit for a planet being dragged: like the +, but nothing to press. */
+    private readonly heldPlaceView;
+    private readonly editor;
+    private editing;
+    private arrival;
+    /** A node held up to be dragged somewhere else. */
+    private nodeDrag;
+    /** The frame a dragged node was let go in: the flight that follows starts from it. */
+    private dropFrom;
+    /** A long press no one took a menu for, on a node it lifts: let go without moving, the node is typed into. */
+    private editOnLift;
+    /** The lifted node and the drop target last drawn, so a change draws every node again. */
+    private dragMarks;
+    private ambientRunning;
+    /** Drift not painted yet, in degrees: less than a `DRIFT_STEP`. */
+    private pendingDrift;
+    /** How far the current view's spinning bodies reach from the sun (world units). */
+    private spinReach;
+    private pageScrollCheck;
+    private readonly listeners;
+    private destroyed;
+    private warnedFlat;
+    private warnedTheme;
+    constructor(container: HTMLElement, options?: RendererOptions);
+    /**
+     * Draws a map: markdown or YAML source (parsed forgivingly), a parsed
+     * document, or a node tree. A document's frontmatter options apply, though
+     * options given to the renderer win. Drawing a new version of the same map
+     * keeps the reader's place: the focused node, or its closest ancestor that
+     * still exists.
+     */
+    render(input: string | OrbitNode | OrbitDocument): void;
+    setOptions(options: RendererOptions): void;
+    /**
+     * Listens for a map event; returns a function that stops listening. The
+     * same events are dispatched on the container as `orbit-<name>` DOM events.
+     */
+    on<Name extends OrbitEventName>(name: Name, listener: (detail: OrbitEventMap[Name]) => void): () => void;
+    getSVGElement(): SVGSVGElement;
+    /**
+     * The current view as a standalone SVG document: colors resolved, labels
+     * as SVG text, nothing that depends on the page's stylesheet.
+     */
+    toSVGString(): string;
+    getViewMode(): ViewMode;
+    /** Switches between focus mode and the overview (fires onViewModeChange). */
+    setViewMode(mode: ViewMode): void;
+    /** Ids from the root to the focused node. */
+    getFocusPath(): string[];
+    /** The node focused in focus mode (the sun). */
+    getFocusedNode(): OrbitNode | null;
+    /**
+     * Focuses a node by id and flies to it (fires onFocusChange). In the
+     * overview, the camera moves to the node instead. Returns false when the
+     * id isn't in the map.
+     */
+    focusNode(id: string): boolean;
+    /**
+     * Flies to a node by id, switching to focus mode if needed (fires
+     * onFocusChange and onViewModeChange). Returns false when there's no such node.
+     */
+    flyTo(id: string): boolean;
+    /** Flies out to the overview of the whole map (fires onViewModeChange). */
+    overview(): void;
+    /** Zooms by `factor` around the middle of the map (above 1 zooms in). */
+    zoomBy(factor: number): void;
+    /** Returns the camera to the fitted view. */
+    fit(): void;
+    /**
+     * Flicks the orbit at `speed` degrees per second; negative speeds turn it
+     * counterclockwise. Only in focus mode.
+     */
+    spin(speed: number): void;
+    /**
+     * Shows a node's picture or video in the media viewer, over the whole
+     * window, opening it if it's closed: to show a picture big, or play a
+     * video, from your own controls. A node with both shows its picture
+     * unless `kind` is `video`, and a video starts playing unless `autoplay`
+     * is `false`, from the start or `startAt` seconds in. It opens whatever
+     * `mediaViewer`, `showDetailSheet` and `interactive` say; on a map that
+     * isn't interactive, the viewer takes no input of its own and has no
+     * buttons. Fires `media-open`. Returns false when the map has no such
+     * node, or the node no such picture or video.
+     */
+    openMedia(nodeId: string, options?: OrbitMediaOptions): boolean;
+    /** Closes the media viewer, if it's open (fires `media-close`). */
+    closeMedia(): void;
+    /**
+     * Plays the video in the media viewer. Returns false when it shows no
+     * video, or one on a site Orbit has no player for. Files, YouTube and
+     * Vimeo play.
+     */
+    playMedia(): boolean;
+    /** Pauses the video in the media viewer. Returns false when it shows no video it can pause. */
+    pauseMedia(): boolean;
+    /** Moves the video in the media viewer to `seconds` from its start. Returns false when it shows no video it can move. */
+    seekMedia(seconds: number): boolean;
+    /**
+     * Turns on the sound of the video in the media viewer: one a browser
+     * started muted, say. Browsers allow sound only once the reader has
+     * interacted with the page, so call it from a press, such as a "Tap for
+     * sound" button's. Returns false when it shows no video it can drive.
+     */
+    unmuteMedia(): boolean;
+    /**
+     * The color a node is drawn with: its own, its type's, or its branch's
+     * from the palette and theme. For lists and legends next to the map. A hex
+     * color, or the CSS color as written when Orbit can't read it; `null` when
+     * the id isn't in the map.
+     */
+    getNodeColor(id: string): string | null;
+    /**
+     * The theme's tokens as the page resolves them, read once per task:
+     * reading them asks the browser for every token, and a list next to a big
+     * map asks for hundreds of colors at once.
+     */
+    private tokensForThisTask;
+    /**
+     * The map as a document: its tree, and the options its source set in
+     * frontmatter. Edits change this tree in place.
+     */
+    getDocument(): OrbitDocument | null;
+    /**
+     * The map as orbit-md, frontmatter included: what to save after an edit.
+     * A map read from markdown comes back as it was written, with only what
+     * the edits changed written again, so a file written by hand or by
+     * another app keeps its formatting and everything Orbit doesn't read.
+     */
+    toMarkdown(): string;
+    /**
+     * Adds a node under `parentId`, at `index` among its children (default:
+     * last), with any `children` it lists under it; it flies out of its parent
+     * into place. Ids come from the text, as when the map is read from
+     * markdown. Fires `edit` once. Returns the new node, or null when there's
+     * no such parent.
+     */
+    addNode(parentId: string, input: OrbitNewNode, index?: number): OrbitNode | null;
+    /**
+     * Changes a node's text or attributes: `{ text: 'Budget' }`, `{ status:
+     * 'done' }`, or `{ color: undefined }` to remove one. New text gives the
+     * node a new id when its id came from its text and no link points at it,
+     * so the saved map needs no id attribute. Fires `edit`. Returns the
+     * node, or null when there's no such node.
+     */
+    updateNode(id: string, changes: OrbitNodeInput): OrbitNode | null;
+    /**
+     * Removes a node and everything under it. When the node in focus goes,
+     * the nearest node left takes the focus. The root stays. Fires `edit`.
+     * Returns the removed node, or null.
+     */
+    removeNode(id: string): OrbitNode | null;
+    /**
+     * Moves a node, with everything under it, under `parentId` at `index`
+     * among its children (default: last). Fires `edit`. Returns the node,
+     * or null when either node is missing, the node is the root, or
+     * `parentId` is inside the node.
+     */
+    moveNode(id: string, parentId: string, index?: number): OrbitNode | null;
+    /**
+     * Opens a field over a node to type its text where it is: Enter saves,
+     * Escape cancels, and leaving the field saves. A moon, or a node out of
+     * view, flies into view first. Fires `editor-open`, then `editor-close`.
+     * Returns false when there's no such node.
+     */
+    editNode(id: string): boolean;
+    /**
+     * Adds an idea by typing it on the map: a field opens in the orbit of
+     * `parentId` (default: the node in focus), at `index` among its children
+     * (default: after the last), flying there first. Enter adds the idea
+     * where it was typed and opens the next one after it; Escape, or Enter
+     * with nothing typed, stops. Fires `editor-open`, `edit` for each idea,
+     * then `editor-close`. Returns false when there's no such node.
+     */
+    editNewNode(parentId?: string, index?: number): boolean;
+    /** Closes the field for typing on the map, keeping what was typed unless `save` is false. */
+    stopEditing(save?: boolean): void;
+    destroy(): void;
+    /** Draws `tree`, keeping the reader's place in it. */
+    private showTree;
+    /** Whether `tree`, with the document's `options`, is the map as drawn now, in another object. */
+    private isSameMap;
+    /**
+     * Takes a copy of the map as drawn without drawing it again, so a flight or
+     * an edit's animation carries on. The copy proved equal to the drawn tree
+     * (see `isSameMap`): the drawn nodes stay, so their views, labels and
+     * outline entries carry on too; the copy lends only its places in the source.
+     */
+    private adoptTree;
+    /** Shows an edit, keeping the reader's place, and reports it. */
+    private afterEdit;
+    /** Adds a node; `arrival`, where a new idea was typed, is where it first shows. */
+    private insertNode;
+    /** Whether Tab, Shift+Enter and Delete edit the map (see `editingKeys`). */
+    private get editingKeys();
+    /** Shift+Enter: a new idea beside `id`, right after it. Beside the root, which has no orbit around it, is under it. */
+    private addBeside;
+    /** Delete: removes `id`, and keyboard focus moves on to the node after it, or before it, or up to its parent. */
+    private removeWithKey;
+    /**
+     * Tab and Shift+Tab in the field (see `editingKeys`). Tab goes on a level
+     * down: under the idea just typed, or with nothing typed, under the idea
+     * before. Shift+Tab goes on a level up, beside the parent. What was typed
+     * is kept first. Returns whether the key was used.
+     */
+    private tabFromEditor;
+    /** Keeps what was typed: new text for a node, or a new idea (and, after Enter, the field moves on to the next). */
+    private saveEdit;
+    /**
+     * Closes the field. `returnFocus` puts keyboard focus back on the node
+     * (or the +) when it was in the field; `refresh` moves the + back to its
+     * place, unless an edit is about to redraw the map anyway.
+     */
+    private finishEditing;
+    /** Redraws the view when the + should show, move or go. */
+    private refreshSlot;
+    /** Where the + goes in the focused node's orbit: where a new idea is being typed, else after its children on editable maps. */
+    private slotPlace;
+    private emitEditor;
+    /** Keeps the view's place on a node whose id an edit changed. */
+    private renameView;
+    /** Defaults, then the document's options, then the caller's. `undefined` means "not set". */
+    private resolveOptions;
+    private createExtensions;
+    /**
+     * Speaks the language the options ask for, or else the one the map's
+     * element is in now, and writes the map's words again if that changed.
+     */
+    private syncLanguage;
+    /** Applies the current options. With `previous`, also updates the map for what changed. */
+    private applyOptionEffects;
+    /** Whether the camera shows the view as it's fitted, not zoomed or panned away from it. */
+    private isFitted;
+    /** The theme object to apply, with a registered theme's name replaced by its tokens. */
+    private themeOption;
+    private themePreset;
+    private applyTheme;
+    /** A token as the page resolves it (its CSS can set any), or as the theme sets it while the map isn't on a page. */
+    private themeValue;
+    /** Concrete theme values for exports: the preset, then the theme object, then the page's CSS. */
+    private exportTokens;
+    private syncInteractivity;
+    private get focusId();
+    private get rotation();
+    private sceneOptions;
+    /**
+     * The scene for the current view, or null while there is nothing to draw
+     * or no room to draw it. `withSlot: false` leaves out the + (for exports).
+     */
+    private buildScene;
+    /**
+     * The focus view of `focusId`. Where the focused node's buttons have no
+     * place around the sun, it's fitted to leave room for them under the orbit.
+     */
+    private focusScene;
+    /**
+     * The room (px) a focus view needs under its orbit for the focused node's
+     * buttons: none where they have a place in the view as it's fitted.
+     */
+    private roomForActions;
+    private showsActions;
+    /**
+     * Where the focused node's buttons go, or null where every place would
+     * cover something: under the sun where its planets leave room at every
+     * turn of the orbit, else on its lower rim under its name, else under the
+     * orbit (`focusScene` fits views to leave room there).
+     */
+    private actionsPlace;
+    /**
+     * How `count` buttons lay out under the orbit with their top `top` px down
+     * the map (by default, as low as they go): between the sides of the map
+     * that `insets` leave, or short of the zoom buttons where they come down
+     * beside them, on more lines if they must.
+     */
+    private rowsUnderOrbit;
+    /**
+     * Moves to a view: `nodeId` in focus, or the overview. Fires
+     * onFocusChange and onViewModeChange unless `notify` is false.
+     */
+    private navigate;
+    private flyToCurrentView;
+    /**
+     * Where to put `target` in today's world so the flight has a fixed point:
+     * a node both views show stays put while the camera moves.
+     */
+    private placeTarget;
+    private commonAncestorScene;
+    private startTransition;
+    /** Reduced motion: fade the current view out and the next one in, without moving anything. */
+    private startFade;
+    private flightDuration;
+    private readonly transitionTask;
+    private finishTransition;
+    /** Jumps to the end of any flight in progress. */
+    private completeTransition;
+    /** Shows `scene` at rest, fitted. */
+    private restOn;
+    private afterArrival;
+    /**
+     * Builds the view again: `enter` animates it in, `morph` moves today's
+     * nodes into their new places, `instant` just shows it.
+     */
+    private rebuild;
+    /** Rebuilds the current view in place (new colors, same layout). */
+    private refreshScene;
+    private currentDisplay;
+    /** Stops every camera and orbit motion except a flight between views. */
+    private stopMotion;
+    private paint;
+    private paintRings;
+    private paintLinks;
+    /**
+     * Turns the layers of the planets and moons with the orbit (see
+     * `OrbitTurn`). Returns the turn (degrees) its bodies are drawn in, or
+     * undefined when each is drawn where it is.
+     */
+    private paintTurn;
+    private paintNodes;
+    /**
+     * The on-screen radius (px) below which flat bodies are specks, for this
+     * screen's pixels; the stylesheet sizes specks' rims from it.
+     */
+    private speckRadius;
+    /**
+     * A family whose members don't all move alike in this flight (some travel
+     * on, the rest leave) splits in two, the fewer of them moving to a group of
+     * their own, so each part moves as one.
+     */
+    private splitIfMixed;
+    /**
+     * The group a node is drawn in: its family's, in the layer of its role. A
+     * node stays in its group while its parent and role do, so nothing moves
+     * between groups when a flight lands; the ideas a flight brings in get a
+     * group of their own, so they can move as one while their siblings travel.
+     */
+    private placeInFamily;
+    /** A new family's group; one that starts hidden (newcomers yet to appear) is hidden before it joins the map, so its members aren't styled until they show. */
+    private createFamily;
+    private moveIntoFamily;
+    /** The node whose text is being typed on the map, if any. */
+    private editedId;
+    private paintAddSlot;
+    /** The place held for a planet being dragged: an empty ring where it's laid out, under the press's way. */
+    private paintHeldPlace;
+    /** Lays the field for typing over its node, or the +, wherever they are this frame. */
+    private placeEditor;
+    /**
+     * The field's place and size: the label's, inside the node; a node too
+     * small to hold it gets a field floating over it at a readable size. Over a
+     * node with a "+N" (`hiddenChildren` it doesn't draw), the field rises as
+     * it grows, as names do, to keep clear of the count.
+     */
+    private editorPlacement;
+    private removeNodeView;
+    /**
+     * While only the camera moves (a pan, a pinch, a zoom, a glide), labels and counts ride along
+     * as one layer instead of being placed again on every frame, which for a big view means
+     * restyling hundreds of them. They're placed again once the camera rests, or has gone far
+     * enough that they'd be too big or too small, or missing for nodes coming into view. Returns
+     * the layer's transform from where they were placed, or null to place them now.
+     */
+    private labelRide;
+    /** Fits and places every label again, where it is (the fonts changed). */
+    private fitLabelsAgain;
+    /** Whether the labels were placed for this very view: the same nodes, the camera where it was, nothing changed. */
+    private labelsStill;
+    private setLabelLayerTransform;
+    private paintLabels;
+    /** Shows a planned label: its view (made when it has none yet) placed and fitted as planned. */
+    private showLabel;
+    /**
+     * While the labels ride along with the camera, shows the next names
+     * waiting to: placed as planned, for the camera the labels were placed
+     * at, so they ride along with the rest.
+     */
+    private showWaitingLabels;
+    /** Whether the node shows a picture or its type's own content, so its label goes outside. */
+    private showsImage;
+    /**
+     * Draws what node types render inside their nodes: a 100 × 100 px box per
+     * node, moved and scaled with it each frame, created when the node comes
+     * on the map and cleaned up when it leaves.
+     */
+    private paintContents;
+    private removeContent;
+    /** Whether the theme's light text has more contrast on this node's color than its dark text. Measured once per node and color. */
+    private usesLightText;
+    /** The theme's label colors as plain values. */
+    private resolveTextColors;
+    private paintOverlay;
+    /** The "+N" of nodes with children that aren't drawn, at their lower right. In the label layer, so they ride along with the labels. */
+    private paintCounts;
+    private clearViews;
+    /** One tab stop for the whole map (roving tabindex); arrow keys move between nodes. */
+    private updateTabStops;
+    private focusNodeElement;
+    private updateControls;
+    /** The outline, and the pictures and videos the viewer steps through, follow the map. */
+    private updateOutline;
+    private toggleOutline;
+    private selectFromOutline;
+    private announceView;
+    private updateTooltip;
+    private positionTooltip;
+    private tooltipAnchor;
+    private readonly handleClick;
+    /** A right click, or the browser's own long press or context menu key, on a node. */
+    private readonly handleContextMenu;
+    /**
+     * Where a context menu event points on the map: the pointer when it is on
+     * the node, otherwise the node's center (menus opened from the keyboard
+     * report the element's corner, or nothing).
+     */
+    private contextPoint;
+    /** A node's center on the map. */
+    private nodeOnScreen;
+    /**
+     * Reports a long press, right click or context menu key on a node.
+     * Returns whether someone took it: an `onNodeContext` callback, a
+     * `node-context` listener, or a DOM listener that called
+     * `preventDefault()`. A press someone took doesn't open the node, and the
+     * browser's menu stays closed.
+     */
+    private openNodeContext;
+    /** Whether a press held on node `id` lifts it: on an editable map at rest, any node but the root and the sun. */
+    private canLift;
+    /** A press held still on node `id`: it lifts, to be dragged somewhere else. Returns whether it did. */
+    private liftNode;
+    /** The press holding a lifted node moved, was let go, or was taken away. */
+    private dragNode;
+    /**
+     * The lifted node leaves its place to follow the press. A planet of the
+     * focused orbit keeps its place held, so nothing moves and nothing slides
+     * under the press; anything else leaves an empty place behind.
+     */
+    private startCarrying;
+    /** Whether the node being dragged is one of the focused orbit's planets, laid out at the place held for it. */
+    private carriesPlanet;
+    /**
+     * Where the dragged node would go if let go now: into the node under the
+     * press, at the place in the orbit under it, or else at the place held for
+     * it. Null when there's none of those.
+     */
+    private dropPlaceAt;
+    /**
+     * Follows where the dragged node would go, and tells the page when that
+     * changes. The orbit is laid out again only when the place held in it
+     * moves: hovering a node leaves the planets where they are, so the node
+     * stays under the press.
+     */
+    private updateDropPlace;
+    /**
+     * Lays the view out again around the node being dragged, with the place
+     * held for it where it would land in the orbit, the planets making room.
+     * They glide from wherever they are this frame, and the camera holds still.
+     */
+    private relayoutForDrag;
+    /** Lets the dragged node go at `place`: it moves there (an `edit`), and flies from where it was let go. */
+    private dropNode;
+    /**
+     * Puts the dragged node back where it was: it flies back from where it
+     * was let go. One only lifted goes back down; `released` without moving
+     * after a long press no one took, it's typed into.
+     */
+    private putBack;
+    private emitDrag;
+    /**
+     * `display` with the node being dragged, and its moons, under the press:
+     * over a node it would go into, smaller, nearer the press and without its
+     * name, as if about to go inside.
+     */
+    private withCarried;
+    /** A click (or Enter) on a node: the sun goes back up, anything else is entered. */
+    private activate;
+    /** Up a level in focus mode; from the overview, back to focus mode. */
+    private goBack;
+    private readonly handleKeyDown;
+    /**
+     * Arrow-key movement. Focus mode: left and right step through the planets
+     * (turning the orbit so the chosen one sits on top), down enters the
+     * orbit, up returns to the sun. Overview: the tree, as in a tree view.
+     */
+    private moveFocus;
+    /** Turns the orbit so `planet` sits at the top. */
+    private turnToTop;
+    /** Pans the overview so a node that has keyboard focus is on screen. */
+    private keepInView;
+    private readonly handlePointerOver;
+    private readonly handlePointerOut;
+    private readonly handleFocusIn;
+    private readonly handleFocusOut;
+    private dragGestureAt;
+    private sunOnScreen;
+    private releaseSpin;
+    private readonly spinTask;
+    private spinSettled;
+    private planetNearestTop;
+    /** A short vibration each time a planet passes the top, like the detents of a dial. */
+    private tickHaptics;
+    /** The slow drift of `orbitAnimation`; it pauses while the reader is pointing at, holding or tabbing through the map. */
+    private syncAmbientMotion;
+    private shouldDrift;
+    private readonly ambientTask;
+    /** How far the bodies that spin with the orbit reach from the sun, in world units. */
+    private spinningReach;
+    private zoomLevel;
+    private zoomRange;
+    private viewportCenter;
+    /**
+     * Keeps the content reachable. The overview can pan until its edge meets
+     * the middle of the map; focus mode stays centered on the sun when fitted
+     * and gains room to pan the further it zooms in.
+     */
+    private clampCamera;
+    private panCamera;
+    private readonly glideTask;
+    /** Zooms immediately by `factor` around `anchor`, within the zoom range. */
+    private zoomAt;
+    /** Zooming into a planet or moon enters it; zooming out of a view leaves it. */
+    private checkZoomNavigation;
+    /** The planet or moon under `point` at least `minimumRadius` px on screen, preferring the smallest (most specific). */
+    private bodyAt;
+    /** After a pinch or wheel zoom: focus mode springs back from a partial zoom-out. */
+    private settleZoom;
+    private handleWheel;
+    private readonly wheelTask;
+    private handleDoubleTap;
+    /** An animated zoom step (buttons, keys, double taps). */
+    private zoomStep;
+    private flyCamera;
+    private readonly cameraFlightTask;
+    private afterCameraFlight;
+    /** Whether the page around the map scrolls; if so, a plain wheel scrolls the page instead of zooming. */
+    private pageScrolls;
+    private updateEmbedding;
+    private emitFocusChange;
+    /**
+     * Calls the `on()` listeners, then dispatches `orbit-<name>` on the
+     * container. Returns false when a DOM listener cancelled the event.
+     */
+    private emit;
+    /** Runs a button: one of Orbit's, or one of your actions, after `onAction` and the `action` event let it. */
+    private runAction;
+    /** Whether a button may do what it does: `onAction` didn't return `false` and no listener called the `action` event's `preventDefault()`. */
+    private allowAction;
+    /**
+     * A picture or video pressed in the detail sheet: a press of "View image"
+     * or "Play video". The viewer opens over the sheet; a page that takes the
+     * press gets the sheet closed, so what it opens is in front.
+     */
+    private viewFromSheet;
+    private openDetails;
+    /** The media viewer opened, stepped, or closed: the drift rests behind it, and the page hears of it. */
+    private mediaShown;
+    private mediaPlayed;
+    /** The node a `#id` link points at, in this map. */
+    private findLinked;
+    /** Where a node's link button goes: a page, or another node of the map ("Go to Research"). */
+    private describeLink;
+    /** Flies to the node a `#id` link points at, from a link button, the detail sheet or a note. */
+    private followNodeLink;
+    private observeResize;
+    /** Rests the drift while the map is scrolled out of sight, so a page of maps only moves the ones in view. */
+    private observeVisibility;
+    /** A map in a container without a height is invisible; say so once, in the console, where it gets noticed. */
+    private warnIfFlat;
+    private handleResize;
+    private setViewport;
+    private readContainerSize;
+    /** Flights and camera moves animate unless reduced motion is on or `transitionDuration` is 0. */
+    private animationsEnabled;
+    private prefersReducedMotion;
+    private now;
+}