@fusion.dev/helix-headless 0.56.1 → 0.57.0

package/custom-elements.json

@@ -106746,210 +106746,6 @@
         }
       ]
     },
-    {
-      "kind": "javascript-module",
-      "path": "src/video/root/captions.ts",
-      "declarations": [
-        {
-          "kind": "function",
-          "name": "captionTracks",
-          "return": {
-            "type": {
-              "text": "TextTrack[]"
-            }
-          },
-          "parameters": [
-            {
-              "name": "video",
-              "type": {
-                "text": "HTMLVideoElement | null"
-              }
-            }
-          ],
-          "description": "The tracks a reader could choose between, in the order they were written.\n\nFiltered by kind, because `textTracks` also carries `chapters`, `metadata`\nand `descriptions`, and a menu offering \"Chapters\" as a subtitle language\nwould be offering something that draws no words. Read off the video rather\nthan off the slot: a `<track>` added later is in one and not the other, and\nthe video is the one that has resolved them."
-        },
-        {
-          "kind": "function",
-          "name": "showCaption",
-          "return": {
-            "type": {
-              "text": "void"
-            }
-          },
-          "parameters": [
-            {
-              "name": "tracks",
-              "type": {
-                "text": "readonly TextTrack[]"
-              }
-            },
-            {
-              "name": "index",
-              "type": {
-                "text": "number"
-              }
-            }
-          ],
-          "description": "Shows one track and disables every other, or shows none at `-1`.\n\nEvery other, rather than only the one that was on. Two tracks in `hidden`\nboth fire `cuechange`, so the rendered cue becomes whichever fired last and\na reader who switched language gets the two interleaved. Measured as two\nsubtitles alternating line by line.\n\n`hidden`, never `showing`. Hidden is the mode where a track still fires\n`cuechange` and still fills `activeCues`, and the browser draws nothing,\nwhich is exactly what is wanted when something else is doing the drawing."
-        },
-        {
-          "kind": "function",
-          "name": "adoptTrack",
-          "return": {
-            "type": {
-              "text": "boolean"
-            }
-          },
-          "parameters": [
-            {
-              "name": "track",
-              "type": {
-                "text": "TextTrack"
-              }
-            }
-          ],
-          "description": "Whether a track the platform started showing is now ours to draw.\n\nA `<track default>` arrives `showing`, which is the browser drawing it.\nMoved to `hidden` so the cues keep coming and we draw them instead. What\ncomes back is whether captions are on, which is not always \"off\": a button\nthat began there reported the opposite of what was on screen."
-        },
-        {
-          "kind": "function",
-          "name": "captionsAmong",
-          "return": {
-            "type": {
-              "text": "Caption[]"
-            }
-          },
-          "parameters": [
-            {
-              "name": "media",
-              "type": {
-                "text": "readonly TrackCopy[]"
-              }
-            }
-          ],
-          "description": "The caption tracks among the copies, before the render that draws them.\n\nBy the platform's own reading of `kind`, which is what makes a `<track>` a\ncaption at all: missing is `subtitles` and anything it does not know is\n`metadata`. Read from the video's tracks after the render instead, the count\narrived a render late and asked for one more. Choosing one still goes\nthrough the video's tracks, which hold them in the same order."
-        },
-        {
-          "kind": "function",
-          "name": "activeCue",
-          "return": {
-            "type": {
-              "text": "DocumentFragment | undefined"
-            }
-          },
-          "parameters": [
-            {
-              "name": "track",
-              "type": {
-                "text": "TextTrack | undefined"
-              }
-            }
-          ],
-          "description": "The cue on screen now, as nodes, or nothing between cues.\n\nNodes rather than a string, because `VTTCue.text` is the cue's *source*:\nWebVTT carries markup, and a caption file in the wild is full of it. `<v\nHildy>` names who is speaking, `<b>` and `<i>` and `<u>` mark emphasis, and\n`<c.loud>` classes a line. Rendered as text every one of those arrives on\nscreen as visible angle brackets.\n\n`getCueAsHTML` is the platform parsing its own format, so nothing here has\nto know the grammar and no cue text is ever treated as HTML: what comes\nback is a fragment the browser built, not a string anybody interpolated."
-        },
-        {
-          "kind": "class",
-          "description": "Listens to one track's cues at a time, so the next one can take it off.\n\nTaken off whatever it was on before adding it here. `follow` runs from\n`loadedmetadata`, which fires again for every source a reader moves to, and\na consumer adding a `<track>` later gets another. Added without removing, a\nplaylist of six left six listeners on tracks that between them fire for\nevery cue in the video.",
-          "name": "CueController",
-          "members": [
-            {
-              "kind": "field",
-              "name": "track",
-              "type": {
-                "text": "TextTrack | undefined"
-              },
-              "privacy": "private"
-            },
-            {
-              "kind": "method",
-              "name": "follow",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "parameters": [
-                {
-                  "name": "track",
-                  "type": {
-                    "text": "TextTrack"
-                  }
-                }
-              ]
-            },
-            {
-              "kind": "method",
-              "name": "hostDisconnected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              }
-            },
-            {
-              "kind": "method",
-              "name": "stop",
-              "privacy": "private",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              }
-            }
-          ],
-          "helix": {}
-        }
-      ],
-      "exports": [
-        {
-          "kind": "js",
-          "name": "captionTracks",
-          "declaration": {
-            "name": "captionTracks",
-            "module": "src/video/root/captions.ts"
-          }
-        },
-        {
-          "kind": "js",
-          "name": "showCaption",
-          "declaration": {
-            "name": "showCaption",
-            "module": "src/video/root/captions.ts"
-          }
-        },
-        {
-          "kind": "js",
-          "name": "adoptTrack",
-          "declaration": {
-            "name": "adoptTrack",
-            "module": "src/video/root/captions.ts"
-          }
-        },
-        {
-          "kind": "js",
-          "name": "captionsAmong",
-          "declaration": {
-            "name": "captionsAmong",
-            "module": "src/video/root/captions.ts"
-          }
-        },
-        {
-          "kind": "js",
-          "name": "activeCue",
-          "declaration": {
-            "name": "activeCue",
-            "module": "src/video/root/captions.ts"
-          }
-        },
-        {
-          "kind": "js",
-          "name": "CueController",
-          "declaration": {
-            "name": "CueController",
-            "module": "src/video/root/captions.ts"
-          }
-        }
-      ]
-    },
     {
       "kind": "javascript-module",
       "path": "src/video/root/extra-controls.ts",
@@ -107086,117 +106882,6 @@
         }
       ]
     },
