@videojs/spf 10.0.0-beta.10 → 10.0.0-beta.12

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

@@ -0,0 +1,49 @@
+import { effect } from "../../core/signals/effect.js";
+import { update } from "../../core/signals/primitives.js";
+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 cleanupEffect = effect(() => {
+		const { mediaElement } = owners.get();
+		if (mediaElement === lastMediaElement) return;
+		removeListeners?.();
+		removeListeners = null;
+		lastMediaElement = mediaElement;
+		if (!mediaElement) return;
+		const sync = () => {
+			update(state, { currentTime: mediaElement.currentTime });
+		};
+		sync();
+		const removeTimeupdate = listen(mediaElement, "timeupdate", sync);
+		const removeSeeking = listen(mediaElement, "seeking", sync);
+		removeListeners = () => {
+			removeTimeupdate();
+			removeSeeking();
+		};
+	});
+	return () => {
+		removeListeners?.();
+		cleanupEffect();
+	};
+}
+//#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 { effect } from '../../core/signals/effect';\nimport { type Signal, update } from '../../core/signals/primitives';\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<S extends CurrentTimeState, O extends CurrentTimeOwners>({\n  state,\n  owners,\n}: {\n  state: Signal<S>;\n  owners: Signal<O>;\n}): () => void {\n  let lastMediaElement: HTMLMediaElement | undefined;\n  let removeListeners: (() => void) | null = null;\n\n  const cleanupEffect = effect(() => {\n    const { mediaElement } = owners.get();\n\n    if (mediaElement === lastMediaElement) return;\n\n    removeListeners?.();\n    removeListeners = null;\n    lastMediaElement = mediaElement;\n\n    if (!mediaElement) return;\n\n    const sync = () => {\n      const patch: Partial<CurrentTimeState> = { currentTime: mediaElement.currentTime };\n      update(state, patch);\n    };\n\n    // Sync immediately so consumers don't wait for the first event\n    sync();\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    cleanupEffect();\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA2CA,SAAgB,iBAA0E,EACxF,OACA,UAIa;CACb,IAAI;CACJ,IAAI,kBAAuC;CAE3C,MAAM,gBAAgB,aAAa;EACjC,MAAM,EAAE,iBAAiB,OAAO,KAAK;AAErC,MAAI,iBAAiB,iBAAkB;AAEvC,qBAAmB;AACnB,oBAAkB;AAClB,qBAAmB;AAEnB,MAAI,CAAC,aAAc;EAEnB,MAAM,aAAa;AAEjB,UAAO,OADkC,EAAE,aAAa,aAAa,aAAa,CAC9D;;AAItB,QAAM;EACN,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,iBAAe"}

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

@@ -0,0 +1,44 @@
+import { Signal } from "../../core/signals/primitives.js";
+
+//#region src/dom/features/track-playback-initiated.d.ts
+/**
+ * State shape for playback initiation tracking.
+ */
+interface PlaybackInitiatedState {
+  /** True once play has been requested for the current presentation URL. */
+  playbackInitiated?: boolean;
+  /** Current presentation — URL is used to detect source changes. */
+  presentation?: {
+    url?: string;
+  };
+}
+/**
+ * Owners shape for playback initiation tracking.
+ */
+interface PlaybackInitiatedOwners {
+  mediaElement?: HTMLMediaElement | undefined;
+}
+/**
+ * Track whether playback has been initiated for the current presentation URL.
+ *
+ * Uses a local intermediate signal written by two effect streams:
+ * - false stream: resets on URL change
+ * - true stream: sets on play event
+ *
+ * A third merge effect reads the local signal and writes to state, reading
+ * `state.get()` at merge time so the spread uses the up-to-date value after
+ * the async forward bridge has run.
+ *
+ * @example
+ * const cleanup = trackPlaybackInitiated({ state, owners, events });
+ */
+declare function trackPlaybackInitiated<S extends PlaybackInitiatedState, O extends PlaybackInitiatedOwners>({
+  state,
+  owners
+}: {
+  state: Signal<S>;
+  owners: Signal<O>;
+}): () => 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":";;;;;AAOA;UAAiB,sBAAA;;EAEf,iBAAA;EAAA;EAEA,YAAA;IAAiB,GAAA;EAAA;AAAA;AAMnB;;;AAAA,UAAiB,uBAAA;EACf,YAAA,GAAe,gBAAA;AAAA;;;;;;;;;;;;;;;iBAiBD,sBAAA,WAAiC,sBAAA,YAAkC,uBAAA,CAAA,CAAA;EACjF,KAAA;EACA;AAAA;EAEA,KAAA,EAAO,MAAA,CAAO,CAAA;EACd,MAAA,EAAQ,MAAA,CAAO,CAAA;AAAA"}

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

