@videojs/spf 10.0.0-beta.3 → 10.0.0-beta.30

package/dist/default/media/dom/mse/mediasource-setup.js

@@ -0,0 +1,242 @@
+//#region src/media/dom/mse/mediasource-setup.ts
+/**
+* MediaSource Setup
+*
+* Utilities for creating and configuring MediaSource/ManagedMediaSource
+* for MSE (Media Source Extensions) playback.
+*
+* Global ManagedMediaSource types are defined in ./mediasource.d.ts
+*/
+/**
+* Check if MediaSource API is supported.
+*/
+function supportsMediaSource() {
+	return typeof MediaSource !== "undefined";
+}
+/**
+* Check if ManagedMediaSource API is supported.
+* ManagedMediaSource is a newer Safari API with better lifecycle management.
+*/
+function supportsManagedMediaSource() {
+	return typeof ManagedMediaSource !== "undefined";
+}
+/**
+* Create a MediaSource or ManagedMediaSource instance.
+*
+* @param options - Creation options
+* @returns A MediaSource or ManagedMediaSource instance
+* @throws Error if no MediaSource API is available
+*
+* @example
+* const mediaSource = createMediaSource();
+* const mediaElement = document.querySelector('video');
+* attachMediaSource(mediaSource, mediaElement);
+*/
+function createMediaSource(options = {}) {
+	const { preferManaged = false } = options;
+	if (preferManaged && supportsManagedMediaSource()) return new ManagedMediaSource();
+	if (supportsMediaSource()) return new MediaSource();
+	throw new Error("MediaSource API is not supported");
+}
+/**
+* Attach a MediaSource to an HTMLMediaElement via the `src` attribute.
+*
+* The object URL on the `src` attribute is the industry-hardened MSE attach
+* across the browser matrix, and works for ManagedMediaSource too (`srcObject`
+* buys nothing over it and forfeits the uniform URL lifecycle).
+*
+* @param mediaSource - The MediaSource to attach
+* @param mediaElement - The media element to attach to
+* @returns Object with URL and detach function
+*
+* @example
+* const mediaSource = createMediaSource();
+* const { detach } = attachMediaSource(mediaSource, videoElement);
+* // Use mediaSource...
+* // Later, to clean up:
+* detach();
+*/
+function attachMediaSource(mediaSource, mediaElement) {
+	if (supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource) mediaElement.disableRemotePlayback = true;
+	const url = URL.createObjectURL(mediaSource);
+	mediaElement.src = url;
+	const detach = ({ deferReset } = {}) => {
+		mediaElement.removeAttribute("src");
+		scheduleReset(mediaSource, mediaElement, url, deferReset);
+		URL.revokeObjectURL(url);
+	};
+	return {
+		url,
+		detach
+	};
+}
+/**
+* Attach a MediaSource as a `<source>` child element.
+*
+* The object URL rides a `<source type="video/mp4">` inserted as the
+* element's FIRST child (any bare `src` attribute is dropped; `load()`
+* re-runs resource selection). Unlike `srcObject`/`src` — which commit the
+* element to the MSE resource and ignore every `<source>` child — this
+* keeps sibling `<source>` alternatives part of resource selection, so a
+* composition can offer the element a natively-playable alternative next to
+* MSE. Canonical consumer: `setupAirPlay`'s native-HLS fallback source,
+* wired through `setupMediaSource`'s `attachMediaSource` config
+* (https://webkit.org/blog/15036/how-to-use-media-source-extensions-with-airplay/).
+*/
+function attachMediaSourceAsSourceElement(mediaSource, mediaElement) {
+	if (supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource) mediaElement.disableRemotePlayback = true;
+	const url = URL.createObjectURL(mediaSource);
+	const sourceEl = document.createElement("source");
+	sourceEl.type = "video/mp4";
+	sourceEl.src = url;
+	mediaElement.removeAttribute("src");
+	mediaElement.prepend(sourceEl);
+	mediaElement.load();
+	const detach = ({ deferReset } = {}) => {
+		sourceEl.remove();
+		scheduleReset(mediaSource, mediaElement, url, deferReset);
+		URL.revokeObjectURL(url);
+	};
+	return {
+		url,
+		detach
+	};
+}
+/**
+* Detach's `load()` reset, applied only when tearing down an **unclosed**
+* attachment the element is still committed to:
+*
+* - **Closed MediaSource**: skip. The attachment is already dead, and the
+*   element deliberately keeps whatever playback state it carries for
+*   whatever attaches next — that attach's own `load()` performs the reset.
+* - **Element moved to another resource**: skip — resetting would rip that
+*   resource out from under its owner.
+*/
+function resetIfOwnedAndNotClosed(mediaSource, mediaElement, url) {
+	if (mediaSource.readyState !== "closed" && mediaElement.currentSrc === url) mediaElement.load();
+}
+/**
+* Run the reset now, or on the next microtask when the caller has sibling
+* `<source>` owners that clear on an effect (see {@link DetachOptions.deferReset}).
+*
+* Deferring is safe because removing this attachment's own source does not by
+* itself re-run resource selection: the element stays committed to the object
+* URL until something calls `load()`, so nothing starts playing in the gap.
+*/
+function scheduleReset(mediaSource, mediaElement, url, deferReset) {
+	if (deferReset) {
+		queueMicrotask(() => resetIfOwnedAndNotClosed(mediaSource, mediaElement, url));
+		return;
+	}
+	resetIfOwnedAndNotClosed(mediaSource, mediaElement, url);
+}
+/**
+* Create a SourceBuffer on a MediaSource.
+*
+* @param mediaSource - The MediaSource (must be in 'open' state)
+* @param mimeCodec - MIME type with codecs (e.g., 'video/mp4; codecs="avc1.42E01E"')
+* @returns The created SourceBuffer
+* @throws Error if MediaSource is not open or codec is unsupported
+*
+* @example
+* const buffer = createSourceBuffer(mediaSource, 'video/mp4; codecs="avc1.42E01E"');
+*/
+function createSourceBuffer(mediaSource, mimeCodec) {
+	if (mediaSource.readyState !== "open") throw new Error("MediaSource is not open");
+	if (!isCodecSupported(mimeCodec)) throw new Error(`Codec not supported: ${mimeCodec}`);
+	return mediaSource.addSourceBuffer(mimeCodec);
+}
+/**
+* Build a MIME codec string from a track's `mimeType` + `codecs`. Works
+* on partially-resolved tracks — both fields come from the multivariant
+* playlist and are available before media-playlist resolution.
+*
+* @param track - Track carrying `mimeType` and `codecs`
+* @returns MIME codec string suitable for `MediaSource.addSourceBuffer`
+*
+* @example
+* buildMimeCodec({ mimeType: 'video/mp4', codecs: ['avc1.42E01E'] })
+* // => 'video/mp4; codecs="avc1.42E01E"'
+*/
+function buildMimeCodec(track) {
+	const codecString = track.codecs?.join(",") ?? "";
+	return `${track.mimeType}; codecs="${codecString}"`;
+}
+/**
+* Check if a codec is supported.
+*
+* @param mimeCodec - MIME type with codecs string
+* @returns True if the codec is supported
+*
+* @example
+* if (isCodecSupported('video/mp4; codecs="avc1.42E01E"')) {
+*   // Create source buffer
+* }
+*/
+function isCodecSupported(mimeCodec) {
+	if (!supportsMediaSource()) return false;
+	return MediaSource.isTypeSupported(mimeCodec);
+}
+/**
+* Observe `mediaSource.readyState` changes via DOM events.
+*
+* Listens to `sourceopen`, `sourceended`, and `sourceclose` and invokes
+* `onChange` with the current `readyState` after each event. Listeners
+* are automatically removed when `abortSignal` is aborted.
+*
+* @param mediaSource - The MediaSource to observe
+* @param abortSignal - AbortSignal that controls listener lifetime
+* @param onChange - Called with the current readyState after each change
+*
+* @example
+* const controller = new AbortController();
+* onMediaSourceReadyStateChange(mediaSource, controller.signal, (state) => {
+*   if (state === 'open') { ... }
+* });
+* // Later: controller.abort();
+*/
+function onMediaSourceReadyStateChange(mediaSource, abortSignal, onChange) {
+	const update = () => onChange(mediaSource.readyState);
+	const options = { signal: abortSignal };
+	mediaSource.addEventListener("sourceopen", update, options);
+	mediaSource.addEventListener("sourceended", update, options);
+	mediaSource.addEventListener("sourceclose", update, options);
+}
+/**
+* Wait until `mediaSource.readyState` transitions away from `'closed'`
+* (the next `sourceopen`/`sourceended`/`sourceclose` event), or until
+* `signal` aborts — whichever fires first.
+*
+* Resolves immediately when `readyState` is already `'open'` or `'ended'`
+* (no further transition is coming, so there's nothing to wait for). The
+* caller is expected to re-check `readyState` after the await to
+* distinguish `'open'` from terminal states.
+*
+* Companion to `onMediaSourceReadyStateChange` for one-shot use in async
+* sequences (e.g., a behavior's reactor entry that needs to wait for the
+* MediaSource to attach before performing a spec-conforming mutation).
+*
+* @example
+* await waitForMediaSourceOpen(mediaSource, signal);
+* if (signal.aborted || mediaSource.readyState !== 'open') return;
+* // safe to perform 'open'-state-only work
+*/
+function waitForMediaSourceOpen(mediaSource, signal) {
+	if (signal.aborted) return Promise.resolve();
+	if (mediaSource.readyState !== "closed") return Promise.resolve();
+	return new Promise((resolve) => {
+		const done = () => resolve();
+		const options = {
+			once: true,
+			signal
+		};
+		mediaSource.addEventListener("sourceopen", done, options);
+		mediaSource.addEventListener("sourceended", done, options);
+		mediaSource.addEventListener("sourceclose", done, options);
+		signal.addEventListener("abort", done, { once: true });
+	});
+}
+//#endregion
+export { attachMediaSource, attachMediaSourceAsSourceElement, buildMimeCodec, createMediaSource, createSourceBuffer, isCodecSupported, onMediaSourceReadyStateChange, supportsManagedMediaSource, supportsMediaSource, waitForMediaSourceOpen };
+
+//# sourceMappingURL=mediasource-setup.js.map

