@videojs/spf 10.0.0-beta.1 → 10.0.0-beta.11

package/dist/dev/dom/features/track-current-time.d.ts

@@ -0,0 +1,40 @@
+import { WritableState } from "../../core/state/create-state.js";
+
+//#region src/dom/features/track-current-time.d.ts
+/**
+ * State shape for current time tracking.
+ */
+interface CurrentTimeState {
+  currentTime?: number;
+}
+/**
+ * Owners shape for current time tracking.
+ */
+interface CurrentTimeOwners {
+  mediaElement?: HTMLMediaElement | undefined;
+}
+/**
+ * Track current playback position from the media element.
+ *
+ * Mirrors `mediaElement.currentTime` into reactive state on:
+ * - `timeupdate` — fires during playback (~4 Hz)
+ * - `seeking` — fires when a seek begins; per spec, `currentTime` is
+ *   already at the new position when this event dispatches, so buffer
+ *   management can react immediately rather than waiting for `timeupdate`,
+ *   which does not fire while paused.
+ *
+ * Also syncs immediately when a media element becomes available.
+ *
+ * @example
+ * const cleanup = trackCurrentTime({ state, owners });
+ */
+declare function trackCurrentTime({
+  state,
+  owners
+}: {
+  state: WritableState<CurrentTimeState>;
+  owners: WritableState<CurrentTimeOwners>;
+}): () => void;
+//#endregion
+export { CurrentTimeOwners, CurrentTimeState, trackCurrentTime };
+//# sourceMappingURL=track-current-time.d.ts.map

package/dist/dev/dom/features/track-current-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-current-time.d.ts","names":[],"sources":["../../../../src/dom/features/track-current-time.ts"],"mappings":";;;;;AAMA;UAAiB,gBAAA;EACf,WAAA;AAAA;;AAMF;;UAAiB,iBAAA;EACf,YAAA,GAAe,gBAAA;AAAA;;;;;;;;;;;;;;;;iBA4BD,gBAAA,CAAA;EACd,KAAA;EACA;AAAA;EAEA,KAAA,EAAO,aAAA,CAAc,gBAAA;EACrB,MAAA,EAAQ,aAAA,CAAc,iBAAA;AAAA"}

package/dist/dev/dom/features/track-current-time.js

@@ -0,0 +1,46 @@
+import { listen } from "@videojs/utils/dom";
+
+//#region src/dom/features/track-current-time.ts
+/**
+* Track current playback position from the media element.
+*
+* Mirrors `mediaElement.currentTime` into reactive state on:
+* - `timeupdate` — fires during playback (~4 Hz)
+* - `seeking` — fires when a seek begins; per spec, `currentTime` is
+*   already at the new position when this event dispatches, so buffer
+*   management can react immediately rather than waiting for `timeupdate`,
+*   which does not fire while paused.
+*
+* Also syncs immediately when a media element becomes available.
+*
+* @example
+* const cleanup = trackCurrentTime({ state, owners });
+*/
+function trackCurrentTime({ state, owners }) {
+	let lastMediaElement;
+	let removeListeners = null;
+	const unsubscribe = owners.subscribe((currentOwners) => {
+		const { mediaElement } = currentOwners;
+		if (mediaElement === lastMediaElement) return;
+		removeListeners?.();
+		removeListeners = null;
+		lastMediaElement = mediaElement;
+		if (!mediaElement) return;
+		state.patch({ currentTime: mediaElement.currentTime });
+		const sync = () => state.patch({ currentTime: mediaElement.currentTime });
+		const removeTimeupdate = listen(mediaElement, "timeupdate", sync);
+		const removeSeeking = listen(mediaElement, "seeking", sync);
+		removeListeners = () => {
+			removeTimeupdate();
+			removeSeeking();
+		};
+	});
+	return () => {
+		removeListeners?.();
+		unsubscribe();
+	};
+}
+
+//#endregion
+export { trackCurrentTime };
+//# sourceMappingURL=track-current-time.js.map