@@ -0,0 +1,53 @@
+import { effect } from "../../core/signals/effect.js";
+import { computed, signal, update } from "../../core/signals/primitives.js";
+import { listen } from "@videojs/utils/dom";
+//#region src/dom/features/track-playback-initiated.ts
+/**
+* Track whether playback has been initiated for the current presentation URL.
+*
+* Uses a local intermediate signal written by two effect streams:
+* - false stream: resets on URL change
+* - true stream: sets on play event
+*
+* A third merge effect reads the local signal and writes to state, reading
+* `state.get()` at merge time so the spread uses the up-to-date value after
+* the async forward bridge has run.
+*
+* @example
+* const cleanup = trackPlaybackInitiated({ state, owners, events });
+*/
+function trackPlaybackInitiated({ state, owners }) {
+	const presentationUrl = computed(() => state.get().presentation?.url);
+	const mediaElement = computed(() => owners.get().mediaElement);
+	const playbackInitiated = signal(void 0);
+	let lastPresentationUrl;
+	let lastMediaElement;
+	const cleanupResetEffect = effect(() => {
+		const url = presentationUrl.get();
+		const el = mediaElement.get();
+		if (url !== lastPresentationUrl && lastPresentationUrl !== void 0 || el !== lastMediaElement && lastMediaElement !== void 0) playbackInitiated.set(false);
+		lastPresentationUrl = url;
+		lastMediaElement = el;
+	});
+	const cleanupPlayEffect = effect(() => {
+		const el = mediaElement.get();
+		if (!el) return;
+		return listen(el, "play", () => {
+			playbackInitiated.set(true);
+		});
+	});
+	const cleanupMergeEffect = effect(() => {
+		const pi = playbackInitiated.get();
+		if (pi === void 0) return;
+		if (state.get().playbackInitiated !== pi) update(state, { playbackInitiated: pi });
+	});
+	return () => {
+		cleanupResetEffect();
+		cleanupPlayEffect();
+		cleanupMergeEffect();
+	};
+}
+//#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 { effect } from '../../core/signals/effect';\nimport { computed, type Signal, signal, update } from '../../core/signals/primitives';\n\n/**\n * State shape for playback initiation tracking.\n */\nexport interface PlaybackInitiatedState {\n  /** True once play has been requested for the current presentation URL. */\n  playbackInitiated?: boolean;\n  /** Current presentation — URL is used to detect source changes. */\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 for the current presentation URL.\n *\n * Uses a local intermediate signal written by two effect streams:\n * - false stream: resets on URL change\n * - true stream: sets on play event\n *\n * A third merge effect reads the local signal and writes to state, reading\n * `state.get()` at merge time so the spread uses the up-to-date value after\n * the async forward bridge has run.\n *\n * @example\n * const cleanup = trackPlaybackInitiated({ state, owners, events });\n */\nexport function trackPlaybackInitiated<S extends PlaybackInitiatedState, O extends PlaybackInitiatedOwners>({\n  state,\n  owners,\n}: {\n  state: Signal<S>;\n  owners: Signal<O>;\n}): () => void {\n  const presentationUrl = computed(() => state.get().presentation?.url);\n  const mediaElement = computed(() => owners.get().mediaElement);\n\n  // Local signal: written by the URL effect (false) and the play listener (true).\n  // undefined = not yet initialized (suppresses the merge effect on startup).\n  const playbackInitiated = signal<boolean | undefined>(undefined);\n\n  let lastPresentationUrl: string | undefined;\n  let lastMediaElement: HTMLMediaElement | undefined;\n\n  // False stream: reset on URL change or element swap.\n  const cleanupResetEffect = effect(() => {\n    const url = presentationUrl.get();\n    const el = mediaElement.get();\n\n    const urlChanged = url !== lastPresentationUrl;\n    const elChanged = el !== lastMediaElement;\n\n    if ((urlChanged && lastPresentationUrl !== undefined) || (elChanged && lastMediaElement !== undefined)) {\n      playbackInitiated.set(false);\n    }\n\n    lastPresentationUrl = url;\n    lastMediaElement = el;\n  });\n\n  // True stream: set on play event. Cleanup return removes the listener on element swap.\n  const cleanupPlayEffect = effect(() => {\n    const el = mediaElement.get();\n    if (!el) return;\n    return listen(el, 'play', () => {\n      playbackInitiated.set(true);\n    });\n  });\n\n  // Merge effect: bridge local signal → state.\n  // Reads state.get() at merge time (after the async forward bridge has flushed)\n  // so the spread captures the current value rather than a stale event-time snapshot.\n  // The guard makes the write idempotent.\n  const cleanupMergeEffect = effect(() => {\n    const pi = playbackInitiated.get();\n    if (pi === undefined) return;\n    const current = state.get();\n    if (current.playbackInitiated !== pi) {\n      const patch: Partial<PlaybackInitiatedState> = { playbackInitiated: pi };\n      update(state, patch);\n    }\n  });\n\n  return () => {\n    cleanupResetEffect();\n    cleanupPlayEffect();\n    cleanupMergeEffect();\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmCA,SAAgB,uBAA4F,EAC1G,OACA,UAIa;CACb,MAAM,kBAAkB,eAAe,MAAM,KAAK,CAAC,cAAc,IAAI;CACrE,MAAM,eAAe,eAAe,OAAO,KAAK,CAAC,aAAa;CAI9D,MAAM,oBAAoB,OAA4B,KAAA,EAAU;CAEhE,IAAI;CACJ,IAAI;CAGJ,MAAM,qBAAqB,aAAa;EACtC,MAAM,MAAM,gBAAgB,KAAK;EACjC,MAAM,KAAK,aAAa,KAAK;AAK7B,MAHmB,QAAQ,uBAGR,wBAAwB,KAAA,KAFzB,OAAO,oBAE8C,qBAAqB,KAAA,EAC1F,mBAAkB,IAAI,MAAM;AAG9B,wBAAsB;AACtB,qBAAmB;GACnB;CAGF,MAAM,oBAAoB,aAAa;EACrC,MAAM,KAAK,aAAa,KAAK;AAC7B,MAAI,CAAC,GAAI;AACT,SAAO,OAAO,IAAI,cAAc;AAC9B,qBAAkB,IAAI,KAAK;IAC3B;GACF;CAMF,MAAM,qBAAqB,aAAa;EACtC,MAAM,KAAK,kBAAkB,KAAK;AAClC,MAAI,OAAO,KAAA,EAAW;AAEtB,MADgB,MAAM,KAAK,CACf,sBAAsB,GAEhC,QAAO,OADwC,EAAE,mBAAmB,IAAI,CACpD;GAEtB;AAEF,cAAa;AACX,sBAAoB;AACpB,qBAAmB;AACnB,sBAAoB"}

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

