@videojs/spf 10.0.0-beta.9 → 10.0.0-rc.1

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

@@ -0,0 +1,227 @@
+//#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.
+*
+* @example
+*   const mediaSource = createMediaSource();
+*   const mediaElement = document.querySelector('video');
+*   attachMediaSource(mediaSource, mediaElement);
+*
+* @param options - Creation options
+* @returns A MediaSource or ManagedMediaSource instance
+* @throws Error if no MediaSource API is available
+*/
+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).
+*
+* @example
+*   const mediaSource = createMediaSource();
+*   const { detach } = attachMediaSource(mediaSource, videoElement);
+*   // Use mediaSource...
+*   // Later, to clean up:
+*   detach();
+*
+* @param mediaSource - The MediaSource to attach
+* @param mediaElement - The media element to attach to
+* @returns Object with URL and detach function
+*/
+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.
+*
+* @example
+*   const buffer = createSourceBuffer(mediaSource, 'video/mp4; codecs="avc1.42E01E"');
+*
+* @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
+*/
+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.
+*
+* @example
+*   buildMimeCodec({ mimeType: 'video/mp4', codecs: ['avc1.42E01E'] });
+*   // => 'video/mp4; codecs="avc1.42E01E"'
+*
+* @param track - Track carrying `mimeType` and `codecs`
+* @returns MIME codec string suitable for `MediaSource.addSourceBuffer`
+*/
+function buildMimeCodec(track) {
+	const codecString = track.codecs?.join(",") ?? "";
+	return `${track.mimeType}; codecs="${codecString}"`;
+}
+/**
+* Check if a codec is supported.
+*
+* @example
+*   if (isCodecSupported('video/mp4; codecs="avc1.42E01E"')) {
+*     // Create source buffer
+*   }
+*
+* @param mimeCodec - MIME type with codecs string
+* @returns True if the codec is supported
+*/
+function isCodecSupported(mimeCodec) {
+	if (supportsMediaSource()) return MediaSource.isTypeSupported(mimeCodec);
+	if (supportsManagedMediaSource()) return ManagedMediaSource.isTypeSupported(mimeCodec);
+	return false;
+}
+/**
+* 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.
+*
+* @example
+*   const controller = new AbortController();
+*   onMediaSourceReadyStateChange(mediaSource, controller.signal, (state) => {
+*   if (state === 'open') { ... }
+*   });
+*   // Later: controller.abort();
+*
+* @param mediaSource - The MediaSource to observe
+* @param abortSignal - AbortSignal that controls listener lifetime
+* @param onChange - Called with the current readyState after each change
+*/
+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 for MSE (Media Source Extensions) playback.\n *\n * Global ManagedMediaSource types are defined in ./mediasource.d.ts\n */\n\n/** Check if MediaSource API is supported. */\nexport function supportsMediaSource(): boolean {\n  return typeof MediaSource !== 'undefined';\n}\n\n/**\n * Check if ManagedMediaSource API is supported. ManagedMediaSource is a newer Safari API with better lifecycle\n * management.\n */\nexport function supportsManagedMediaSource(): boolean {\n  return typeof ManagedMediaSource !== 'undefined';\n}\n\n/** Options for creating a MediaSource. */\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 * @example\n *   const mediaSource = createMediaSource();\n *   const mediaElement = document.querySelector('video');\n *   attachMediaSource(mediaSource, mediaElement);\n *\n * @param options - Creation options\n * @returns A MediaSource or ManagedMediaSource instance\n * @throws Error if no MediaSource API is available\n */\nexport function createMediaSource(options: CreateMediaSourceOptions = {}): MediaSource {\n  const { preferManaged = false } = options;\n  if (preferManaged && supportsManagedMediaSource()) return new ManagedMediaSource!();\n\n  if (supportsMediaSource()) {\n    return new MediaSource();\n  }\n\n  throw new Error('MediaSource API is not supported');\n}\n\n/** Options for `detach`. */\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 the same element and drops them from a\n   * signal effect: effects re-run on a 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. Canonical caller: `setupMediaSource`, whose\n   * compositions may include `setupAirPlay`'s native-HLS fallback source.\n   *\n   * The ownership guard is evaluated when the reset actually fires, so a re-attach landing in the interim correctly\n   * suppresses it.\n   */\n  deferReset?: boolean;\n}\n\n/** Result of attaching a MediaSource to a media element. */\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 across the browser matrix, and works for\n * ManagedMediaSource too (`srcObject` buys nothing over it and forfeits the uniform URL lifecycle).\n *\n * @example\n *   const mediaSource = createMediaSource();\n *   const { detach } = attachMediaSource(mediaSource, videoElement);\n *   // Use mediaSource...\n *   // Later, to clean up:\n *   detach();\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 */\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\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 element's FIRST child (any bare `src` attribute is\n * dropped; `load()` re-runs resource selection). Unlike `srcObject`/`src` — which commit the element to the MSE\n * resource and ignore every `<source>` child — this keeps sibling `<source>` alternatives part of resource selection,\n * so a composition can offer the element a natively-playable alternative next to MSE. Canonical consumer:\n * `setupAirPlay`'s native-HLS fallback source, 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\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** attachment the element is still committed to:\n *\n * - **Closed MediaSource**: skip. The attachment is already dead, and the element deliberately keeps whatever playback\n *   state it carries for whatever attaches next — that attach's own `load()` performs the reset.\n * - **Element moved to another resource**: skip — resetting would rip that 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 `<source>` owners that clear on an effect\n * (see {@link DetachOptions.deferReset}).\n *\n * Deferring is safe because removing this attachment's own source does not by itself re-run resource selection: the\n * element stays committed to the object 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\n  resetIfOwnedAndNotClosed(mediaSource, mediaElement, url);\n}\n\n/**\n * Create a SourceBuffer on a MediaSource.\n *\n * @example\n *   const buffer = createSourceBuffer(mediaSource, 'video/mp4; codecs=\"avc1.42E01E\"');\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 */\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 on partially-resolved tracks — both fields come\n * from the multivariant playlist and are available before media-playlist resolution.\n *\n * @example\n *   buildMimeCodec({ mimeType: 'video/mp4', codecs: ['avc1.42E01E'] });\n *   // => 'video/mp4; codecs=\"avc1.42E01E\"'\n *\n * @param track - Track carrying `mimeType` and `codecs`\n * @returns MIME codec string suitable for `MediaSource.addSourceBuffer`\n */\nexport function buildMimeCodec(track: { mimeType: string; codecs?: string[] }): string {\n  const codecString = track.codecs?.join(',') ?? '';\n\n  return `${track.mimeType}; codecs=\"${codecString}\"`;\n}\n\n/**\n * Check if a codec is supported.\n *\n * @example\n *   if (isCodecSupported('video/mp4; codecs=\"avc1.42E01E\"')) {\n *     // Create source buffer\n *   }\n *\n * @param mimeCodec - MIME type with codecs string\n * @returns True if the codec is supported\n */\nexport function isCodecSupported(mimeCodec: string): boolean {\n  if (supportsMediaSource()) {\n    return MediaSource.isTypeSupported(mimeCodec);\n  }\n\n  if (supportsManagedMediaSource()) {\n    return ManagedMediaSource!.isTypeSupported(mimeCodec);\n  }\n\n  return false;\n}\n\n/**\n * Observe `mediaSource.readyState` changes via DOM events.\n *\n * Listens to `sourceopen`, `sourceended`, and `sourceclose` and invokes `onChange` with the current `readyState` after\n * each event. Listeners are automatically removed when `abortSignal` is aborted.\n *\n * @example\n *   const controller = new AbortController();\n *   onMediaSourceReadyStateChange(mediaSource, controller.signal, (state) => {\n *   if (state === 'open') { ... }\n *   });\n *   // Later: controller.abort();\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 */\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\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'` (the next\n * `sourceopen`/`sourceended`/`sourceclose` event), or until `signal` aborts — whichever fires first.\n *\n * Resolves immediately when `readyState` is already `'open'` or `'ended'` (no further transition is coming, so there's\n * nothing to wait for). The caller is expected to re-check `readyState` after the await to distinguish `'open'` from\n * terminal states.\n *\n * Companion to `onMediaSourceReadyStateChange` for one-shot use in async sequences (e.g., a behavior's reactor entry\n * that needs to wait for the 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\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\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":";;;;;;;;;AASA,SAAgB,sBAA+B;CAC7C,OAAO,OAAO,gBAAgB;AAChC;;;;;AAMA,SAAgB,6BAAsC;CACpD,OAAO,OAAO,uBAAuB;AACvC;;;;;;;;;;;;;AAoBA,SAAgB,kBAAkB,UAAoC,CAAC,GAAgB;CACrF,MAAM,EAAE,gBAAgB,UAAU;CAClC,IAAI,iBAAiB,2BAA2B,GAAG,OAAO,IAAI,mBAAoB;CAElF,IAAI,oBAAoB,GACtB,OAAO,IAAI,YAAY;CAGzB,MAAM,IAAI,MAAM,kCAAkC;AACpD;;;;;;;;;;;;;;;;;;AA2CA,SAAgB,kBAAkB,aAA0B,cAAyD;CAInH,IAAI,2BAA2B,KAAK,uBAAuB,oBACzD,aAAa,wBAAwB;CAGvC,MAAM,MAAM,IAAI,gBAAgB,WAAW;CAE3C,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;;;;;;;;;;;AAYA,SAAgB,iCACd,aACA,cACyB;CAKzB,IAAI,2BAA2B,KAAK,uBAAuB,oBACzD,aAAa,wBAAwB;CAGvC,MAAM,MAAM,IAAI,gBAAgB,WAAW;CAC3C,MAAM,WAAW,SAAS,cAAc,QAAQ;CAEhD,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;;;;;;;;AASA,SAAS,yBAAyB,aAA0B,cAAgC,KAAmB;CAC7G,IAAI,YAAY,eAAe,YAAY,aAAa,eAAe,KACrE,aAAa,KAAK;AAEtB;;;;;;;;AASA,SAAS,cACP,aACA,cACA,KACA,YACM;CACN,IAAI,YAAY;EACd,qBAAqB,yBAAyB,aAAa,cAAc,GAAG,CAAC;EAC7E;CACF;CAEA,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;;;;;;;;;;;;AAaA,SAAgB,eAAe,OAAwD;CACrF,MAAM,cAAc,MAAM,QAAQ,KAAK,GAAG,KAAK;CAE/C,OAAO,GAAG,MAAM,SAAS,YAAY,YAAY;AACnD;;;;;;;;;;;;AAaA,SAAgB,iBAAiB,WAA4B;CAC3D,IAAI,oBAAoB,GACtB,OAAO,YAAY,gBAAgB,SAAS;CAG9C,IAAI,2BAA2B,GAC7B,OAAO,mBAAoB,gBAAgB,SAAS;CAGtD,OAAO;AACT;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,8BACd,aACA,aACA,UACM;CACN,MAAM,eAAe,SAAS,YAAY,UAAU;CACpD,MAAM,UAAU,EAAE,QAAQ,YAAY;CAEtC,YAAY,iBAAiB,cAAc,QAAQ,OAAO;CAC1D,YAAY,iBAAiB,eAAe,QAAQ,OAAO;CAC3D,YAAY,iBAAiB,eAAe,QAAQ,OAAO;AAC7D;;;;;;;;;;;;;;;;;AAkBA,SAAgB,uBAAuB,aAA0B,QAAoC;CACnG,IAAI,OAAO,SAAS,OAAO,QAAQ,QAAQ;CAE3C,IAAI,YAAY,eAAe,UAAU,OAAO,QAAQ,QAAQ;CAEhE,OAAO,IAAI,SAAe,YAAY;EACpC,MAAM,aAAa,QAAQ;EAC3B,MAAM,UAAU;GAAE,MAAM;GAAM;EAAO;EAErC,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,95 @@
+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 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/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 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/default/media/dom/text/text-track-slots.js