-    {
-      "kind": "javascript-module",
-      "path": "src/video/root/fullscreen.ts",
-      "declarations": [
-        {
-          "kind": "class",
-          "description": "Into fullscreen and back, and honest about where the element is.\n\nThe state follows `fullscreenchange` rather than the request, so a refused\nrequest leaves a button that correctly reports \"not fullscreen\".",
-          "name": "FullscreenController",
-          "members": [
-            {
-              "kind": "method",
-              "name": "toggle",
-              "return": {
-                "type": {
-                  "text": "Promise<void>"
-                }
-              },
-              "description": "Into fullscreen and back, and quiet about being refused.\n\n`requestFullscreen` rejects rather than returning false, and the two\nrefusals a consumer will actually meet are a Permissions Policy that does\nnot grant `fullscreen` to the frame the player is in, and a call without\nuser activation. Both are `TypeError: Permissions check failed`, which is\nthe same message for two different causes.\n\nCaught rather than `void`ed, or a refusal becomes an unhandled rejection\nnaming neither the element nor the reason."
-            },
-            {
-              "kind": "method",
-              "name": "hostConnected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              }
-            },
-            {
-              "kind": "method",
-              "name": "hostDisconnected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              }
-            },
-            {
-              "kind": "field",
-              "name": "handleChange",
-              "privacy": "private",
-              "readonly": true
-            }
-          ],
-          "helix": {}
-        }
-      ],
-      "exports": [
-        {
-          "kind": "js",
-          "name": "FullscreenController",
-          "declaration": {
-            "name": "FullscreenController",
-            "module": "src/video/root/fullscreen.ts"
-          }
-        }
-      ]
-    },
-    {
-      "kind": "javascript-module",
-      "path": "src/video/root/idle.ts",
-      "declarations": [
-        {
-          "kind": "class",
-          "description": "How long the reader has been still, which decides when the bar goes.\n\nA wait rather than leaving with the pointer, or a reader moving across the\npicture to reach a control watches the bar vanish under them. The wait is\nonly ever about *idling*: whether a paused video keeps its bar is the\nelement's decision, and this only says when the reader stopped.\n\nThe delay is asked for on every restart rather than taken once, because it\nis a property the consumer can change while the video plays.",
-          "name": "IdleController",
-          "members": [
-            {
-              "kind": "field",
-              "name": "timer",
-              "type": {
-                "text": "ReturnType<typeof setTimeout> | undefined"
-              },
-              "privacy": "private"
-            },
-            {
-              "kind": "field",
-              "name": "stir",
-              "readonly": true,
-              "description": "Restarts the wait, on anything that counts as the reader being here.\n\nPointer movement and focus both count, and both have to: a reader using the\nkeyboard never moves a pointer, and a bar that only answered the mouse\nwould leave them nothing to look at. Zero turns the wait off and the bar\ngoes immediately; a large number keeps it up for as long as anyone is\nlikely to look."
-            },
-            {
-              "kind": "field",
-              "name": "leave",
-              "readonly": true,
-              "description": "Leaving is the one case that does not wait: the reader has gone somewhere\nelse, and there is nothing to reach for."
-            },
-            {
-              "kind": "method",
-              "name": "hostDisconnected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              }
-            }
-          ],
-          "helix": {}
-        }
-      ],
-      "exports": [
-        {
-          "kind": "js",
-          "name": "IdleController",
-          "declaration": {
-            "name": "IdleController",
-            "module": "src/video/root/idle.ts"
-          }
-        }
-      ]
-    },
     {
       "kind": "javascript-module",
       "path": "src/video/root/keys.ts",
@@ -107243,249 +106928,6 @@
         }
       ]
     },