@@ -0,0 +1,34 @@
+import { Signal } from "../../core/signals/primitives.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<O extends PlaybackRateOwners>({
+  state,
+  owners
+}: {
+  state: Signal<PlaybackRateState>;
+  owners: Signal<O>;
+}): () => 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":";;;;;AAOA;UAAiB,iBAAA;EACf,YAAA;AAAA;;AAMF;;UAAiB,kBAAA;EACf,YAAA,GAAe,gBAAA;AAAA;AAYjB;;;;;;;;;AAAA,iBAAgB,iBAAA,WAA4B,kBAAA,CAAA,CAAA;EAC1C,KAAA;EACA;AAAA;EAEA,KAAA,EAAO,MAAA,CAAO,iBAAA;EACd,MAAA,EAAQ,MAAA,CAAO,CAAA;AAAA"}

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

@@ -0,0 +1,32 @@
+import { effect } from "../../core/signals/effect.js";
+import { computed, update } from "../../core/signals/primitives.js";
+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 }) {
+	const mediaElementSignal = computed(() => owners.get().mediaElement);
+	const canTrackPlaybackRate = computed(() => !!mediaElementSignal.get());
+	const cleanupEffect = effect(() => {
+		if (!canTrackPlaybackRate.get()) return;
+		const mediaElement = mediaElementSignal.get();
+		update(state, { playbackRate: mediaElement.playbackRate });
+		return listen(mediaElement, "ratechange", () => {
+			update(state, { playbackRate: mediaElement.playbackRate });
+		});
+	});
+	return () => {
+		cleanupEffect();
+	};
+}
+//#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 { effect } from '../../core/signals/effect';\nimport { computed, type Signal, update } from '../../core/signals/primitives';\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 * 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<O extends PlaybackRateOwners>({\n  state,\n  owners,\n}: {\n  state: Signal<PlaybackRateState>;\n  owners: Signal<O>;\n}): () => void {\n  const mediaElementSignal = computed(() => owners.get().mediaElement);\n  const canTrackPlaybackRate = computed(() => !!mediaElementSignal.get());\n\n  const cleanupEffect = effect(() => {\n    if (!canTrackPlaybackRate.get()) return;\n    const mediaElement = mediaElementSignal.get() as HTMLMediaElement;\n\n    update(state, { playbackRate: mediaElement.playbackRate });\n\n    return listen(mediaElement, 'ratechange', () => {\n      update(state, { playbackRate: mediaElement.playbackRate });\n    });\n  });\n\n  return () => {\n    cleanupEffect();\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AA2BA,SAAgB,kBAAgD,EAC9D,OACA,UAIa;CACb,MAAM,qBAAqB,eAAe,OAAO,KAAK,CAAC,aAAa;CACpE,MAAM,uBAAuB,eAAe,CAAC,CAAC,mBAAmB,KAAK,CAAC;CAEvE,MAAM,gBAAgB,aAAa;AACjC,MAAI,CAAC,qBAAqB,KAAK,CAAE;EACjC,MAAM,eAAe,mBAAmB,KAAK;AAE7C,SAAO,OAAO,EAAE,cAAc,aAAa,cAAc,CAAC;AAE1D,SAAO,OAAO,cAAc,oBAAoB;AAC9C,UAAO,OAAO,EAAE,cAAc,aAAa,cAAc,CAAC;IAC1D;GACF;AAEF,cAAa;AACX,iBAAe"}

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