package/dist/default/media/dom/mse/mediasource-setup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediasource-setup.js","names":[],"sources":["../../../../../src/media/dom/mse/mediasource-setup.ts"],"sourcesContent":["/**\n * MediaSource Setup\n *\n * Utilities for creating and configuring MediaSource/ManagedMediaSource\n * for MSE (Media Source Extensions) playback.\n *\n * Global ManagedMediaSource types are defined in ./mediasource.d.ts\n */\n\n/**\n * Check if MediaSource API is supported.\n */\nexport function supportsMediaSource(): boolean {\n  return typeof MediaSource !== 'undefined';\n}\n\n/**\n * Check if ManagedMediaSource API is supported.\n * ManagedMediaSource is a newer Safari API with better lifecycle management.\n */\nexport function supportsManagedMediaSource(): boolean {\n  return typeof ManagedMediaSource !== 'undefined';\n}\n\n/**\n * Options for creating a MediaSource.\n */\nexport interface CreateMediaSourceOptions {\n  /** Prefer ManagedMediaSource when available (default: false for broader compatibility). */\n  preferManaged?: boolean;\n}\n\n/**\n * Create a MediaSource or ManagedMediaSource instance.\n *\n * @param options - Creation options\n * @returns A MediaSource or ManagedMediaSource instance\n * @throws Error if no MediaSource API is available\n *\n * @example\n * const mediaSource = createMediaSource();\n * const mediaElement = document.querySelector('video');\n * attachMediaSource(mediaSource, mediaElement);\n */\nexport function createMediaSource(options: CreateMediaSourceOptions = {}): MediaSource {\n  const { preferManaged = false } = options;\n\n  if (preferManaged && supportsManagedMediaSource()) {\n    return new ManagedMediaSource!();\n  }\n\n  if (supportsMediaSource()) {\n    return new MediaSource();\n  }\n\n  throw new Error('MediaSource API is not supported');\n}\n\n/**\n * Options for `detach`.\n */\nexport interface DetachOptions {\n  /**\n   * Run the `load()` reset on the next microtask instead of synchronously.\n   *\n   * Required whenever another owner contributes sibling `<source>` children to\n   * the same element and drops them from a signal effect: effects re-run on a\n   * microtask, so a synchronous reset would run resource selection while those\n   * siblings are still in the DOM and commit the element to one of them.\n   * Canonical caller: `setupMediaSource`, whose compositions may include\n   * `setupAirPlay`'s native-HLS fallback source.\n   *\n   * The ownership guard is evaluated when the reset actually fires, so a\n   * re-attach landing in the interim correctly suppresses it.\n   */\n  deferReset?: boolean;\n}\n\n/**\n * Result of attaching a MediaSource to a media element.\n */\nexport interface AttachMediaSourceResult {\n  /** The object URL created for the MediaSource. */\n  url: string;\n  /** Detach the MediaSource and clean up resources. */\n  detach: (options?: DetachOptions) => void;\n}\n\n/**\n * Attach a MediaSource to an HTMLMediaElement via the `src` attribute.\n *\n * The object URL on the `src` attribute is the industry-hardened MSE attach\n * across the browser matrix, and works for ManagedMediaSource too (`srcObject`\n * buys nothing over it and forfeits the uniform URL lifecycle).\n *\n * @param mediaSource - The MediaSource to attach\n * @param mediaElement - The media element to attach to\n * @returns Object with URL and detach function\n *\n * @example\n * const mediaSource = createMediaSource();\n * const { detach } = attachMediaSource(mediaSource, videoElement);\n * // Use mediaSource...\n * // Later, to clean up:\n * detach();\n */\nexport function attachMediaSource(mediaSource: MediaSource, mediaElement: HTMLMediaElement): AttachMediaSourceResult {\n  // ManagedMediaSource requires disableRemotePlayback — without it Safari\n  // will not fire sourceopen. (MMS-only: on other platforms the flag governs\n  // the standard Remote Playback API and must be left alone.)\n  if (supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource!) {\n    mediaElement.disableRemotePlayback = true;\n  }\n\n  const url = URL.createObjectURL(mediaSource);\n  mediaElement.src = url;\n\n  const detach = ({ deferReset }: DetachOptions = {}): void => {\n    mediaElement.removeAttribute('src');\n    scheduleReset(mediaSource, mediaElement, url, deferReset);\n    URL.revokeObjectURL(url);\n  };\n\n  return { url, detach };\n}\n\n/**\n * Attach a MediaSource as a `<source>` child element.\n *\n * The object URL rides a `<source type=\"video/mp4\">` inserted as the\n * element's FIRST child (any bare `src` attribute is dropped; `load()`\n * re-runs resource selection). Unlike `srcObject`/`src` — which commit the\n * element to the MSE resource and ignore every `<source>` child — this\n * keeps sibling `<source>` alternatives part of resource selection, so a\n * composition can offer the element a natively-playable alternative next to\n * MSE. Canonical consumer: `setupAirPlay`'s native-HLS fallback source,\n * wired through `setupMediaSource`'s `attachMediaSource` config\n * (https://webkit.org/blog/15036/how-to-use-media-source-extensions-with-airplay/).\n */\nexport function attachMediaSourceAsSourceElement(\n  mediaSource: MediaSource,\n  mediaElement: HTMLMediaElement\n): AttachMediaSourceResult {\n  // ManagedMediaSource requires disableRemotePlayback — without it Safari\n  // will not fire sourceopen. (MMS-only: on other platforms the flag governs\n  // the standard Remote Playback API and must be left alone.) Features that\n  // need it false flip it once the source is open.\n  if (supportsManagedMediaSource() && mediaSource instanceof ManagedMediaSource!) {\n    mediaElement.disableRemotePlayback = true;\n  }\n\n  const url = URL.createObjectURL(mediaSource);\n  const sourceEl = document.createElement('source');\n  sourceEl.type = 'video/mp4';\n  sourceEl.src = url;\n\n  mediaElement.removeAttribute('src');\n  mediaElement.prepend(sourceEl);\n  mediaElement.load();\n\n  const detach = ({ deferReset }: DetachOptions = {}): void => {\n    sourceEl.remove();\n    scheduleReset(mediaSource, mediaElement, url, deferReset);\n    URL.revokeObjectURL(url);\n  };\n\n  return { url, detach };\n}\n\n/**\n * Detach's `load()` reset, applied only when tearing down an **unclosed**\n * attachment the element is still committed to:\n *\n * - **Closed MediaSource**: skip. The attachment is already dead, and the\n *   element deliberately keeps whatever playback state it carries for\n *   whatever attaches next — that attach's own `load()` performs the reset.\n * - **Element moved to another resource**: skip — resetting would rip that\n *   resource out from under its owner.\n */\nfunction resetIfOwnedAndNotClosed(mediaSource: MediaSource, mediaElement: HTMLMediaElement, url: string): void {\n  if (mediaSource.readyState !== 'closed' && mediaElement.currentSrc === url) {\n    mediaElement.load();\n  }\n}\n\n/**\n * Run the reset now, or on the next microtask when the caller has sibling\n * `<source>` owners that clear on an effect (see {@link DetachOptions.deferReset}).\n *\n * Deferring is safe because removing this attachment's own source does not by\n * itself re-run resource selection: the element stays committed to the object\n * URL until something calls `load()`, so nothing starts playing in the gap.\n */\nfunction scheduleReset(\n  mediaSource: MediaSource,\n  mediaElement: HTMLMediaElement,\n  url: string,\n  deferReset: boolean | undefined\n): void {\n  if (deferReset) {\n    queueMicrotask(() => resetIfOwnedAndNotClosed(mediaSource, mediaElement, url));\n    return;\n  }\n  resetIfOwnedAndNotClosed(mediaSource, mediaElement, url);\n}\n\n/**\n * Create a SourceBuffer on a MediaSource.\n *\n * @param mediaSource - The MediaSource (must be in 'open' state)\n * @param mimeCodec - MIME type with codecs (e.g., 'video/mp4; codecs=\"avc1.42E01E\"')\n * @returns The created SourceBuffer\n * @throws Error if MediaSource is not open or codec is unsupported\n *\n * @example\n * const buffer = createSourceBuffer(mediaSource, 'video/mp4; codecs=\"avc1.42E01E\"');\n */\nexport function createSourceBuffer(mediaSource: MediaSource, mimeCodec: string): SourceBuffer {\n  if (mediaSource.readyState !== 'open') {\n    throw new Error('MediaSource is not open');\n  }\n\n  if (!isCodecSupported(mimeCodec)) {\n    throw new Error(`Codec not supported: ${mimeCodec}`);\n  }\n\n  return mediaSource.addSourceBuffer(mimeCodec);\n}\n\n/**\n * Build a MIME codec string from a track's `mimeType` + `codecs`. Works\n * on partially-resolved tracks — both fields come from the multivariant\n * playlist and are available before media-playlist resolution.\n *\n * @param track - Track carrying `mimeType` and `codecs`\n * @returns MIME codec string suitable for `MediaSource.addSourceBuffer`\n *\n * @example\n * buildMimeCodec({ mimeType: 'video/mp4', codecs: ['avc1.42E01E'] })\n * // => 'video/mp4; codecs=\"avc1.42E01E\"'\n */\nexport function buildMimeCodec(track: { mimeType: string; codecs?: string[] }): string {\n  const codecString = track.codecs?.join(',') ?? '';\n  return `${track.mimeType}; codecs=\"${codecString}\"`;\n}\n\n/**\n * Check if a codec is supported.\n *\n * @param mimeCodec - MIME type with codecs string\n * @returns True if the codec is supported\n *\n * @example\n * if (isCodecSupported('video/mp4; codecs=\"avc1.42E01E\"')) {\n *   // Create source buffer\n * }\n */\nexport function isCodecSupported(mimeCodec: string): boolean {\n  if (!supportsMediaSource()) {\n    return false;\n  }\n\n  return MediaSource.isTypeSupported(mimeCodec);\n}\n\n/**\n * Observe `mediaSource.readyState` changes via DOM events.\n *\n * Listens to `sourceopen`, `sourceended`, and `sourceclose` and invokes\n * `onChange` with the current `readyState` after each event. Listeners\n * are automatically removed when `abortSignal` is aborted.\n *\n * @param mediaSource - The MediaSource to observe\n * @param abortSignal - AbortSignal that controls listener lifetime\n * @param onChange - Called with the current readyState after each change\n *\n * @example\n * const controller = new AbortController();\n * onMediaSourceReadyStateChange(mediaSource, controller.signal, (state) => {\n *   if (state === 'open') { ... }\n * });\n * // Later: controller.abort();\n */\nexport function onMediaSourceReadyStateChange(\n  mediaSource: MediaSource,\n  abortSignal: AbortSignal,\n  onChange: (readyState: MediaSource['readyState']) => void\n): void {\n  const update = () => onChange(mediaSource.readyState);\n  const options = { signal: abortSignal };\n  mediaSource.addEventListener('sourceopen', update, options);\n  mediaSource.addEventListener('sourceended', update, options);\n  mediaSource.addEventListener('sourceclose', update, options);\n}\n\n/**\n * Wait until `mediaSource.readyState` transitions away from `'closed'`\n * (the next `sourceopen`/`sourceended`/`sourceclose` event), or until\n * `signal` aborts — whichever fires first.\n *\n * Resolves immediately when `readyState` is already `'open'` or `'ended'`\n * (no further transition is coming, so there's nothing to wait for). The\n * caller is expected to re-check `readyState` after the await to\n * distinguish `'open'` from terminal states.\n *\n * Companion to `onMediaSourceReadyStateChange` for one-shot use in async\n * sequences (e.g., a behavior's reactor entry that needs to wait for the\n * MediaSource to attach before performing a spec-conforming mutation).\n *\n * @example\n * await waitForMediaSourceOpen(mediaSource, signal);\n * if (signal.aborted || mediaSource.readyState !== 'open') return;\n * // safe to perform 'open'-state-only work\n */\nexport function waitForMediaSourceOpen(mediaSource: MediaSource, signal: AbortSignal): Promise<void> {\n  if (signal.aborted) return Promise.resolve();\n  if (mediaSource.readyState !== 'closed') return Promise.resolve();\n\n  return new Promise<void>((resolve) => {\n    const done = () => resolve();\n    const options = { once: true, signal };\n    mediaSource.addEventListener('sourceopen', done, options);\n    mediaSource.addEventListener('sourceended', done, options);\n    mediaSource.addEventListener('sourceclose', done, options);\n    signal.addEventListener('abort', done, { once: true });\n  });\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgB,sBAA+B;CAC7C,OAAO,OAAO,gBAAgB;AAChC;;;;;AAMA,SAAgB,6BAAsC;CACpD,OAAO,OAAO,uBAAuB;AACvC;;;;;;;;;;;;;AAsBA,SAAgB,kBAAkB,UAAoC,CAAC,GAAgB;CACrF,MAAM,EAAE,gBAAgB,UAAU;CAElC,IAAI,iBAAiB,2BAA2B,GAC9C,OAAO,IAAI,mBAAoB;CAGjC,IAAI,oBAAoB,GACtB,OAAO,IAAI,YAAY;CAGzB,MAAM,IAAI,MAAM,kCAAkC;AACpD;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,kBAAkB,aAA0B,cAAyD;CAInH,IAAI,2BAA2B,KAAK,uBAAuB,oBACzD,aAAa,wBAAwB;CAGvC,MAAM,MAAM,IAAI,gBAAgB,WAAW;CAC3C,aAAa,MAAM;CAEnB,MAAM,UAAU,EAAE,eAA8B,CAAC,MAAY;EAC3D,aAAa,gBAAgB,KAAK;EAClC,cAAc,aAAa,cAAc,KAAK,UAAU;EACxD,IAAI,gBAAgB,GAAG;CACzB;CAEA,OAAO;EAAE;EAAK;CAAO;AACvB;;;;;;;;;;;;;;AAeA,SAAgB,iCACd,aACA,cACyB;CAKzB,IAAI,2BAA2B,KAAK,uBAAuB,oBACzD,aAAa,wBAAwB;CAGvC,MAAM,MAAM,IAAI,gBAAgB,WAAW;CAC3C,MAAM,WAAW,SAAS,cAAc,QAAQ;CAChD,SAAS,OAAO;CAChB,SAAS,MAAM;CAEf,aAAa,gBAAgB,KAAK;CAClC,aAAa,QAAQ,QAAQ;CAC7B,aAAa,KAAK;CAElB,MAAM,UAAU,EAAE,eAA8B,CAAC,MAAY;EAC3D,SAAS,OAAO;EAChB,cAAc,aAAa,cAAc,KAAK,UAAU;EACxD,IAAI,gBAAgB,GAAG;CACzB;CAEA,OAAO;EAAE;EAAK;CAAO;AACvB;;;;;;;;;;;AAYA,SAAS,yBAAyB,aAA0B,cAAgC,KAAmB;CAC7G,IAAI,YAAY,eAAe,YAAY,aAAa,eAAe,KACrE,aAAa,KAAK;AAEtB;;;;;;;;;AAUA,SAAS,cACP,aACA,cACA,KACA,YACM;CACN,IAAI,YAAY;EACd,qBAAqB,yBAAyB,aAAa,cAAc,GAAG,CAAC;EAC7E;CACF;CACA,yBAAyB,aAAa,cAAc,GAAG;AACzD;;;;;;;;;;;;AAaA,SAAgB,mBAAmB,aAA0B,WAAiC;CAC5F,IAAI,YAAY,eAAe,QAC7B,MAAM,IAAI,MAAM,yBAAyB;CAG3C,IAAI,CAAC,iBAAiB,SAAS,GAC7B,MAAM,IAAI,MAAM,wBAAwB,WAAW;CAGrD,OAAO,YAAY,gBAAgB,SAAS;AAC9C;;;;;;;;;;;;;AAcA,SAAgB,eAAe,OAAwD;CACrF,MAAM,cAAc,MAAM,QAAQ,KAAK,GAAG,KAAK;CAC/C,OAAO,GAAG,MAAM,SAAS,YAAY,YAAY;AACnD;;;;;;;;;;;;AAaA,SAAgB,iBAAiB,WAA4B;CAC3D,IAAI,CAAC,oBAAoB,GACvB,OAAO;CAGT,OAAO,YAAY,gBAAgB,SAAS;AAC9C;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,8BACd,aACA,aACA,UACM;CACN,MAAM,eAAe,SAAS,YAAY,UAAU;CACpD,MAAM,UAAU,EAAE,QAAQ,YAAY;CACtC,YAAY,iBAAiB,cAAc,QAAQ,OAAO;CAC1D,YAAY,iBAAiB,eAAe,QAAQ,OAAO;CAC3D,YAAY,iBAAiB,eAAe,QAAQ,OAAO;AAC7D;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,uBAAuB,aAA0B,QAAoC;CACnG,IAAI,OAAO,SAAS,OAAO,QAAQ,QAAQ;CAC3C,IAAI,YAAY,eAAe,UAAU,OAAO,QAAQ,QAAQ;CAEhE,OAAO,IAAI,SAAe,YAAY;EACpC,MAAM,aAAa,QAAQ;EAC3B,MAAM,UAAU;GAAE,MAAM;GAAM;EAAO;EACrC,YAAY,iBAAiB,cAAc,MAAM,OAAO;EACxD,YAAY,iBAAiB,eAAe,MAAM,OAAO;EACzD,YAAY,iBAAiB,eAAe,MAAM,OAAO;EACzD,OAAO,iBAAiB,SAAS,MAAM,EAAE,MAAM,KAAK,CAAC;CACvD,CAAC;AACH"}

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

@@ -0,0 +1,112 @@
+import { scaleResolution } from "../primitives/resolution.js";
+import { getDevicePixelRatio, listen, watchDevicePixelRatio } from "@videojs/utils/dom";
+import { isFunction } from "@videojs/utils/predicate";
+import { shallowEqual } from "@videojs/utils/object";
+//#region src/media/dom/screen.ts
+/**
+* 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
+* 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 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.
+*
+* 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;
+	if (!screen) return void 0;
+	return scaleResolution(screen, useDevicePixelRatio ? getDevicePixelRatio() : 1);
+}
+/**
+* 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.
+*
+* `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.
+*
+*   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.
+*/
+function watchScreenResolution(onChange, options = { useDevicePixelRatio: true }) {
+	const disconnect = new AbortController();
+	const { signal } = disconnect;
+	let current = getScreenResolution(options);
+	const check = () => {
+		const next = getScreenResolution(options);
+		if (shallowEqual(current, next)) return;
+		current = next;
+		onChange(next);
+	};
+	onChange(current);
+	watchDevicePixelRatio(check, signal);
+	const screen = globalThis.screen;
+	const orientation = screen?.orientation;
+	if (globalThis.window) listen(globalThis.window, "resize", check, { signal });
+	if (isEventTarget(screen)) listen(screen, "change", check, { signal });
+	if (orientation) listen(orientation, "change", check, { signal });
+	return () => disconnect.abort();
+}
+function isEventTarget(value) {
+	return isFunction(value?.addEventListener);
+}
+//#endregion
+export { getScreenResolution, watchScreenResolution };
+
+//# sourceMappingURL=screen.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,50 @@
+//#region src/media/dom/text/resolve-vtt-segment.ts
+let dummyVideo = null;
+function ensureDummyVideo() {
+	if (!dummyVideo) {
+		dummyVideo = document.createElement("video");
+		dummyVideo.muted = true;
+		dummyVideo.preload = "none";
+		dummyVideo.style.display = "none";
+		dummyVideo.crossOrigin = "anonymous";
+	}
+	return dummyVideo;
+}
+function resolveVttSegment(url) {
+	const video = ensureDummyVideo();
+	const track = document.createElement("track");
+	track.kind = "subtitles";
+	return new Promise((resolve, reject) => {
+		const onLoad = () => {
+			const cues = [];
+			const textTrack = track.track;
+			if (textTrack.cues) for (let i = 0; i < textTrack.cues.length; i++) {
+				const cue = textTrack.cues[i];
+				if (cue) cues.push(cue);
+			}
+			cleanup();
+			resolve(cues);
+		};
+		const onError = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`Failed to load VTT segment: ${url}`));
+		};
+		const cleanup = () => {
+			track.removeEventListener("load", onLoad);
+			track.removeEventListener("error", onError);
+			video.removeChild(track);
+		};
+		track.addEventListener("load", onLoad);
+		track.addEventListener("error", onError);
+		video.appendChild(track);
+		track.track.mode = "hidden";
+		track.src = url;
+	});
+}
+function destroyVttResolver() {
+	dummyVideo = null;
+}
+//#endregion
+export { destroyVttResolver, resolveVttSegment };
+
+//# sourceMappingURL=resolve-vtt-segment.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,69 @@
+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.
+*/
+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`.
+*/
+function addSubtitlesTracksToMedia(mediaElement, modelTextTracks) {
+	for (const modelTrack of modelTextTracks) {
+		const el = document.createElement("track");
+		el.id = modelTrack.id;
+		el.kind = modelTrack.kind;
+		el.label = modelTrack.label;
+		el.toggleAttribute("data-src-track", true);
+		if (modelTrack.language) el.srclang = modelTrack.language;
+		mediaElement.appendChild(el);
+	}
+}
+/**
+* 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);
+	for (const el of elements) {
+		const track = el.track;
+		if (track.mode === "showing" && isCaptionOrSubtitleTrack(track)) return track;
+	}
+}
+/**
+* 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.
+*/
+function syncTextTrackModes(textTracks, selectedId) {
+	for (let i = 0; i < textTracks.length; i++) {
+		const track = textTracks[i];
+		if (!isCaptionOrSubtitleTrack(track)) continue;
+		track.mode = track.id === selectedId ? "showing" : "disabled";
+	}
+}
+//#endregion
+export { addSubtitlesTracksToMedia, getShowingSubtitlesTrackFromMedia, removeAllSubtitlesTracksFromMedia, syncTextTrackModes };
+
+//# sourceMappingURL=text-track-slots.js.map

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

@@ -0,0 +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"}

package/dist/default/media/errors.js

@@ -0,0 +1,69 @@
+//#region src/media/errors.ts
+/** SVTA 1 [Media Content] 004 — the video is in a format we can't play (e.g. an MPEG-TS container). */
+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.
+*/
+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.
+*/
+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.
+*
+* 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.
+*
+* 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).
+*/
+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).
+*/
+function svtaIndex(code) {
+	return code % 1e3;
+}
+//#endregion
+export { SVTA_NO_SUPPORTED_AUDIO_TRACK, SVTA_NO_SUPPORTED_VIDEO_TRACK, SVTA_UNSUPPORTED_AUDIO_FORMAT, SVTA_UNSUPPORTED_DRM_SYSTEM, SVTA_UNSUPPORTED_PLAYBACK_FEATURE, SVTA_UNSUPPORTED_VIDEO_FORMAT, svtaCategory, svtaIndex };
+
+//# sourceMappingURL=errors.js.map

package/dist/default/media/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../../../src/media/errors.ts"],"sourcesContent":["/**\n * SVTA 2070 (Standardized Error Codes) — the vocabulary for identifying a\n * playback failure or notice, independent of how it's transported or who\n * decides what to do about it.\n *\n * A code is a single integer: the leading digit(s) are the **category** (the\n * error's domain) and the trailing three are the **index** (the specific error\n * within it). Four digits for natively-defined errors, five when an external\n * standard is embedded — `\"03404\"` is an HTTP 404 under the network category.\n * Categories are `0` unknown, `1` media content, `2` playback, `3` network,\n * `4` content protection, `5` accessibility, `6` remote play, `7` advertising,\n * `99` custom.\n *\n * Two properties of the spec shape the types here:\n *\n * - **Severity is deliberately not part of a code.** Per §Approach, \"impact\n *   varies with player implementation, breaking the consistency of a specific\n *   error mapping to single code.\" So an error carries no fatal flag — whether a\n *   condition is fatal depends on the composition observing it, and is decided\n *   downstream.\n * - **Reporting is partial and stacked** (Principles 5–6). Errors are reported\n *   as encountered, most of them non-fatal, and the *sequence* carries causation\n *   a single value can't.\n *\n * See `internal/design/spf/features/errors.md`.\n */\n\n/**\n * A reported condition, identified by its SVTA code.\n *\n * Named for the spec rather than the engine because the vocabulary is\n * format- and player-neutral. Not `MediaError` — that name belongs to the\n * `@videojs/media` DOM-facing class this eventually maps *onto*, and the mapping\n * is the point at which severity and user-facing text get decided.\n */\nexport interface SvtaError {\n  /** The SVTA code — see {@link svtaCategory} / {@link svtaIndex}. */\n  code: number;\n  /** Engineer-facing detail. Optional; the code is the identity. */\n  message?: string;\n  /** Reporter-specific context (track type, url, the constraint that fired). */\n  data?: unknown;\n}\n\n/** SVTA 1 [Media Content] 004 — the video is in a format we can't play (e.g. an MPEG-TS container). */\nexport const SVTA_UNSUPPORTED_VIDEO_FORMAT = 1004;\n\n/** SVTA 1 [Media Content] 005 — the audio counterpart of {@link SVTA_UNSUPPORTED_VIDEO_FORMAT}. */\nexport const SVTA_UNSUPPORTED_AUDIO_FORMAT = 1005;\n\n/**\n * SVTA 4 [Content Protection] 008 — unsupported or unavailable DRM system. Used\n * for \"this source is encrypted and we have no decryption pipeline,\" which is\n * detection, not a license failure.\n */\nexport const SVTA_UNSUPPORTED_DRM_SYSTEM = 4008;\n\n/**\n * SVTA 2 [Playback] 011 — no video track the environment can play.\n *\n * Covers both ways a composition can end up with nothing to select: renditions\n * that existed and were all excluded as unplayable, and — where the composition\n * composes `reportAbsentTrackType` to say it needs the type — a source carrying\n * none to begin with. Deliberately one code for both, because they are the same\n * answer to a viewer, and because the alternative is a code the SVTA spec doesn't\n * define. Whether an absent type is a failure is the composition's to state,\n * which is why it opts in rather than being read off the source.\n */\nexport const SVTA_NO_SUPPORTED_VIDEO_TRACK = 2011;\n\n/** SVTA 2 [Playback] 012 — the audio counterpart of {@link SVTA_NO_SUPPORTED_VIDEO_TRACK}. */\nexport const SVTA_NO_SUPPORTED_AUDIO_TRACK = 2012;\n\n/**\n * SVTA 99 [Custom] 001 — this engine has no pipeline for something the source\n * requires, so the source is unplayable *here* rather than broken.\n *\n * Custom rather than standard because the standard codes available describe\n * either narrower or wider things. The causes (1004/1005 unsupported format,\n * 4008 unsupported DRM) say what one rendition hit; the verdicts (2011/2012 no\n * supported track) say a type emptied without saying why it's unfixable. And\n * 2039 \"Manifest feature unsupported\" covers features that are unsupported but\n * still *playable* — LL-HLS degrading to standard live is a 2039 — so\n * overloading it for a fatal condition would make it useless for the notices it\n * belongs on.\n *\n * Index `001`: the spec defines only `99000` (Unknown) for the custom category\n * and leaves the rest to the publisher, so this is the first code we define.\n *\n * Five digits, and deliberately not special-cased anywhere: {@link svtaCategory}\n * and {@link svtaIndex} decompose it correctly by arithmetic alone, because\n * every standard category is below `8000` and custom starts at `99000`.\n */\nexport const SVTA_UNSUPPORTED_PLAYBACK_FEATURE = 99001;\n\n/**\n * The error's domain — `code / 1000`, per the spec's \"divide by one thousand to\n * obtain the error category\". Works uniformly across the four-digit native form\n * and the five-digit form embedding an external standard: `\"03404\"` is\n * numerically 3404, which decomposes identically. That also makes a numeric code\n * immune to the spec's inconsistent zero-padding (§Approach writes a\n * category-unknown network error as `\"0300\"` where the error index implies\n * category 3 / index 000).\n */\nexport function svtaCategory(code: number): number {\n  return Math.floor(code / 1000);\n}\n\n/**\n * The specific error within its category — `code % 1000`. For a five-digit code\n * this is the embedded external value (an HTTP status, a VAST code).\n */\nexport function svtaIndex(code: number): number {\n  return code % 1000;\n}\n"],"mappings":";;AA6CA,MAAa,gCAAgC;;AAG7C,MAAa,gCAAgC;;;;;;AAO7C,MAAa,8BAA8B;;;;;;;;;;;;AAa3C,MAAa,gCAAgC;;AAG7C,MAAa,gCAAgC;;;;;;;;;;;;;;;;;;;;;AAsB7C,MAAa,oCAAoC;;;;;;;;;;AAWjD,SAAgB,aAAa,MAAsB;CACjD,OAAO,KAAK,MAAM,OAAO,GAAI;AAC/B;;;;;AAMA,SAAgB,UAAU,MAAsB;CAC9C,OAAO,OAAO;AAChB"}