@@ -0,0 +1,61 @@
+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 `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/default/media/errors.js

@@ -0,0 +1,60 @@
+//#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 playback failure or notice, independent of\n * how it's transported or who decides what to do about it.\n *\n * A code is a single integer: the leading digit(s) are the **category** (the error's domain) and the trailing three are\n * the **index** (the specific error within it). Four digits for natively-defined errors, five when an external standard\n * is embedded — `\"03404\"` is an HTTP 404 under the network category. Categories are `0` unknown, `1` media content, `2`\n * playback, `3` network, `4` content protection, `5` accessibility, `6` remote play, `7` advertising, `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 varies with player implementation, breaking\n *   the consistency of a specific 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 downstream.\n * - **Reporting is partial and stacked** (Principles 5–6). Errors are reported as encountered, most of them non-fatal,\n *   and the _sequence_ carries causation 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 format- and player-neutral. Not `MediaError` —\n * that name belongs to the `@videojs/media` DOM-facing class this eventually maps _onto_, and the mapping is the point\n * 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 for \"this source is encrypted and we\n * have no decryption pipeline,\" which is 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 that existed and were all excluded as\n * unplayable, and — where the composition 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 answer to a viewer, and because the\n * alternative is a code the SVTA spec doesn't define. Whether an absent type is a failure is the composition's to\n * state, 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 requires, so the source is unplayable\n * _here_ rather than broken.\n *\n * Custom rather than standard because the standard codes available describe either narrower or wider things. The causes\n * (1004/1005 unsupported format, 4008 unsupported DRM) say what one rendition hit; the verdicts (2011/2012 no supported\n * track) say a type emptied without saying why it's unfixable. And 2039 \"Manifest feature unsupported\" covers features\n * that are unsupported but still _playable_ — LL-HLS degrading to standard live is a 2039 — so overloading it for a\n * fatal condition would make it useless for the notices it belongs on.\n *\n * Index `001`: the spec defines only `99000` (Unknown) for the custom category and leaves the rest to the publisher, so\n * this is the first code we define.\n *\n * Five digits, and deliberately not special-cased anywhere: {@link svtaCategory} and {@link svtaIndex} decompose it\n * correctly by arithmetic alone, because 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 obtain the error category\". Works\n * uniformly across the four-digit native form and the five-digit form embedding an external standard: `\"03404\"` is\n * numerically 3404, which decomposes identically. That also makes a numeric code immune to the spec's inconsistent\n * zero-padding (§Approach writes a category-unknown network error as `\"0300\"` where the error index implies category 3\n * / 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 this is the embedded external value (an\n * HTTP status, a VAST code).\n */\nexport function svtaIndex(code: number): number {\n  return code % 1000;\n}\n"],"mappings":";;AAqCA,MAAa,gCAAgC;;AAG7C,MAAa,gCAAgC;;;;;AAM7C,MAAa,8BAA8B;;;;;;;;;;AAW3C,MAAa,gCAAgC;;AAG7C,MAAa,gCAAgC;;;;;;;;;;;;;;;;;AAkB7C,MAAa,oCAAoC;;;;;;;;AASjD,SAAgB,aAAa,MAAsB;CACjD,OAAO,KAAK,MAAM,OAAO,GAAI;AAC/B;;;;;AAMA,SAAgB,UAAU,MAAsB;CAC9C,OAAO,OAAO;AAChB"}