-    {
-      "kind": "javascript-module",
-      "path": "src/video/root/media-copy.ts",
-      "declarations": [
-        {
-          "kind": "function",
-          "name": "copiesOf",
-          "return": {
-            "type": {
-              "text": "MediaCopy[]"
-            }
-          },
-          "parameters": [
-            {
-              "name": "elements",
-              "type": {
-                "text": "readonly Element[]"
-              }
-            }
-          ],
-          "description": "The copies to make of what the default slot is given."
-        },
-        {
-          "kind": "function",
-          "name": "sameCopies",
-          "return": {
-            "type": {
-              "text": "boolean"
-            }
-          },
-          "parameters": [
-            {
-              "name": "one",
-              "type": {
-                "text": "readonly MediaCopy[]"
-              }
-            },
-            {
-              "name": "two",
-              "type": {
-                "text": "readonly MediaCopy[]"
-              }
-            }
-          ],
-          "description": "Whether two reads describe the same media.\n\nThe same set again is not a change. A video reloads for every new list, and\nthe first `slotchange` reports the children the element has already read."
-        }
-      ],
-      "exports": [
-        {
-          "kind": "js",
-          "name": "copiesOf",
-          "declaration": {
-            "name": "copiesOf",
-            "module": "src/video/root/media-copy.ts"
-          }
-        },
-        {
-          "kind": "js",
-          "name": "sameCopies",
-          "declaration": {
-            "name": "sameCopies",
-            "module": "src/video/root/media-copy.ts"
-          }
-        }
-      ]
-    },
-    {
-      "kind": "javascript-module",
-      "path": "src/video/root/media-session.ts",
-      "declarations": [
-        {
-          "kind": "variable",
-          "name": "SKIP_SECONDS",
-          "type": {
-            "text": "number"
-          },
-          "default": "10",
-          "description": "How far a skip control moves, in seconds.\n\nTen, which is the number every player that has one uses, and the number the\nplatform names in `seekbackward` and `seekforward` when it hands over a\ndefault. A different length here would be correct only on this player."
-        },
-        {
-          "kind": "class",
-          "description": "Holds the page's media session for one player, and tells the platform what\nis playing.\n\nThe handlers are what make a headset's play, pause and skip work at all.\nWithout them a platform falls back to guessing which element was meant,\nwhich is right often enough to hide the fault and wrong exactly when there\nare two.",
-          "name": "MediaSessionController",
-          "members": [
-            {
-              "kind": "method",
-              "name": "claim",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "parameters": [
-                {
-                  "name": "metadata",
-                  "type": {
-                    "text": "{ artwork: string; title: string }"
-                  }
-                },
-                {
-                  "name": "handlers",
-                  "type": {
-                    "text": "SessionHandlers"
-                  }
-                }
-              ],
-              "description": "Takes the session.\n\nOn play rather than on render, which is the ownership rule: a page with two\nplayers gives the session to whichever one the reader started, so a\nheadset's buttons land on what they are listening to rather than on\nwhichever came first in the markup."
-            },
-            {
-              "kind": "method",
-              "name": "report",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "parameters": [
-                {
-                  "name": "playing",
-                  "type": {
-                    "text": "boolean"
-                  }
-                }
-              ],
-              "description": "Tells the platform whether the owner is playing, and nothing if it is not the owner."
-            },
-            {
-              "kind": "method",
-              "name": "hostDisconnected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              },
-              "description": "The page's one media session goes back to nobody, but only if this\nelement is the one holding it."
-            }
-          ],
-          "helix": {}
-        }
-      ],
-      "exports": [
-        {
-          "kind": "js",
-          "name": "SKIP_SECONDS",
-          "declaration": {
-            "name": "SKIP_SECONDS",
-            "module": "src/video/root/media-session.ts"
-          }
-        },
-        {
-          "kind": "js",
-          "name": "MediaSessionController",
-          "declaration": {
-            "name": "MediaSessionController",
-            "module": "src/video/root/media-session.ts"
-          }
-        }
-      ]
-    },
-    {
-      "kind": "javascript-module",
-      "path": "src/video/root/remote-playback.ts",
-      "declarations": [
-        {
-          "kind": "class",
-          "description": "Watches for something to play the video on, and stops on the way out.\n\nThe Remote Playback API is the standard one, and it is what Safari\nimplements for AirPlay and Chrome for Cast: one call covers both, where the\nolder `webkitShowPlaybackTargetPicker` covers only the first. Firefox has\nneither, and `remote` simply being absent is what turns the control off\nthere.\n\n`watchAvailability` returns an id that has to be canceled, or the callback\noutlives the element that owns it: a callback holding a removed element is a\nleak with a `@state` write on the end.",
-          "name": "RemotePlaybackController",
-          "members": [
-            {
-              "kind": "field",
-              "name": "video",
-              "type": {
-                "text": "HTMLVideoElement | undefined"
-              },
-              "privacy": "private"
-            },
-            {
-              "kind": "field",
-              "name": "watch",
-              "type": {
-                "text": "number | undefined"
-              },
-              "privacy": "private",
-              "description": "Cancels the availability watch, since it outlives a single render."
-            },
-            {
-              "kind": "method",
-              "name": "attach",
-              "return": {
-                "type": {
-                  "text": "Promise<void>"
-                }
-              },
-              "parameters": [
-                {
-                  "name": "video",
-                  "type": {
-                    "text": "HTMLVideoElement"
-                  }
-                }
-              ],
-              "description": "Starts watching the video, once there is one."
-            },
-            {
-              "kind": "method",
-              "name": "prompt",
-              "return": {
-                "type": {
-                  "text": "Promise<void>"
-                }
-              },
-              "description": "Opens the platform's own device picker. It has no list of its own."
-            },
-            {
-              "kind": "method",
-              "name": "hostDisconnected",
-              "return": {
-                "type": {
-                  "text": "void"
-                }
-              }
-            },
-            {
-              "kind": "field",
-              "name": "handleState",
-              "privacy": "private",
-              "readonly": true
-            }
-          ],
-          "helix": {}
-        }
-      ],
-      "exports": [
-        {
-          "kind": "js",
-          "name": "RemotePlaybackController",
-          "declaration": {
-            "name": "RemotePlaybackController",
-            "module": "src/video/root/remote-playback.ts"
-          }
-        }
-      ]
-    },
     {
       "kind": "javascript-module",
       "path": "src/video/root/video-root.ts",

package/dist/video/root/keys.js

@@ -1,4 +1,4 @@
-import { SKIP_SECONDS } from './media-session.js';
+import { SKIP_SECONDS } from '@fusion.dev/helix-core';
 export const takeKey = (event, video, actions) => {
     if (event.target?.tagName === 'INPUT') {
         return false;

package/dist/video/root/video-root.js

@@ -4,20 +4,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { customElement, drawIcon, HelixElement, HelixNextEvent, HelixPreviousEvent, onUnlessFalse, writtenList, } from '@fusion.dev/helix-core';
+import { activeCue, adoptTrack, CueController, captionsAmong, captionTracks, copiesOf, customElement, drawIcon, FullscreenController, HelixElement, HelixNextEvent, HelixPreviousEvent, IdleController, MediaSessionController, onUnlessFalse, RemotePlaybackController, SKIP_SECONDS, sameCopies, showCaption, writtenList, } from '@fusion.dev/helix-core';
 import { airplay, arrowClockwise, arrowCounterClockwise, closedCaptioning, cornersIn, cornersOut, dotsThreeVertical, download, gauge, pause, pictureInPicture, play, skipBack, skipForward, speakerHigh, speakerX, } from '@fusion.dev/helix-icons';
 import { nothing } from 'lit';
 import { property, state } from 'lit/decorators.js';
 import { html } from 'lit/static-html.js';
 import '../../menu/index.js';
-import { activeCue, adoptTrack, CueController, captionsAmong, captionTracks, showCaption, } from './captions.js';
 import { barControls, menuControls, ownFile } from './extra-controls.js';
-import { FullscreenController } from './fullscreen.js';
-import { IdleController } from './idle.js';
 import { takeKey } from './keys.js';
-import { copiesOf, sameCopies } from './media-copy.js';
-import { MediaSessionController, SKIP_SECONDS } from './media-session.js';
-import { RemotePlaybackController } from './remote-playback.js';
 const clock = (seconds) => {
     if (!Number.isFinite(seconds) || seconds < 0) {
         return '0:00';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusion.dev/helix-headless",
   "description": "Headless component tier. Structure, accessibility, state, and form participation. No styling.",
-  "version": "0.56.1",
+  "version": "0.57.0",
   "license": "MIT",
   "author": "Ross Sheppard <ross.sheppard@fusion.dev>",
   "repository": {
@@ -46,14 +46,14 @@
   },
   "bugs": "https://github.com/project-fusion/fusion/issues",
   "dependencies": {
-    "@fusion.dev/helix-core": "0.56.1",
-    "@fusion.dev/helix-icons": "0.56.1",
+    "@fusion.dev/helix-core": "0.57.0",
+    "@fusion.dev/helix-icons": "0.57.0",
     "uqr": "^0.1.3"
   },
   "devDependencies": {
     "@custom-elements-manifest/analyzer": "^0.11.0",
-    "@fusion.dev/helix-cem": "0.56.1",
-    "@fusion.dev/helix-testing": "0.56.1",
+    "@fusion.dev/helix-cem": "0.57.0",
+    "@fusion.dev/helix-testing": "0.57.0",
     "@fusion.dev/scripts": "0.0.0-dev",
     "@happy-dom/global-registrator": "^20.0.0",
     "@lit-labs/ssr": "^4.1.0",

package/dist/video/root/captions.d.ts

@@ -1,85 +0,0 @@
-import type { ReactiveController, ReactiveControllerHost } from 'lit';
-/** One caption track, named as the menu names it. */
-export interface Caption {
-    label: string;
-    language: string;
-}
-/** A `<track>` as the consumer wrote it, reduced to what naming it needs. */
-interface TrackCopy {
-    attrs: Record<string, string>;
-    tag: string;
-}
-/**
- * The tracks a reader could choose between, in the order they were written.
- *
- * Filtered by kind, because `textTracks` also carries `chapters`, `metadata`
- * and `descriptions`, and a menu offering "Chapters" as a subtitle language
- * would be offering something that draws no words. Read off the video rather
- * than off the slot: a `<track>` added later is in one and not the other, and
- * the video is the one that has resolved them.
- */
-export declare const captionTracks: (video: HTMLVideoElement | null) => TextTrack[];
-/**
- * Shows one track and disables every other, or shows none at `-1`.
- *
- * Every other, rather than only the one that was on. Two tracks in `hidden`
- * both fire `cuechange`, so the rendered cue becomes whichever fired last and
- * a reader who switched language gets the two interleaved. Measured as two
- * subtitles alternating line by line.
- *
- * `hidden`, never `showing`. Hidden is the mode where a track still fires
- * `cuechange` and still fills `activeCues`, and the browser draws nothing,
- * which is exactly what is wanted when something else is doing the drawing.
- */
-export declare const showCaption: (tracks: readonly TextTrack[], index: number) => void;
-/**
- * Whether a track the platform started showing is now ours to draw.
- *
- * A `<track default>` arrives `showing`, which is the browser drawing it.
- * Moved to `hidden` so the cues keep coming and we draw them instead. What
- * comes back is whether captions are on, which is not always "off": a button
- * that began there reported the opposite of what was on screen.
- */
-export declare const adoptTrack: (track: TextTrack) => boolean;
-/**
- * The caption tracks among the copies, before the render that draws them.
- *
- * By the platform's own reading of `kind`, which is what makes a `<track>` a
- * caption at all: missing is `subtitles` and anything it does not know is
- * `metadata`. Read from the video's tracks after the render instead, the count
- * arrived a render late and asked for one more. Choosing one still goes
- * through the video's tracks, which hold them in the same order.
- */
-export declare const captionsAmong: (media: readonly TrackCopy[]) => Caption[];
-/**
- * The cue on screen now, as nodes, or nothing between cues.
- *
- * Nodes rather than a string, because `VTTCue.text` is the cue's *source*:
- * WebVTT carries markup, and a caption file in the wild is full of it. `<v
- * Hildy>` names who is speaking, `<b>` and `<i>` and `<u>` mark emphasis, and
- * `<c.loud>` classes a line. Rendered as text every one of those arrives on
- * screen as visible angle brackets.
- *
- * `getCueAsHTML` is the platform parsing its own format, so nothing here has
- * to know the grammar and no cue text is ever treated as HTML: what comes
- * back is a fragment the browser built, not a string anybody interpolated.
- */
-export declare const activeCue: (track: TextTrack | undefined) => DocumentFragment | undefined;
-/**
- * Listens to one track's cues at a time, so the next one can take it off.
- *
- * Taken off whatever it was on before adding it here. `follow` runs from
- * `loadedmetadata`, which fires again for every source a reader moves to, and
- * a consumer adding a `<track>` later gets another. Added without removing, a
- * playlist of six left six listeners on tracks that between them fire for
- * every cue in the video.
- */
-export declare class CueController implements ReactiveController {
-    private readonly listener;
-    private track;
-    constructor(host: ReactiveControllerHost, listener: () => void);
-    follow(track: TextTrack): void;
-    hostDisconnected(): void;
-    private stop;
-}
-export {};

package/dist/video/root/captions.js

@@ -1,45 +0,0 @@
-export const captionTracks = (video) => {
-    const tracks = video?.textTracks;
-    if (!tracks) {
-        return [];
-    }
-    return [...tracks].filter((one) => one.kind === 'subtitles' || one.kind === 'captions');
-};
-export const showCaption = (tracks, index) => {
-    tracks.forEach((track, at) => {
-        track.mode = at === index ? 'hidden' : 'disabled';
-    });
-};
-export const adoptTrack = (track) => {
-    if (track.mode === 'showing') {
-        track.mode = 'hidden';
-    }
-    return track.mode === 'hidden';
-};
-export const captionsAmong = (media) => media
-    .filter((one) => one.tag === 'track' &&
-    (one.attrs.kind === undefined ||
-        ['captions', 'subtitles'].includes(one.attrs.kind.toLowerCase())))
-    .map((one) => ({ label: one.attrs.label ?? '', language: one.attrs.srclang ?? '' }));
-export const activeCue = (track) => {
-    const active = track?.activeCues?.[0];
-    return active instanceof VTTCue ? active.getCueAsHTML() : undefined;
-};
-export class CueController {
-    constructor(host, listener) {
-        this.listener = listener;
-        host.addController(this);
-    }
-    follow(track) {
-        this.stop();
-        this.track = track;
-        track.addEventListener('cuechange', this.listener);
-    }
-    hostDisconnected() {
-        this.stop();
-    }
-    stop() {
-        this.track?.removeEventListener('cuechange', this.listener);
-        this.track = undefined;
-    }
-}

package/dist/video/root/fullscreen.d.ts

@@ -1,28 +0,0 @@
-import type { ReactiveController, ReactiveControllerHost } from 'lit';
-/**
- * Into fullscreen and back, and honest about where the element is.
- *
- * The state follows `fullscreenchange` rather than the request, so a refused
- * request leaves a button that correctly reports "not fullscreen".
- */
-export declare class FullscreenController implements ReactiveController {
-    private readonly host;
-    private readonly report;
-    constructor(host: ReactiveControllerHost & HTMLElement, report: (full: boolean) => void);
-    /**
-     * Into fullscreen and back, and quiet about being refused.
-     *
-     * `requestFullscreen` rejects rather than returning false, and the two
-     * refusals a consumer will actually meet are a Permissions Policy that does
-     * not grant `fullscreen` to the frame the player is in, and a call without
-     * user activation. Both are `TypeError: Permissions check failed`, which is
-     * the same message for two different causes.
-     *
-     * Caught rather than `void`ed, or a refusal becomes an unhandled rejection
-     * naming neither the element nor the reason.
-     */
-    toggle(): Promise<void>;
-    hostConnected(): void;
-    hostDisconnected(): void;
-    private readonly handleChange;
-}

package/dist/video/root/fullscreen.js

@@ -1,28 +0,0 @@
-export class FullscreenController {
-    constructor(host, report) {
-        this.host = host;
-        this.report = report;
-        this.handleChange = () => {
-            this.report(document.fullscreenElement === this.host);
-        };
-        host.addController(this);
-    }
-    async toggle() {
-        try {
-            if (document.fullscreenElement === this.host) {
-                await document.exitFullscreen();
-                return;
-            }
-            await this.host.requestFullscreen();
-        }
-        catch (error) {
-            console.warn(`<${this.host.localName}> could not enter fullscreen. If it is inside an iframe, that frame needs allow="fullscreen".`, error);
-        }
-    }
-    hostConnected() {
-        document.addEventListener('fullscreenchange', this.handleChange);
-    }
-    hostDisconnected() {
-        document.removeEventListener('fullscreenchange', this.handleChange);
-    }
-}

package/dist/video/root/idle.d.ts

@@ -1,34 +0,0 @@
-import type { ReactiveController, ReactiveControllerHost } from 'lit';
-/**
- * How long the reader has been still, which decides when the bar goes.
- *
- * A wait rather than leaving with the pointer, or a reader moving across the
- * picture to reach a control watches the bar vanish under them. The wait is
- * only ever about *idling*: whether a paused video keeps its bar is the
- * element's decision, and this only says when the reader stopped.
- *
- * The delay is asked for on every restart rather than taken once, because it
- * is a property the consumer can change while the video plays.
- */
-export declare class IdleController implements ReactiveController {
-    private readonly delay;
-    private readonly report;
-    private timer;
-    constructor(host: ReactiveControllerHost, delay: () => number, report: (idle: boolean) => void);
-    /**
-     * Restarts the wait, on anything that counts as the reader being here.
-     *
-     * Pointer movement and focus both count, and both have to: a reader using the
-     * keyboard never moves a pointer, and a bar that only answered the mouse
-     * would leave them nothing to look at. Zero turns the wait off and the bar
-     * goes immediately; a large number keeps it up for as long as anyone is
-     * likely to look.
-     */
-    readonly stir: () => void;
-    /**
-     * Leaving is the one case that does not wait: the reader has gone somewhere
-     * else, and there is nothing to reach for.
-     */
-    readonly leave: () => void;
-    hostDisconnected(): void;
-}

package/dist/video/root/idle.js

@@ -1,24 +0,0 @@
-export class IdleController {
-    constructor(host, delay, report) {
-        this.delay = delay;
-        this.report = report;
-        this.stir = () => {
-            this.report(false);
-            clearTimeout(this.timer);
-            const delay = this.delay();
-            if (delay > 0) {
-                this.timer = setTimeout(() => {
-                    this.report(true);
-                }, delay);
-            }
-        };
-        this.leave = () => {
-            clearTimeout(this.timer);
-            this.report(true);
-        };
-        host.addController(this);
-    }
-    hostDisconnected() {
-        clearTimeout(this.timer);
-    }
-}

package/dist/video/root/media-copy.d.ts

@@ -1,25 +0,0 @@
-/**
- * What the consumer slotted, as the plain data a `<video>` can be given.
- *
- * Separable because it is a read of light DOM and nothing else: no media
- * element, no playback state, nothing drawn. A media element runs resource
- * selection over its own child nodes and a slot is one node, so the element
- * copies rather than slots, and the two questions the copying asks are answered
- * here: which attributes come across, and whether a fresh read differs from the
- * set already held. When to read, and what to do with the answer, stay with the
- * element.
- */
-/** A `<source>` or `<track>` as the consumer wrote it, reduced to what the copy carries. */
-export interface MediaCopy {
-    attrs: Record<string, string>;
-    tag: 'source' | 'track';
-}
-/** The copies to make of what the default slot is given. */
-export declare const copiesOf: (elements: readonly Element[]) => MediaCopy[];
-/**
- * Whether two reads describe the same media.
- *
- * The same set again is not a change. A video reloads for every new list, and
- * the first `slotchange` reports the children the element has already read.
- */
-export declare const sameCopies: (one: readonly MediaCopy[], two: readonly MediaCopy[]) => boolean;

package/dist/video/root/media-copy.js

@@ -1,18 +0,0 @@
-const CARRIED = {
-    source: ['media', 'sizes', 'src', 'srcset', 'type'],
-    track: ['default', 'kind', 'label', 'src', 'srclang'],
-};
-export const copiesOf = (elements) => elements
-    .filter((node) => node instanceof HTMLSourceElement || node instanceof HTMLTrackElement)
-    .map((node) => {
-    const tag = node instanceof HTMLTrackElement ? 'track' : 'source';
-    const attrs = {};
-    for (const name of CARRIED[tag]) {
-        const value = node.getAttribute(name);
-        if (value !== null) {
-            attrs[name] = value;
-        }
-    }
-    return { attrs, tag };
-});
-export const sameCopies = (one, two) => JSON.stringify(one) === JSON.stringify(two);

package/dist/video/root/media-session.d.ts

@@ -1,54 +0,0 @@
-import type { ReactiveController, ReactiveControllerHost } from 'lit';
-/**
- * How far a skip control moves, in seconds.
- *
- * Ten, which is the number every player that has one uses, and the number the
- * platform names in `seekbackward` and `seekforward` when it hands over a
- * default. A different length here would be correct only on this player.
- */
-export declare const SKIP_SECONDS = 10;
-/** What a headset's buttons do, handed over by the player that owns them. */
-export interface SessionHandlers {
-    /**
-     * Asks for the next item, or `null` where the consumer has named nothing to
-     * skip to: the platform draws the key from whether a handler is set.
-     */
-    next: (() => void) | null;
-    /** And the previous one, under the same rule. */
-    previous: (() => void) | null;
-    seek: (seconds: number) => void;
-    skipBy: (seconds: number) => void;
-    toggle: () => void;
-}
-/**
- * Holds the page's media session for one player, and tells the platform what
- * is playing.
- *
- * The handlers are what make a headset's play, pause and skip work at all.
- * Without them a platform falls back to guessing which element was meant,
- * which is right often enough to hide the fault and wrong exactly when there
- * are two.
- */
-export declare class MediaSessionController implements ReactiveController {
-    private readonly host;
-    constructor(host: ReactiveControllerHost & HTMLElement);
-    /**
-     * Takes the session.
-     *
-     * On play rather than on render, which is the ownership rule: a page with two
-     * players gives the session to whichever one the reader started, so a
-     * headset's buttons land on what they are listening to rather than on
-     * whichever came first in the markup.
-     */
-    claim(metadata: {
-        artwork: string;
-        title: string;
-    }, handlers: SessionHandlers): void;
-    /** Tells the platform whether the owner is playing, and nothing if it is not the owner. */
-    report(playing: boolean): void;
-    /**
-     * The page's one media session goes back to nobody, but only if this
-     * element is the one holding it.
-     */
-    hostDisconnected(): void;
-}

package/dist/video/root/media-session.js

@@ -1,49 +0,0 @@
-let owner;
-export const SKIP_SECONDS = 10;
-export class MediaSessionController {
-    constructor(host) {
-        this.host = host;
-        host.addController(this);
-    }
-    claim(metadata, handlers) {
-        if (typeof navigator === 'undefined' || !navigator.mediaSession) {
-            return;
-        }
-        owner = this.host;
-        const session = navigator.mediaSession;
-        session.metadata = new MediaMetadata({
-            artwork: metadata.artwork === '' ? [] : [{ src: metadata.artwork }],
-            title: metadata.title,
-        });
-        session.setActionHandler('play', handlers.toggle);
-        session.setActionHandler('pause', handlers.toggle);
-        session.setActionHandler('seekto', (details) => {
-            if (details.seekTime !== undefined && details.seekTime !== null) {
-                handlers.seek(details.seekTime);
-            }
-        });
-        session.setActionHandler('seekbackward', (details) => {
-            handlers.skipBy(-(details.seekOffset ?? SKIP_SECONDS));
-        });
-        session.setActionHandler('seekforward', (details) => {
-            handlers.skipBy(details.seekOffset ?? SKIP_SECONDS);
-        });
-        session.setActionHandler('nexttrack', handlers.next);
-        session.setActionHandler('previoustrack', handlers.previous);
-    }
-    report(playing) {
-        if (owner === this.host && typeof navigator !== 'undefined' && navigator.mediaSession) {
-            navigator.mediaSession.playbackState = playing ? 'playing' : 'paused';
-        }
-    }
-    hostDisconnected() {
-        if (owner !== this.host) {
-            return;
-        }
-        owner = undefined;
-        if (typeof navigator !== 'undefined' && navigator.mediaSession) {
-            navigator.mediaSession.metadata = null;
-            navigator.mediaSession.playbackState = 'none';
-        }
-    }
-}

package/dist/video/root/remote-playback.d.ts

@@ -1,34 +0,0 @@
-import type { ReactiveController, ReactiveControllerHost } from 'lit';
-/** What the watch reports, as it learns it. */
-export interface RemoteReport {
-    /** Whether anything on the network offers to play this. */
-    available: (available: boolean) => void;
-    /** Whether it is playing somewhere else right now. */
-    connected: (connected: boolean) => void;
-}
-/**
- * Watches for something to play the video on, and stops on the way out.
- *
- * The Remote Playback API is the standard one, and it is what Safari
- * implements for AirPlay and Chrome for Cast: one call covers both, where the
- * older `webkitShowPlaybackTargetPicker` covers only the first. Firefox has
- * neither, and `remote` simply being absent is what turns the control off
- * there.
- *
- * `watchAvailability` returns an id that has to be canceled, or the callback
- * outlives the element that owns it: a callback holding a removed element is a
- * leak with a `@state` write on the end.
- */
-export declare class RemotePlaybackController implements ReactiveController {
-    private readonly report;
-    private video;
-    /** Cancels the availability watch, since it outlives a single render. */
-    private watch;
-    constructor(host: ReactiveControllerHost, report: RemoteReport);
-    /** Starts watching the video, once there is one. */
-    attach(video: HTMLVideoElement): Promise<void>;
-    /** Opens the platform's own device picker. It has no list of its own. */
-    prompt(): Promise<void>;
-    hostDisconnected(): void;
-    private readonly handleState;
-}

package/dist/video/root/remote-playback.js

@@ -1,38 +0,0 @@
-export class RemotePlaybackController {
-    constructor(host, report) {
-        this.report = report;
-        this.handleState = () => {
-            this.report.connected(this.video?.remote?.state === 'connected');
-        };
-        host.addController(this);
-    }
-    async attach(video) {
-        this.video = video;
-        video.remote?.addEventListener?.('connect', this.handleState);
-        video.remote?.addEventListener?.('disconnect', this.handleState);
-        const remote = video.remote;
-        if (!remote?.watchAvailability) {
-            return;
-        }
-        try {
-            this.watch = await remote.watchAvailability((available) => {
-                this.report.available(available);
-            });
-        }
-        catch {
-        }
-    }
-    async prompt() {
-        try {
-            await this.video?.remote?.prompt();
-        }
-        catch {
-        }
-    }
-    hostDisconnected() {
-        if (this.watch !== undefined) {
-            void this.video?.remote?.cancelWatchAvailability?.(this.watch);
-            this.watch = undefined;
-        }
-    }
-}