@enigmax/primitives 0.25.0 → 0.27.0

package/dist/{chunk-Z3VDE7OA.js → chunk-YQV5XZIA.js}

@@ -6,7 +6,7 @@ function isAction(entry) {
   return (entry.type ?? "item") === "item";
 }
 var CONTEXT_MENU_SEARCH_KEYS = ["label", "description", "group", "keywords"];
-var SEARCHABLE_FROM = 8;
+var SEARCHABLE_FROM = 12;
 var PAGE = 5;
 var DEFAULT_CACHE_MS = 5 * 60 * 1e3;
 function fold(value) {
@@ -32,7 +32,7 @@ function createContextMenu(options = {}) {
     return path.join("\0");
   }
   function searchableFor(item, entries) {
-    const asked = item?.searchable ?? "auto";
+    const asked = (item ? item.searchable : opts.searchable) ?? "auto";
     if (asked !== "auto") return asked;
     return entries.filter(isAction).length >= SEARCHABLE_FROM;
   }

package/dist/clipboard-menu-eemzEBqB.d.ts

@@ -0,0 +1,93 @@
+import { b as ContextMenuEntry } from './context-menu-qqpGBkny.js';
+
+/**
+ * The rows every context menu on a desktop already has: Copy, Cut and Paste.
+ *
+ * A menu opened over a selection or over a field is expected to offer them - the browser's own
+ * does, and replacing that menu with a custom one takes them away without saying so. Which is
+ * why they are ON by default here and turned off with a prop, rather than the other way round:
+ * the defect is silent, so the default has to be the safe one.
+ *
+ * WHAT DECIDES THEY APPEAR is what was right-clicked, and it is read at the moment the menu
+ * opens, not from React state - by then the selection is settled (a `contextmenu` event fires
+ * after the press has adjusted it) and the caret is still where the visitor left it.
+ *
+ * - **Copy**, when there is selected text under the pointer.
+ * - **Cut**, when that selection is also in something writable.
+ * - **Paste**, in anything writable - and disabled when the clipboard is known to be empty.
+ *
+ * Not a React module: what a selection is, whether a field takes writes, and how text is put
+ * back into one are DOM questions, so a menu drawn by anything else gets the same rows.
+ */
+
+/** The ids these rows carry. Namespaced, so they can never collide with a caller's own. */
+declare const CLIPBOARD_PREFIX = "enigma:clipboard:";
+type ClipboardAction = "copy" | "cut" | "paste";
+/** What the menu was opened over, as far as the clipboard is concerned. */
+interface ClipboardTarget {
+    /** The field or contenteditable under the pointer, or null when it is neither. */
+    editable: HTMLElement | null;
+    /** Whether that element takes writes: not disabled, not read-only. */
+    writable: boolean;
+    /** The selected text, from the field's own selection or the document's. */
+    selection: string;
+    /**
+     * Whether that text may be put on the clipboard.
+     *
+     * False for a password field. The clipboard is shared with every other application on the
+     * machine and is not cleared, so a menu that copies a password out of a masked field
+     * leaks it somewhere the visitor cannot see - and the browser's own menu refuses too.
+     */
+    copyable: boolean;
+    /** Where the selection was, so it can be put back after the menu has taken focus. */
+    range: {
+        start: number;
+        end: number;
+    } | null;
+}
+interface ClipboardMenuLabels {
+    copy?: string;
+    cut?: string;
+    paste?: string;
+}
+interface ClipboardMenuOptions {
+    copy?: boolean;
+    cut?: boolean;
+    paste?: boolean;
+    labels?: ClipboardMenuLabels;
+    /** Whatever the renderer draws icons with. `unknown`, because a core cannot know. */
+    icons?: {
+        copy?: unknown;
+        cut?: unknown;
+        paste?: unknown;
+    };
+    /** The clipboard is known to be empty, so Paste is listed and greyed rather than missing. */
+    clipboardEmpty?: boolean;
+}
+/** What was right-clicked, read the moment the menu opens. */
+declare function inspectClipboardTarget(node: EventTarget | null): ClipboardTarget;
+/**
+ * Whether the clipboard has text in it, or null when that cannot be known.
+ *
+ * Null is the common answer and not a failure: reading the clipboard needs permission, and
+ * asking for it puts a browser prompt on screen just to decide whether to grey out a row -
+ * which is a worse trade than showing an enabled Paste that turns out to do nothing. So the
+ * permission is only READ, never requested, and the clipboard is only opened where it has
+ * already been granted.
+ */
+declare function clipboardHasText(): Promise<boolean | null>;
+/** The rows for this target, in the order every desktop menu puts them. */
+declare function clipboardEntries(target: ClipboardTarget, options?: ClipboardMenuOptions): ContextMenuEntry[];
+/** Which clipboard row an id belongs to, or null for anything that is not one of ours. */
+declare function clipboardAction(id: string): ClipboardAction | null;
+/**
+ * Do what the row says.
+ *
+ * Called straight from the press that chose it, so the browser still counts it as a user
+ * gesture - which is what the clipboard API requires and what makes a paste possible at all.
+ * Returns whether the action happened: a refused permission and an empty clipboard are both
+ * "no", and neither is worth an exception the caller has to catch.
+ */
+declare function performClipboardAction(action: ClipboardAction, target: ClipboardTarget): Promise<boolean>;
+
+export { CLIPBOARD_PREFIX as C, type ClipboardAction as a, type ClipboardMenuLabels as b, type ClipboardMenuOptions as c, type ClipboardTarget as d, clipboardAction as e, clipboardEntries as f, clipboardHasText as g, inspectClipboardTarget as i, performClipboardAction as p };

package/dist/context-DR1dpO8b.d.ts

@@ -0,0 +1,54 @@
+import { ReactNode, RefObject } from 'react';
+import { a as ContextMenuAction, b as ContextMenuEntry, c as ContextMenuInstance, j as ContextMenuState, h as ContextMenuPoint } from './context-menu-qqpGBkny.js';
+
+/**
+ * One row, as React draws it. The core carries `icon` as `unknown` because it cannot know
+ * what a node is; here it is one.
+ */
+interface ContextMenuItem extends Omit<ContextMenuAction, "icon" | "items"> {
+    icon?: ReactNode;
+    items?: readonly ContextMenuNode[];
+}
+/** Anything that can appear in a menu, with React's icon type. */
+type ContextMenuNode = ContextMenuItem | Exclude<ContextMenuEntry, ContextMenuAction>;
+interface ContextMenuContextValue {
+    instance: ContextMenuInstance;
+    state: ContextMenuState;
+    /**
+     * Open at a point, over what the press landed on. False when there was nothing to show,
+     * so the press is left alone.
+     *
+     * `target` is what the clipboard rows are built from - the field or the selection under
+     * the pointer - and a caller that leaves it out gets a menu with none of them, which is
+     * the right answer for a menu opened from somewhere that is not a press.
+     */
+    open: (point: ContextMenuPoint, target?: EventTarget | null) => boolean;
+    close: () => void;
+    /** ids the parts need to point at each other. */
+    ids: {
+        trigger: string;
+    };
+    panelId: (level: number) => string;
+    itemId: (level: number, index: number) => string;
+    triggerRef: RefObject<HTMLElement | null>;
+    /** Which panel the keyboard is in. Always the deepest open one. */
+    onMenuKeyDown: (event: React.KeyboardEvent) => void;
+    /** How long the pointer must rest on a row before its submenu opens, and before one closes. */
+    delays: {
+        open: number;
+        close: number;
+    };
+    /** Drop the pending close, wherever it was scheduled. Called wherever the pointer lands. */
+    cancelClose: () => void;
+    /** Close everything below `level`, after the beat - replacing any close already waiting. */
+    scheduleClose: (level: number) => void;
+    /** Draw a row instead of the default icon / label / shortcut. */
+    renderItem?: (item: ContextMenuItem, level: number, index: number) => ReactNode;
+    /** Shown while a fetched submenu has not answered. */
+    loadingLabel: ReactNode;
+    /** Shown when a filter matched nothing, or a fetched submenu came back with nothing. */
+    emptyLabel: ReactNode;
+}
+declare function useContextMenuContext(part: string): ContextMenuContextValue;
+
+export { type ContextMenuContextValue as C, type ContextMenuItem as a, type ContextMenuNode as b, useContextMenuContext as u };

package/dist/{clipboard-menu-B_ouitfS.d.ts → context-menu-qqpGBkny.d.ts}

@@ -126,6 +126,12 @@ interface ContextMenuOptions {
     /** A row was invoked. The menu has already closed unless the row keeps it open. */
     onSelect?: (item: ContextMenuAction, path: string[]) => void;
     onOpenChange?: (open: boolean) => void;
+    /**
+     * Whether the ROOT level draws a filter. `"auto"` (the default) grows one from
+     * `SEARCHABLE_FROM` rows; `true` puts one there whatever the count, which is what a menu
+     * filling itself from somewhere wants; `false` never does.
+     */
+    searchable?: boolean | "auto";
 }
 interface ContextMenuInstance {
     readonly state: ContextMenuState;
@@ -171,94 +177,4 @@ interface ContextMenuInstance {
 type ContextMenuMoveKey = "ArrowDown" | "ArrowUp" | "Home" | "End" | "PageDown" | "PageUp";
 declare function createContextMenu(options?: ContextMenuOptions): ContextMenuInstance;
 
-/**
- * The rows every context menu on a desktop already has: Copy, Cut and Paste.
- *
- * A menu opened over a selection or over a field is expected to offer them - the browser's own
- * does, and replacing that menu with a custom one takes them away without saying so. Which is
- * why they are ON by default here and turned off with a prop, rather than the other way round:
- * the defect is silent, so the default has to be the safe one.
- *
- * WHAT DECIDES THEY APPEAR is what was right-clicked, and it is read at the moment the menu
- * opens, not from React state - by then the selection is settled (a `contextmenu` event fires
- * after the press has adjusted it) and the caret is still where the visitor left it.
- *
- * - **Copy**, when there is selected text under the pointer.
- * - **Cut**, when that selection is also in something writable.
- * - **Paste**, in anything writable - and disabled when the clipboard is known to be empty.
- *
- * Not a React module: what a selection is, whether a field takes writes, and how text is put
- * back into one are DOM questions, so a menu drawn by anything else gets the same rows.
- */
-
-/** The ids these rows carry. Namespaced, so they can never collide with a caller's own. */
-declare const CLIPBOARD_PREFIX = "enigma:clipboard:";
-type ClipboardAction = "copy" | "cut" | "paste";
-/** What the menu was opened over, as far as the clipboard is concerned. */
-interface ClipboardTarget {
-    /** The field or contenteditable under the pointer, or null when it is neither. */
-    editable: HTMLElement | null;
-    /** Whether that element takes writes: not disabled, not read-only. */
-    writable: boolean;
-    /** The selected text, from the field's own selection or the document's. */
-    selection: string;
-    /**
-     * Whether that text may be put on the clipboard.
-     *
-     * False for a password field. The clipboard is shared with every other application on the
-     * machine and is not cleared, so a menu that copies a password out of a masked field
-     * leaks it somewhere the visitor cannot see - and the browser's own menu refuses too.
-     */
-    copyable: boolean;
-    /** Where the selection was, so it can be put back after the menu has taken focus. */
-    range: {
-        start: number;
-        end: number;
-    } | null;
-}
-interface ClipboardMenuLabels {
-    copy?: string;
-    cut?: string;
-    paste?: string;
-}
-interface ClipboardMenuOptions {
-    copy?: boolean;
-    cut?: boolean;
-    paste?: boolean;
-    labels?: ClipboardMenuLabels;
-    /** Whatever the renderer draws icons with. `unknown`, because a core cannot know. */
-    icons?: {
-        copy?: unknown;
-        cut?: unknown;
-        paste?: unknown;
-    };
-    /** The clipboard is known to be empty, so Paste is listed and greyed rather than missing. */
-    clipboardEmpty?: boolean;
-}
-/** What was right-clicked, read the moment the menu opens. */
-declare function inspectClipboardTarget(node: EventTarget | null): ClipboardTarget;
-/**
- * Whether the clipboard has text in it, or null when that cannot be known.
- *
- * Null is the common answer and not a failure: reading the clipboard needs permission, and
- * asking for it puts a browser prompt on screen just to decide whether to grey out a row -
- * which is a worse trade than showing an enabled Paste that turns out to do nothing. So the
- * permission is only READ, never requested, and the clipboard is only opened where it has
- * already been granted.
- */
-declare function clipboardHasText(): Promise<boolean | null>;
-/** The rows for this target, in the order every desktop menu puts them. */
-declare function clipboardEntries(target: ClipboardTarget, options?: ClipboardMenuOptions): ContextMenuEntry[];
-/** Which clipboard row an id belongs to, or null for anything that is not one of ours. */
-declare function clipboardAction(id: string): ClipboardAction | null;
-/**
- * Do what the row says.
- *
- * Called straight from the press that chose it, so the browser still counts it as a user
- * gesture - which is what the clipboard API requires and what makes a paste possible at all.
- * Returns whether the action happened: a refused permission and an empty clipboard are both
- * "no", and neither is worth an exception the caller has to catch.
- */
-declare function performClipboardAction(action: ClipboardAction, target: ClipboardTarget): Promise<boolean>;
-
-export { CLIPBOARD_PREFIX as C, CONTEXT_MENU_SEARCH_KEYS as a, type ClipboardAction as b, type ClipboardMenuLabels as c, type ClipboardMenuOptions as d, type ClipboardTarget as e, type ContextMenuAction as f, type ContextMenuEntry as g, type ContextMenuInstance as h, type ContextMenuLabel as i, type ContextMenuLevel as j, type ContextMenuMoveKey as k, type ContextMenuOptions as l, type ContextMenuPoint as m, type ContextMenuSeparator as n, type ContextMenuState as o, clipboardAction as p, clipboardEntries as q, clipboardHasText as r, createContextMenu as s, inspectClipboardTarget as t, isAction as u, performClipboardAction as v };
+export { CONTEXT_MENU_SEARCH_KEYS as C, type ContextMenuAction as a, type ContextMenuEntry as b, type ContextMenuInstance as c, type ContextMenuLabel as d, type ContextMenuLevel as e, type ContextMenuMoveKey as f, type ContextMenuOptions as g, type ContextMenuPoint as h, type ContextMenuSeparator as i, type ContextMenuState as j, createContextMenu as k, isAction as l };

package/dist/index.d.ts

@@ -9,7 +9,8 @@ export { R as RelativeTimeFormat, a as RelativeTimeOptions, b as RelativeTimePre
 export { F as FLAG_CDN, a as FLAG_RATIO, b as FlagConfig, c as FlagFormat, d as FlagOptions, e as FlagShape, f as FlagSource, g as FlagView, h as configureFlags, i as flagAttributes, j as flagConfig, k as flagName, l as flagSrc, m as flagView, n as normalizeFlagCode, r as resetFlagConfig } from './flags-BQU1V9rE.js';
 export { P as PaletteKey, a as PositionedRow, R as RecentEntry, b as RecentStore, c as RecentStoreOptions, d as RowGroup, e as createRecentStore, g as groupRows, i as isPaletteShortcut, m as moveActive, r as recentKey, s as shortcutLabel } from './palette-D7iuQh_T.js';
 export { S as SELECT_SEARCH_KEYS, a as SelectInstance, b as SelectMoveKey, c as SelectOption, d as SelectOptions, e as SelectState, f as createSelect } from './select-ClSy-J1f.js';
-export { C as CLIPBOARD_PREFIX, a as CONTEXT_MENU_SEARCH_KEYS, b as ClipboardAction, c as ClipboardMenuLabels, d as ClipboardMenuOptions, e as ClipboardTarget, f as ContextMenuAction, g as ContextMenuEntry, h as ContextMenuInstance, i as ContextMenuLabel, j as ContextMenuLevel, k as ContextMenuMoveKey, l as ContextMenuOptions, m as ContextMenuPoint, n as ContextMenuSeparator, o as ContextMenuState, p as clipboardAction, q as clipboardEntries, r as clipboardHasText, s as createContextMenu, t as inspectClipboardTarget, u as isAction, v as performClipboardAction } from './clipboard-menu-B_ouitfS.js';
+export { C as CONTEXT_MENU_SEARCH_KEYS, a as ContextMenuAction, b as ContextMenuEntry, c as ContextMenuInstance, d as ContextMenuLabel, e as ContextMenuLevel, f as ContextMenuMoveKey, g as ContextMenuOptions, h as ContextMenuPoint, i as ContextMenuSeparator, j as ContextMenuState, k as createContextMenu, l as isAction } from './context-menu-qqpGBkny.js';
+export { C as CLIPBOARD_PREFIX, a as ClipboardAction, b as ClipboardMenuLabels, c as ClipboardMenuOptions, d as ClipboardTarget, e as clipboardAction, f as clipboardEntries, g as clipboardHasText, i as inspectClipboardTarget, p as performClipboardAction } from './clipboard-menu-eemzEBqB.js';
 export { D as DEFAULT_SELECTION_SHORTCUTS, S as SelectionClickModifiers, a as SelectionCommand, b as SelectionCommandEvent, c as SelectionCommandName, d as SelectionInstance, e as SelectionOptions, f as SelectionShortcuts, g as SelectionState, h as createSelection } from './selection-B_pmzHpy.js';
 export { S as Shortcut, a as ShortcutEvent, b as ShortcutSpec, T as TYPEAHEAD_MS, c as TypeaheadState, d as TypeaheadStep, i as isApplePlatform, m as matchesShortcut, p as parseShortcut, s as shortcutList, e as shortcutText, f as shortcutTokens, t as typeaheadStep } from './keys-D2zJs1uB.js';
 
@@ -39,4 +40,293 @@ declare const INPUT_ICON_PATHS: {
 /** The same shapes as a standalone SVG string, for the DOM renderer below. */
 declare function iconMarkup(paths: readonly string[]): string;
 
-export { INPUT_ICON_PATHS, iconMarkup };
+/**
+ * The arithmetic behind the image viewer: zoom around a point, panning that cannot lose the
+ * image, moving through a set, and getting a file onto the disk.
+ *
+ * Not a React module, and deliberately: none of this is rendering. A page drawing its own
+ * viewer, or a test, gets the same maths - and the parts that are easy to get wrong (zoom
+ * that drifts away from the cursor, a pan that strands the image off screen, a download that
+ * silently opens a tab instead) are then testable without a browser.
+ */
+/** How far the image is scaled, and where its centre sits relative to the frame's, in px. */
+interface Transform {
+    scale: number;
+    x: number;
+    y: number;
+}
+interface ZoomLimits {
+    min: number;
+    max: number;
+}
+/** A box in viewport coordinates - the frame the image is being viewed in. */
+interface Box {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+declare const IDENTITY: Transform;
+declare const ZOOM_LIMITS: ZoomLimits;
+/** What a keyboard `+`/`-` step multiplies by, and the ratio a double press toggles to. */
+declare const ZOOM_STEP = 1.35;
+declare const ZOOM_DOUBLE = 2.5;
+declare function clampScale(scale: number, limits?: ZoomLimits): number;
+/**
+ * A wheel notch to a zoom factor.
+ *
+ * `deltaMode` matters: a mouse reports pixels, but Firefox reports LINES (mode 1) and a page
+ * scroll reports pages (mode 2), so treating every delta as pixels makes the same gesture
+ * zoom a hundred times harder in one browser than another. The exponential keeps a notch
+ * proportional - zooming out from 8x and in from 1x take the same number of turns.
+ */
+declare function wheelFactor(deltaY: number, deltaMode?: number): number;
+/**
+ * Zoom, keeping the point under the pointer under the pointer.
+ *
+ * The defect this exists for: scaling around the frame's centre slides whatever the visitor
+ * was pointing at out from under them, so zooming into a face means zooming and then hunting
+ * for it again. The offset is corrected by how much that point moved when the scale changed.
+ */
+declare function zoomAt(current: Transform, factor: number, point: {
+    x: number;
+    y: number;
+}, box: Box, limits?: ZoomLimits): Transform;
+/**
+ * Keep the image over the frame.
+ *
+ * At 1x it is centred and there is nothing to pan. Zoomed, the offset is bounded by the half
+ * of the image that hangs outside the frame - without it a drag can throw the picture off the
+ * screen entirely, and the only way back is to close the viewer.
+ */
+declare function clampPan(transform: Transform, box: Box, natural: {
+    width: number;
+    height: number;
+}): Transform;
+/** The size an image is DRAWN at inside a frame it is fitted to, which is what pan is bounded by. */
+declare function fittedSize(natural: {
+    width: number;
+    height: number;
+}, box: Box): {
+    width: number;
+    height: number;
+};
+/** The distance between two pointers, for a pinch. */
+declare function pinchDistance(a: {
+    x: number;
+    y: number;
+}, b: {
+    x: number;
+    y: number;
+}): number;
+/**
+ * The next index in a set, skipping what has been discarded.
+ *
+ * Returns -1 when there is nothing left to show, which is the viewer's cue to close rather
+ * than to sit on an empty frame.
+ */
+declare function nextIndex(index: number, length: number, step: number, options?: {
+    loop?: boolean;
+    skip?: ReadonlySet<number>;
+}): number;
+/** The file name to save as: whatever the caller asked for, else the one in the URL. */
+declare function filenameFrom(url: string, fallback?: string): string;
+/**
+ * Save the file, rather than navigate to it.
+ *
+ * `<a download>` is honoured only for a same-origin URL; on a CDN the browser ignores the
+ * attribute and opens the image in a tab instead, which is not what the row said it would do.
+ * So the bytes are fetched and handed over as a blob, and the plain anchor is the fallback for
+ * when that is refused (no CORS header) - a tab is still better than nothing happening.
+ */
+declare function downloadFile(url: string, filename?: string): Promise<void>;
+/**
+ * A `data:` URL as the bytes it stands for.
+ *
+ * Synchronous on purpose: it is used to open a tab, and a window opened after an `await` is a
+ * popup with no gesture behind it, which the browser blocks.
+ */
+declare function dataUrlToBlob(url: string): Blob;
+/**
+ * The picture on its own, in another tab.
+ *
+ * Chromium refuses a top-level navigation to a `data:` URL - it was a phishing vector - so a
+ * row that just called `window.open` on one did nothing at all, silently, which is how it
+ * shipped. Those are handed over as a blob instead; everything else opens as it is.
+ *
+ * `noopener` on both: the new tab must not get a handle on the page that opened it.
+ */
+declare function openInNewTab(url: string): void;
+/** How long the picture takes to fly, when the stylesheet does not say otherwise. */
+declare const FLIGHT_MS = 300;
+/**
+ * How long the flight ACTUALLY lasts, read off the element.
+ *
+ * The duration lives in the stylesheet (`--enigma-image-flight`), so a project that slows it
+ * down would otherwise have the viewer give up waiting halfway through and close mid-flight.
+ * The constant above is only the answer for an element with no transition on it at all.
+ */
+declare function flightMs(element: Element | null): number;
+/**
+ * The transform that puts a picture exactly over another box.
+ *
+ * This is the FLIP the lightbox opens with: the full-size image is laid out where it belongs,
+ * measured, and then drawn back ON the thumbnail with this transform - so releasing it to the
+ * identity transform is the picture growing out of the one in the page rather than a dialog
+ * appearing over it. Closing is the same transform applied in the other direction.
+ *
+ * Both boxes are the same picture, so one scale is enough; the width is used because a
+ * thumbnail is nearly always constrained by it. Null when either box has not been laid out
+ * yet, which is the caller's cue to skip the animation rather than to divide by zero.
+ */
+declare function flightFrom(from: Box, to: Box): Transform | null;
+/** Whether the reader has asked for less movement. Every animation here is skipped when they have. */
+declare function prefersReducedMotion(): boolean;
+
+/**
+ * The arithmetic behind the video player: times, seeking, buffering, volume and the keys.
+ *
+ * None of it is rendering, so it is testable without a browser and reusable by a page that
+ * draws its own controls - the same split the colour maths and the image viewer's are in.
+ */
+/** The playback rates the settings menu offers, in the order it lists them. */
+declare const SPEEDS: readonly [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2];
+/** How far the arrows seek, in seconds, and what a bigger jump moves by. */
+declare const SEEK_STEP = 5;
+declare const SEEK_JUMP = 10;
+declare const VOLUME_STEP = 0.05;
+/**
+ * Seconds as a clock, sized by the LONGEST time it will have to show.
+ *
+ * `duration` is what stops the label changing width mid-playback: a 1h04m video passing 10:00
+ * would otherwise go from `9:59` to `10:00` to `1:00:00`, and every control after it moves.
+ */
+declare function formatTime(seconds: number, duration?: number): string;
+/** A time as a fraction of the duration, safe before the metadata says what that is. */
+declare function progress(time: number, duration: number): number;
+/** Where a press on a horizontal rail lands, as a fraction of it. */
+declare function fractionAt(box: {
+    left: number;
+    width: number;
+}, clientX: number): number;
+/**
+ * How much is buffered AHEAD of where playback is.
+ *
+ * The range under the playhead, not the largest one: a viewer who seeks past the buffer is
+ * looking at a bar that says nothing is loaded, which is true of the part they are watching.
+ */
+declare function bufferedAhead(ranges: TimeRanges | null, time: number, duration: number): number;
+/** The next rate in the list, wrapping - what a repeated press on the speed row does. */
+declare function nextSpeed(current: number, step?: number): number;
+/** What a key press means, or null when the player should leave it to the page. */
+type PlayerCommand = {
+    type: "toggle";
+} | {
+    type: "seek";
+    by: number;
+} | {
+    type: "seekTo";
+    fraction: number;
+} | {
+    type: "volume";
+    by: number;
+} | {
+    type: "mute";
+} | {
+    type: "fullscreen";
+} | {
+    type: "captions";
+} | {
+    type: "pip";
+};
+/**
+ * The shortcuts, as the platform's video players define them.
+ *
+ * Space and K play, J and L jump ten, the arrows nudge five and the volume, M mutes, F is
+ * fullscreen, C captions, and a digit seeks to that tenth of the video.
+ */
+declare function commandFor(key: string): PlayerCommand | null;
+/**
+ * Whether a key press belongs to the page rather than to the player.
+ *
+ * A shortcut that fires while somebody is typing turns their space bar into a pause, so the
+ * player stands down inside anything that takes text.
+ */
+declare function isTypingTarget(target: EventTarget | null): boolean;
+/** Whether the document is showing something fullscreen, across the two spellings of it. */
+declare function fullscreenElement(): Element | null;
+/**
+ * Fullscreen, including the one platform that will not give it to a container.
+ *
+ * iOS Safari has no Fullscreen API on an arbitrary element: the only thing that can fill the
+ * screen is the video itself, through `webkitEnterFullscreen`. Without that branch the button
+ * does nothing at all on an iPhone, which is where most video is watched.
+ */
+declare function toggleFullscreen(container: HTMLElement, video: HTMLVideoElement | null): Promise<void>;
+/** Picture in picture, where the browser has it. Firefox has its own button and no API. */
+declare function supportsPip(): boolean;
+declare function togglePip(video: HTMLVideoElement): Promise<void>;
+/**
+ * The type a URL's extension implies, or undefined.
+ *
+ * Read from the PATH, so a query string or a fragment cannot be mistaken for one -
+ * `/clip.mp4?token=...` is still an mp4, and `/download?file=x.webm` is not a webm, because
+ * the extension has to be on the path's last segment. A `blob:` or `data:` URL has no
+ * extension to read and gets nothing, which is the right answer: the browser sniffs.
+ */
+declare function sourceType(url: string): string | undefined;
+/** One subtitle track, as the menu lists it. */
+interface CaptionTrack {
+    /** Where it sits in the element's own `textTracks`, which is what turns it on. */
+    index: number;
+    label: string;
+    language: string;
+}
+/** Which of the element's text tracks are subtitles a viewer would choose between. */
+declare function captionTracks(list: TextTrackList | null | undefined): CaptionTrack[];
+/**
+ * The track the element is SHOWING, or -1.
+ *
+ * Read rather than remembered: a `default` track is showing before any button was pressed, and
+ * a player that assumed "off" would need two presses to turn something off.
+ */
+declare function activeCaption(list: TextTrackList | null | undefined): number;
+/**
+ * Show one track and disable the rest. -1 turns them all off.
+ *
+ * "disabled" rather than "hidden": a hidden track still fires its cues, so a page listening to
+ * `cuechange` for its own transcript would keep receiving a language nobody asked for.
+ */
+declare function showCaption(list: TextTrackList | null | undefined, index: number): void;
+/** What the cast control knows about the world. */
+interface RemoteState {
+    /** There is somewhere to cast TO. Before the browser has looked, this is optimistic. */
+    available: boolean;
+    /** Playing on that screen right now. */
+    connected: boolean;
+}
+/**
+ * Whether this element can be cast at all.
+ *
+ * `disableRemotePlayback` is honoured: a page that asked for the button to be gone does not
+ * get one drawn over its video by a component.
+ */
+declare function supportsRemote(video: HTMLVideoElement | null): boolean;
+/**
+ * Watch for a screen to cast to, and for the connection to it.
+ *
+ * WHY AVAILABILITY IS OPTIMISTIC WHEN THE WATCH FAILS. `watchAvailability` rejects with
+ * NotSupportedError on the platforms that can still `prompt()` - Safari, and Chromium for some
+ * sources - so treating a rejection as "no devices" hides a control that works. A button that
+ * opens an empty picker is a smaller loss than a missing one.
+ */
+declare function watchRemote(video: HTMLVideoElement, onChange: (state: RemoteState) => void): () => void;
+/**
+ * Open the browser's own device picker.
+ *
+ * There is no list to draw ourselves: both APIs hand the choice to the platform, which is the
+ * only thing that can enumerate the screens on the network.
+ */
+declare function promptRemote(video: HTMLVideoElement): Promise<void>;
+
+export { type Box, type CaptionTrack, FLIGHT_MS, IDENTITY, INPUT_ICON_PATHS, type PlayerCommand, type RemoteState, SEEK_JUMP, SEEK_STEP, SPEEDS, type Transform, VOLUME_STEP, ZOOM_DOUBLE, ZOOM_LIMITS, ZOOM_STEP, type ZoomLimits, activeCaption, bufferedAhead, captionTracks, clampPan, clampScale, commandFor, dataUrlToBlob, downloadFile, filenameFrom, fittedSize, flightFrom, flightMs, formatTime, fractionAt, fullscreenElement, iconMarkup, isTypingTarget, nextIndex, nextSpeed, openInNewTab, pinchDistance, prefersReducedMotion, progress, promptRemote, showCaption, sourceType, supportsPip, supportsRemote, toggleFullscreen, togglePip, watchRemote, wheelFactor, zoomAt };

package/dist/index.js

@@ -1,14 +1,16 @@
+export { FLIGHT_MS, IDENTITY, ZOOM_DOUBLE, ZOOM_LIMITS, ZOOM_STEP, clampPan, clampScale, dataUrlToBlob, downloadFile, filenameFrom, fittedSize, flightFrom, flightMs, nextIndex, openInNewTab, pinchDistance, prefersReducedMotion, wheelFactor, zoomAt } from './chunk-HUUINHPR.js';
 export { createInput } from './chunk-KJINGUQN.js';
+export { colorEquals, formatColor, hslToRgb, hsvToRgb, parseColor, rgbToHsl, rgbToHsv, toHex } from './chunk-S2FPN5ID.js';
+export { SERVER_NETWORK_STATE, createNetworkMonitor } from './chunk-2QFTRNAZ.js';
 export { ensureZone, normalizeDate, parseDuration, relativeTimeAttributes, relativeTimeView } from './chunk-IXVMRVD4.js';
 export { estimatePasswordStrength, generatePassword } from './chunk-HC2ME5PU.js';
-export { colorEquals, formatColor, hslToRgb, hsvToRgb, parseColor, rgbToHsl, rgbToHsv, toHex } from './chunk-S2FPN5ID.js';
-export { CLIPBOARD_PREFIX, CONTEXT_MENU_SEARCH_KEYS, clipboardAction, clipboardEntries, clipboardHasText, createContextMenu, inspectClipboardTarget, isAction, performClipboardAction } from './chunk-Z3VDE7OA.js';
+export { CLIPBOARD_PREFIX, CONTEXT_MENU_SEARCH_KEYS, clipboardAction, clipboardEntries, clipboardHasText, createContextMenu, inspectClipboardTarget, isAction, performClipboardAction } from './chunk-YQV5XZIA.js';
 export { DEFAULT_SELECTION_SHORTCUTS, createSelection } from './chunk-WSQC3PCC.js';
+export { SEEK_JUMP, SEEK_STEP, SPEEDS, VOLUME_STEP, activeCaption, bufferedAhead, captionTracks, commandFor, formatTime, fractionAt, fullscreenElement, isTypingTarget, nextSpeed, progress, promptRemote, showCaption, sourceType, supportsPip, supportsRemote, toggleFullscreen, togglePip, watchRemote } from './chunk-JLZDS6CV.js';
 export { createButton } from './chunk-MMQPZGSU.js';
 export { FLAG_CDN, FLAG_RATIO, configureFlags, flagAttributes, flagConfig, flagName, flagSrc, flagView, normalizeFlagCode, resetFlagConfig } from './chunk-LMZJBOZG.js';
 export { createNotifications } from './chunk-SNYUBXWQ.js';
 export { createMarquee } from './chunk-UOSSNUSC.js';
-export { SERVER_NETWORK_STATE, createNetworkMonitor } from './chunk-2QFTRNAZ.js';
 export { INPUT_ICON_PATHS, iconMarkup } from './chunk-F25CGNQC.js';
 export { SELECT_SEARCH_KEYS, createSelect } from './chunk-NONGREXC.js';
 export { TYPEAHEAD_MS, isApplePlatform, matchesShortcut, parseShortcut, shortcutList, shortcutText, shortcutTokens, typeaheadStep } from './chunk-4VUHQFAT.js';

package/dist/menu-52PXC5PL.js

@@ -0,0 +1,33 @@
+import { ContextMenu, useContextMenuContext } from './chunk-CPJJ3FPW.js';
+import './chunk-YQV5XZIA.js';
+import './chunk-4VUHQFAT.js';
+import './chunk-HS3X3XCW.js';
+import './chunk-4ZPMP47J.js';
+import { useEffect } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+function VideoMenu({ rows, title, onSelect, onReady }) {
+  return /* @__PURE__ */ jsxs(
+    ContextMenu.Root,
+    {
+      items: rows,
+      title,
+      clipboard: false,
+      onSelect,
+      children: [
+        /* @__PURE__ */ jsx(Publish, { onReady }),
+        /* @__PURE__ */ jsx(ContextMenu.Content, {})
+      ]
+    }
+  );
+}
+function Publish({ onReady }) {
+  const menu = useContextMenuContext("Video.Menu");
+  useEffect(() => {
+    onReady(menu.open);
+    return () => onReady(null);
+  }, [menu.open, onReady]);
+  return null;
+}
+
+export { VideoMenu };