@videojs/spf 10.0.0-beta.31 → 10.0.0-beta.32

package/dist/dev/media/dom/screen.js

@@ -6,33 +6,28 @@ import { shallowEqual } from "@videojs/utils/object";
 /**
 * Screen resolution, as the signal source for a screen-size rendition cap.
 *
-* Reported as a width and a height rather than a `"720p"`-style tier, because
-* the cap that consumes it compares against real track dimensions. A tier only
-* describes a track once you assume its aspect ratio, and that assumption
+* Reported as a width and a height rather than a `"720p"`-style tier, because the cap that consumes it compares against
+* real track dimensions. A tier only describes a track once you assume its aspect ratio, and that assumption
 * mis-measures an anamorphic or otherwise non-16:9 rendition.
 *
-* The signal source for the screen-size cap in
-* `internal/design/spf/features/rendition-selection-caps.md`.
+* The signal source for the screen-size cap in `internal/design/spf/features/rendition-selection-caps.md`.
 *
-* The screen underneath a window is not stable: rotating a device swaps the axes,
-* and unplugging a monitor or dragging the window to another display changes the
-* numbers *and* which physical screen they describe. So `getScreenResolution`
-* reads at call time and caches nothing, and `watchScreenResolution` layers the
-* reacting on top rather than the reader holding state of its own.
+* The screen underneath a window is not stable: rotating a device swaps the axes, and unplugging a monitor or dragging
+* the window to another display changes the numbers _and_ which physical screen they describe. So `getScreenResolution`
+* reads at call time and caches nothing, and `watchScreenResolution` layers the reacting on top rather than the reader
+* holding state of its own.
 */
 /**
 * Read the screen's resolution, or `undefined` where there isn't one to read.
 *
-* `undefined` means "unknown", which is the answer a cap needs in order to not
-* cap. `screenResolutionCap` reads it that way and declines to narrow, so an
-* unknown screen is "no cap" rather than a cap of zero — the reading a naive
-* `?? 0` would produce, which would pin every source to its smallest rendition on
-* exactly the environments we know least about.
+* `undefined` means "unknown", which is the answer a cap needs in order to not cap. `screenResolutionCap` reads it that
+* way and declines to narrow, so an unknown screen is "no cap" rather than a cap of zero — the reading a naive `?? 0`
+* would produce, which would pin every source to its smallest rendition on exactly the environments we know least
+* about.
 *
-* Dimensions are reported as-is, including the axis swap a rotated device
-* applies to them. Normalizing orientation away is a policy question — whether a
-* cap should flap on rotation, or hold the larger budget across both — and
-* belongs to the cap rather than to the reading.
+* Dimensions are reported as-is, including the axis swap a rotated device applies to them. Normalizing orientation away
+* is a policy question — whether a cap should flap on rotation, or hold the larger budget across both — and belongs to
+* the cap rather than to the reading.
 */
 function getScreenResolution({ useDevicePixelRatio } = { useDevicePixelRatio: true }) {
 	const screen = globalThis.screen;
@@ -40,49 +35,37 @@ function getScreenResolution({ useDevicePixelRatio } = { useDevicePixelRatio: tr
 	return scaleResolution(screen, useDevicePixelRatio ? getDevicePixelRatio() : 1);
 }
 /**
-* Call `onChange` whenever {@link getScreenResolution} would start answering
-* differently. Returns a function that stops watching.
+* Call `onChange` whenever {@link getScreenResolution} would start answering differently. Returns a function that stops
+* watching.
 *
-* There is no single event for "the screen changed", so this subscribes to every
-* signal that implies one and compares readings to decide whether anything
-* actually moved. Comparing is what makes that safe: the signals overlap and
-* `resize` in particular is noisy, so over-subscribing costs a discarded read
-* rather than a spurious call.
+* There is no single event for "the screen changed", so this subscribes to every signal that implies one and compares
+* readings to decide whether anything actually moved. Comparing is what makes that safe: the signals overlap and
+* `resize` in particular is noisy, so over-subscribing costs a discarded read rather than a spurious call.
 *
-* `onChange` is called once on subscribe with the starting value — including
-* `undefined` where there is no screen — and after that only on a genuine change.
-* So a consumer gets its initial state from the watcher and never has to pair it
+* `onChange` is called once on subscribe with the starting value — including `undefined` where there is no screen — and
+* after that only on a genuine change. So a consumer gets its initial state from the watcher and never has to pair it
 * with a separate {@link getScreenResolution} call.
 *
 * The signals, and what each one is here for:
 *
-* - **`screen`'s own `change`** — the screen itself being reconfigured, or the
-*   window landing on a different one. The direct signal, and the only one that
-*   catches a window moving between two same-size, same-ratio displays. From the
-*   Window Management API, but on the base `Screen` rather than behind
-*   `getScreenDetails()`, so it needs no permission — only a secure context.
-*   Measured present in Chromium and absent in WebKit and Firefox, hence the
-*   three below rather than this alone.
-* - **`resize`** — the window changing size, which is also what the OS does to it
-*   when the display it was on goes away.
-* - **`screen.orientation` change** — rotation, which swaps the axes without
-*   necessarily resizing the window.
-* - **a `(resolution: <ratio>dppx)` media query** (`watchDevicePixelRatio`) — the
-*   device pixel ratio changing under a window that kept its size, which is the
-*   cross-display drag between displays of different density.
+* - **`screen`'s own `change`** — the screen itself being reconfigured, or the window landing on a different one. The
+*   direct signal, and the only one that catches a window moving between two same-size, same-ratio displays. From the
+*   Window Management API, but on the base `Screen` rather than behind `getScreenDetails()`, so it needs no permission
+*   — only a secure context. Measured present in Chromium and absent in WebKit and Firefox, hence the three below
+*   rather than this alone.
+* - **`resize`** — the window changing size, which is also what the OS does to it when the display it was on goes away.
+* - **`screen.orientation` change** — rotation, which swaps the axes without necessarily resizing the window.
+* - **a `(resolution: <ratio>dppx)` media query** (`watchDevicePixelRatio`) — the device pixel ratio changing under a
+*   window that kept its size, which is the cross-display drag between displays of different density.
 *
-*   Worth keeping despite looking redundant, because it is the only coverage that
-*   case has in WebKit and Firefox: neither implements `screen`'s change event,
-*   and the drag doesn't resize the window. It is also a cleaner signal in Safari
-*   than elsewhere — WebKit holds `devicePixelRatio` independent of page zoom, so
-*   there it moves only on a real density change, where Chromium and Gecko fold
-*   zoom into it as well.
+*   Worth keeping despite looking redundant, because it is the only coverage that case has in WebKit and Firefox: neither
+*   implements `screen`'s change event, and the drag doesn't resize the window. It is also a cleaner signal in Safari
+*   than elsewhere — WebKit holds `devicePixelRatio` independent of page zoom, so there it moves only on a real density
+*   change, where Chromium and Gecko fold zoom into it as well.
 *
-* ⚠️ Known gap, on engines without `screen`'s change event: dragging a window
-* between two different-size displays that share a ratio, without the window
-* resizing, changes the reading with nothing firing. Closing it there would mean
-* polling, whose interval and battery cost are a policy decision this function
-* shouldn't be making.
+* ⚠️ Known gap, on engines without `screen`'s change event: dragging a window between two different-size displays that
+* share a ratio, without the window resizing, changes the reading with nothing firing. Closing it there would mean
+* polling, whose interval and battery cost are a policy decision this function shouldn't be making.
 */
 function watchScreenResolution(onChange, options = { useDevicePixelRatio: true }) {
 	const disconnect = new AbortController();

package/dist/dev/media/dom/screen.js.map

@@ -1 +1 @@
-{"version":3,"file":"screen.js","names":[],"sources":["../../../../src/media/dom/screen.ts"],"sourcesContent":["/**\n * Screen resolution, as the signal source for a screen-size rendition cap.\n *\n * Reported as a width and a height rather than a `\"720p\"`-style tier, because\n * the cap that consumes it compares against real track dimensions. A tier only\n * describes a track once you assume its aspect ratio, and that assumption\n * mis-measures an anamorphic or otherwise non-16:9 rendition.\n *\n * The signal source for the screen-size cap in\n * `internal/design/spf/features/rendition-selection-caps.md`.\n *\n * The screen underneath a window is not stable: rotating a device swaps the axes,\n * and unplugging a monitor or dragging the window to another display changes the\n * numbers *and* which physical screen they describe. So `getScreenResolution`\n * reads at call time and caches nothing, and `watchScreenResolution` layers the\n * reacting on top rather than the reader holding state of its own.\n */\n\nimport { getDevicePixelRatio, listen, watchDevicePixelRatio } from '@videojs/utils/dom';\nimport { shallowEqual } from '@videojs/utils/object';\nimport { isFunction } from '@videojs/utils/predicate';\nimport { type Resolution, scaleResolution } from '../primitives/resolution';\n\n/** A screen's pixel dimensions. */\nexport type ScreenResolution = Resolution;\n\nexport interface ScreenResolutionOptions {\n  /**\n   * Scale the reading from CSS pixels into device pixels. On by default, since\n   * device pixels are what the screen actually has, and a rendition's dimensions\n   * are in the same units.\n   *\n   * Opt out for CSS pixels. Note that derating — a 3x phone rarely wanting 3x the\n   * pixels of its layout — is a scale applied over this reading rather than a\n   * reason to turn it off.\n   *\n   * ⚠️ Chromium and Gecko fold page zoom into `devicePixelRatio`, so with this on,\n   * zooming moves the reading even though the screen didn't change. WebKit holds\n   * the ratio independent of zoom and is unaffected. Whether a cap should track\n   * zoom is the cap's call; this flag is only what puts zoom in scope.\n   */\n  useDevicePixelRatio: boolean;\n}\n\n/**\n * Read the screen's resolution, or `undefined` where there isn't one to read.\n *\n * `undefined` means \"unknown\", which is the answer a cap needs in order to not\n * cap. `screenResolutionCap` reads it that way and declines to narrow, so an\n * unknown screen is \"no cap\" rather than a cap of zero — the reading a naive\n * `?? 0` would produce, which would pin every source to its smallest rendition on\n * exactly the environments we know least about.\n *\n * Dimensions are reported as-is, including the axis swap a rotated device\n * applies to them. Normalizing orientation away is a policy question — whether a\n * cap should flap on rotation, or hold the larger budget across both — and\n * belongs to the cap rather than to the reading.\n */\nexport function getScreenResolution(\n  { useDevicePixelRatio }: ScreenResolutionOptions = { useDevicePixelRatio: true }\n): ScreenResolution | undefined {\n  const screen = globalThis.screen;\n  if (!screen) return undefined;\n\n  // A missing or nonsense ratio falls back to 1 (see `getDevicePixelRatio`): a\n  // CSS-pixel reading is still true and still cappable, so it isn't worth failing\n  // the whole answer over. Rounding, and the nothing-to-report case a `NaN` or\n  // zero dimension lands in, belong to `scaleResolution`.\n  return scaleResolution(screen, useDevicePixelRatio ? getDevicePixelRatio() : 1);\n}\n\n/**\n * Call `onChange` whenever {@link getScreenResolution} would start answering\n * differently. Returns a function that stops watching.\n *\n * There is no single event for \"the screen changed\", so this subscribes to every\n * signal that implies one and compares readings to decide whether anything\n * actually moved. Comparing is what makes that safe: the signals overlap and\n * `resize` in particular is noisy, so over-subscribing costs a discarded read\n * rather than a spurious call.\n *\n * `onChange` is called once on subscribe with the starting value — including\n * `undefined` where there is no screen — and after that only on a genuine change.\n * So a consumer gets its initial state from the watcher and never has to pair it\n * with a separate {@link getScreenResolution} call.\n *\n * The signals, and what each one is here for:\n *\n * - **`screen`'s own `change`** — the screen itself being reconfigured, or the\n *   window landing on a different one. The direct signal, and the only one that\n *   catches a window moving between two same-size, same-ratio displays. From the\n *   Window Management API, but on the base `Screen` rather than behind\n *   `getScreenDetails()`, so it needs no permission — only a secure context.\n *   Measured present in Chromium and absent in WebKit and Firefox, hence the\n *   three below rather than this alone.\n * - **`resize`** — the window changing size, which is also what the OS does to it\n *   when the display it was on goes away.\n * - **`screen.orientation` change** — rotation, which swaps the axes without\n *   necessarily resizing the window.\n * - **a `(resolution: <ratio>dppx)` media query** (`watchDevicePixelRatio`) — the\n *   device pixel ratio changing under a window that kept its size, which is the\n *   cross-display drag between displays of different density.\n *\n *   Worth keeping despite looking redundant, because it is the only coverage that\n *   case has in WebKit and Firefox: neither implements `screen`'s change event,\n *   and the drag doesn't resize the window. It is also a cleaner signal in Safari\n *   than elsewhere — WebKit holds `devicePixelRatio` independent of page zoom, so\n *   there it moves only on a real density change, where Chromium and Gecko fold\n *   zoom into it as well.\n *\n * ⚠️ Known gap, on engines without `screen`'s change event: dragging a window\n * between two different-size displays that share a ratio, without the window\n * resizing, changes the reading with nothing firing. Closing it there would mean\n * polling, whose interval and battery cost are a policy decision this function\n * shouldn't be making.\n */\nexport function watchScreenResolution(\n  onChange: (resolution: ScreenResolution | undefined) => void,\n  options: ScreenResolutionOptions = { useDevicePixelRatio: true }\n): () => void {\n  // One signal for every listener, so stopping is one call rather than a handle\n  // per subscription. Also makes a late ratio re-arm inert: `addEventListener`\n  // drops a listener whose signal has already aborted.\n  const disconnect = new AbortController();\n  const { signal } = disconnect;\n  let current = getScreenResolution(options);\n\n  const check = () => {\n    const next = getScreenResolution(options);\n    if (shallowEqual(current, next)) return;\n\n    current = next;\n    onChange(next);\n  };\n\n  // Deliver the starting value up front, so a consumer gets its initial state from\n  // the watcher rather than having to pair it with a separate read. Unconditional,\n  // rather than falling out of comparing against an empty `current`: an unknown\n  // reading is a value too, and a consumer that only ever heard from us about a\n  // *known* screen couldn't tell \"there is no screen\" from \"not called yet\".\n  //\n  // Before the listeners rather than after, so a callback that throws takes\n  // nothing with it — there is no subscription yet to strand.\n  onChange(current);\n\n  watchDevicePixelRatio(check, signal);\n\n  // Each signal is optional for the same reason the reading is: an environment\n  // missing one has nothing to report from it, which is not a reason to fail.\n  // `screen`'s own change event is subscribed without feature-detecting — where\n  // it isn't implemented it simply never fires, and a signal that never fires\n  // costs nothing under comparison.\n  const screen = globalThis.screen;\n  const orientation = screen?.orientation;\n\n  if (globalThis.window) listen(globalThis.window, 'resize', check, { signal });\n  // NOTE: Chromium browsers support screen change event.\n  // See: https://developer.mozilla.org/en-US/docs/Web/API/Screen/change_event\n  if (isEventTarget(screen)) listen(screen, 'change', check, { signal });\n  if (orientation) listen(orientation, 'change', check, { signal });\n\n  return () => disconnect.abort();\n}\n\nfunction isEventTarget(value: any): value is EventTarget {\n  return isFunction(value?.addEventListener);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,SAAgB,oBACd,EAAE,wBAAiD,EAAE,qBAAqB,KAAK,GACjD;CAC9B,MAAM,SAAS,WAAW;CAC1B,IAAI,CAAC,QAAQ,OAAO,KAAA;CAMpB,OAAO,gBAAgB,QAAQ,sBAAsB,oBAAoB,IAAI,CAAC;AAChF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,sBACd,UACA,UAAmC,EAAE,qBAAqB,KAAK,GACnD;CAIZ,MAAM,aAAa,IAAI,gBAAgB;CACvC,MAAM,EAAE,WAAW;CACnB,IAAI,UAAU,oBAAoB,OAAO;CAEzC,MAAM,cAAc;EAClB,MAAM,OAAO,oBAAoB,OAAO;EACxC,IAAI,aAAa,SAAS,IAAI,GAAG;EAEjC,UAAU;EACV,SAAS,IAAI;CACf;CAUA,SAAS,OAAO;CAEhB,sBAAsB,OAAO,MAAM;CAOnC,MAAM,SAAS,WAAW;CAC1B,MAAM,cAAc,QAAQ;CAE5B,IAAI,WAAW,QAAQ,OAAO,WAAW,QAAQ,UAAU,OAAO,EAAE,OAAO,CAAC;CAG5E,IAAI,cAAc,MAAM,GAAG,OAAO,QAAQ,UAAU,OAAO,EAAE,OAAO,CAAC;CACrE,IAAI,aAAa,OAAO,aAAa,UAAU,OAAO,EAAE,OAAO,CAAC;CAEhE,aAAa,WAAW,MAAM;AAChC;AAEA,SAAS,cAAc,OAAkC;CACvD,OAAO,WAAW,OAAO,gBAAgB;AAC3C"}
+{"version":3,"file":"screen.js","names":[],"sources":["../../../../src/media/dom/screen.ts"],"sourcesContent":["/**\n * Screen resolution, as the signal source for a screen-size rendition cap.\n *\n * Reported as a width and a height rather than a `\"720p\"`-style tier, because the cap that consumes it compares against\n * real track dimensions. A tier only describes a track once you assume its aspect ratio, and that assumption\n * mis-measures an anamorphic or otherwise non-16:9 rendition.\n *\n * The signal source for the screen-size cap in `internal/design/spf/features/rendition-selection-caps.md`.\n *\n * The screen underneath a window is not stable: rotating a device swaps the axes, and unplugging a monitor or dragging\n * the window to another display changes the numbers _and_ which physical screen they describe. So `getScreenResolution`\n * reads at call time and caches nothing, and `watchScreenResolution` layers the reacting on top rather than the reader\n * holding state of its own.\n */\n\nimport { getDevicePixelRatio, listen, watchDevicePixelRatio } from '@videojs/utils/dom';\nimport { shallowEqual } from '@videojs/utils/object';\nimport { isFunction } from '@videojs/utils/predicate';\n\nimport { type Resolution, scaleResolution } from '../primitives/resolution';\n\n/** A screen's pixel dimensions. */\nexport type ScreenResolution = Resolution;\n\nexport interface ScreenResolutionOptions {\n  /**\n   * Scale the reading from CSS pixels into device pixels. On by default, since device pixels are what the screen\n   * actually has, and a rendition's dimensions are in the same units.\n   *\n   * Opt out for CSS pixels. Note that derating — a 3x phone rarely wanting 3x the pixels of its layout — is a scale\n   * applied over this reading rather than a reason to turn it off.\n   *\n   * ⚠️ Chromium and Gecko fold page zoom into `devicePixelRatio`, so with this on, zooming moves the reading even\n   * though the screen didn't change. WebKit holds the ratio independent of zoom and is unaffected. Whether a cap should\n   * track zoom is the cap's call; this flag is only what puts zoom in scope.\n   */\n  useDevicePixelRatio: boolean;\n}\n\n/**\n * Read the screen's resolution, or `undefined` where there isn't one to read.\n *\n * `undefined` means \"unknown\", which is the answer a cap needs in order to not cap. `screenResolutionCap` reads it that\n * way and declines to narrow, so an unknown screen is \"no cap\" rather than a cap of zero — the reading a naive `?? 0`\n * would produce, which would pin every source to its smallest rendition on exactly the environments we know least\n * about.\n *\n * Dimensions are reported as-is, including the axis swap a rotated device applies to them. Normalizing orientation away\n * is a policy question — whether a cap should flap on rotation, or hold the larger budget across both — and belongs to\n * the cap rather than to the reading.\n */\nexport function getScreenResolution(\n  { useDevicePixelRatio }: ScreenResolutionOptions = { useDevicePixelRatio: true }\n): ScreenResolution | undefined {\n  const screen = globalThis.screen;\n  if (!screen) return undefined;\n\n  // A missing or nonsense ratio falls back to 1 (see `getDevicePixelRatio`): a\n  // CSS-pixel reading is still true and still cappable, so it isn't worth failing\n  // the whole answer over. Rounding, and the nothing-to-report case a `NaN` or\n  // zero dimension lands in, belong to `scaleResolution`.\n  return scaleResolution(screen, useDevicePixelRatio ? getDevicePixelRatio() : 1);\n}\n\n/**\n * Call `onChange` whenever {@link getScreenResolution} would start answering differently. Returns a function that stops\n * watching.\n *\n * There is no single event for \"the screen changed\", so this subscribes to every signal that implies one and compares\n * readings to decide whether anything actually moved. Comparing is what makes that safe: the signals overlap and\n * `resize` in particular is noisy, so over-subscribing costs a discarded read rather than a spurious call.\n *\n * `onChange` is called once on subscribe with the starting value — including `undefined` where there is no screen — and\n * after that only on a genuine change. So a consumer gets its initial state from the watcher and never has to pair it\n * with a separate {@link getScreenResolution} call.\n *\n * The signals, and what each one is here for:\n *\n * - **`screen`'s own `change`** — the screen itself being reconfigured, or the window landing on a different one. The\n *   direct signal, and the only one that catches a window moving between two same-size, same-ratio displays. From the\n *   Window Management API, but on the base `Screen` rather than behind `getScreenDetails()`, so it needs no permission\n *   — only a secure context. Measured present in Chromium and absent in WebKit and Firefox, hence the three below\n *   rather than this alone.\n * - **`resize`** — the window changing size, which is also what the OS does to it when the display it was on goes away.\n * - **`screen.orientation` change** — rotation, which swaps the axes without necessarily resizing the window.\n * - **a `(resolution: <ratio>dppx)` media query** (`watchDevicePixelRatio`) — the device pixel ratio changing under a\n *   window that kept its size, which is the cross-display drag between displays of different density.\n *\n *   Worth keeping despite looking redundant, because it is the only coverage that case has in WebKit and Firefox: neither\n *   implements `screen`'s change event, and the drag doesn't resize the window. It is also a cleaner signal in Safari\n *   than elsewhere — WebKit holds `devicePixelRatio` independent of page zoom, so there it moves only on a real density\n *   change, where Chromium and Gecko fold zoom into it as well.\n *\n * ⚠️ Known gap, on engines without `screen`'s change event: dragging a window between two different-size displays that\n * share a ratio, without the window resizing, changes the reading with nothing firing. Closing it there would mean\n * polling, whose interval and battery cost are a policy decision this function shouldn't be making.\n */\nexport function watchScreenResolution(\n  onChange: (resolution: ScreenResolution | undefined) => void,\n  options: ScreenResolutionOptions = { useDevicePixelRatio: true }\n): () => void {\n  // One signal for every listener, so stopping is one call rather than a handle\n  // per subscription. Also makes a late ratio re-arm inert: `addEventListener`\n  // drops a listener whose signal has already aborted.\n  const disconnect = new AbortController();\n  const { signal } = disconnect;\n  let current = getScreenResolution(options);\n\n  const check = () => {\n    const next = getScreenResolution(options);\n    if (shallowEqual(current, next)) return;\n\n    current = next;\n    onChange(next);\n  };\n\n  // Deliver the starting value up front, so a consumer gets its initial state from\n  // the watcher rather than having to pair it with a separate read. Unconditional,\n  // rather than falling out of comparing against an empty `current`: an unknown\n  // reading is a value too, and a consumer that only ever heard from us about a\n  // *known* screen couldn't tell \"there is no screen\" from \"not called yet\".\n  //\n  // Before the listeners rather than after, so a callback that throws takes\n  // nothing with it — there is no subscription yet to strand.\n  onChange(current);\n\n  watchDevicePixelRatio(check, signal);\n\n  // Each signal is optional for the same reason the reading is: an environment\n  // missing one has nothing to report from it, which is not a reason to fail.\n  // `screen`'s own change event is subscribed without feature-detecting — where\n  // it isn't implemented it simply never fires, and a signal that never fires\n  // costs nothing under comparison.\n  const screen = globalThis.screen;\n  const orientation = screen?.orientation;\n\n  if (globalThis.window) listen(globalThis.window, 'resize', check, { signal });\n\n  // NOTE: Chromium browsers support screen change event.\n  // See: https://developer.mozilla.org/en-US/docs/Web/API/Screen/change_event\n  if (isEventTarget(screen)) listen(screen, 'change', check, { signal });\n\n  if (orientation) listen(orientation, 'change', check, { signal });\n\n  return () => disconnect.abort();\n}\n\nfunction isEventTarget(value: any): value is EventTarget {\n  return isFunction(value?.addEventListener);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,SAAgB,oBACd,EAAE,wBAAiD,EAAE,qBAAqB,KAAK,GACjD;CAC9B,MAAM,SAAS,WAAW;CAC1B,IAAI,CAAC,QAAQ,OAAO,KAAA;CAMpB,OAAO,gBAAgB,QAAQ,sBAAsB,oBAAoB,IAAI,CAAC;AAChF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,sBACd,UACA,UAAmC,EAAE,qBAAqB,KAAK,GACnD;CAIZ,MAAM,aAAa,IAAI,gBAAgB;CACvC,MAAM,EAAE,WAAW;CACnB,IAAI,UAAU,oBAAoB,OAAO;CAEzC,MAAM,cAAc;EAClB,MAAM,OAAO,oBAAoB,OAAO;EACxC,IAAI,aAAa,SAAS,IAAI,GAAG;EAEjC,UAAU;EACV,SAAS,IAAI;CACf;CAUA,SAAS,OAAO;CAEhB,sBAAsB,OAAO,MAAM;CAOnC,MAAM,SAAS,WAAW;CAC1B,MAAM,cAAc,QAAQ;CAE5B,IAAI,WAAW,QAAQ,OAAO,WAAW,QAAQ,UAAU,OAAO,EAAE,OAAO,CAAC;CAI5E,IAAI,cAAc,MAAM,GAAG,OAAO,QAAQ,UAAU,OAAO,EAAE,OAAO,CAAC;CAErE,IAAI,aAAa,OAAO,aAAa,UAAU,OAAO,EAAE,OAAO,CAAC;CAEhE,aAAa,WAAW,MAAM;AAChC;AAEA,SAAS,cAAc,OAAkC;CACvD,OAAO,WAAW,OAAO,gBAAgB;AAC3C"}

package/dist/dev/media/dom/text/resolve-vtt-segment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-vtt-segment.d.ts","names":[],"sources":["../../../../../src/media/dom/text/resolve-vtt-segment.ts"],"mappings":";iBAuBgB,kBAAkB,cAAc,QAAQ;iBAkDxC"}
+{"version":3,"file":"resolve-vtt-segment.d.ts","names":[],"sources":["../../../../../src/media/dom/text/resolve-vtt-segment.ts"],"mappings":";iBAwBgB,kBAAkB,cAAc,QAAQ;iBAoDxC"}

package/dist/dev/media/dom/text/resolve-vtt-segment.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-vtt-segment.js","names":[],"sources":["../../../../../src/media/dom/text/resolve-vtt-segment.ts"],"sourcesContent":["/**\n * Parse a VTT segment using browser's native parser.\n *\n * Creates a dummy video element with a track element to leverage\n * the browser's optimized VTT parsing. Returns parsed VTTCue objects.\n */\n\nimport { resolveVttSegmentMetadata, type TextSegmentMetadata } from '../../text/resolve-vtt-metadata';\n\n// Singleton dummy video (reused across all parsing)\nlet dummyVideo: HTMLVideoElement | null = null;\n\nfunction ensureDummyVideo(): HTMLVideoElement {\n  if (!dummyVideo) {\n    dummyVideo = document.createElement('video');\n    dummyVideo.muted = true;\n    dummyVideo.preload = 'none';\n    dummyVideo.style.display = 'none';\n    dummyVideo.crossOrigin = 'anonymous';\n  }\n  return dummyVideo;\n}\n\nexport function resolveVttSegment(url: string): Promise<VTTCue[]> {\n  const video = ensureDummyVideo();\n  const track = document.createElement('track');\n  track.kind = 'subtitles';\n\n  return new Promise((resolve, reject) => {\n    const onLoad = (): void => {\n      const cues: VTTCue[] = [];\n      const textTrack = track.track;\n\n      if (textTrack.cues) {\n        for (let i = 0; i < textTrack.cues.length; i++) {\n          const cue = textTrack.cues[i];\n          if (cue) {\n            cues.push(cue as VTTCue);\n          }\n        }\n      }\n\n      cleanup();\n      resolve(cues);\n    };\n\n    const onError = (): void => {\n      cleanup();\n      reject(new Error(`Failed to load VTT segment: ${url}`));\n    };\n\n    const cleanup = (): void => {\n      track.removeEventListener('load', onLoad);\n      track.removeEventListener('error', onError);\n      video.removeChild(track);\n    };\n\n    track.addEventListener('load', onLoad);\n    track.addEventListener('error', onError);\n    video.appendChild(track);\n    // Force the browser to load and parse THIS track's resource by activating\n    // it explicitly. Relying on `default = true` only works for the first track\n    // appended to the reused dummy video: the media element's automatic\n    // text-track selection runs once, so on Firefox every subsequent `<track>`\n    // stays inactive, its resource is never fetched, and `load` never fires —\n    // stranding all cues past the first segment. Setting `mode = 'hidden'`\n    // (active but not rendered — this video is never shown) loads each segment\n    // on every browser.\n    track.track.mode = 'hidden';\n    track.src = url;\n  });\n}\n\nexport function destroyVttResolver(): void {\n  dummyVideo = null;\n}\n\n/**\n * A resolved VTT segment paired with its header metadata — the shape used when a\n * caller needs the `X-TIMESTAMP-MAP` correlation (e.g. non-zero-PTS sources),\n * not just the cues.\n */\nexport interface ResolvedVttSegment {\n  cues: VTTCue[];\n  metadata: TextSegmentMetadata;\n}\n\n/**\n * Resolve a VTT segment's cues and header metadata together. Cues still come\n * from the browser's native parser ({@link resolveVttSegment}); the header is\n * scraped in parallel ({@link resolveVttSegmentMetadata}).\n */\nexport function resolveVttSegmentWithMetadata(url: string): Promise<ResolvedVttSegment> {\n  return Promise.all([resolveVttSegment(url), resolveVttSegmentMetadata(url)]).then(([cues, metadata]) => ({\n    cues,\n    metadata,\n  }));\n}\n"],"mappings":";AAUA,IAAI,aAAsC;AAE1C,SAAS,mBAAqC;CAC5C,IAAI,CAAC,YAAY;EACf,aAAa,SAAS,cAAc,OAAO;EAC3C,WAAW,QAAQ;EACnB,WAAW,UAAU;EACrB,WAAW,MAAM,UAAU;EAC3B,WAAW,cAAc;CAC3B;CACA,OAAO;AACT;AAEA,SAAgB,kBAAkB,KAAgC;CAChE,MAAM,QAAQ,iBAAiB;CAC/B,MAAM,QAAQ,SAAS,cAAc,OAAO;CAC5C,MAAM,OAAO;CAEb,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,eAAqB;GACzB,MAAM,OAAiB,CAAC;GACxB,MAAM,YAAY,MAAM;GAExB,IAAI,UAAU,MACZ,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,KAAK,QAAQ,KAAK;IAC9C,MAAM,MAAM,UAAU,KAAK;IAC3B,IAAI,KACF,KAAK,KAAK,GAAa;GAE3B;GAGF,QAAQ;GACR,QAAQ,IAAI;EACd;EAEA,MAAM,gBAAsB;GAC1B,QAAQ;GACR,uBAAO,IAAI,MAAM,+BAA+B,KAAK,CAAC;EACxD;EAEA,MAAM,gBAAsB;GAC1B,MAAM,oBAAoB,QAAQ,MAAM;GACxC,MAAM,oBAAoB,SAAS,OAAO;GAC1C,MAAM,YAAY,KAAK;EACzB;EAEA,MAAM,iBAAiB,QAAQ,MAAM;EACrC,MAAM,iBAAiB,SAAS,OAAO;EACvC,MAAM,YAAY,KAAK;EASvB,MAAM,MAAM,OAAO;EACnB,MAAM,MAAM;CACd,CAAC;AACH;AAEA,SAAgB,qBAA2B;CACzC,aAAa;AACf"}
+{"version":3,"file":"resolve-vtt-segment.js","names":[],"sources":["../../../../../src/media/dom/text/resolve-vtt-segment.ts"],"sourcesContent":["/**\n * Parse a VTT segment using browser's native parser.\n *\n * Creates a dummy video element with a track element to leverage the browser's optimized VTT parsing. Returns parsed\n * VTTCue objects.\n */\n\nimport { resolveVttSegmentMetadata, type TextSegmentMetadata } from '../../text/resolve-vtt-metadata';\n\n// Singleton dummy video (reused across all parsing)\nlet dummyVideo: HTMLVideoElement | null = null;\n\nfunction ensureDummyVideo(): HTMLVideoElement {\n  if (!dummyVideo) {\n    dummyVideo = document.createElement('video');\n    dummyVideo.muted = true;\n    dummyVideo.preload = 'none';\n    dummyVideo.style.display = 'none';\n    dummyVideo.crossOrigin = 'anonymous';\n  }\n\n  return dummyVideo;\n}\n\nexport function resolveVttSegment(url: string): Promise<VTTCue[]> {\n  const video = ensureDummyVideo();\n  const track = document.createElement('track');\n\n  track.kind = 'subtitles';\n\n  return new Promise((resolve, reject) => {\n    const onLoad = (): void => {\n      const cues: VTTCue[] = [];\n      const textTrack = track.track;\n\n      if (textTrack.cues) {\n        for (let i = 0; i < textTrack.cues.length; i++) {\n          const cue = textTrack.cues[i];\n\n          if (cue) {\n            cues.push(cue as VTTCue);\n          }\n        }\n      }\n\n      cleanup();\n      resolve(cues);\n    };\n\n    const onError = (): void => {\n      cleanup();\n      reject(new Error(`Failed to load VTT segment: ${url}`));\n    };\n\n    const cleanup = (): void => {\n      track.removeEventListener('load', onLoad);\n      track.removeEventListener('error', onError);\n      video.removeChild(track);\n    };\n\n    track.addEventListener('load', onLoad);\n    track.addEventListener('error', onError);\n    video.appendChild(track);\n    // Force the browser to load and parse THIS track's resource by activating\n    // it explicitly. Relying on `default = true` only works for the first track\n    // appended to the reused dummy video: the media element's automatic\n    // text-track selection runs once, so on Firefox every subsequent `<track>`\n    // stays inactive, its resource is never fetched, and `load` never fires —\n    // stranding all cues past the first segment. Setting `mode = 'hidden'`\n    // (active but not rendered — this video is never shown) loads each segment\n    // on every browser.\n    track.track.mode = 'hidden';\n    track.src = url;\n  });\n}\n\nexport function destroyVttResolver(): void {\n  dummyVideo = null;\n}\n\n/**\n * A resolved VTT segment paired with its header metadata — the shape used when a caller needs the `X-TIMESTAMP-MAP`\n * correlation (e.g. non-zero-PTS sources), not just the cues.\n */\nexport interface ResolvedVttSegment {\n  cues: VTTCue[];\n  metadata: TextSegmentMetadata;\n}\n\n/**\n * Resolve a VTT segment's cues and header metadata together. Cues still come from the browser's native parser ({@link\n * resolveVttSegment}); the header is scraped in parallel ({@link resolveVttSegmentMetadata}).\n */\nexport function resolveVttSegmentWithMetadata(url: string): Promise<ResolvedVttSegment> {\n  return Promise.all([resolveVttSegment(url), resolveVttSegmentMetadata(url)]).then(([cues, metadata]) => ({\n    cues,\n    metadata,\n  }));\n}\n"],"mappings":";AAUA,IAAI,aAAsC;AAE1C,SAAS,mBAAqC;CAC5C,IAAI,CAAC,YAAY;EACf,aAAa,SAAS,cAAc,OAAO;EAC3C,WAAW,QAAQ;EACnB,WAAW,UAAU;EACrB,WAAW,MAAM,UAAU;EAC3B,WAAW,cAAc;CAC3B;CAEA,OAAO;AACT;AAEA,SAAgB,kBAAkB,KAAgC;CAChE,MAAM,QAAQ,iBAAiB;CAC/B,MAAM,QAAQ,SAAS,cAAc,OAAO;CAE5C,MAAM,OAAO;CAEb,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,eAAqB;GACzB,MAAM,OAAiB,CAAC;GACxB,MAAM,YAAY,MAAM;GAExB,IAAI,UAAU,MACZ,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,KAAK,QAAQ,KAAK;IAC9C,MAAM,MAAM,UAAU,KAAK;IAE3B,IAAI,KACF,KAAK,KAAK,GAAa;GAE3B;GAGF,QAAQ;GACR,QAAQ,IAAI;EACd;EAEA,MAAM,gBAAsB;GAC1B,QAAQ;GACR,uBAAO,IAAI,MAAM,+BAA+B,KAAK,CAAC;EACxD;EAEA,MAAM,gBAAsB;GAC1B,MAAM,oBAAoB,QAAQ,MAAM;GACxC,MAAM,oBAAoB,SAAS,OAAO;GAC1C,MAAM,YAAY,KAAK;EACzB;EAEA,MAAM,iBAAiB,QAAQ,MAAM;EACrC,MAAM,iBAAiB,SAAS,OAAO;EACvC,MAAM,YAAY,KAAK;EASvB,MAAM,MAAM,OAAO;EACnB,MAAM,MAAM;CACd,CAAC;AACH;AAEA,SAAgB,qBAA2B;CACzC,aAAa;AACf"}

package/dist/dev/media/dom/text/text-track-slots.d.ts

@@ -1,28 +1,22 @@
 import { PartiallyResolvedTextTrack, TextTrack } from "../../types/index.js";
 //#region src/media/dom/text/text-track-slots.d.ts
 /**
- * Allocate text-track slots on `mediaElement` for each model track by creating
- * and appending `<track>` children. Marks each element with `data-src-track`
- * so it can be distinguished from `<track>` children the host page added
- * directly — used by `getShowingSubtitlesTrackFromMedia` and
- * `removeAllSubtitlesTracksFromMedia` to scope their reads/removals to
- * SPF-owned slots. The spec has no `removeTextTrack` API, so creating
- * `<track>` elements is the only mechanism for adding *and* removing entries
- * to `mediaElement.textTracks`.
+ * Allocate text-track slots on `mediaElement` for each model track by creating and appending `<track>` children. Marks
+ * each element with `data-src-track` so it can be distinguished from `<track>` children the host page added directly —
+ * used by `getShowingSubtitlesTrackFromMedia` and `removeAllSubtitlesTracksFromMedia` to scope their reads/removals to
+ * SPF-owned slots. The spec has no `removeTextTrack` API, so creating `<track>` elements is the only mechanism for
+ * adding _and_ removing entries to `mediaElement.textTracks`.
  */
 declare function addSubtitlesTracksToMedia(mediaElement: HTMLMediaElement, modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]): void;
 /**
- * Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'`
- * mode, or `undefined` if none. Restricts the search to slots created by
- * `addSubtitlesTracksToMedia` (via the `data-src-track` selector) so a showing
- * track that the host page added directly is ignored — SPF selection only
- * mirrors tracks it owns.
+ * Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'` mode, or `undefined` if none. Restricts
+ * the search to slots created by `addSubtitlesTracksToMedia` (via the `data-src-track` selector) so a showing track
+ * that the host page added directly is ignored — SPF selection only mirrors tracks it owns.
  */
 declare function getShowingSubtitlesTrackFromMedia(mediaElement: HTMLMediaElement): globalThis.TextTrack | undefined;
 /**
- * Remove every SPF-owned `<track>` child from `mediaElement` (those tagged
- * with `data-src-track` by `addSubtitlesTracksToMedia`). `<track>` elements
- * the host page added directly are left in place.
+ * Remove every SPF-owned `<track>` child from `mediaElement` (those tagged with `data-src-track` by
+ * `addSubtitlesTracksToMedia`). `<track>` elements the host page added directly are left in place.
  */
 declare function removeAllSubtitlesTracksFromMedia(mediaElement: HTMLMediaElement): void;
 //#endregion

package/dist/dev/media/dom/text/text-track-slots.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text-track-slots.d.ts","names":[],"sources":["../../../../../src/media/dom/text/text-track-slots.ts"],"mappings":";;;;;;;;;;;;iBAqBgB,0BACd,cAAc,kBACd,2BAA2B,6BAA6B;;;;;;;;iBA0B1C,kCAAkC,cAAc,mBAAmB,WAAW;;;;;;iBAgB9E,kCAAkC,cAAc"}
+{"version":3,"file":"text-track-slots.d.ts","names":[],"sources":["../../../../../src/media/dom/text/text-track-slots.ts"],"mappings":";;;;;;;;;iBAiBgB,0BACd,cAAc,kBACd,2BAA2B,6BAA6B;;;;;;iBA2B1C,kCAAkC,cAAc,mBAAmB,WAAW;;;;;iBAe9E,kCAAkC,cAAc"}

package/dist/dev/media/dom/text/text-track-slots.js

@@ -1,20 +1,16 @@
 import { isCaptionOrSubtitleTrack } from "@videojs/utils/dom";
 //#region src/media/dom/text/text-track-slots.ts
 /**
-* SPF-owned `<track>` selector. Each slot created by
-* `addSubtitlesTracksToMedia` carries this attribute so reads and removals can
-* filter SPF-owned tracks from host-page-owned ones.
+* SPF-owned `<track>` selector. Each slot created by `addSubtitlesTracksToMedia` carries this attribute so reads and
+* removals can filter SPF-owned tracks from host-page-owned ones.
 */
 const SPF_TRACK_SELECTOR = "track[data-src-track]";
 /**
-* Allocate text-track slots on `mediaElement` for each model track by creating
-* and appending `<track>` children. Marks each element with `data-src-track`
-* so it can be distinguished from `<track>` children the host page added
-* directly — used by `getShowingSubtitlesTrackFromMedia` and
-* `removeAllSubtitlesTracksFromMedia` to scope their reads/removals to
-* SPF-owned slots. The spec has no `removeTextTrack` API, so creating
-* `<track>` elements is the only mechanism for adding *and* removing entries
-* to `mediaElement.textTracks`.
+* Allocate text-track slots on `mediaElement` for each model track by creating and appending `<track>` children. Marks
+* each element with `data-src-track` so it can be distinguished from `<track>` children the host page added directly —
+* used by `getShowingSubtitlesTrackFromMedia` and `removeAllSubtitlesTracksFromMedia` to scope their reads/removals to
+* SPF-owned slots. The spec has no `removeTextTrack` API, so creating `<track>` elements is the only mechanism for
+* adding _and_ removing entries to `mediaElement.textTracks`.
 */
 function addSubtitlesTracksToMedia(mediaElement, modelTextTracks) {
 	for (const modelTrack of modelTextTracks) {
@@ -28,11 +24,9 @@ function addSubtitlesTracksToMedia(mediaElement, modelTextTracks) {
 	}
 }
 /**
-* Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'`
-* mode, or `undefined` if none. Restricts the search to slots created by
-* `addSubtitlesTracksToMedia` (via the `data-src-track` selector) so a showing
-* track that the host page added directly is ignored — SPF selection only
-* mirrors tracks it owns.
+* Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'` mode, or `undefined` if none. Restricts
+* the search to slots created by `addSubtitlesTracksToMedia` (via the `data-src-track` selector) so a showing track
+* that the host page added directly is ignored — SPF selection only mirrors tracks it owns.
 */
 function getShowingSubtitlesTrackFromMedia(mediaElement) {
 	const elements = mediaElement.querySelectorAll(SPF_TRACK_SELECTOR);
@@ -42,19 +36,17 @@ function getShowingSubtitlesTrackFromMedia(mediaElement) {
 	}
 }
 /**
-* Remove every SPF-owned `<track>` child from `mediaElement` (those tagged
-* with `data-src-track` by `addSubtitlesTracksToMedia`). `<track>` elements
-* the host page added directly are left in place.
+* Remove every SPF-owned `<track>` child from `mediaElement` (those tagged with `data-src-track` by
+* `addSubtitlesTracksToMedia`). `<track>` elements the host page added directly are left in place.
 */
 function removeAllSubtitlesTracksFromMedia(mediaElement) {
 	const elements = mediaElement.querySelectorAll(SPF_TRACK_SELECTOR);
 	for (const el of elements) el.remove();
 }
 /**
-* Apply a selection to a `TextTrackList` by setting each subtitle/caption
-* track's `mode` to `'showing'` if its `id` matches `selectedId` and
-* `'disabled'` otherwise. Tracks of other kinds (chapters, metadata,
-* descriptions) are left untouched — they may be owned by the host page.
+* Apply a selection to a `TextTrackList` by setting each subtitle/caption track's `mode` to `'showing'` if its `id`
+* matches `selectedId` and `'disabled'` otherwise. Tracks of other kinds (chapters, metadata, descriptions) are left
+* untouched — they may be owned by the host page.
 */
 function syncTextTrackModes(textTracks, selectedId) {
 	for (let i = 0; i < textTracks.length; i++) {

package/dist/dev/media/dom/text/text-track-slots.js.map

@@ -1 +1 @@
-{"version":3,"file":"text-track-slots.js","names":[],"sources":["../../../../../src/media/dom/text/text-track-slots.ts"],"sourcesContent":["import { isCaptionOrSubtitleTrack } from '@videojs/utils/dom';\n\nimport type { PartiallyResolvedTextTrack, TextTrack } from '../../types';\n\n/**\n * SPF-owned `<track>` selector. Each slot created by\n * `addSubtitlesTracksToMedia` carries this attribute so reads and removals can\n * filter SPF-owned tracks from host-page-owned ones.\n */\nconst SPF_TRACK_SELECTOR = 'track[data-src-track]';\n\n/**\n * Allocate text-track slots on `mediaElement` for each model track by creating\n * and appending `<track>` children. Marks each element with `data-src-track`\n * so it can be distinguished from `<track>` children the host page added\n * directly — used by `getShowingSubtitlesTrackFromMedia` and\n * `removeAllSubtitlesTracksFromMedia` to scope their reads/removals to\n * SPF-owned slots. The spec has no `removeTextTrack` API, so creating\n * `<track>` elements is the only mechanism for adding *and* removing entries\n * to `mediaElement.textTracks`.\n */\nexport function addSubtitlesTracksToMedia(\n  mediaElement: HTMLMediaElement,\n  modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]\n): void {\n  for (const modelTrack of modelTextTracks) {\n    const el = document.createElement('track');\n    el.id = modelTrack.id;\n    el.kind = modelTrack.kind;\n    el.label = modelTrack.label;\n    el.toggleAttribute('data-src-track', true);\n    if (modelTrack.language) el.srclang = modelTrack.language;\n    // Deliberately NOT propagating `modelTrack.default` to the `default`\n    // attribute: that makes the browser auto-activate the slot on insertion,\n    // which fires a `change` that `syncTextTracks` records as user intent —\n    // auto-enabling captions past SPF's opt-in policy (`enableDefaultTrack`\n    // governs DEFAULT=YES handling in `switchTextTrack`, not the browser). SPF\n    // owns selection; these slots are containers, so they carry no selection hint.\n    mediaElement.appendChild(el);\n  }\n}\n\n/**\n * Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'`\n * mode, or `undefined` if none. Restricts the search to slots created by\n * `addSubtitlesTracksToMedia` (via the `data-src-track` selector) so a showing\n * track that the host page added directly is ignored — SPF selection only\n * mirrors tracks it owns.\n */\nexport function getShowingSubtitlesTrackFromMedia(mediaElement: HTMLMediaElement): globalThis.TextTrack | undefined {\n  const elements = mediaElement.querySelectorAll<HTMLTrackElement>(SPF_TRACK_SELECTOR);\n  for (const el of elements) {\n    const track = el.track;\n    if (track.mode === 'showing' && isCaptionOrSubtitleTrack(track)) {\n      return track;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Remove every SPF-owned `<track>` child from `mediaElement` (those tagged\n * with `data-src-track` by `addSubtitlesTracksToMedia`). `<track>` elements\n * the host page added directly are left in place.\n */\nexport function removeAllSubtitlesTracksFromMedia(mediaElement: HTMLMediaElement): void {\n  const elements = mediaElement.querySelectorAll<HTMLTrackElement>(SPF_TRACK_SELECTOR);\n  for (const el of elements) {\n    el.remove();\n  }\n}\n\n/**\n * Apply a selection to a `TextTrackList` by setting each subtitle/caption\n * track's `mode` to `'showing'` if its `id` matches `selectedId` and\n * `'disabled'` otherwise. Tracks of other kinds (chapters, metadata,\n * descriptions) are left untouched — they may be owned by the host page.\n */\nexport function syncTextTrackModes(textTracks: TextTrackList, selectedId: string | undefined): void {\n  for (let i = 0; i < textTracks.length; i++) {\n    const track = textTracks[i]!;\n    if (!isCaptionOrSubtitleTrack(track)) continue;\n    track.mode = track.id === selectedId ? 'showing' : 'disabled';\n  }\n}\n"],"mappings":";;;;;;;AASA,MAAM,qBAAqB;;;;;;;;;;;AAY3B,SAAgB,0BACd,cACA,iBACM;CACN,KAAK,MAAM,cAAc,iBAAiB;EACxC,MAAM,KAAK,SAAS,cAAc,OAAO;EACzC,GAAG,KAAK,WAAW;EACnB,GAAG,OAAO,WAAW;EACrB,GAAG,QAAQ,WAAW;EACtB,GAAG,gBAAgB,kBAAkB,IAAI;EACzC,IAAI,WAAW,UAAU,GAAG,UAAU,WAAW;EAOjD,aAAa,YAAY,EAAE;CAC7B;AACF;;;;;;;;AASA,SAAgB,kCAAkC,cAAkE;CAClH,MAAM,WAAW,aAAa,iBAAmC,kBAAkB;CACnF,KAAK,MAAM,MAAM,UAAU;EACzB,MAAM,QAAQ,GAAG;EACjB,IAAI,MAAM,SAAS,aAAa,yBAAyB,KAAK,GAC5D,OAAO;CAEX;AAEF;;;;;;AAOA,SAAgB,kCAAkC,cAAsC;CACtF,MAAM,WAAW,aAAa,iBAAmC,kBAAkB;CACnF,KAAK,MAAM,MAAM,UACf,GAAG,OAAO;AAEd;;;;;;;AAQA,SAAgB,mBAAmB,YAA2B,YAAsC;CAClG,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;EAC1C,MAAM,QAAQ,WAAW;EACzB,IAAI,CAAC,yBAAyB,KAAK,GAAG;EACtC,MAAM,OAAO,MAAM,OAAO,aAAa,YAAY;CACrD;AACF"}
+{"version":3,"file":"text-track-slots.js","names":[],"sources":["../../../../../src/media/dom/text/text-track-slots.ts"],"sourcesContent":["import { isCaptionOrSubtitleTrack } from '@videojs/utils/dom';\n\nimport type { PartiallyResolvedTextTrack, TextTrack } from '../../types';\n\n/**\n * SPF-owned `<track>` selector. Each slot created by `addSubtitlesTracksToMedia` carries this attribute so reads and\n * removals can filter SPF-owned tracks from host-page-owned ones.\n */\nconst SPF_TRACK_SELECTOR = 'track[data-src-track]';\n\n/**\n * Allocate text-track slots on `mediaElement` for each model track by creating and appending `<track>` children. Marks\n * each element with `data-src-track` so it can be distinguished from `<track>` children the host page added directly —\n * used by `getShowingSubtitlesTrackFromMedia` and `removeAllSubtitlesTracksFromMedia` to scope their reads/removals to\n * SPF-owned slots. The spec has no `removeTextTrack` API, so creating `<track>` elements is the only mechanism for\n * adding _and_ removing entries to `mediaElement.textTracks`.\n */\nexport function addSubtitlesTracksToMedia(\n  mediaElement: HTMLMediaElement,\n  modelTextTracks: readonly (PartiallyResolvedTextTrack | TextTrack)[]\n): void {\n  for (const modelTrack of modelTextTracks) {\n    const el = document.createElement('track');\n\n    el.id = modelTrack.id;\n    el.kind = modelTrack.kind;\n    el.label = modelTrack.label;\n    el.toggleAttribute('data-src-track', true);\n\n    if (modelTrack.language) el.srclang = modelTrack.language;\n\n    // Deliberately NOT propagating `modelTrack.default` to the `default`\n    // attribute: that makes the browser auto-activate the slot on insertion,\n    // which fires a `change` that `syncTextTracks` records as user intent —\n    // auto-enabling captions past SPF's opt-in policy (`enableDefaultTrack`\n    // governs DEFAULT=YES handling in `switchTextTrack`, not the browser). SPF\n    // owns selection; these slots are containers, so they carry no selection hint.\n    mediaElement.appendChild(el);\n  }\n}\n\n/**\n * Return the SPF-owned subtitle/caption `TextTrack` currently in `'showing'` mode, or `undefined` if none. Restricts\n * the search to slots created by `addSubtitlesTracksToMedia` (via the `data-src-track` selector) so a showing track\n * that the host page added directly is ignored — SPF selection only mirrors tracks it owns.\n */\nexport function getShowingSubtitlesTrackFromMedia(mediaElement: HTMLMediaElement): globalThis.TextTrack | undefined {\n  const elements = mediaElement.querySelectorAll<HTMLTrackElement>(SPF_TRACK_SELECTOR);\n\n  for (const el of elements) {\n    const track = el.track;\n    if (track.mode === 'showing' && isCaptionOrSubtitleTrack(track)) return track;\n  }\n\n  return undefined;\n}\n\n/**\n * Remove every SPF-owned `<track>` child from `mediaElement` (those tagged with `data-src-track` by\n * `addSubtitlesTracksToMedia`). `<track>` elements the host page added directly are left in place.\n */\nexport function removeAllSubtitlesTracksFromMedia(mediaElement: HTMLMediaElement): void {\n  const elements = mediaElement.querySelectorAll<HTMLTrackElement>(SPF_TRACK_SELECTOR);\n\n  for (const el of elements) {\n    el.remove();\n  }\n}\n\n/**\n * Apply a selection to a `TextTrackList` by setting each subtitle/caption track's `mode` to `'showing'` if its `id`\n * matches `selectedId` and `'disabled'` otherwise. Tracks of other kinds (chapters, metadata, descriptions) are left\n * untouched — they may be owned by the host page.\n */\nexport function syncTextTrackModes(textTracks: TextTrackList, selectedId: string | undefined): void {\n  for (let i = 0; i < textTracks.length; i++) {\n    const track = textTracks[i]!;\n    if (!isCaptionOrSubtitleTrack(track)) continue;\n\n    track.mode = track.id === selectedId ? 'showing' : 'disabled';\n  }\n}\n"],"mappings":";;;;;;AAQA,MAAM,qBAAqB;;;;;;;;AAS3B,SAAgB,0BACd,cACA,iBACM;CACN,KAAK,MAAM,cAAc,iBAAiB;EACxC,MAAM,KAAK,SAAS,cAAc,OAAO;EAEzC,GAAG,KAAK,WAAW;EACnB,GAAG,OAAO,WAAW;EACrB,GAAG,QAAQ,WAAW;EACtB,GAAG,gBAAgB,kBAAkB,IAAI;EAEzC,IAAI,WAAW,UAAU,GAAG,UAAU,WAAW;EAQjD,aAAa,YAAY,EAAE;CAC7B;AACF;;;;;;AAOA,SAAgB,kCAAkC,cAAkE;CAClH,MAAM,WAAW,aAAa,iBAAmC,kBAAkB;CAEnF,KAAK,MAAM,MAAM,UAAU;EACzB,MAAM,QAAQ,GAAG;EACjB,IAAI,MAAM,SAAS,aAAa,yBAAyB,KAAK,GAAG,OAAO;CAC1E;AAGF;;;;;AAMA,SAAgB,kCAAkC,cAAsC;CACtF,MAAM,WAAW,aAAa,iBAAmC,kBAAkB;CAEnF,KAAK,MAAM,MAAM,UACf,GAAG,OAAO;AAEd;;;;;;AAOA,SAAgB,mBAAmB,YAA2B,YAAsC;CAClG,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;EAC1C,MAAM,QAAQ,WAAW;EACzB,IAAI,CAAC,yBAAyB,KAAK,GAAG;EAEtC,MAAM,OAAO,MAAM,OAAO,aAAa,YAAY;CACrD;AACF"}

package/dist/dev/media/errors.d.ts

@@ -1,37 +1,29 @@
 //#region src/media/errors.d.ts
 /**
- * SVTA 2070 (Standardized Error Codes) — the vocabulary for identifying a
- * playback failure or notice, independent of how it's transported or who
- * decides what to do about it.
+ * SVTA 2070 (Standardized Error Codes) — the vocabulary for identifying a playback failure or notice, independent of
+ * how it's transported or who decides what to do about it.
  *
- * A code is a single integer: the leading digit(s) are the **category** (the
- * error's domain) and the trailing three are the **index** (the specific error
- * within it). Four digits for natively-defined errors, five when an external
- * standard is embedded — `"03404"` is an HTTP 404 under the network category.
- * Categories are `0` unknown, `1` media content, `2` playback, `3` network,
- * `4` content protection, `5` accessibility, `6` remote play, `7` advertising,
- * `99` custom.
+ * A code is a single integer: the leading digit(s) are the **category** (the error's domain) and the trailing three are
+ * the **index** (the specific error within it). Four digits for natively-defined errors, five when an external standard
+ * is embedded — `"03404"` is an HTTP 404 under the network category. Categories are `0` unknown, `1` media content, `2`
+ * playback, `3` network, `4` content protection, `5` accessibility, `6` remote play, `7` advertising, `99` custom.
  *
  * Two properties of the spec shape the types here:
  *
- * - **Severity is deliberately not part of a code.** Per §Approach, "impact
- *   varies with player implementation, breaking the consistency of a specific
- *   error mapping to single code." So an error carries no fatal flag — whether a
- *   condition is fatal depends on the composition observing it, and is decided
- *   downstream.
- * - **Reporting is partial and stacked** (Principles 5–6). Errors are reported
- *   as encountered, most of them non-fatal, and the *sequence* carries causation
- *   a single value can't.
+ * - **Severity is deliberately not part of a code.** Per §Approach, "impact varies with player implementation, breaking
+ *   the consistency of a specific error mapping to single code." So an error carries no fatal flag — whether a
+ *   condition is fatal depends on the composition observing it, and is decided downstream.
+ * - **Reporting is partial and stacked** (Principles 5–6). Errors are reported as encountered, most of them non-fatal,
+ *   and the _sequence_ carries causation a single value can't.
  *
  * See `internal/design/spf/features/errors.md`.
  */
 /**
  * A reported condition, identified by its SVTA code.
  *
- * Named for the spec rather than the engine because the vocabulary is
- * format- and player-neutral. Not `MediaError` — that name belongs to the
- * `@videojs/media` DOM-facing class this eventually maps *onto*, and the mapping
- * is the point at which severity and user-facing text get decided.
+ * Named for the spec rather than the engine because the vocabulary is format- and player-neutral. Not `MediaError` —
+ * that name belongs to the `@videojs/media` DOM-facing class this eventually maps _onto_, and the mapping is the point
+ * at which severity and user-facing text get decided.
  */
 interface SvtaError {
   /** The SVTA code — see {@link svtaCategory} / {@link svtaIndex}. */
@@ -42,39 +34,33 @@ interface SvtaError {
   data?: unknown;
 }
 /**
- * SVTA 99 [Custom] 001 — this engine has no pipeline for something the source
- * requires, so the source is unplayable *here* rather than broken.
+ * SVTA 99 [Custom] 001 — this engine has no pipeline for something the source requires, so the source is unplayable
+ * _here_ rather than broken.
  *
- * Custom rather than standard because the standard codes available describe
- * either narrower or wider things. The causes (1004/1005 unsupported format,
- * 4008 unsupported DRM) say what one rendition hit; the verdicts (2011/2012 no
- * supported track) say a type emptied without saying why it's unfixable. And
- * 2039 "Manifest feature unsupported" covers features that are unsupported but
- * still *playable* — LL-HLS degrading to standard live is a 2039 — so
- * overloading it for a fatal condition would make it useless for the notices it
- * belongs on.
+ * Custom rather than standard because the standard codes available describe either narrower or wider things. The causes
+ * (1004/1005 unsupported format, 4008 unsupported DRM) say what one rendition hit; the verdicts (2011/2012 no supported
+ * track) say a type emptied without saying why it's unfixable. And 2039 "Manifest feature unsupported" covers features
+ * that are unsupported but still _playable_ — LL-HLS degrading to standard live is a 2039 — so overloading it for a
+ * fatal condition would make it useless for the notices it belongs on.
  *
- * Index `001`: the spec defines only `99000` (Unknown) for the custom category
- * and leaves the rest to the publisher, so this is the first code we define.
+ * Index `001`: the spec defines only `99000` (Unknown) for the custom category and leaves the rest to the publisher, so
+ * this is the first code we define.
  *
- * Five digits, and deliberately not special-cased anywhere: {@link svtaCategory}
- * and {@link svtaIndex} decompose it correctly by arithmetic alone, because
- * every standard category is below `8000` and custom starts at `99000`.
+ * Five digits, and deliberately not special-cased anywhere: {@link svtaCategory} and {@link svtaIndex} decompose it
+ * correctly by arithmetic alone, because every standard category is below `8000` and custom starts at `99000`.
  */
 declare const SVTA_UNSUPPORTED_PLAYBACK_FEATURE = 99001;
 /**
- * The error's domain — `code / 1000`, per the spec's "divide by one thousand to
- * obtain the error category". Works uniformly across the four-digit native form
- * and the five-digit form embedding an external standard: `"03404"` is
- * numerically 3404, which decomposes identically. That also makes a numeric code
- * immune to the spec's inconsistent zero-padding (§Approach writes a
- * category-unknown network error as `"0300"` where the error index implies
- * category 3 / index 000).
+ * The error's domain — `code / 1000`, per the spec's "divide by one thousand to obtain the error category". Works
+ * uniformly across the four-digit native form and the five-digit form embedding an external standard: `"03404"` is
+ * numerically 3404, which decomposes identically. That also makes a numeric code immune to the spec's inconsistent
+ * zero-padding (§Approach writes a category-unknown network error as `"0300"` where the error index implies category 3
+ * / index 000).
  */
 declare function svtaCategory(code: number): number;
 /**
- * The specific error within its category — `code % 1000`. For a five-digit code
- * this is the embedded external value (an HTTP status, a VAST code).
+ * The specific error within its category — `code % 1000`. For a five-digit code this is the embedded external value (an
+ * HTTP status, a VAST code).
  */
 declare function svtaIndex(code: number): number;
 //#endregion

package/dist/dev/media/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","names":[],"sources":["../../../src/media/errors.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmCiB;;EAEf;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;cAoDW;;;;;;;;;;iBAWG,aAAa;;;;;iBAQb,UAAU"}
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../../../src/media/errors.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;UA2BiB;;EAEf;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;cA6CW;;;;;;;;iBASG,aAAa;;;;;iBAQb,UAAU"}

package/dist/dev/media/errors.js

@@ -4,61 +4,52 @@ const SVTA_UNSUPPORTED_VIDEO_FORMAT = 1004;
 /** SVTA 1 [Media Content] 005 — the audio counterpart of {@link SVTA_UNSUPPORTED_VIDEO_FORMAT}. */
 const SVTA_UNSUPPORTED_AUDIO_FORMAT = 1005;
 /**
-* SVTA 4 [Content Protection] 008 — unsupported or unavailable DRM system. Used
-* for "this source is encrypted and we have no decryption pipeline," which is
-* detection, not a license failure.
+* SVTA 4 [Content Protection] 008 — unsupported or unavailable DRM system. Used for "this source is encrypted and we
+* have no decryption pipeline," which is detection, not a license failure.
 */
 const SVTA_UNSUPPORTED_DRM_SYSTEM = 4008;
 /**
 * SVTA 2 [Playback] 011 — no video track the environment can play.
 *
-* Covers both ways a composition can end up with nothing to select: renditions
-* that existed and were all excluded as unplayable, and — where the composition
-* composes `reportAbsentTrackType` to say it needs the type — a source carrying
-* none to begin with. Deliberately one code for both, because they are the same
-* answer to a viewer, and because the alternative is a code the SVTA spec doesn't
-* define. Whether an absent type is a failure is the composition's to state,
-* which is why it opts in rather than being read off the source.
+* Covers both ways a composition can end up with nothing to select: renditions that existed and were all excluded as
+* unplayable, and — where the composition composes `reportAbsentTrackType` to say it needs the type — a source carrying
+* none to begin with. Deliberately one code for both, because they are the same answer to a viewer, and because the
+* alternative is a code the SVTA spec doesn't define. Whether an absent type is a failure is the composition's to
+* state, which is why it opts in rather than being read off the source.
 */
 const SVTA_NO_SUPPORTED_VIDEO_TRACK = 2011;
 /** SVTA 2 [Playback] 012 — the audio counterpart of {@link SVTA_NO_SUPPORTED_VIDEO_TRACK}. */
 const SVTA_NO_SUPPORTED_AUDIO_TRACK = 2012;
 /**
-* SVTA 99 [Custom] 001 — this engine has no pipeline for something the source
-* requires, so the source is unplayable *here* rather than broken.
+* SVTA 99 [Custom] 001 — this engine has no pipeline for something the source requires, so the source is unplayable
+* _here_ rather than broken.
 *
-* Custom rather than standard because the standard codes available describe
-* either narrower or wider things. The causes (1004/1005 unsupported format,
-* 4008 unsupported DRM) say what one rendition hit; the verdicts (2011/2012 no
-* supported track) say a type emptied without saying why it's unfixable. And
-* 2039 "Manifest feature unsupported" covers features that are unsupported but
-* still *playable* — LL-HLS degrading to standard live is a 2039 — so
-* overloading it for a fatal condition would make it useless for the notices it
-* belongs on.
+* Custom rather than standard because the standard codes available describe either narrower or wider things. The causes
+* (1004/1005 unsupported format, 4008 unsupported DRM) say what one rendition hit; the verdicts (2011/2012 no supported
+* track) say a type emptied without saying why it's unfixable. And 2039 "Manifest feature unsupported" covers features
+* that are unsupported but still _playable_ — LL-HLS degrading to standard live is a 2039 — so overloading it for a
+* fatal condition would make it useless for the notices it belongs on.
 *
-* Index `001`: the spec defines only `99000` (Unknown) for the custom category
-* and leaves the rest to the publisher, so this is the first code we define.
+* Index `001`: the spec defines only `99000` (Unknown) for the custom category and leaves the rest to the publisher, so
+* this is the first code we define.
 *
-* Five digits, and deliberately not special-cased anywhere: {@link svtaCategory}
-* and {@link svtaIndex} decompose it correctly by arithmetic alone, because
-* every standard category is below `8000` and custom starts at `99000`.
+* Five digits, and deliberately not special-cased anywhere: {@link svtaCategory} and {@link svtaIndex} decompose it
+* correctly by arithmetic alone, because every standard category is below `8000` and custom starts at `99000`.
 */
 const SVTA_UNSUPPORTED_PLAYBACK_FEATURE = 99001;
 /**
-* The error's domain — `code / 1000`, per the spec's "divide by one thousand to
-* obtain the error category". Works uniformly across the four-digit native form
-* and the five-digit form embedding an external standard: `"03404"` is
-* numerically 3404, which decomposes identically. That also makes a numeric code
-* immune to the spec's inconsistent zero-padding (§Approach writes a
-* category-unknown network error as `"0300"` where the error index implies
-* category 3 / index 000).
+* The error's domain — `code / 1000`, per the spec's "divide by one thousand to obtain the error category". Works
+* uniformly across the four-digit native form and the five-digit form embedding an external standard: `"03404"` is
+* numerically 3404, which decomposes identically. That also makes a numeric code immune to the spec's inconsistent
+* zero-padding (§Approach writes a category-unknown network error as `"0300"` where the error index implies category 3
+* / index 000).
 */
 function svtaCategory(code) {
 	return Math.floor(code / 1e3);
 }
 /**
-* The specific error within its category — `code % 1000`. For a five-digit code
-* this is the embedded external value (an HTTP status, a VAST code).
+* The specific error within its category — `code % 1000`. For a five-digit code this is the embedded external value (an
+* HTTP status, a VAST code).
 */
 function svtaIndex(code) {
 	return code % 1e3;