package/dist/dev/dom/features/track-current-time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-current-time.js","names":[],"sources":["../../../../src/dom/features/track-current-time.ts"],"sourcesContent":["import { listen } from '@videojs/utils/dom';\nimport type { WritableState } from '../../core/state/create-state';\n\n/**\n * State shape for current time tracking.\n */\nexport interface CurrentTimeState {\n  currentTime?: number;\n}\n\n/**\n * Owners shape for current time tracking.\n */\nexport interface CurrentTimeOwners {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\n/**\n * Check if we can track current time.\n *\n * Requires:\n * - mediaElement exists in owners\n */\nexport function canTrackCurrentTime(owners: CurrentTimeOwners): boolean {\n  return !!owners.mediaElement;\n}\n\n/**\n * Track current playback position from the media element.\n *\n * Mirrors `mediaElement.currentTime` into reactive state on:\n * - `timeupdate` — fires during playback (~4 Hz)\n * - `seeking` — fires when a seek begins; per spec, `currentTime` is\n *   already at the new position when this event dispatches, so buffer\n *   management can react immediately rather than waiting for `timeupdate`,\n *   which does not fire while paused.\n *\n * Also syncs immediately when a media element becomes available.\n *\n * @example\n * const cleanup = trackCurrentTime({ state, owners });\n */\nexport function trackCurrentTime({\n  state,\n  owners,\n}: {\n  state: WritableState<CurrentTimeState>;\n  owners: WritableState<CurrentTimeOwners>;\n}): () => void {\n  let lastMediaElement: HTMLMediaElement | undefined;\n  let removeListeners: (() => void) | null = null;\n\n  const unsubscribe = owners.subscribe((currentOwners) => {\n    const { mediaElement } = currentOwners;\n\n    if (mediaElement === lastMediaElement) return;\n\n    removeListeners?.();\n    removeListeners = null;\n    lastMediaElement = mediaElement;\n\n    if (!mediaElement) return;\n\n    // Sync immediately so consumers don't wait for the first event\n    state.patch({ currentTime: mediaElement.currentTime });\n\n    const sync = () => state.patch({ currentTime: mediaElement.currentTime });\n    const removeTimeupdate = listen(mediaElement, 'timeupdate', sync);\n    const removeSeeking = listen(mediaElement, 'seeking', sync);\n    removeListeners = () => {\n      removeTimeupdate();\n      removeSeeking();\n    };\n  });\n\n  return () => {\n    removeListeners?.();\n    unsubscribe();\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA0CA,SAAgB,iBAAiB,EAC/B,OACA,UAIa;CACb,IAAI;CACJ,IAAI,kBAAuC;CAE3C,MAAM,cAAc,OAAO,WAAW,kBAAkB;EACtD,MAAM,EAAE,iBAAiB;AAEzB,MAAI,iBAAiB,iBAAkB;AAEvC,qBAAmB;AACnB,oBAAkB;AAClB,qBAAmB;AAEnB,MAAI,CAAC,aAAc;AAGnB,QAAM,MAAM,EAAE,aAAa,aAAa,aAAa,CAAC;EAEtD,MAAM,aAAa,MAAM,MAAM,EAAE,aAAa,aAAa,aAAa,CAAC;EACzE,MAAM,mBAAmB,OAAO,cAAc,cAAc,KAAK;EACjE,MAAM,gBAAgB,OAAO,cAAc,WAAW,KAAK;AAC3D,0BAAwB;AACtB,qBAAkB;AAClB,kBAAe;;GAEjB;AAEF,cAAa;AACX,qBAAmB;AACnB,eAAa"}

package/dist/dev/dom/features/track-playback-initiated.d.ts

@@ -0,0 +1,53 @@
+import { WritableState } from "../../core/state/create-state.js";
+import { EventStream } from "../../core/events/create-event-stream.js";
+import { PresentationAction } from "../../core/features/resolve-presentation.js";
+
+//#region src/dom/features/track-playback-initiated.d.ts
+/**
+ * State shape for playback initiation tracking.
+ */
+interface PlaybackInitiatedState {
+  /** True once the user has initiated playback (play event fired). */
+  playbackInitiated?: boolean;
+  /** Current presentation — watched for URL changes to reset playbackInitiated. */
+  presentation?: {
+    url?: string;
+  };
+}
+/**
+ * Owners shape for playback initiation tracking.
+ */
+interface PlaybackInitiatedOwners {
+  mediaElement?: HTMLMediaElement | undefined;
+}
+/**
+ * Track whether playback has been initiated by the user.
+ *
+ * Sets `state.playbackInitiated = true` when the media element fires a `play`
+ * event (via `element.play()`, native controls, or autoplay) and simultaneously
+ * dispatches `{ type: 'play' }` to the event stream so `resolvePresentation`
+ * can react.
+ *
+ * Resets `state.playbackInitiated = false` when `presentation.url` changes,
+ * so a new source with `preload="none"` won't load segments until play is
+ * triggered again.
+ *
+ * This flag is used by `shouldLoadSegments` to allow segment loading after
+ * play is initiated regardless of the initial `preload` setting — `preload`
+ * is a startup hint, not a runtime gate.
+ *
+ * @example
+ * const cleanup = trackPlaybackInitiated({ state, owners, events });
+ */
+declare function trackPlaybackInitiated({
+  state,
+  owners,
+  events
+}: {
+  state: WritableState<PlaybackInitiatedState>;
+  owners: WritableState<PlaybackInitiatedOwners>;
+  events: EventStream<PresentationAction>;
+}): () => void;
+//#endregion
+export { PlaybackInitiatedOwners, PlaybackInitiatedState, trackPlaybackInitiated };
+//# sourceMappingURL=track-playback-initiated.d.ts.map

package/dist/dev/dom/features/track-playback-initiated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-playback-initiated.d.ts","names":[],"sources":["../../../../src/dom/features/track-playback-initiated.ts"],"mappings":";;;;;;;AAQA;UAAiB,sBAAA;;EAEf,iBAAA;EAAA;EAEA,YAAA;IAAiB,GAAA;EAAA;AAAA;AAMnB;;;AAAA,UAAiB,uBAAA;EACf,YAAA,GAAe,gBAAA;AAAA;;;;;;;;;;;;;;;;;;;;iBAsBD,sBAAA,CAAA;EACd,KAAA;EACA,MAAA;EACA;AAAA;EAEA,KAAA,EAAO,aAAA,CAAc,sBAAA;EACrB,MAAA,EAAQ,aAAA,CAAc,uBAAA;EACtB,MAAA,EAAQ,WAAA,CAAY,kBAAA;AAAA"}

package/dist/dev/dom/features/track-playback-initiated.js

@@ -0,0 +1,55 @@
+import { listen } from "@videojs/utils/dom";
+
+//#region src/dom/features/track-playback-initiated.ts
+/**
+* Track whether playback has been initiated by the user.
+*
+* Sets `state.playbackInitiated = true` when the media element fires a `play`
+* event (via `element.play()`, native controls, or autoplay) and simultaneously
+* dispatches `{ type: 'play' }` to the event stream so `resolvePresentation`
+* can react.
+*
+* Resets `state.playbackInitiated = false` when `presentation.url` changes,
+* so a new source with `preload="none"` won't load segments until play is
+* triggered again.
+*
+* This flag is used by `shouldLoadSegments` to allow segment loading after
+* play is initiated regardless of the initial `preload` setting — `preload`
+* is a startup hint, not a runtime gate.
+*
+* @example
+* const cleanup = trackPlaybackInitiated({ state, owners, events });
+*/
+function trackPlaybackInitiated({ state, owners, events }) {
+	let lastMediaElement;
+	let removeListener = null;
+	let lastPresentationUrl;
+	const unsubscribeState = state.subscribe((currentState) => {
+		const url = currentState.presentation?.url;
+		if (url !== lastPresentationUrl) {
+			if (lastPresentationUrl !== void 0) state.patch({ playbackInitiated: false });
+			lastPresentationUrl = url;
+		}
+	});
+	const unsubscribeOwners = owners.subscribe((currentOwners) => {
+		const { mediaElement } = currentOwners;
+		if (mediaElement === lastMediaElement) return;
+		removeListener?.();
+		removeListener = null;
+		lastMediaElement = mediaElement;
+		if (!mediaElement) return;
+		removeListener = listen(mediaElement, "play", () => {
+			state.patch({ playbackInitiated: true });
+			events.dispatch({ type: "play" });
+		});
+	});
+	return () => {
+		removeListener?.();
+		unsubscribeState();
+		unsubscribeOwners();
+	};
+}
+
+//#endregion
+export { trackPlaybackInitiated };
+//# sourceMappingURL=track-playback-initiated.js.map

package/dist/dev/dom/features/track-playback-initiated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-playback-initiated.js","names":[],"sources":["../../../../src/dom/features/track-playback-initiated.ts"],"sourcesContent":["import { listen } from '@videojs/utils/dom';\nimport type { EventStream } from '../../core/events/create-event-stream';\nimport type { PresentationAction } from '../../core/features/resolve-presentation';\nimport type { WritableState } from '../../core/state/create-state';\n\n/**\n * State shape for playback initiation tracking.\n */\nexport interface PlaybackInitiatedState {\n  /** True once the user has initiated playback (play event fired). */\n  playbackInitiated?: boolean;\n  /** Current presentation — watched for URL changes to reset playbackInitiated. */\n  presentation?: { url?: string };\n}\n\n/**\n * Owners shape for playback initiation tracking.\n */\nexport interface PlaybackInitiatedOwners {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\n/**\n * Track whether playback has been initiated by the user.\n *\n * Sets `state.playbackInitiated = true` when the media element fires a `play`\n * event (via `element.play()`, native controls, or autoplay) and simultaneously\n * dispatches `{ type: 'play' }` to the event stream so `resolvePresentation`\n * can react.\n *\n * Resets `state.playbackInitiated = false` when `presentation.url` changes,\n * so a new source with `preload=\"none\"` won't load segments until play is\n * triggered again.\n *\n * This flag is used by `shouldLoadSegments` to allow segment loading after\n * play is initiated regardless of the initial `preload` setting — `preload`\n * is a startup hint, not a runtime gate.\n *\n * @example\n * const cleanup = trackPlaybackInitiated({ state, owners, events });\n */\nexport function trackPlaybackInitiated({\n  state,\n  owners,\n  events,\n}: {\n  state: WritableState<PlaybackInitiatedState>;\n  owners: WritableState<PlaybackInitiatedOwners>;\n  events: EventStream<PresentationAction>;\n}): () => void {\n  let lastMediaElement: HTMLMediaElement | undefined;\n  let removeListener: (() => void) | null = null;\n  let lastPresentationUrl: string | undefined;\n\n  // Watch for presentation URL changes to reset playbackInitiated\n  const unsubscribeState = state.subscribe((currentState) => {\n    const url = currentState.presentation?.url;\n    if (url !== lastPresentationUrl) {\n      if (lastPresentationUrl !== undefined) {\n        // URL changed to a new value — reset so new source requires play again\n        state.patch({ playbackInitiated: false });\n      }\n      lastPresentationUrl = url;\n    }\n  });\n\n  // Bridge media element play event → state flag + event stream\n  const unsubscribeOwners = owners.subscribe((currentOwners) => {\n    const { mediaElement } = currentOwners;\n\n    if (mediaElement === lastMediaElement) return;\n\n    removeListener?.();\n    removeListener = null;\n    lastMediaElement = mediaElement;\n\n    if (!mediaElement) return;\n\n    removeListener = listen(mediaElement, 'play', () => {\n      state.patch({ playbackInitiated: true });\n      events.dispatch({ type: 'play' });\n    });\n  });\n\n  return () => {\n    removeListener?.();\n    unsubscribeState();\n    unsubscribeOwners();\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,uBAAuB,EACrC,OACA,QACA,UAKa;CACb,IAAI;CACJ,IAAI,iBAAsC;CAC1C,IAAI;CAGJ,MAAM,mBAAmB,MAAM,WAAW,iBAAiB;EACzD,MAAM,MAAM,aAAa,cAAc;AACvC,MAAI,QAAQ,qBAAqB;AAC/B,OAAI,wBAAwB,OAE1B,OAAM,MAAM,EAAE,mBAAmB,OAAO,CAAC;AAE3C,yBAAsB;;GAExB;CAGF,MAAM,oBAAoB,OAAO,WAAW,kBAAkB;EAC5D,MAAM,EAAE,iBAAiB;AAEzB,MAAI,iBAAiB,iBAAkB;AAEvC,oBAAkB;AAClB,mBAAiB;AACjB,qBAAmB;AAEnB,MAAI,CAAC,aAAc;AAEnB,mBAAiB,OAAO,cAAc,cAAc;AAClD,SAAM,MAAM,EAAE,mBAAmB,MAAM,CAAC;AACxC,UAAO,SAAS,EAAE,MAAM,QAAQ,CAAC;IACjC;GACF;AAEF,cAAa;AACX,oBAAkB;AAClB,oBAAkB;AAClB,qBAAmB"}

package/dist/dev/dom/features/track-playback-rate.d.ts

@@ -0,0 +1,34 @@
+import { WritableState } from "../../core/state/create-state.js";
+
+//#region src/dom/features/track-playback-rate.d.ts
+/**
+ * State shape for playback rate tracking.
+ */
+interface PlaybackRateState {
+  playbackRate?: number;
+}
+/**
+ * Owners shape for playback rate tracking.
+ */
+interface PlaybackRateOwners {
+  mediaElement?: HTMLMediaElement | undefined;
+}
+/**
+ * Track playback rate from the media element.
+ *
+ * Mirrors `mediaElement.playbackRate` into reactive state on each `ratechange`
+ * event. Also syncs immediately when a media element becomes available.
+ *
+ * @example
+ * const cleanup = trackPlaybackRate({ state, owners });
+ */
+declare function trackPlaybackRate({
+  state,
+  owners
+}: {
+  state: WritableState<PlaybackRateState>;
+  owners: WritableState<PlaybackRateOwners>;
+}): () => void;
+//#endregion
+export { PlaybackRateOwners, PlaybackRateState, trackPlaybackRate };
+//# sourceMappingURL=track-playback-rate.d.ts.map

package/dist/dev/dom/features/track-playback-rate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-playback-rate.d.ts","names":[],"sources":["../../../../src/dom/features/track-playback-rate.ts"],"mappings":";;;;;AAMA;UAAiB,iBAAA;EACf,YAAA;AAAA;;AAMF;;UAAiB,kBAAA;EACf,YAAA,GAAe,gBAAA;AAAA;;;;;;;;;;iBAsBD,iBAAA,CAAA;EACd,KAAA;EACA;AAAA;EAEA,KAAA,EAAO,aAAA,CAAc,iBAAA;EACrB,MAAA,EAAQ,aAAA,CAAc,kBAAA;AAAA"}

package/dist/dev/dom/features/track-playback-rate.js

@@ -0,0 +1,36 @@
+import { listen } from "@videojs/utils/dom";
+
+//#region src/dom/features/track-playback-rate.ts
+/**
+* Track playback rate from the media element.
+*
+* Mirrors `mediaElement.playbackRate` into reactive state on each `ratechange`
+* event. Also syncs immediately when a media element becomes available.
+*
+* @example
+* const cleanup = trackPlaybackRate({ state, owners });
+*/
+function trackPlaybackRate({ state, owners }) {
+	let lastMediaElement;
+	let removeListener = null;
+	const unsubscribe = owners.subscribe((currentOwners) => {
+		const { mediaElement } = currentOwners;
+		if (mediaElement === lastMediaElement) return;
+		removeListener?.();
+		removeListener = null;
+		lastMediaElement = mediaElement;
+		if (!mediaElement) return;
+		state.patch({ playbackRate: mediaElement.playbackRate });
+		removeListener = listen(mediaElement, "ratechange", () => {
+			state.patch({ playbackRate: mediaElement.playbackRate });
+		});
+	});
+	return () => {
+		removeListener?.();
+		unsubscribe();
+	};
+}
+
+//#endregion
+export { trackPlaybackRate };
+//# sourceMappingURL=track-playback-rate.js.map

package/dist/dev/dom/features/track-playback-rate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-playback-rate.js","names":[],"sources":["../../../../src/dom/features/track-playback-rate.ts"],"sourcesContent":["import { listen } from '@videojs/utils/dom';\nimport type { WritableState } from '../../core/state/create-state';\n\n/**\n * State shape for playback rate tracking.\n */\nexport interface PlaybackRateState {\n  playbackRate?: number;\n}\n\n/**\n * Owners shape for playback rate tracking.\n */\nexport interface PlaybackRateOwners {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\n/**\n * Check if we can track playback rate.\n *\n * Requires:\n * - mediaElement exists in owners\n */\nexport function canTrackPlaybackRate(owners: PlaybackRateOwners): boolean {\n  return !!owners.mediaElement;\n}\n\n/**\n * Track playback rate from the media element.\n *\n * Mirrors `mediaElement.playbackRate` into reactive state on each `ratechange`\n * event. Also syncs immediately when a media element becomes available.\n *\n * @example\n * const cleanup = trackPlaybackRate({ state, owners });\n */\nexport function trackPlaybackRate({\n  state,\n  owners,\n}: {\n  state: WritableState<PlaybackRateState>;\n  owners: WritableState<PlaybackRateOwners>;\n}): () => void {\n  let lastMediaElement: HTMLMediaElement | undefined;\n  let removeListener: (() => void) | null = null;\n\n  const unsubscribe = owners.subscribe((currentOwners) => {\n    const { mediaElement } = currentOwners;\n\n    if (mediaElement === lastMediaElement) return;\n\n    removeListener?.();\n    removeListener = null;\n    lastMediaElement = mediaElement;\n\n    if (!mediaElement) return;\n\n    state.patch({ playbackRate: mediaElement.playbackRate });\n\n    removeListener = listen(mediaElement, 'ratechange', () => {\n      state.patch({ playbackRate: mediaElement.playbackRate });\n    });\n  });\n\n  return () => {\n    removeListener?.();\n    unsubscribe();\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAoCA,SAAgB,kBAAkB,EAChC,OACA,UAIa;CACb,IAAI;CACJ,IAAI,iBAAsC;CAE1C,MAAM,cAAc,OAAO,WAAW,kBAAkB;EACtD,MAAM,EAAE,iBAAiB;AAEzB,MAAI,iBAAiB,iBAAkB;AAEvC,oBAAkB;AAClB,mBAAiB;AACjB,qBAAmB;AAEnB,MAAI,CAAC,aAAc;AAEnB,QAAM,MAAM,EAAE,cAAc,aAAa,cAAc,CAAC;AAExD,mBAAiB,OAAO,cAAc,oBAAoB;AACxD,SAAM,MAAM,EAAE,cAAc,aAAa,cAAc,CAAC;IACxD;GACF;AAEF,cAAa;AACX,oBAAkB;AAClB,eAAa"}

package/dist/dev/dom/features/update-duration.js

@@ -0,0 +1,72 @@
+import { hasPresentationDuration } from "../../core/types/index.js";
+import { combineLatest } from "../../core/reactive/combine-latest.js";
+
+//#region src/dom/features/update-duration.ts
+/**
+* Check if we can update MediaSource duration (have required data).
+*/
+function canUpdateDuration(state, owners) {
+	return !!(owners.mediaSource && state.presentation && hasPresentationDuration(state.presentation));
+}
+/**
+* Get the maximum buffered end time across all SourceBuffers.
+*/
+function getMaxBufferedEnd(owners) {
+	let maxEnd = 0;
+	const buffers = [owners.videoSourceBuffer, owners.audioSourceBuffer].filter((buf) => buf !== void 0);
+	for (const buffer of buffers) {
+		const { buffered } = buffer;
+		if (buffered.length > 0) {
+			const end = buffered.end(buffered.length - 1);
+			if (end > maxEnd) maxEnd = end;
+		}
+	}
+	return maxEnd;
+}
+/**
+* Check if we should update MediaSource duration (conditions met).
+*/
+function shouldUpdateDuration(state, owners) {
+	if (!canUpdateDuration(state, owners)) return false;
+	const { mediaSource } = owners;
+	const { presentation } = state;
+	if (mediaSource.readyState !== "open") return false;
+	const duration = presentation.duration;
+	if (!Number.isFinite(duration) || Number.isNaN(duration) || duration <= 0) return false;
+	return Number.isNaN(mediaSource.duration);
+}
+/**
+* Wait for all currently-updating SourceBuffers to finish.
+*
+* The MSE spec forbids setting MediaSource.duration while any attached
+* SourceBuffer has updating === true. This defers until all are idle.
+*/
+function waitForSourceBuffersReady(owners) {
+	const updating = [owners.videoSourceBuffer, owners.audioSourceBuffer].filter((buf) => buf?.updating === true);
+	if (updating.length === 0) return Promise.resolve();
+	return Promise.all(updating.map((buf) => new Promise((resolve) => buf.addEventListener("updateend", () => resolve(), { once: true })))).then(() => void 0);
+}
+/**
+* Update MediaSource duration when presentation duration becomes available.
+*/
+function updateDuration({ state, owners }) {
+	let destroyed = false;
+	const unsubscribe = combineLatest([state, owners]).subscribe(async ([currentState, currentOwners]) => {
+		if (!shouldUpdateDuration(currentState, currentOwners)) return;
+		const { mediaSource } = currentOwners;
+		await waitForSourceBuffersReady(currentOwners);
+		if (destroyed || mediaSource.readyState !== "open") return;
+		let duration = currentState.presentation.duration;
+		const maxBufferedEnd = getMaxBufferedEnd(currentOwners);
+		if (maxBufferedEnd > duration) duration = maxBufferedEnd;
+		mediaSource.duration = duration;
+	});
+	return () => {
+		destroyed = true;
+		unsubscribe();
+	};
+}
+
+//#endregion
+export { updateDuration };
+//# sourceMappingURL=update-duration.js.map

package/dist/dev/dom/features/update-duration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-duration.js","names":[],"sources":["../../../../src/dom/features/update-duration.ts"],"sourcesContent":["import { combineLatest } from '../../core/reactive/combine-latest';\nimport type { WritableState } from '../../core/state/create-state';\nimport type { Presentation } from '../../core/types';\nimport { hasPresentationDuration } from '../../core/types';\n\nexport interface DurationUpdateState {\n  presentation?: Presentation;\n}\n\nexport interface DurationUpdateOwners {\n  mediaSource?: MediaSource;\n  videoSourceBuffer?: SourceBuffer;\n  audioSourceBuffer?: SourceBuffer;\n}\n\n/**\n * Check if we can update MediaSource duration (have required data).\n */\nexport function canUpdateDuration(state: DurationUpdateState, owners: DurationUpdateOwners): boolean {\n  return !!(owners.mediaSource && state.presentation && hasPresentationDuration(state.presentation));\n}\n\n/**\n * Get the maximum buffered end time across all SourceBuffers.\n */\nexport function getMaxBufferedEnd(owners: DurationUpdateOwners): number {\n  let maxEnd = 0;\n\n  const buffers = [owners.videoSourceBuffer, owners.audioSourceBuffer].filter(\n    (buf): buf is SourceBuffer => buf !== undefined\n  );\n\n  for (const buffer of buffers) {\n    const { buffered } = buffer;\n    if (buffered.length > 0) {\n      const end = buffered.end(buffered.length - 1);\n      if (end > maxEnd) {\n        maxEnd = end;\n      }\n    }\n  }\n\n  return maxEnd;\n}\n\n/**\n * Check if we should update MediaSource duration (conditions met).\n */\nexport function shouldUpdateDuration(state: DurationUpdateState, owners: DurationUpdateOwners): boolean {\n  if (!canUpdateDuration(state, owners)) return false;\n\n  const { mediaSource } = owners;\n  const { presentation } = state;\n\n  // MediaSource must be open\n  if (mediaSource!.readyState !== 'open') return false;\n\n  const duration = presentation!.duration!;\n\n  // Validate duration: finite, positive, not NaN\n  if (!Number.isFinite(duration) || Number.isNaN(duration) || duration <= 0) return false;\n\n  // Only set duration on initial MediaSource setup, when it hasn't been set yet.\n  // A freshly opened MediaSource has duration === NaN. Once set (either by this\n  // task or by endOfStreamTask from buffered.end()), we leave it alone — attempting\n  // to re-sync a slight drift between mediaSource.duration and presentation.duration\n  // races with concurrent appendBuffer() calls from loadSegmentsTask.\n  return Number.isNaN(mediaSource!.duration);\n}\n\n/**\n * Wait for all currently-updating SourceBuffers to finish.\n *\n * The MSE spec forbids setting MediaSource.duration while any attached\n * SourceBuffer has updating === true. This defers until all are idle.\n */\nfunction waitForSourceBuffersReady(owners: DurationUpdateOwners): Promise<void> {\n  const updating = [owners.videoSourceBuffer, owners.audioSourceBuffer].filter(\n    (buf): buf is SourceBuffer => buf?.updating === true\n  );\n\n  if (updating.length === 0) return Promise.resolve();\n\n  return Promise.all(\n    updating.map(\n      (buf) => new Promise<void>((resolve) => buf.addEventListener('updateend', () => resolve(), { once: true }))\n    )\n  ).then(() => undefined);\n}\n\n/**\n * Update MediaSource duration when presentation duration becomes available.\n */\nexport function updateDuration({\n  state,\n  owners,\n}: {\n  state: WritableState<DurationUpdateState>;\n  owners: WritableState<DurationUpdateOwners>;\n}): () => void {\n  let destroyed = false;\n\n  const unsubscribe = combineLatest([state, owners]).subscribe(\n    async ([currentState, currentOwners]: [DurationUpdateState, DurationUpdateOwners]) => {\n      if (!shouldUpdateDuration(currentState, currentOwners)) return;\n\n      const { mediaSource } = currentOwners;\n\n      // MSE spec: duration cannot be set while any SourceBuffer is updating\n      await waitForSourceBuffersReady(currentOwners);\n\n      // Re-check after async wait: destroyed, or readyState changed (e.g. endOfStream\n      // already called endOfStream(), transitioning 'open' → 'ended').\n      if (destroyed || mediaSource!.readyState !== 'open') return;\n\n      let duration = currentState.presentation!.duration!;\n\n      // Get max buffered end time across all SourceBuffers\n      const maxBufferedEnd = getMaxBufferedEnd(currentOwners);\n\n      // MSE spec: duration cannot be less than any buffered range\n      // If buffered ranges exceed calculated duration, extend to match\n      if (maxBufferedEnd > duration) {\n        duration = maxBufferedEnd;\n      }\n\n      // Set duration on MediaSource\n      mediaSource!.duration = duration;\n    }\n  );\n\n  return () => {\n    destroyed = true;\n    unsubscribe();\n  };\n}\n"],"mappings":";;;;;;;AAkBA,SAAgB,kBAAkB,OAA4B,QAAuC;AACnG,QAAO,CAAC,EAAE,OAAO,eAAe,MAAM,gBAAgB,wBAAwB,MAAM,aAAa;;;;;AAMnG,SAAgB,kBAAkB,QAAsC;CACtE,IAAI,SAAS;CAEb,MAAM,UAAU,CAAC,OAAO,mBAAmB,OAAO,kBAAkB,CAAC,QAClE,QAA6B,QAAQ,OACvC;AAED,MAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,EAAE,aAAa;AACrB,MAAI,SAAS,SAAS,GAAG;GACvB,MAAM,MAAM,SAAS,IAAI,SAAS,SAAS,EAAE;AAC7C,OAAI,MAAM,OACR,UAAS;;;AAKf,QAAO;;;;;AAMT,SAAgB,qBAAqB,OAA4B,QAAuC;AACtG,KAAI,CAAC,kBAAkB,OAAO,OAAO,CAAE,QAAO;CAE9C,MAAM,EAAE,gBAAgB;CACxB,MAAM,EAAE,iBAAiB;AAGzB,KAAI,YAAa,eAAe,OAAQ,QAAO;CAE/C,MAAM,WAAW,aAAc;AAG/B,KAAI,CAAC,OAAO,SAAS,SAAS,IAAI,OAAO,MAAM,SAAS,IAAI,YAAY,EAAG,QAAO;AAOlF,QAAO,OAAO,MAAM,YAAa,SAAS;;;;;;;;AAS5C,SAAS,0BAA0B,QAA6C;CAC9E,MAAM,WAAW,CAAC,OAAO,mBAAmB,OAAO,kBAAkB,CAAC,QACnE,QAA6B,KAAK,aAAa,KACjD;AAED,KAAI,SAAS,WAAW,EAAG,QAAO,QAAQ,SAAS;AAEnD,QAAO,QAAQ,IACb,SAAS,KACN,QAAQ,IAAI,SAAe,YAAY,IAAI,iBAAiB,mBAAmB,SAAS,EAAE,EAAE,MAAM,MAAM,CAAC,CAAC,CAC5G,CACF,CAAC,WAAW,OAAU;;;;;AAMzB,SAAgB,eAAe,EAC7B,OACA,UAIa;CACb,IAAI,YAAY;CAEhB,MAAM,cAAc,cAAc,CAAC,OAAO,OAAO,CAAC,CAAC,UACjD,OAAO,CAAC,cAAc,mBAAgE;AACpF,MAAI,CAAC,qBAAqB,cAAc,cAAc,CAAE;EAExD,MAAM,EAAE,gBAAgB;AAGxB,QAAM,0BAA0B,cAAc;AAI9C,MAAI,aAAa,YAAa,eAAe,OAAQ;EAErD,IAAI,WAAW,aAAa,aAAc;EAG1C,MAAM,iBAAiB,kBAAkB,cAAc;AAIvD,MAAI,iBAAiB,SACnB,YAAW;AAIb,cAAa,WAAW;GAE3B;AAED,cAAa;AACX,cAAY;AACZ,eAAa"}

package/dist/dev/dom/media/append-segment.d.ts

@@ -0,0 +1,24 @@
+//#region src/dom/media/append-segment.d.ts
+/**
+ * Segment appender helper.
+ *
+ * Appends media data (ArrayBuffer or AsyncIterable<Uint8Array> stream) to a
+ * SourceBuffer, waiting for `updateend` between calls so the browser can
+ * process each append before the next one arrives.
+ */
+/** Data accepted by appendSegment — a full buffer or an async chunk stream. */
+type AppendData = ArrayBuffer | AsyncIterable<Uint8Array>;
+/**
+ * Append media data to a SourceBuffer.
+ *
+ * Accepts either a full ArrayBuffer (single append) or an AsyncIterable of
+ * Uint8Array chunks (one append per chunk, in order). Waits for `updateend`
+ * between each call so appends are serialized correctly.
+ *
+ * Errors from the SourceBuffer (`error` event) or from the iterable are
+ * propagated as rejections.
+ */
+declare function appendSegment(sourceBuffer: SourceBuffer, data: AppendData, signal?: AbortSignal): Promise<void>;
+//#endregion
+export { AppendData, appendSegment };
+//# sourceMappingURL=append-segment.d.ts.map

package/dist/dev/dom/media/append-segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"append-segment.d.ts","names":[],"sources":["../../../../src/dom/media/append-segment.ts"],"mappings":";;AASA;;;;;;;KAAY,UAAA,GAAa,WAAA,GAAc,aAAA,CAAc,UAAA;;;;;;AAYrD;;;;;iBAAsB,aAAA,CAAc,YAAA,EAAc,YAAA,EAAc,IAAA,EAAM,UAAA,EAAY,MAAA,GAAS,WAAA,GAAc,OAAA"}

package/dist/dev/dom/media/append-segment.js

@@ -0,0 +1,60 @@
+//#region src/dom/media/append-segment.ts
+/**
+* Append media data to a SourceBuffer.
+*
+* Accepts either a full ArrayBuffer (single append) or an AsyncIterable of
+* Uint8Array chunks (one append per chunk, in order). Waits for `updateend`
+* between each call so appends are serialized correctly.
+*
+* Errors from the SourceBuffer (`error` event) or from the iterable are
+* propagated as rejections.
+*/
+async function appendSegment(sourceBuffer, data, signal) {
+	if (data instanceof ArrayBuffer) await appendChunk(sourceBuffer, data);
+	else try {
+		for await (const chunk of data) {
+			if (signal?.aborted) throw signal.reason ?? new DOMException("Aborted", "AbortError");
+			await appendChunk(sourceBuffer, chunk);
+		}
+	} catch (e) {
+		if (e instanceof DOMException && e.name === "AbortError" && !sourceBuffer.updating) try {
+			sourceBuffer.abort();
+		} catch {}
+		throw e;
+	}
+}
+async function appendChunk(sourceBuffer, data) {
+	if (sourceBuffer.updating) await new Promise((resolve) => {
+		const onUpdateEnd = () => {
+			sourceBuffer.removeEventListener("updateend", onUpdateEnd);
+			resolve();
+		};
+		sourceBuffer.addEventListener("updateend", onUpdateEnd);
+	});
+	return new Promise((resolve, reject) => {
+		const onUpdateEnd = () => {
+			cleanup();
+			resolve();
+		};
+		const onError = (event) => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`SourceBuffer append error: ${event.type}`));
+		};
+		const cleanup = () => {
+			sourceBuffer.removeEventListener("updateend", onUpdateEnd);
+			sourceBuffer.removeEventListener("error", onError);
+		};
+		sourceBuffer.addEventListener("updateend", onUpdateEnd);
+		sourceBuffer.addEventListener("error", onError);
+		try {
+			sourceBuffer.appendBuffer(data);
+		} catch (error) {
+			cleanup();
+			reject(error);
+		}
+	});
+}
+
+//#endregion
+export { appendSegment };
+//# sourceMappingURL=append-segment.js.map

package/dist/dev/dom/media/append-segment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"append-segment.js","names":[],"sources":["../../../../src/dom/media/append-segment.ts"],"sourcesContent":["/**\n * Segment appender helper.\n *\n * Appends media data (ArrayBuffer or AsyncIterable<Uint8Array> stream) to a\n * SourceBuffer, waiting for `updateend` between calls so the browser can\n * process each append before the next one arrives.\n */\n\n/** Data accepted by appendSegment — a full buffer or an async chunk stream. */\nexport type AppendData = ArrayBuffer | AsyncIterable<Uint8Array>;\n\n/**\n * Append media data to a SourceBuffer.\n *\n * Accepts either a full ArrayBuffer (single append) or an AsyncIterable of\n * Uint8Array chunks (one append per chunk, in order). Waits for `updateend`\n * between each call so appends are serialized correctly.\n *\n * Errors from the SourceBuffer (`error` event) or from the iterable are\n * propagated as rejections.\n */\nexport async function appendSegment(sourceBuffer: SourceBuffer, data: AppendData, signal?: AbortSignal): Promise<void> {\n  if (data instanceof ArrayBuffer) {\n    await appendChunk(sourceBuffer, data);\n  } else {\n    try {\n      for await (const chunk of data) {\n        // Check between chunks so an abort can stop streaming before the next\n        // appendBuffer call. The current chunk (if any) has already landed in the\n        // SourceBuffer; the partial: true flag in the actor model reflects this.\n        if (signal?.aborted) throw signal.reason ?? new DOMException('Aborted', 'AbortError');\n        await appendChunk(sourceBuffer, chunk);\n      }\n    } catch (e) {\n      // Reset the MSE segment parser on any abort to discard partial fMP4 box\n      // data from the SourceBuffer's internal byte buffer. Two paths reach here:\n      //\n      // 1. Explicit abort check above (signal.aborted between chunks) — the\n      //    last appended chunk may have left the parser mid-fragment.\n      //\n      // 2. The fetch was cancelled (signal fired), causing the underlying\n      //    ReadableStream to error and the for-await loop to throw directly\n      //    without ever passing through the signal check above. Same cleanup\n      //    is needed: partial box data must be cleared before the next append.\n      //\n      // Without this, the next appendBuffer call sees stale partial data and\n      // Chrome throws CHUNK_DEMUXER_ERROR_APPEND_FAILED.\n      if (e instanceof DOMException && e.name === 'AbortError' && !sourceBuffer.updating) {\n        try {\n          sourceBuffer.abort();\n        } catch {\n          // Thrown if the MediaSource is not \"open\" (e.g. during teardown).\n        }\n      }\n      throw e;\n    }\n  }\n}\n\nasync function appendChunk(sourceBuffer: SourceBuffer, data: ArrayBuffer | Uint8Array<ArrayBufferLike>): Promise<void> {\n  if (sourceBuffer.updating) {\n    await new Promise<void>((resolve) => {\n      const onUpdateEnd = () => {\n        sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n        resolve();\n      };\n      sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    });\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const onUpdateEnd = () => {\n      cleanup();\n      resolve();\n    };\n\n    const onError = (event: Event) => {\n      cleanup();\n      reject(new Error(`SourceBuffer append error: ${event.type}`));\n    };\n\n    const cleanup = () => {\n      sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n      sourceBuffer.removeEventListener('error', onError);\n    };\n\n    sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    sourceBuffer.addEventListener('error', onError);\n\n    try {\n      sourceBuffer.appendBuffer(data as ArrayBuffer);\n    } catch (error) {\n      cleanup();\n      reject(error);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;AAqBA,eAAsB,cAAc,cAA4B,MAAkB,QAAqC;AACrH,KAAI,gBAAgB,YAClB,OAAM,YAAY,cAAc,KAAK;KAErC,KAAI;AACF,aAAW,MAAM,SAAS,MAAM;AAI9B,OAAI,QAAQ,QAAS,OAAM,OAAO,UAAU,IAAI,aAAa,WAAW,aAAa;AACrF,SAAM,YAAY,cAAc,MAAM;;UAEjC,GAAG;AAcV,MAAI,aAAa,gBAAgB,EAAE,SAAS,gBAAgB,CAAC,aAAa,SACxE,KAAI;AACF,gBAAa,OAAO;UACd;AAIV,QAAM;;;AAKZ,eAAe,YAAY,cAA4B,MAAgE;AACrH,KAAI,aAAa,SACf,OAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;AACxB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,YAAS;;AAEX,eAAa,iBAAiB,aAAa,YAAY;GACvD;AAGJ,QAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;AACxB,YAAS;AACT,YAAS;;EAGX,MAAM,WAAW,UAAiB;AAChC,YAAS;AACT,0BAAO,IAAI,MAAM,8BAA8B,MAAM,OAAO,CAAC;;EAG/D,MAAM,gBAAgB;AACpB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,gBAAa,oBAAoB,SAAS,QAAQ;;AAGpD,eAAa,iBAAiB,aAAa,YAAY;AACvD,eAAa,iBAAiB,SAAS,QAAQ;AAE/C,MAAI;AACF,gBAAa,aAAa,KAAoB;WACvC,OAAO;AACd,YAAS;AACT,UAAO,MAAM;;GAEf"}

package/dist/dev/dom/media/buffer-flusher.d.ts

@@ -0,0 +1,24 @@
+//#region src/dom/media/buffer-flusher.d.ts
+/**
+ * Buffer flusher helper (P12)
+ *
+ * Removes a time range from a SourceBuffer to manage memory.
+ */
+/**
+ * Remove a time range from a SourceBuffer.
+ *
+ * Waits for the SourceBuffer to be ready (not updating), then removes
+ * the specified range. Returns a promise that resolves when removal completes.
+ *
+ * @param sourceBuffer - The SourceBuffer to remove data from
+ * @param start - Start of the time range to remove (seconds)
+ * @param end - End of the time range to remove (seconds)
+ * @returns Promise that resolves when removal completes
+ *
+ * @example
+ * await flushBuffer(videoSourceBuffer, 0, 30);
+ */
+declare function flushBuffer(sourceBuffer: SourceBuffer, start: number, end: number): Promise<void>;
+//#endregion
+export { flushBuffer };
+//# sourceMappingURL=buffer-flusher.d.ts.map

package/dist/dev/dom/media/buffer-flusher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-flusher.d.ts","names":[],"sources":["../../../../src/dom/media/buffer-flusher.ts"],"mappings":";;AAoBA;;;;;;;;;;;;;;;;;;iBAAsB,WAAA,CAAY,YAAA,EAAc,YAAA,EAAc,KAAA,UAAe,GAAA,WAAc,OAAA"}

package/dist/dev/dom/media/buffer-flusher.js

@@ -0,0 +1,55 @@
+//#region src/dom/media/buffer-flusher.ts
+/**
+* Buffer flusher helper (P12)
+*
+* Removes a time range from a SourceBuffer to manage memory.
+*/
+/**
+* Remove a time range from a SourceBuffer.
+*
+* Waits for the SourceBuffer to be ready (not updating), then removes
+* the specified range. Returns a promise that resolves when removal completes.
+*
+* @param sourceBuffer - The SourceBuffer to remove data from
+* @param start - Start of the time range to remove (seconds)
+* @param end - End of the time range to remove (seconds)
+* @returns Promise that resolves when removal completes
+*
+* @example
+* await flushBuffer(videoSourceBuffer, 0, 30);
+*/
+async function flushBuffer(sourceBuffer, start, end) {
+	if (sourceBuffer.updating) await new Promise((resolve) => {
+		const onUpdateEnd = () => {
+			sourceBuffer.removeEventListener("updateend", onUpdateEnd);
+			resolve();
+		};
+		sourceBuffer.addEventListener("updateend", onUpdateEnd);
+	});
+	return new Promise((resolve, reject) => {
+		const onUpdateEnd = () => {
+			cleanup();
+			resolve();
+		};
+		const onError = (event) => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`SourceBuffer remove error: ${event.type}`));
+		};
+		const cleanup = () => {
+			sourceBuffer.removeEventListener("updateend", onUpdateEnd);
+			sourceBuffer.removeEventListener("error", onError);
+		};
+		sourceBuffer.addEventListener("updateend", onUpdateEnd);
+		sourceBuffer.addEventListener("error", onError);
+		try {
+			sourceBuffer.remove(start, end);
+		} catch (error) {
+			cleanup();
+			reject(error);
+		}
+	});
+}
+
+//#endregion
+export { flushBuffer };
+//# sourceMappingURL=buffer-flusher.js.map

package/dist/dev/dom/media/buffer-flusher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-flusher.js","names":[],"sources":["../../../../src/dom/media/buffer-flusher.ts"],"sourcesContent":["/**\n * Buffer flusher helper (P12)\n *\n * Removes a time range from a SourceBuffer to manage memory.\n */\n\n/**\n * Remove a time range from a SourceBuffer.\n *\n * Waits for the SourceBuffer to be ready (not updating), then removes\n * the specified range. Returns a promise that resolves when removal completes.\n *\n * @param sourceBuffer - The SourceBuffer to remove data from\n * @param start - Start of the time range to remove (seconds)\n * @param end - End of the time range to remove (seconds)\n * @returns Promise that resolves when removal completes\n *\n * @example\n * await flushBuffer(videoSourceBuffer, 0, 30);\n */\nexport async function flushBuffer(sourceBuffer: SourceBuffer, start: number, end: number): Promise<void> {\n  // Wait for SourceBuffer to be ready (not currently updating)\n  if (sourceBuffer.updating) {\n    await new Promise<void>((resolve) => {\n      const onUpdateEnd = () => {\n        sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n        resolve();\n      };\n      sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    });\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const onUpdateEnd = () => {\n      cleanup();\n      resolve();\n    };\n\n    const onError = (event: Event) => {\n      cleanup();\n      reject(new Error(`SourceBuffer remove error: ${event.type}`));\n    };\n\n    const cleanup = () => {\n      sourceBuffer.removeEventListener('updateend', onUpdateEnd);\n      sourceBuffer.removeEventListener('error', onError);\n    };\n\n    sourceBuffer.addEventListener('updateend', onUpdateEnd);\n    sourceBuffer.addEventListener('error', onError);\n\n    try {\n      sourceBuffer.remove(start, end);\n    } catch (error) {\n      cleanup();\n      reject(error);\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,eAAsB,YAAY,cAA4B,OAAe,KAA4B;AAEvG,KAAI,aAAa,SACf,OAAM,IAAI,SAAe,YAAY;EACnC,MAAM,oBAAoB;AACxB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,YAAS;;AAEX,eAAa,iBAAiB,aAAa,YAAY;GACvD;AAGJ,QAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,oBAAoB;AACxB,YAAS;AACT,YAAS;;EAGX,MAAM,WAAW,UAAiB;AAChC,YAAS;AACT,0BAAO,IAAI,MAAM,8BAA8B,MAAM,OAAO,CAAC;;EAG/D,MAAM,gBAAgB;AACpB,gBAAa,oBAAoB,aAAa,YAAY;AAC1D,gBAAa,oBAAoB,SAAS,QAAQ;;AAGpD,eAAa,iBAAiB,aAAa,YAAY;AACvD,eAAa,iBAAiB,SAAS,QAAQ;AAE/C,MAAI;AACF,gBAAa,OAAO,OAAO,IAAI;WACxB,OAAO;AACd,YAAS;AACT,UAAO,MAAM;;GAEf"}