@@ -0,0 +1,78 @@
+import { effect } from "../../core/signals/effect.js";
+import { hasPresentationDuration } from "../../core/types/index.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 ((owners.mediaSourceReadyState?.get() ?? owners.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;
+	let running = false;
+	const cleanupEffect = effect(() => {
+		const currentState = state.get();
+		const currentOwners = owners.get();
+		if (!shouldUpdateDuration(currentState, currentOwners) || running) return;
+		const { mediaSource } = currentOwners;
+		running = true;
+		waitForSourceBuffersReady(currentOwners).then(() => {
+			if (destroyed || mediaSource.readyState !== "open") return;
+			let duration = currentState.presentation.duration;
+			const maxBufferedEnd = getMaxBufferedEnd(currentOwners);
+			if (maxBufferedEnd > duration) duration = maxBufferedEnd;
+			mediaSource.duration = duration;
+		}).finally(() => {
+			running = false;
+		});
+	});
+	return () => {
+		destroyed = true;
+		cleanupEffect();
+	};
+}
+//#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 { effect } from '../../core/signals/effect';\nimport type { ReadonlySignal, Signal } from '../../core/signals/primitives';\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  /** Reactive mirror of `mediaSource.readyState` — updated via DOM events. */\n  mediaSourceReadyState?: ReadonlySignal<MediaSource['readyState']>;\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 — use reactive readyState signal when available\n  // so the effect re-evaluates when readyState changes from 'closed' to 'open'.\n  const readyState = owners.mediaSourceReadyState?.get() ?? owners.mediaSource?.readyState;\n  if (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<S extends DurationUpdateState, O extends DurationUpdateOwners>({\n  state,\n  owners,\n}: {\n  state: Signal<S>;\n  owners: Signal<O>;\n}): () => void {\n  let destroyed = false;\n  let running = false;\n\n  const cleanupEffect = effect(() => {\n    const currentState = state.get();\n    const currentOwners = owners.get();\n\n    if (!shouldUpdateDuration(currentState, currentOwners) || running) return;\n\n    const { mediaSource } = currentOwners;\n    running = true;\n\n    // MSE spec: duration cannot be set while any SourceBuffer is updating.\n    // Capture the snapshot; the async helper does not read signals.\n    waitForSourceBuffersReady(currentOwners)\n      .then(() => {\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        // MSE spec: duration cannot be less than any buffered range.\n        // If buffered ranges exceed calculated duration, extend to match.\n        const maxBufferedEnd = getMaxBufferedEnd(currentOwners);\n        if (maxBufferedEnd > duration) {\n          duration = maxBufferedEnd;\n        }\n\n        mediaSource!.duration = duration;\n      })\n      .finally(() => {\n        running = false;\n      });\n  });\n\n  return () => {\n    destroyed = true;\n    cleanupEffect();\n  };\n}\n"],"mappings":";;;;;;AAoBA,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,KAAA,EACvC;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;AAKzB,MADmB,OAAO,uBAAuB,KAAK,IAAI,OAAO,aAAa,gBAC3D,OAAQ,QAAO;CAElC,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,KAAA,EAAU;;;;;AAMzB,SAAgB,eAA8E,EAC5F,OACA,UAIa;CACb,IAAI,YAAY;CAChB,IAAI,UAAU;CAEd,MAAM,gBAAgB,aAAa;EACjC,MAAM,eAAe,MAAM,KAAK;EAChC,MAAM,gBAAgB,OAAO,KAAK;AAElC,MAAI,CAAC,qBAAqB,cAAc,cAAc,IAAI,QAAS;EAEnE,MAAM,EAAE,gBAAgB;AACxB,YAAU;AAIV,4BAA0B,cAAc,CACrC,WAAW;AAGV,OAAI,aAAa,YAAa,eAAe,OAAQ;GAErD,IAAI,WAAW,aAAa,aAAc;GAI1C,MAAM,iBAAiB,kBAAkB,cAAc;AACvD,OAAI,iBAAiB,SACnB,YAAW;AAGb,eAAa,WAAW;IACxB,CACD,cAAc;AACb,aAAU;IACV;GACJ;AAEF,cAAa;AACX,cAAY;AACZ,iBAAe"}

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"}