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

package/dist/default/media/dom/mse/duration.js.map

@@ -1 +1 @@
-{"version":3,"file":"duration.js","names":[],"sources":["../../../../../src/media/dom/mse/duration.ts"],"sourcesContent":["/**\n * MediaSource duration helpers.\n *\n * Predicates and async primitives for propagating a presentation's duration\n * to `mediaSource.duration` under the MSE spec's constraints:\n *\n * - `duration` cannot be set while any attached SourceBuffer is `updating`.\n * - `duration` cannot be less than any buffered range's end time.\n *\n * The buffer-set helpers take a `SourceBufferList` (or any iterable of\n * `SourceBuffer`) — they operate uniformly across whatever buffers are\n * attached, so callers in audio-only, video-only, and mixed configurations\n * compose them without per-type plumbing. `mediaSource.sourceBuffers` is the\n * canonical aggregate.\n *\n * Consumed by `updateMediaSourceDuration` (DOM behavior) — kept here so the layering\n * stays clean: the predicates and wait helper are pure DOM/MSE primitives\n * with no `core/` reactivity.\n */\n\nimport type { MaybeResolvedPresentation } from '../../types';\nimport { hasPresentationDuration } from '../../types';\n\ntype SourceBufferIterable = SourceBufferList | Iterable<SourceBuffer>;\n\n/**\n * Check if we have the basics to update MediaSource duration:\n * a `mediaSource` and a `presentation` with a numeric duration.\n */\nexport function canUpdateDuration(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): boolean {\n  return !!(mediaSource && presentation && hasPresentationDuration(presentation));\n}\n\nexport function getBufferedEnd(\n  buffers: SourceBufferIterable,\n  isEndMatch: (next: number, current: number) => boolean\n): number {\n  return (\n    ([...buffers].reduce((endMatch: number | undefined, buffer) => {\n      const { buffered } = buffer;\n      if (!buffered.length) return endMatch;\n      const end = buffered.end(buffered.length - 1);\n      if (!endMatch) return end;\n      return isEndMatch(end, endMatch) ? end : endMatch;\n    }, undefined) as number) ?? 0\n  );\n}\n\nconst isGreaterThan = (x: number, y: number) => x > y;\nconst isLessThan = (x: number, y: number) => x < y;\n\n/**\n * Get the maximum buffered end time across an iterable of SourceBuffers\n * (typically `mediaSource.sourceBuffers`). Returns `0` when the collection is\n * empty or no buffer has any buffered ranges.\n */\nexport function getMaxBufferedEnd(buffers: SourceBufferIterable): number {\n  return getBufferedEnd(buffers, isGreaterThan);\n}\n\n/**\n * Get the reachable buffered end across an iterable of SourceBuffers (typically\n * `mediaSource.sourceBuffers`): the `min` of each buffer's last buffered-range end\n * — the furthest point every track can play to (the intersection end). Buffers with\n * no buffered ranges are skipped. Returns `0` when the collection is empty or no\n * buffer has any buffered ranges.\n *\n * Counterpart to {@link getMaxBufferedEnd}: `max` bounds the overall presentation\n * end (e.g. for setting `duration`), `min` bounds where playback can actually reach\n * when tracks end at slightly different times (e.g. skewed A/V near end-of-stream).\n */\nexport function getMinBufferedEnd(buffers: SourceBufferIterable): number {\n  return getBufferedEnd(buffers, isLessThan);\n}\n\n/**\n * Check if the preconditions are met to *attempt* a `mediaSource.duration`\n * write: a `mediaSource` is in scope and the presentation has a valid\n * positive duration (or `Infinity` for live).\n *\n * Does **not** check `mediaSource.readyState` or `mediaSource.duration` —\n * those are DOM properties the caller resolves at write time (e.g., by\n * `await`ing `waitForMediaSourceOpen` and re-checking `readyState` after,\n * and guarding on the existing `mediaSource.duration` for idempotency).\n * Keeping these off the signal-driven predicate lets callers use this\n * inside reactor state derivation without smuggling non-reactive DOM\n * reads into `computed(...)`.\n *\n * `Infinity` is allowed — per the MSE spec, `mediaSource.duration = +Infinity`\n * is how live playback signals an indefinite duration.\n */\nexport function shouldUpdateDuration(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): boolean {\n  if (!canUpdateDuration(presentation, mediaSource)) return false;\n\n  const duration = presentation!.duration!;\n\n  if (Number.isNaN(duration) || duration <= 0) return false;\n\n  return true;\n}\n\n/**\n * Wait for all currently-updating SourceBuffers in `buffers` to finish, or\n * until `signal` aborts — whichever fires first.\n *\n * The MSE spec forbids setting `MediaSource.duration` while any attached\n * SourceBuffer has `updating === true`. This defers until all are idle.\n * Listeners are registered with `{ signal }` so an abort tears them down\n * up-front rather than leaving them dangling until the next `updateend`.\n */\nexport function waitForSourceBuffersReady(buffers: SourceBufferIterable, signal: AbortSignal): Promise<void> {\n  if (signal.aborted) return Promise.resolve();\n\n  const updating: SourceBuffer[] = [];\n  for (const buf of buffers) {\n    if (buf.updating) updating.push(buf);\n  }\n\n  if (updating.length === 0) return Promise.resolve();\n\n  return new Promise<void>((resolve) => {\n    let remaining = updating.length;\n    const onUpdateEnd = () => {\n      remaining--;\n      if (remaining === 0) resolve();\n    };\n\n    for (const buf of updating) {\n      buf.addEventListener('updateend', onUpdateEnd, { once: true, signal });\n    }\n\n    signal.addEventListener('abort', () => resolve(), { once: true });\n  });\n}\n"],"mappings":";;;;;;AA6BA,SAAgB,kBACd,cACA,aACS;CACT,OAAO,CAAC,EAAE,eAAe,gBAAgB,wBAAwB,YAAY;AAC/E;AAEA,SAAgB,eACd,SACA,YACQ;CACR,OACG,CAAC,GAAG,OAAO,CAAC,CAAC,QAAQ,UAA8B,WAAW;EAC7D,MAAM,EAAE,aAAa;EACrB,IAAI,CAAC,SAAS,QAAQ,OAAO;EAC7B,MAAM,MAAM,SAAS,IAAI,SAAS,SAAS,CAAC;EAC5C,IAAI,CAAC,UAAU,OAAO;EACtB,OAAO,WAAW,KAAK,QAAQ,IAAI,MAAM;CAC3C,GAAG,KAAA,CAAS,KAAgB;AAEhC;AAEA,MAAM,iBAAiB,GAAW,MAAc,IAAI;AACpD,MAAM,cAAc,GAAW,MAAc,IAAI;;;;;;AAOjD,SAAgB,kBAAkB,SAAuC;CACvE,OAAO,eAAe,SAAS,aAAa;AAC9C;;;;;;;;;;;;AAaA,SAAgB,kBAAkB,SAAuC;CACvE,OAAO,eAAe,SAAS,UAAU;AAC3C;;;;;;;;;;;;;;;;;AAkBA,SAAgB,qBACd,cACA,aACS;CACT,IAAI,CAAC,kBAAkB,cAAc,WAAW,GAAG,OAAO;CAE1D,MAAM,WAAW,aAAc;CAE/B,IAAI,OAAO,MAAM,QAAQ,KAAK,YAAY,GAAG,OAAO;CAEpD,OAAO;AACT;;;;;;;;;;AAWA,SAAgB,0BAA0B,SAA+B,QAAoC;CAC3G,IAAI,OAAO,SAAS,OAAO,QAAQ,QAAQ;CAE3C,MAAM,WAA2B,CAAC;CAClC,KAAK,MAAM,OAAO,SAChB,IAAI,IAAI,UAAU,SAAS,KAAK,GAAG;CAGrC,IAAI,SAAS,WAAW,GAAG,OAAO,QAAQ,QAAQ;CAElD,OAAO,IAAI,SAAe,YAAY;EACpC,IAAI,YAAY,SAAS;EACzB,MAAM,oBAAoB;GACxB;GACA,IAAI,cAAc,GAAG,QAAQ;EAC/B;EAEA,KAAK,MAAM,OAAO,UAChB,IAAI,iBAAiB,aAAa,aAAa;GAAE,MAAM;GAAM;EAAO,CAAC;EAGvE,OAAO,iBAAiB,eAAe,QAAQ,GAAG,EAAE,MAAM,KAAK,CAAC;CAClE,CAAC;AACH"}
+{"version":3,"file":"duration.js","names":[],"sources":["../../../../../src/media/dom/mse/duration.ts"],"sourcesContent":["/**\n * MediaSource duration helpers.\n *\n * Predicates and async primitives for propagating a presentation's duration to `mediaSource.duration` under the MSE\n * spec's constraints:\n *\n * - `duration` cannot be set while any attached SourceBuffer is `updating`.\n * - `duration` cannot be less than any buffered range's end time.\n *\n * The buffer-set helpers take a `SourceBufferList` (or any iterable of `SourceBuffer`) — they operate uniformly across\n * whatever buffers are attached, so callers in audio-only, video-only, and mixed configurations compose them without\n * per-type plumbing. `mediaSource.sourceBuffers` is the canonical aggregate.\n *\n * Consumed by `updateMediaSourceDuration` (DOM behavior) — kept here so the layering stays clean: the predicates and\n * wait helper are pure DOM/MSE primitives with no `core/` reactivity.\n */\n\nimport type { MaybeResolvedPresentation } from '../../types';\nimport { hasPresentationDuration } from '../../types';\n\ntype SourceBufferIterable = SourceBufferList | Iterable<SourceBuffer>;\n\n/**\n * Check if we have the basics to update MediaSource duration: a `mediaSource` and a `presentation` with a numeric\n * duration.\n */\nexport function canUpdateDuration(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): boolean {\n  return !!(mediaSource && presentation && hasPresentationDuration(presentation));\n}\n\nexport function getBufferedEnd(\n  buffers: SourceBufferIterable,\n  isEndMatch: (next: number, current: number) => boolean\n): number {\n  return (\n    ([...buffers].reduce((endMatch: number | undefined, buffer) => {\n      const { buffered } = buffer;\n      if (!buffered.length) return endMatch;\n\n      const end = buffered.end(buffered.length - 1);\n\n      if (!endMatch) return end;\n\n      return isEndMatch(end, endMatch) ? end : endMatch;\n    }, undefined) as number) ?? 0\n  );\n}\n\nconst isGreaterThan = (x: number, y: number) => x > y;\nconst isLessThan = (x: number, y: number) => x < y;\n\n/**\n * Get the maximum buffered end time across an iterable of SourceBuffers (typically `mediaSource.sourceBuffers`).\n * Returns `0` when the collection is empty or no buffer has any buffered ranges.\n */\nexport function getMaxBufferedEnd(buffers: SourceBufferIterable): number {\n  return getBufferedEnd(buffers, isGreaterThan);\n}\n\n/**\n * Get the reachable buffered end across an iterable of SourceBuffers (typically `mediaSource.sourceBuffers`): the `min`\n * of each buffer's last buffered-range end — the furthest point every track can play to (the intersection end). Buffers\n * with no buffered ranges are skipped. Returns `0` when the collection is empty or no buffer has any buffered ranges.\n *\n * Counterpart to {@link getMaxBufferedEnd}: `max` bounds the overall presentation end (e.g. for setting `duration`),\n * `min` bounds where playback can actually reach when tracks end at slightly different times (e.g. skewed A/V near\n * end-of-stream).\n */\nexport function getMinBufferedEnd(buffers: SourceBufferIterable): number {\n  return getBufferedEnd(buffers, isLessThan);\n}\n\n/**\n * Check if the preconditions are met to _attempt_ a `mediaSource.duration` write: a `mediaSource` is in scope and the\n * presentation has a valid positive duration (or `Infinity` for live).\n *\n * Does **not** check `mediaSource.readyState` or `mediaSource.duration` — those are DOM properties the caller resolves\n * at write time (e.g., by `await`ing `waitForMediaSourceOpen` and re-checking `readyState` after, and guarding on the\n * existing `mediaSource.duration` for idempotency). Keeping these off the signal-driven predicate lets callers use this\n * inside reactor state derivation without smuggling non-reactive DOM reads into `computed(...)`.\n *\n * `Infinity` is allowed — per the MSE spec, `mediaSource.duration = +Infinity` is how live playback signals an\n * indefinite duration.\n */\nexport function shouldUpdateDuration(\n  presentation: MaybeResolvedPresentation | undefined,\n  mediaSource: MediaSource | undefined\n): boolean {\n  if (!canUpdateDuration(presentation, mediaSource)) return false;\n\n  const duration = presentation!.duration!;\n  if (Number.isNaN(duration) || duration <= 0) return false;\n\n  return true;\n}\n\n/**\n * Wait for all currently-updating SourceBuffers in `buffers` to finish, or until `signal` aborts — whichever fires\n * first.\n *\n * The MSE spec forbids setting `MediaSource.duration` while any attached SourceBuffer has `updating === true`. This\n * defers until all are idle. Listeners are registered with `{ signal }` so an abort tears them down up-front rather\n * than leaving them dangling until the next `updateend`.\n */\nexport function waitForSourceBuffersReady(buffers: SourceBufferIterable, signal: AbortSignal): Promise<void> {\n  if (signal.aborted) return Promise.resolve();\n\n  const updating: SourceBuffer[] = [];\n\n  for (const buf of buffers) {\n    if (buf.updating) updating.push(buf);\n  }\n\n  if (updating.length === 0) return Promise.resolve();\n\n  return new Promise<void>((resolve) => {\n    let remaining = updating.length;\n    const onUpdateEnd = () => {\n      remaining--;\n\n      if (remaining === 0) resolve();\n    };\n\n    for (const buf of updating) {\n      buf.addEventListener('updateend', onUpdateEnd, { once: true, signal });\n    }\n\n    signal.addEventListener('abort', () => resolve(), { once: true });\n  });\n}\n"],"mappings":";;;;;;AA0BA,SAAgB,kBACd,cACA,aACS;CACT,OAAO,CAAC,EAAE,eAAe,gBAAgB,wBAAwB,YAAY;AAC/E;AAEA,SAAgB,eACd,SACA,YACQ;CACR,OACG,CAAC,GAAG,OAAO,CAAC,CAAC,QAAQ,UAA8B,WAAW;EAC7D,MAAM,EAAE,aAAa;EACrB,IAAI,CAAC,SAAS,QAAQ,OAAO;EAE7B,MAAM,MAAM,SAAS,IAAI,SAAS,SAAS,CAAC;EAE5C,IAAI,CAAC,UAAU,OAAO;EAEtB,OAAO,WAAW,KAAK,QAAQ,IAAI,MAAM;CAC3C,GAAG,KAAA,CAAS,KAAgB;AAEhC;AAEA,MAAM,iBAAiB,GAAW,MAAc,IAAI;AACpD,MAAM,cAAc,GAAW,MAAc,IAAI;;;;;AAMjD,SAAgB,kBAAkB,SAAuC;CACvE,OAAO,eAAe,SAAS,aAAa;AAC9C;;;;;;;;;;AAWA,SAAgB,kBAAkB,SAAuC;CACvE,OAAO,eAAe,SAAS,UAAU;AAC3C;;;;;;;;;;;;;AAcA,SAAgB,qBACd,cACA,aACS;CACT,IAAI,CAAC,kBAAkB,cAAc,WAAW,GAAG,OAAO;CAE1D,MAAM,WAAW,aAAc;CAC/B,IAAI,OAAO,MAAM,QAAQ,KAAK,YAAY,GAAG,OAAO;CAEpD,OAAO;AACT;;;;;;;;;AAUA,SAAgB,0BAA0B,SAA+B,QAAoC;CAC3G,IAAI,OAAO,SAAS,OAAO,QAAQ,QAAQ;CAE3C,MAAM,WAA2B,CAAC;CAElC,KAAK,MAAM,OAAO,SAChB,IAAI,IAAI,UAAU,SAAS,KAAK,GAAG;CAGrC,IAAI,SAAS,WAAW,GAAG,OAAO,QAAQ,QAAQ;CAElD,OAAO,IAAI,SAAe,YAAY;EACpC,IAAI,YAAY,SAAS;EACzB,MAAM,oBAAoB;GACxB;GAEA,IAAI,cAAc,GAAG,QAAQ;EAC/B;EAEA,KAAK,MAAM,OAAO,UAChB,IAAI,iBAAiB,aAAa,aAAa;GAAE,MAAM;GAAM;EAAO,CAAC;EAGvE,OAAO,iBAAiB,eAAe,QAAQ,GAAG,EAAE,MAAM,KAAK,CAAC;CAClE,CAAC;AACH"}

package/dist/default/media/dom/mse/end-of-stream.js

@@ -1,12 +1,9 @@
 //#region src/media/dom/mse/end-of-stream.ts
 /**
-* Check if the temporally last segment of `expectedSegments` is present in
-* `appendedSegments` and not marked partial.
+* Check if the temporally last segment of `expectedSegments` is present in `appendedSegments` and not marked partial.
 *
-* Compares by segment ID rather than by a pipeline flag, so the result
-* stays correct across quality switches (different tracks have different
-* segment IDs) and back-buffer flushes (flushed segment IDs are removed
-* from the appended list).
+* Compares by segment ID rather than by a pipeline flag, so the result stays correct across quality switches (different
+* tracks have different segment IDs) and back-buffer flushes (flushed segment IDs are removed from the appended list).
 */
 function isLastSegmentAppended(expectedSegments, appendedSegments) {
 	if (expectedSegments.length === 0) return true;

package/dist/default/media/dom/mse/end-of-stream.js.map

@@ -1 +1 @@
-{"version":3,"file":"end-of-stream.js","names":[],"sources":["../../../../../src/media/dom/mse/end-of-stream.ts"],"sourcesContent":["/**\n * End-of-stream detection helpers.\n *\n * Pure predicate that compares a track's expected segment list against the\n * appended-segment list from an MSE SourceBufferActor's snapshot. Consumed\n * by the `endOfStream` playback behavior to decide when to call\n * `MediaSource.endOfStream()`.\n *\n * Kept here so the layering stays clean: predicate has no `core/`\n * reactivity and operates on plain segment lists extracted by the caller.\n */\n\n/**\n * Minimum information about an appended segment needed to decide whether\n * it counts toward end-of-stream readiness.\n *\n * Matches the shape of `SourceBufferActor`'s context segments — callers\n * typically pass `actor.snapshot.get().context.segments` directly.\n */\nexport interface AppendedSegment {\n  id: string;\n  /**\n   * True while a streaming append is in progress for this segment. A\n   * partial segment is still streaming — it does not count as the last\n   * segment being ready.\n   */\n  partial?: boolean;\n}\n\n/**\n * Check if the temporally last segment of `expectedSegments` is present in\n * `appendedSegments` and not marked partial.\n *\n * Compares by segment ID rather than by a pipeline flag, so the result\n * stays correct across quality switches (different tracks have different\n * segment IDs) and back-buffer flushes (flushed segment IDs are removed\n * from the appended list).\n */\nexport function isLastSegmentAppended(\n  expectedSegments: readonly { id: string }[],\n  appendedSegments: readonly AppendedSegment[] | undefined\n): boolean {\n  if (expectedSegments.length === 0) return true;\n  const lastSeg = expectedSegments[expectedSegments.length - 1];\n  if (!lastSeg) return false;\n  return appendedSegments?.some((s) => s.id === lastSeg.id && !s.partial) ?? false;\n}\n"],"mappings":";;;;;;;;;;AAsCA,SAAgB,sBACd,kBACA,kBACS;CACT,IAAI,iBAAiB,WAAW,GAAG,OAAO;CAC1C,MAAM,UAAU,iBAAiB,iBAAiB,SAAS;CAC3D,IAAI,CAAC,SAAS,OAAO;CACrB,OAAO,kBAAkB,MAAM,MAAM,EAAE,OAAO,QAAQ,MAAM,CAAC,EAAE,OAAO,KAAK;AAC7E"}
+{"version":3,"file":"end-of-stream.js","names":[],"sources":["../../../../../src/media/dom/mse/end-of-stream.ts"],"sourcesContent":["/**\n * End-of-stream detection helpers.\n *\n * Pure predicate that compares a track's expected segment list against the appended-segment list from an MSE\n * SourceBufferActor's snapshot. Consumed by the `endOfStream` playback behavior to decide when to call\n * `MediaSource.endOfStream()`.\n *\n * Kept here so the layering stays clean: predicate has no `core/` reactivity and operates on plain segment lists\n * extracted by the caller.\n */\n\n/**\n * Minimum information about an appended segment needed to decide whether it counts toward end-of-stream readiness.\n *\n * Matches the shape of `SourceBufferActor`'s context segments — callers typically pass\n * `actor.snapshot.get().context.segments` directly.\n */\nexport interface AppendedSegment {\n  id: string;\n  /**\n   * True while a streaming append is in progress for this segment. A partial segment is still streaming — it does not\n   * count as the last segment being ready.\n   */\n  partial?: boolean;\n}\n\n/**\n * Check if the temporally last segment of `expectedSegments` is present in `appendedSegments` and not marked partial.\n *\n * Compares by segment ID rather than by a pipeline flag, so the result stays correct across quality switches (different\n * tracks have different segment IDs) and back-buffer flushes (flushed segment IDs are removed from the appended list).\n */\nexport function isLastSegmentAppended(\n  expectedSegments: readonly { id: string }[],\n  appendedSegments: readonly AppendedSegment[] | undefined\n): boolean {\n  if (expectedSegments.length === 0) return true;\n\n  const lastSeg = expectedSegments[expectedSegments.length - 1];\n  if (!lastSeg) return false;\n\n  return appendedSegments?.some((s) => s.id === lastSeg.id && !s.partial) ?? false;\n}\n"],"mappings":";;;;;;;AAgCA,SAAgB,sBACd,kBACA,kBACS;CACT,IAAI,iBAAiB,WAAW,GAAG,OAAO;CAE1C,MAAM,UAAU,iBAAiB,iBAAiB,SAAS;CAC3D,IAAI,CAAC,SAAS,OAAO;CAErB,OAAO,kBAAkB,MAAM,MAAM,EAAE,OAAO,QAAQ,MAAM,CAAC,EAAE,OAAO,KAAK;AAC7E"}

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

@@ -2,20 +2,17 @@
 /**
 * MediaSource Setup
 *
-* Utilities for creating and configuring MediaSource/ManagedMediaSource
-* for MSE (Media Source Extensions) playback.
+* 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.
-*/
+/** 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.
+* Check if ManagedMediaSource API is supported. ManagedMediaSource is a newer Safari API with better lifecycle
+* management.
 */
 function supportsManagedMediaSource() {
 	return typeof ManagedMediaSource !== "undefined";
@@ -23,14 +20,14 @@ function supportsManagedMediaSource() {
 /**
 * 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
-*
-* @example
-* const mediaSource = createMediaSource();
-* const mediaElement = document.querySelector('video');
-* attachMediaSource(mediaSource, mediaElement);
 */
 function createMediaSource(options = {}) {
 	const { preferManaged = false } = options;
@@ -41,20 +38,19 @@ function createMediaSource(options = {}) {
 /**
 * 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).
+* 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
-*
-* @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;
@@ -73,14 +69,11 @@ function attachMediaSource(mediaSource, mediaElement) {
 /**
 * 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
+* 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) {
@@ -103,25 +96,21 @@ function attachMediaSourceAsSourceElement(mediaSource, mediaElement) {
 	};
 }
 /**
-* 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.
+* 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}).
+* 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.
+* 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) {
@@ -133,13 +122,13 @@ function scheduleReset(mediaSource, mediaElement, url, deferReset) {
 /**
 * 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
-*
-* @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");
@@ -147,16 +136,15 @@ function createSourceBuffer(mediaSource, 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.
+* 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`
-*
-* @example
-* buildMimeCodec({ mimeType: 'video/mp4', codecs: ['avc1.42E01E'] })
-* // => 'video/mp4; codecs="avc1.42E01E"'
 */
 function buildMimeCodec(track) {
 	const codecString = track.codecs?.join(",") ?? "";
@@ -165,13 +153,13 @@ function buildMimeCodec(track) {
 /**
 * 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
-*
-* @example
-* if (isCodecSupported('video/mp4; codecs="avc1.42E01E"')) {
-*   // Create source buffer
-* }
 */
 function isCodecSupported(mimeCodec) {
 	if (!supportsMediaSource()) return false;
@@ -180,20 +168,19 @@ function isCodecSupported(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.
+* 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
-*
-* @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);
@@ -203,23 +190,20 @@ function onMediaSourceReadyStateChange(mediaSource, abortSignal, onChange) {
 	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.
+* 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.
+* 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).
+* 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
+*   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();

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

@@ -1 +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":"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"}
+{"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 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 `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":"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"}

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

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

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

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

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

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