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

package/dist/dev/core/reactors/create-machine-reactor.js

@@ -0,0 +1,84 @@
+import { untrack } from "../signals/primitives.js";
+import { effect } from "../signals/effect.js";
+import { createMachineCore } from "../machine.js";
+//#region src/core/reactors/create-machine-reactor.ts
+const toArray = (x) => x === void 0 ? [] : Array.isArray(x) ? x : [x];
+/**
+* Creates a reactive Reactor from a declarative definition.
+*
+* A Reactor is driven by subscriptions to external signals rather than imperative messages. Each state holds an array
+* of effect functions — every element becomes one independent `effect()` call gated on that state, with its own
+* dependency tracking and cleanup lifecycle.
+*
+* `'destroying'` and `'destroyed'` are always implicit terminal states. `destroy()` transitions through both in
+* sequence: `'destroying'` first (for potential async teardown in a future extension), then immediately `'destroyed'`
+* for the synchronous base case. Active effect cleanups fire via disposal.
+*
+* @example
+*   const reactor = createMachineReactor({
+*     initial: 'waiting',
+*     monitor: () => (srcSignal.get() ? 'active' : 'waiting'),
+*     states: {
+*       active: {
+*         // entry: runs once on state entry; fn body is automatically untracked.
+*         entry: () => listen(el, 'play', handler),
+*         // effects: re-runs whenever tracked signals change.
+*         effects: () => {
+*           currentTimeSignal.get();
+*           return cleanup;
+*         },
+*       },
+*       waiting: {},
+*     },
+*   });
+*/
+function createMachineReactor(def) {
+	const { snapshotSignal, getState, transition } = createMachineCore({ value: def.initial });
+	const effectDisposals = [];
+	const wrapResult = (result) => {
+		if (!result) return void 0;
+		if (typeof result === "function") return result;
+		return () => result.abort();
+	};
+	const untracked = (baseCall) => () => untrack(baseCall);
+	const isTerminal = (snapshot) => snapshot.value === "destroying" || snapshot.value === "destroyed";
+	const descriptors = [...toArray(def.monitor).map((fn) => ({
+		fn: () => {
+			const target = fn();
+			if (target !== getState()) transition(target);
+		},
+		shouldSkip: isTerminal
+	})), ...Object.entries(def.states).flatMap(([state, stateDef]) => {
+		const isNotState = (snapshot) => snapshot.value !== state;
+		return [...toArray(stateDef.entry).map((fn) => ({
+			fn,
+			shouldSkip: isNotState,
+			toFnCall: untracked
+		})), ...toArray(stateDef.effects).map((fn) => ({
+			fn,
+			shouldSkip: isNotState
+		}))];
+	})];
+	const toEffect = ({ fn, shouldSkip, toFnCall = (baseCall) => baseCall }) => effect(() => {
+		if (shouldSkip(snapshotSignal.get())) return;
+		const baseCall = () => fn();
+		return wrapResult(toFnCall(baseCall)());
+	});
+	effectDisposals.push(...descriptors.map(toEffect));
+	return {
+		get snapshot() {
+			return snapshotSignal;
+		},
+		destroy() {
+			const state = getState();
+			if (state === "destroying" || state === "destroyed") return;
+			transition("destroying");
+			transition("destroyed");
+			for (const dispose of effectDisposals) dispose();
+		}
+	};
+}
+//#endregion
+export { createMachineReactor };
+
+//# sourceMappingURL=create-machine-reactor.js.map

package/dist/dev/core/reactors/create-machine-reactor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-machine-reactor.js","names":[],"sources":["../../../../src/core/reactors/create-machine-reactor.ts"],"sourcesContent":["import type { Machine, MachineSnapshot } from '../machine';\nimport { createMachineCore } from '../machine';\nimport { effect } from '../signals/effect';\nimport { untrack } from '../signals/primitives';\n\n// =============================================================================\n// Definition types\n// =============================================================================\n\n/**\n * A reactive state-deriving function used in the `monitor` field.\n *\n * Returns the target state the reactor should be in. Any signals read inside the fn body create reactive dependencies —\n * the framework re-evaluates it when those signals change and automatically calls `transition()` when the returned\n * state differs from the current one.\n */\nexport type ReactorDeriveFn<State extends string> = () => State;\n\n/**\n * An effect function used in reactor `entry` and `effects` blocks.\n *\n * May return a cleanup function that runs before each re-evaluation and on state exit (including destroy).\n */\nexport type ReactorEffectFn = () => (() => void) | { abort(): void } | void;\n\n/**\n * Per-state effect grouping for a single reactor state.\n *\n * - `entry` effects run once on state entry. The fn body is automatically untracked — no `untrack()` calls are needed\n *   inside. Use this for one-time setup: reading current values, attaching event listeners, etc.\n * - `effects` run on state entry and re-run whenever a signal read inside the fn body changes. Use `untrack()` for reads\n *   you do not want to track. Use this for work that must stay in sync with reactive state.\n *\n * Both are optional; pass `{}` for states with no effects.\n */\nexport type ReactorStateDefinition = {\n  entry?: ReactorEffectFn | ReactorEffectFn[];\n  effects?: ReactorEffectFn | ReactorEffectFn[];\n};\n\n/**\n * Full reactor definition passed to `createMachineReactor`.\n *\n * `State` is the set of domain-meaningful states. `'destroying'` and `'destroyed'` are always added by the framework as\n * implicit terminal states — do not include them here.\n */\nexport type ReactorDefinition<State extends string> = {\n  /** Initial state. */\n  initial: State;\n  /**\n   * Reactive state derivation. Registered before per-state effects — the ordering guarantee ensures transitions fired\n   * here take effect before per-state effects re-evaluate in the same flush.\n   */\n  monitor?: ReactorDeriveFn<State> | ReactorDeriveFn<State>[];\n  /**\n   * Per-state effect groupings. Every valid state must be declared — pass `{}` for states with no effects. `entry` and\n   * `effects` each become independent `effect()` calls gated on that state, with their own cleanup lifecycles.\n   */\n  states: Record<State, ReactorStateDefinition>;\n};\n\n// =============================================================================\n// Live reactor interface\n// =============================================================================\n\n/** Live reactor instance returned by `createMachineReactor`. */\nexport type Reactor<State extends string> = Machine<MachineSnapshot<State>>;\n\n// =============================================================================\n// Implementation helpers\n// =============================================================================\n\nconst toArray = <T>(x: T | T[] | undefined): T[] => (x === undefined ? [] : Array.isArray(x) ? x : [x]);\n\n// =============================================================================\n// Implementation\n// =============================================================================\n\n/**\n * Creates a reactive Reactor from a declarative definition.\n *\n * A Reactor is driven by subscriptions to external signals rather than imperative messages. Each state holds an array\n * of effect functions — every element becomes one independent `effect()` call gated on that state, with its own\n * dependency tracking and cleanup lifecycle.\n *\n * `'destroying'` and `'destroyed'` are always implicit terminal states. `destroy()` transitions through both in\n * sequence: `'destroying'` first (for potential async teardown in a future extension), then immediately `'destroyed'`\n * for the synchronous base case. Active effect cleanups fire via disposal.\n *\n * @example\n *   const reactor = createMachineReactor({\n *     initial: 'waiting',\n *     monitor: () => (srcSignal.get() ? 'active' : 'waiting'),\n *     states: {\n *       active: {\n *         // entry: runs once on state entry; fn body is automatically untracked.\n *         entry: () => listen(el, 'play', handler),\n *         // effects: re-runs whenever tracked signals change.\n *         effects: () => {\n *           currentTimeSignal.get();\n *           return cleanup;\n *         },\n *       },\n *       waiting: {},\n *     },\n *   });\n */\nexport function createMachineReactor<State extends string>(\n  def: ReactorDefinition<State>\n): Reactor<State | 'destroying' | 'destroyed'> {\n  type FullState = State | 'destroying' | 'destroyed';\n\n  const { snapshotSignal, getState, transition } = createMachineCore<FullState, MachineSnapshot<FullState>>({\n    value: def.initial as FullState,\n  });\n\n  const effectDisposals: Array<() => void> = [];\n\n  const wrapResult = (result: ReturnType<ReactorEffectFn>) => {\n    if (!result) return undefined;\n\n    if (typeof result === 'function') return result;\n\n    return () => result.abort();\n  };\n\n  type EffectCall = () => ReturnType<ReactorEffectFn>;\n\n  type EffectDescriptor = {\n    fn: ReactorEffectFn;\n    shouldSkip: (snapshot: { value: FullState }) => boolean;\n    toFnCall?: (baseCall: EffectCall) => EffectCall;\n  };\n\n  const untracked: EffectDescriptor['toFnCall'] = (baseCall) => () => untrack(baseCall);\n\n  const isTerminal = (snapshot: { value: FullState }) =>\n    snapshot.value === 'destroying' || snapshot.value === 'destroyed';\n\n  // `monitor` descriptors are built first — the ordering guarantee ensures\n  // transitions they trigger take effect before per-state effects re-evaluate\n  // in the same flush. See the comment on effect registration order in the\n  // previous implementation for full details.\n  const descriptors: EffectDescriptor[] = [\n    ...toArray(def.monitor).map((fn) => ({\n      fn: () => {\n        const target = fn();\n\n        if (target !== (getState() as State)) transition(target as FullState);\n      },\n      shouldSkip: isTerminal,\n    })),\n    ...(Object.entries(def.states) as Array<[State, ReactorStateDefinition]>).flatMap(([state, stateDef]) => {\n      const isNotState = (snapshot: { value: FullState }) => snapshot.value !== state;\n\n      return [\n        ...toArray(stateDef.entry).map((fn) => ({ fn, shouldSkip: isNotState, toFnCall: untracked })),\n        ...toArray(stateDef.effects).map((fn) => ({ fn, shouldSkip: isNotState })),\n      ];\n    }),\n  ];\n\n  const toEffect = ({ fn, shouldSkip, toFnCall = (baseCall) => baseCall }: EffectDescriptor) =>\n    effect(() => {\n      const snapshot = snapshotSignal.get();\n      if (shouldSkip(snapshot)) return;\n\n      const baseCall = () => fn();\n\n      return wrapResult(toFnCall(baseCall)());\n    });\n\n  effectDisposals.push(...descriptors.map(toEffect));\n\n  return {\n    get snapshot() {\n      return snapshotSignal;\n    },\n\n    destroy(): void {\n      const state = getState();\n      if (state === 'destroying' || state === 'destroyed') return;\n\n      // Two-step teardown: transition through 'destroying' first to leave room\n      // for async teardown in a future extension, then immediately 'destroyed'\n      // for the synchronous base case. Active effect cleanups fire via disposal.\n      transition('destroying');\n      transition('destroyed');\n\n      for (const dispose of effectDisposals) dispose();\n    },\n  };\n}\n"],"mappings":";;;;AAwEA,MAAM,WAAc,MAAiC,MAAM,KAAA,IAAY,CAAC,IAAI,MAAM,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCrG,SAAgB,qBACd,KAC6C;CAG7C,MAAM,EAAE,gBAAgB,UAAU,eAAe,kBAAyD,EACxG,OAAO,IAAI,QACb,CAAC;CAED,MAAM,kBAAqC,CAAC;CAE5C,MAAM,cAAc,WAAwC;EAC1D,IAAI,CAAC,QAAQ,OAAO,KAAA;EAEpB,IAAI,OAAO,WAAW,YAAY,OAAO;EAEzC,aAAa,OAAO,MAAM;CAC5B;CAUA,MAAM,aAA2C,mBAAmB,QAAQ,QAAQ;CAEpF,MAAM,cAAc,aAClB,SAAS,UAAU,gBAAgB,SAAS,UAAU;CAMxD,MAAM,cAAkC,CACtC,GAAG,QAAQ,IAAI,OAAO,CAAC,CAAC,KAAK,QAAQ;EACnC,UAAU;GACR,MAAM,SAAS,GAAG;GAElB,IAAI,WAAY,SAAS,GAAa,WAAW,MAAmB;EACtE;EACA,YAAY;CACd,EAAE,GACF,GAAI,OAAO,QAAQ,IAAI,MAAM,CAAC,CAA4C,SAAS,CAAC,OAAO,cAAc;EACvG,MAAM,cAAc,aAAmC,SAAS,UAAU;EAE1E,OAAO,CACL,GAAG,QAAQ,SAAS,KAAK,CAAC,CAAC,KAAK,QAAQ;GAAE;GAAI,YAAY;GAAY,UAAU;EAAU,EAAE,GAC5F,GAAG,QAAQ,SAAS,OAAO,CAAC,CAAC,KAAK,QAAQ;GAAE;GAAI,YAAY;EAAW,EAAE,CAC3E;CACF,CAAC,CACH;CAEA,MAAM,YAAY,EAAE,IAAI,YAAY,YAAY,aAAa,eAC3D,aAAa;EAEX,IAAI,WADa,eAAe,IACV,CAAC,GAAG;EAE1B,MAAM,iBAAiB,GAAG;EAE1B,OAAO,WAAW,SAAS,QAAQ,CAAC,CAAC,CAAC;CACxC,CAAC;CAEH,gBAAgB,KAAK,GAAG,YAAY,IAAI,QAAQ,CAAC;CAEjD,OAAO;EACL,IAAI,WAAW;GACb,OAAO;EACT;EAEA,UAAgB;GACd,MAAM,QAAQ,SAAS;GACvB,IAAI,UAAU,gBAAgB,UAAU,aAAa;GAKrD,WAAW,YAAY;GACvB,WAAW,WAAW;GAEtB,KAAK,MAAM,WAAW,iBAAiB,QAAQ;EACjD;CACF;AACF"}

package/dist/dev/core/signals/effect.d.ts

@@ -0,0 +1,14 @@
+//#region src/core/signals/effect.d.ts
+/**
+ * Run a side effect whenever its signal dependencies change.
+ *
+ * Executes immediately (synchronous initial run), then re-runs on the next microtask after any dependency changes. If
+ * the callback returns a function, it is called before each re-run and when the effect is stopped — the same cleanup
+ * contract as Preact Signals, Maverick Signals, and Svelte 5 $effect.
+ *
+ * Returns a cleanup function that stops the effect.
+ */
+declare function effect(fn: () => (() => void) | void): () => void;
+//#endregion
+export { effect };
+//# sourceMappingURL=effect.d.ts.map

package/dist/dev/core/signals/effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","names":[],"sources":["../../../../src/core/signals/effect.ts"],"mappings":";;;;;;;;;;iBAsDgB,OAAO"}

package/dist/dev/core/signals/effect.js

@@ -0,0 +1,61 @@
+import { Signal } from "signal-polyfill";
+//#region src/core/signals/effect.ts
+const pending = /* @__PURE__ */ new Set();
+const watcher = new Signal.subtle.Watcher(() => {
+	queueMicrotask(runPending);
+});
+function runPending() {
+	for (const c of watcher.getPending()) pending.add(c);
+	watcher.watch();
+	for (const c of pending) {
+		pending.delete(c);
+		c.get();
+		revalidateSources(c);
+	}
+}
+/**
+* Recover an effect that wrote a signal one of its own dependencies reads.
+*
+* When an effect body writes a signal that an intermediate computed in its own dependency graph consumes (e.g. a
+* track-selection effect writing the selection slot a candidate-set computed consults), the graph can't tell the
+* effect: the write marks the intermediate dirty, but the effect is the in-flight consumer, so no watcher notification
+* fires — and the effect finishes the run _clean but stale_. Worse, every later external change routed through that
+* intermediate is deduped against its standing dirty flag, so the effect never hears about those either (the
+* lost-wakeup).
+*
+* Pulling each source once after the run closes the hole: a dirtied intermediate recomputes and its dirty flag clears,
+* so the _next_ change through it propagates and wakes the effect normally. The guarantee is liveness, not immediacy —
+* the effect is deliberately not re-run just because it wrote into its own graph (that would double-run every writing
+* effect); it catches up on the next genuine change. Sources that are clean, or whose recomputation is equals-gated to
+* the same value, cost a cached read and notify no one.
+*/
+function revalidateSources(c) {
+	for (const source of Signal.subtle.introspectSources(c)) source.get();
+}
+/**
+* Run a side effect whenever its signal dependencies change.
+*
+* Executes immediately (synchronous initial run), then re-runs on the next microtask after any dependency changes. If
+* the callback returns a function, it is called before each re-run and when the effect is stopped — the same cleanup
+* contract as Preact Signals, Maverick Signals, and Svelte 5 $effect.
+*
+* Returns a cleanup function that stops the effect.
+*/
+function effect(fn) {
+	let cleanup;
+	const c = new Signal.Computed(() => {
+		if (typeof cleanup === "function") cleanup();
+		cleanup = fn();
+	});
+	watcher.watch(c);
+	c.get();
+	revalidateSources(c);
+	return () => {
+		watcher.unwatch(c);
+		if (typeof cleanup === "function") cleanup();
+	};
+}
+//#endregion
+export { effect };
+
+//# sourceMappingURL=effect.js.map

package/dist/dev/core/signals/effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.js","names":[],"sources":["../../../../src/core/signals/effect.ts"],"sourcesContent":["import { Signal } from 'signal-polyfill';\n\n// Computeds waiting to re-run after their dependencies changed.\nconst pending = new Set<Signal.Computed<void>>();\n\nconst watcher = new Signal.subtle.Watcher(() => {\n  queueMicrotask(runPending);\n});\n\nfunction runPending() {\n  for (const c of watcher.getPending()) {\n    pending.add(c as Signal.Computed<void>);\n  }\n\n  watcher.watch(); // re-arm before running effects, in case they write signals\n\n  for (const c of pending) {\n    pending.delete(c);\n    c.get(); // re-run the effect body\n    revalidateSources(c);\n  }\n}\n\n/**\n * Recover an effect that wrote a signal one of its own dependencies reads.\n *\n * When an effect body writes a signal that an intermediate computed in its own dependency graph consumes (e.g. a\n * track-selection effect writing the selection slot a candidate-set computed consults), the graph can't tell the\n * effect: the write marks the intermediate dirty, but the effect is the in-flight consumer, so no watcher notification\n * fires — and the effect finishes the run _clean but stale_. Worse, every later external change routed through that\n * intermediate is deduped against its standing dirty flag, so the effect never hears about those either (the\n * lost-wakeup).\n *\n * Pulling each source once after the run closes the hole: a dirtied intermediate recomputes and its dirty flag clears,\n * so the _next_ change through it propagates and wakes the effect normally. The guarantee is liveness, not immediacy —\n * the effect is deliberately not re-run just because it wrote into its own graph (that would double-run every writing\n * effect); it catches up on the next genuine change. Sources that are clean, or whose recomputation is equals-gated to\n * the same value, cost a cached read and notify no one.\n */\nfunction revalidateSources(c: Signal.Computed<void>): void {\n  for (const source of Signal.subtle.introspectSources(c)) {\n    (source as Signal.State<unknown> | Signal.Computed<unknown>).get();\n  }\n}\n\n/**\n * Run a side effect whenever its signal dependencies change.\n *\n * Executes immediately (synchronous initial run), then re-runs on the next microtask after any dependency changes. If\n * the callback returns a function, it is called before each re-run and when the effect is stopped — the same cleanup\n * contract as Preact Signals, Maverick Signals, and Svelte 5 $effect.\n *\n * Returns a cleanup function that stops the effect.\n */\nexport function effect(fn: () => (() => void) | void): () => void {\n  let cleanup: (() => void) | void;\n  const c = new Signal.Computed(() => {\n    if (typeof cleanup === 'function') cleanup();\n\n    cleanup = fn();\n  });\n\n  watcher.watch(c);\n  c.get(); // initial run\n  revalidateSources(c); // an initial run may self-write too — see the note\n  return () => {\n    watcher.unwatch(c);\n\n    if (typeof cleanup === 'function') cleanup();\n  };\n}\n"],"mappings":";;AAGA,MAAM,0BAAU,IAAI,IAA2B;AAE/C,MAAM,UAAU,IAAI,OAAO,OAAO,cAAc;CAC9C,eAAe,UAAU;AAC3B,CAAC;AAED,SAAS,aAAa;CACpB,KAAK,MAAM,KAAK,QAAQ,WAAW,GACjC,QAAQ,IAAI,CAA0B;CAGxC,QAAQ,MAAM;CAEd,KAAK,MAAM,KAAK,SAAS;EACvB,QAAQ,OAAO,CAAC;EAChB,EAAE,IAAI;EACN,kBAAkB,CAAC;CACrB;AACF;;;;;;;;;;;;;;;;;AAkBA,SAAS,kBAAkB,GAAgC;CACzD,KAAK,MAAM,UAAU,OAAO,OAAO,kBAAkB,CAAC,GACpD,OAA6D,IAAI;AAErE;;;;;;;;;;AAWA,SAAgB,OAAO,IAA2C;CAChE,IAAI;CACJ,MAAM,IAAI,IAAI,OAAO,eAAe;EAClC,IAAI,OAAO,YAAY,YAAY,QAAQ;EAE3C,UAAU,GAAG;CACf,CAAC;CAED,QAAQ,MAAM,CAAC;CACf,EAAE,IAAI;CACN,kBAAkB,CAAC;CACnB,aAAa;EACX,QAAQ,QAAQ,CAAC;EAEjB,IAAI,OAAO,YAAY,YAAY,QAAQ;CAC7C;AACF"}

package/dist/dev/core/signals/primitives.d.ts

@@ -0,0 +1,44 @@
+import { Signal } from "signal-polyfill";
+//#region src/core/signals/primitives.d.ts
+/** Read a signal value without tracking it as a dependency. */
+declare const untrack: <T>(fn: () => T) => T;
+/** A writable reactive value (read + write). */
+type Signal$1<T> = Signal.State<T>;
+/** A derived reactive value that re-evaluates when its dependencies change (read-only). */
+type Computed<T> = Signal.Computed<T>;
+/** A read-only view of a reactive value. */
+type ReadonlySignal<T> = Omit<Signal.State<T>, 'set'>;
+interface SignalOptions<T> {
+  equals?: (t: T, t2: T) => boolean;
+}
+/** Create a writable reactive value. */
+declare function signal<T>(initialValue: T, options?: SignalOptions<T>): Signal$1<T>;
+/** Create a computed reactive value. */
+declare function computed<T>(fn: () => T, options?: SignalOptions<T>): Computed<T>;
+/**
+ * Update a writable signal. Two forms:
+ *
+ * - **Updater function** `(current) => next`. Works for any signal type, including `Signal<T | undefined>` — handle
+ *   undefined in the updater.
+ * - **Partial object** to merge into the current state. Requires `T extends object`.
+ *
+ * @example
+ *   update(state, { playbackRate: 2 });
+ *   update(state, (s) => ({ ...s, count: s.count + 1 }));
+ *   update(maybeUndefinedSignal, (current) => current ?? defaultValue);
+ */
+declare function update<T>(signal: Signal$1<T>, updater: (current: T) => T): void;
+declare function update<T extends object>(signal: Signal$1<T>, updater: Partial<T>): void;
+/**
+ * Read every signal in a map and return a plain object snapshot. Each read tracks in the surrounding Computed/Effect —
+ * equivalent to calling `.get()` on a single `Signal<S>` over the merged shape.
+ *
+ * Convenience for behaviors that pass whole state/context snapshots to pure helpers; prefer per-field reads when only a
+ * few fields are needed.
+ */
+declare function snapshot<M extends Record<string, ReadonlySignal<unknown>>>(map: M): { [K in keyof M]: M[K] extends {
+  get(): infer V;
+} ? V : never; };
+//#endregion
+export { Computed, ReadonlySignal, Signal$1 as Signal, SignalOptions, computed, signal, snapshot, untrack, update };
+//# sourceMappingURL=primitives.d.ts.map

package/dist/dev/core/signals/primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","names":[],"sources":["../../../../src/core/signals/primitives.ts"],"mappings":";;;cAGa,UAAU,GAAG,UAAU,MAAM;;KAkB9B,SAAO,KAAK,OAAS,MAAM;;KAG3B,SAAS,KAAK,OAAS,SAAS;;KAGhC,eAAe,KAAK,KAAK,OAAS,MAAM;UAEnC,cAAc;EAC7B,UAAU,GAAG,GAAG,IAAI;;;iBAIN,OAAO,GAAG,cAAc,GAAG,UAAU,cAAc,KAAK,SAAO;;iBAK/D,SAAS,GAAG,UAAU,GAAG,UAAU,cAAc,KAAK,SAAS;;;;;;;;;;;;;iBAgB/D,OAAO,GAAG,QAAQ,SAAO,IAAI,UAAU,SAAS,MAAM;iBACtD,OAAO,kBAAkB,QAAQ,SAAO,IAAI,SAAS,QAAQ;;;;;;;;iBAmC7D,SAAS,UAAU,eAAe,0BAChD,KAAK,OACD,WAAW,IAAI,EAAE;EAAa,aAAa;IAAM"}

package/dist/dev/core/signals/primitives.js

@@ -0,0 +1,50 @@
+import { Signal } from "signal-polyfill";
+//#region src/core/signals/primitives.ts
+/** Read a signal value without tracking it as a dependency. */
+const untrack = Signal.subtle.untrack;
+/**
+* Read a signal's current value without tracking it as a dependency. Sugar for `untrack(() => signal.get())` to reduce
+* boilerplate at single-read sites. Structurally typed to accept any signal-like (Signal, Computed, ReadonlySignal).
+*
+* Accepts an optional `transform` to project the value in the same call; the default is the identity function so the
+* single-arg form returns `T` unchanged.
+*
+* @example
+*   const value = peek(someSignal);
+*   const id = peek(presentationSignal, (p) => p?.id);
+*/
+function peek(source, transform = (v) => v) {
+	return untrack(() => transform(source.get()));
+}
+/** Create a writable reactive value. */
+function signal(initialValue, options) {
+	return new Signal.State(initialValue, options);
+}
+/** Create a computed reactive value. */
+function computed(fn, options) {
+	return new Signal.Computed(fn, options);
+}
+function update(signal, updater) {
+	const current = untrack(() => signal.get());
+	if (typeof updater === "function") signal.set(updater(current));
+	else signal.set({
+		...current,
+		...updater
+	});
+}
+/**
+* Read every signal in a map and return a plain object snapshot. Each read tracks in the surrounding Computed/Effect —
+* equivalent to calling `.get()` on a single `Signal<S>` over the merged shape.
+*
+* Convenience for behaviors that pass whole state/context snapshots to pure helpers; prefer per-field reads when only a
+* few fields are needed.
+*/
+function snapshot(map) {
+	const out = {};
+	for (const key in map) out[key] = map[key].get();
+	return out;
+}
+//#endregion
+export { computed, peek, signal, snapshot, untrack, update };
+
+//# sourceMappingURL=primitives.js.map

package/dist/dev/core/signals/primitives.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.js","names":["SignalNS"],"sources":["../../../../src/core/signals/primitives.ts"],"sourcesContent":["import { Signal as SignalNS } from 'signal-polyfill';\n\n/** Read a signal value without tracking it as a dependency. */\nexport const untrack: <T>(fn: () => T) => T = SignalNS.subtle.untrack;\n\n/**\n * Read a signal's current value without tracking it as a dependency. Sugar for `untrack(() => signal.get())` to reduce\n * boilerplate at single-read sites. Structurally typed to accept any signal-like (Signal, Computed, ReadonlySignal).\n *\n * Accepts an optional `transform` to project the value in the same call; the default is the identity function so the\n * single-arg form returns `T` unchanged.\n *\n * @example\n *   const value = peek(someSignal);\n *   const id = peek(presentationSignal, (p) => p?.id);\n */\nexport function peek<T, R = T>(source: { get(): T }, transform: (value: T) => R = (v: T) => v as unknown as R): R {\n  return untrack(() => transform(source.get()));\n}\n\n/** A writable reactive value (read + write). */\nexport type Signal<T> = SignalNS.State<T>;\n\n/** A derived reactive value that re-evaluates when its dependencies change (read-only). */\nexport type Computed<T> = SignalNS.Computed<T>;\n\n/** A read-only view of a reactive value. */\nexport type ReadonlySignal<T> = Omit<SignalNS.State<T>, 'set'>;\n\nexport interface SignalOptions<T> {\n  equals?: (t: T, t2: T) => boolean;\n}\n\n/** Create a writable reactive value. */\nexport function signal<T>(initialValue: T, options?: SignalOptions<T>): Signal<T> {\n  return new SignalNS.State(initialValue, options as SignalNS.Options<T>);\n}\n\n/** Create a computed reactive value. */\nexport function computed<T>(fn: () => T, options?: SignalOptions<T>): Computed<T> {\n  return new SignalNS.Computed(fn, options as SignalNS.Options<T>);\n}\n\n/**\n * Update a writable signal. Two forms:\n *\n * - **Updater function** `(current) => next`. Works for any signal type, including `Signal<T | undefined>` — handle\n *   undefined in the updater.\n * - **Partial object** to merge into the current state. Requires `T extends object`.\n *\n * @example\n *   update(state, { playbackRate: 2 });\n *   update(state, (s) => ({ ...s, count: s.count + 1 }));\n *   update(maybeUndefinedSignal, (current) => current ?? defaultValue);\n */\nexport function update<T>(signal: Signal<T>, updater: (current: T) => T): void;\nexport function update<T extends object>(signal: Signal<T>, updater: Partial<T>): void;\nexport function update<T>(signal: Signal<T>, updater: ((current: T) => T) | object): void {\n  const current = untrack(() => signal.get());\n\n  if (typeof updater === 'function') {\n    signal.set((updater as (current: T) => T)(current));\n  } else {\n    // Partial<T> form — `T extends object` enforced by the public overload.\n    signal.set({ ...(current as object), ...updater } as T);\n  }\n}\n\n/**\n * Equality comparator for objects with an optional `id` field. Designed for use as a `computed` `equals` option when\n * reacting to identity changes (Ham-shaped objects, JSON-API-shaped resources) while filtering internal updates that\n * preserve the id.\n *\n * Handles undefined inputs symmetrically: both undefined → equal; one undefined → different.\n *\n * @example\n *   const presentationById = computed(() => state.presentation.get(), {\n *     equals: equalsById,\n *   });\n */\nexport function equalsById<T extends { id?: string }>(a: T | undefined, b: T | undefined): boolean {\n  return a?.id === b?.id;\n}\n\n/**\n * Read every signal in a map and return a plain object snapshot. Each read tracks in the surrounding Computed/Effect —\n * equivalent to calling `.get()` on a single `Signal<S>` over the merged shape.\n *\n * Convenience for behaviors that pass whole state/context snapshots to pure helpers; prefer per-field reads when only a\n * few fields are needed.\n */\nexport function snapshot<M extends Record<string, ReadonlySignal<unknown>>>(\n  map: M\n): { [K in keyof M]: M[K] extends { get(): infer V } ? V : never } {\n  const out = {} as { [K in keyof M]: M[K] extends { get(): infer V } ? V : never };\n\n  for (const key in map) {\n    out[key] = map[key]!.get() as never;\n  }\n\n  return out;\n}\n"],"mappings":";;;AAGA,MAAa,UAAiCA,OAAS,OAAO;;;;;;;;;;;;AAa9D,SAAgB,KAAe,QAAsB,aAA8B,MAAS,GAAsB;CAChH,OAAO,cAAc,UAAU,OAAO,IAAI,CAAC,CAAC;AAC9C;;AAgBA,SAAgB,OAAU,cAAiB,SAAuC;CAChF,OAAO,IAAIA,OAAS,MAAM,cAAc,OAA8B;AACxE;;AAGA,SAAgB,SAAY,IAAa,SAAyC;CAChF,OAAO,IAAIA,OAAS,SAAS,IAAI,OAA8B;AACjE;AAgBA,SAAgB,OAAU,QAAmB,SAA6C;CACxF,MAAM,UAAU,cAAc,OAAO,IAAI,CAAC;CAE1C,IAAI,OAAO,YAAY,YACrB,OAAO,IAAK,QAA8B,OAAO,CAAC;MAGlD,OAAO,IAAI;EAAE,GAAI;EAAoB,GAAG;CAAQ,CAAM;AAE1D;;;;;;;;AAyBA,SAAgB,SACd,KACiE;CACjE,MAAM,MAAM,CAAC;CAEb,KAAK,MAAM,OAAO,KAChB,IAAI,OAAO,IAAI,IAAI,CAAE,IAAI;CAG3B,OAAO;AACT"}

package/dist/dev/core/signals/when.js

@@ -0,0 +1,36 @@
+import { effect } from "./effect.js";
+//#region src/core/signals/when.ts
+/**
+* Resolve once `condition` returns true. The condition is a tracked read — it re-evaluates whenever a signal it read
+* changes — so this is the promise bridge from signal space into async task bodies (await a state condition mid-task
+* without polling).
+*
+* Settles synchronously when the condition already holds. Rejects with the abort reason when `signal` aborts first (an
+* already-aborted signal rejects without evaluating the condition), so a task awaiting a condition dies with its runner
+* instead of leaking the subscription.
+*/
+function when(condition, options = {}) {
+	const { signal } = options;
+	if (signal?.aborted) return Promise.reject(signal.reason);
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const settle = (complete) => {
+			if (settled) return;
+			settled = true;
+			complete();
+			queueMicrotask(() => {
+				signal?.removeEventListener("abort", onAbort);
+				stop();
+			});
+		};
+		const onAbort = () => settle(() => reject(signal?.reason));
+		signal?.addEventListener("abort", onAbort, { once: true });
+		const stop = effect(() => {
+			if (!settled && condition()) settle(resolve);
+		});
+	});
+}
+//#endregion
+export { when };
+
+//# sourceMappingURL=when.js.map

package/dist/dev/core/signals/when.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"when.js","names":[],"sources":["../../../../src/core/signals/when.ts"],"sourcesContent":["import { effect } from './effect';\n\n/**\n * Resolve once `condition` returns true. The condition is a tracked read — it re-evaluates whenever a signal it read\n * changes — so this is the promise bridge from signal space into async task bodies (await a state condition mid-task\n * without polling).\n *\n * Settles synchronously when the condition already holds. Rejects with the abort reason when `signal` aborts first (an\n * already-aborted signal rejects without evaluating the condition), so a task awaiting a condition dies with its runner\n * instead of leaking the subscription.\n */\nexport function when(condition: () => boolean, options: { signal?: AbortSignal } = {}): Promise<void> {\n  const { signal } = options;\n  if (signal?.aborted) return Promise.reject(signal.reason);\n\n  return new Promise<void>((resolve, reject) => {\n    let settled = false;\n    const settle = (complete: () => void) => {\n      if (settled) return;\n\n      settled = true;\n      complete();\n      // Deferred: on the effect's synchronous initial run `stop` isn't\n      // assigned yet, and stopping an effect from inside its own body is\n      // undefined behavior for the scheduler either way.\n      queueMicrotask(() => {\n        signal?.removeEventListener('abort', onAbort);\n        stop();\n      });\n    };\n    const onAbort = () => settle(() => reject(signal?.reason));\n\n    signal?.addEventListener('abort', onAbort, { once: true });\n    const stop = effect(() => {\n      if (!settled && condition()) settle(resolve);\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,KAAK,WAA0B,UAAoC,CAAC,GAAkB;CACpG,MAAM,EAAE,WAAW;CACnB,IAAI,QAAQ,SAAS,OAAO,QAAQ,OAAO,OAAO,MAAM;CAExD,OAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,IAAI,UAAU;EACd,MAAM,UAAU,aAAyB;GACvC,IAAI,SAAS;GAEb,UAAU;GACV,SAAS;GAIT,qBAAqB;IACnB,QAAQ,oBAAoB,SAAS,OAAO;IAC5C,KAAK;GACP,CAAC;EACH;EACA,MAAM,gBAAgB,aAAa,OAAO,QAAQ,MAAM,CAAC;EAEzD,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EACzD,MAAM,OAAO,aAAa;GACxB,IAAI,CAAC,WAAW,UAAU,GAAG,OAAO,OAAO;EAC7C,CAAC;CACH,CAAC;AACH"}

package/dist/dev/core/tasks/delayed-reschedule.js

@@ -0,0 +1,27 @@
+import { sleep } from "@videojs/utils/time";
+//#region src/core/tasks/delayed-reschedule.ts
+/**
+* Build a {@link Reschedule} from a pure cadence function — the common timer-based, _start-anchored_ implementation.
+*
+* Invoked concurrently with the run, it observes the result, then waits `cadence(current, previous)` milliseconds
+* **measured from when it was invoked** (≈ the run's start): it subtracts the run's own elapsed time, so consecutive
+* runs begin one cadence apart regardless of how long each run takes (per RFC 8216 §6.3.4's "measured from the last
+* time the client began loading"). If the run takes longer than the cadence, the next run starts immediately.
+*
+* A `null` cadence stops the recurrence. A rejected run rejects this reschedule, which the `RecurringRunner` propagates
+* as the recurrence's failure — error recovery (e.g. retrying transient fetch failures) belongs below, at the fetch
+* layer, not in the cadence.
+*/
+function delayedReschedule(cadence) {
+	return async (task) => {
+		const startedAt = Date.now();
+		const ms = cadence(await task.run(), task.previous);
+		if (ms === null) return false;
+		await sleep(Math.max(0, ms - (Date.now() - startedAt)), task.signal);
+		return true;
+	};
+}
+//#endregion
+export { delayedReschedule };
+
+//# sourceMappingURL=delayed-reschedule.js.map

package/dist/dev/core/tasks/delayed-reschedule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delayed-reschedule.js","names":[],"sources":["../../../../src/core/tasks/delayed-reschedule.ts"],"sourcesContent":["import { sleep } from '@videojs/utils/time';\n\nimport type { Reschedule } from './task';\n\n/**\n * Build a {@link Reschedule} from a pure cadence function — the common timer-based, _start-anchored_ implementation.\n *\n * Invoked concurrently with the run, it observes the result, then waits `cadence(current, previous)` milliseconds\n * **measured from when it was invoked** (≈ the run's start): it subtracts the run's own elapsed time, so consecutive\n * runs begin one cadence apart regardless of how long each run takes (per RFC 8216 §6.3.4's \"measured from the last\n * time the client began loading\"). If the run takes longer than the cadence, the next run starts immediately.\n *\n * A `null` cadence stops the recurrence. A rejected run rejects this reschedule, which the `RecurringRunner` propagates\n * as the recurrence's failure — error recovery (e.g. retrying transient fetch failures) belongs below, at the fetch\n * layer, not in the cadence.\n */\nexport function delayedReschedule<TValue>(\n  cadence: (current: TValue, previous: TValue | undefined) => number | null\n): Reschedule<TValue> {\n  return async (task) => {\n    const startedAt = Date.now();\n    const current = await task.run();\n    // `task.previous` is the prior successful value (carried by the runner's\n    // clone); read-only for the cadence, hence the cast off `DeepReadonly`.\n    const ms = cadence(current, task.previous as TValue | undefined);\n    if (ms === null) return false;\n\n    await sleep(Math.max(0, ms - (Date.now() - startedAt)), task.signal);\n    return true;\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;AAgBA,SAAgB,kBACd,SACoB;CACpB,OAAO,OAAO,SAAS;EACrB,MAAM,YAAY,KAAK,IAAI;EAI3B,MAAM,KAAK,QAAQ,MAHG,KAAK,IAAI,GAGH,KAAK,QAA8B;EAC/D,IAAI,OAAO,MAAM,OAAO;EAExB,MAAM,MAAM,KAAK,IAAI,GAAG,MAAM,KAAK,IAAI,IAAI,UAAU,GAAG,KAAK,MAAM;EACnE,OAAO;CACT;AACF"}

package/dist/dev/core/tasks/task.d.ts

@@ -0,0 +1,144 @@
+//#region src/core/tasks/task.d.ts
+/** Recursively marks all properties as readonly. */
+type DeepReadonly<T> = T extends (infer U)[] ? ReadonlyArray<DeepReadonly<U>> : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]>; } : T;
+type TaskStatus = 'pending' | 'running' | 'done' | 'error';
+/** Configuration for a Task. */
+interface TaskConfig {
+  /**
+   * Identifier for this task. - string: used as-is - () => string: called once at construction time - undefined: a
+   * unique ID is generated via generateId()
+   */
+  id?: string | (() => string);
+  /**
+   * Optional external AbortSignal to compose with the task's internal one. The task's work is aborted when either the
+   * internal controller (via abort()) or this external signal fires — whichever comes first.
+   */
+  signal?: AbortSignal;
+}
+/** Minimal contract for a schedulable unit of async work. */
+interface TaskLike<TValue = void, TError = unknown> {
+  readonly id: string;
+  readonly status: TaskStatus;
+  readonly value: DeepReadonly<TValue> | undefined;
+  readonly error: DeepReadonly<TError> | undefined;
+  /**
+   * The last successful value carried forward from the run this was `clone()`d from — the prior cycle's result for a
+   * `RecurringRunner` (undefined for an original, or until the lineage has produced a success).
+   */
+  readonly previous: DeepReadonly<TValue> | undefined;
+  /**
+   * The signal this task's work runs under (its own abort composed with any external one). Aborting the task fires it —
+   * so a `reschedule` can wait on it to have its delay cancelled when the recurrence is aborted.
+   */
+  readonly signal: AbortSignal;
+  /** Run the work, memoized: repeated calls share one execution + result. */
+  run(): Promise<TValue>;
+  abort(): void;
+  /** A fresh, structurally identical task (same work + id) in a pending state — for re-running. */
+  clone(): TaskLike<TValue, TError>;
+}
+/**
+ * Generic reusable task that wraps an async run function.
+ *
+ * Owns its own AbortController so it can always be aborted independently. Optionally composes an external AbortSignal
+ * so that a parent's cancellation propagates into the task's work without requiring the caller to track the task
+ * separately.
+ *
+ * `run()` is memoized: the work runs at most once per instance, and every call returns the same promise (so observers
+ * can `await run()` to read the result without re-triggering the work). To re-run the _same_ work, take a `clone()` — a
+ * fresh instance with its own AbortController and a pending state.
+ *
+ * Ordering guarantee: `value` is written before `status` transitions to `'done'`; `error` is written before `status`
+ * transitions to `'error'`. Any reader observing `status === 'done'` is guaranteed `value` is already present.
+ */
+declare class Task<TValue = void, TError = unknown> implements TaskLike<TValue, TError> {
+  #private;
+  readonly id: string;
+  constructor(runFn: (signal: AbortSignal) => Promise<TValue>, config?: TaskConfig);
+  get status(): TaskStatus;
+  get value(): DeepReadonly<TValue> | undefined;
+  get error(): DeepReadonly<TError> | undefined;
+  get previous(): DeepReadonly<TValue> | undefined;
+  get signal(): AbortSignal;
+  run(): Promise<TValue>;
+  abort(): void;
+  /**
+   * A fresh task with the same work, id, and external signal, in a pending state (its own AbortController, no memoized
+   * result) — so it can be run again. Used to re-run structurally identical work (e.g. `RecurringRunner` reloads).
+   *
+   * The clone inherits this run's value as its `previous` (or this run's own `previous` if it never produced one — e.g.
+   * it errored), so a recurrence's `previous` always tracks the last _successful_ value across the lineage with no
+   * bookkeeping in the runner.
+   */
+  clone(): Task<TValue, TError>;
+}
+/**
+ * Runs tasks concurrently, deduplicated by task id.
+ *
+ * If a task with a given id is already in flight, subsequent schedule() calls for that id are silently ignored until
+ * the first completes. Tasks are stored so abortAll() can cancel any in-flight work (e.g. on engine cleanup).
+ */
+declare class ConcurrentRunner {
+  #private;
+  schedule<TValue = void, TError = unknown>(task: TaskLike<TValue, TError>): Promise<TValue>;
+  /**
+   * Registers a callback to fire when all currently in-flight tasks settle. If the runner is already idle, the callback
+   * is never called. If abortAll() is called before the batch settles, the callback is superseded and silently dropped
+   * — no stale callbacks, no generation token required by the caller.
+   */
+  whenSettled(callback: () => void): void;
+  abortAll(): void;
+  destroy(): void;
+}
+/**
+ * Runs tasks one at a time in submission order.
+ *
+ * Each schedule() call returns a Promise that resolves or rejects with the task's result when it is eventually
+ * executed. Tasks wait in queue until the prior task completes.
+ *
+ * Serialization is achieved by chaining each task's run() onto the tail of a shared promise chain — no explicit queue
+ * or drain loop needed.
+ *
+ * AbortAll() aborts all pending (not yet started) tasks and the currently in-flight task. Pending tasks still run
+ * briefly but receive an aborted signal and are expected to exit early.
+ */
+declare class SerialRunner {
+  #private;
+  schedule<TValue = void, TError = unknown>(task: TaskLike<TValue, TError>): Promise<TValue>;
+  /**
+   * A promise that resolves when all currently-scheduled tasks have settled. Use the reference as a generation token:
+   * capture it after scheduling a batch, then check identity in the resolution callback to detect whether a subsequent
+   * abortAll() + new batch has superseded this one.
+   */
+  get settled(): Promise<void>;
+  /**
+   * Registers a callback to fire when all currently-pending tasks settle. If the runner is already idle (no pending or
+   * running tasks), the callback is never called. If new tasks are scheduled before the current batch settles, the
+   * callback is superseded and silently dropped — no stale callbacks, no generation token required by the caller.
+   */
+  whenSettled(callback: () => void): void;
+  /** Aborts and clears queued tasks without touching the in-flight task. */
+  abortPending(): void;
+  abortAll(): void;
+  destroy(): void;
+}
+/**
+ * Decides whether — and _when_ — a {@link RecurringRunner} re-runs its task. Invoked **concurrently with the run** (so
+ * the inter-run interval can be measured from when the run _started_, not when it finished) with the single
+ * {@link TaskLike}, which carries everything a decision needs:
+ *
+ * - `task.run()` — the in-flight run, observable via this memoized call (does not re-trigger work), e.g. to read its
+ *   result for a cadence/stop decision.
+ * - `task.previous` — the prior successful run's value (`undefined` on the first), for decisions that compare consecutive
+ *   results.
+ * - `task.signal` — aborts the wait (and the recurrence) when the task is.
+ *
+ * Resolves `true` to re-run (after whatever delay it owns) or `false` to stop. The runner deals only in this awaitable
+ * verdict — _how_ the delay is produced (a timer, a frame, an event) and _when_ it's measured from live entirely in the
+ * reschedule function, so the runner itself knows nothing about time. See `delayedReschedule` for the common
+ * timer-based, start-anchored implementation.
+ */
+type Reschedule<TValue> = (task: TaskLike<TValue>) => PromiseLike<boolean>;
+//#endregion
+export { ConcurrentRunner, DeepReadonly, Reschedule, SerialRunner, Task, TaskConfig, TaskLike, TaskStatus };
+//# sourceMappingURL=task.d.ts.map

package/dist/dev/core/tasks/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","names":[],"sources":["../../../../src/core/tasks/task.ts"],"mappings":";;KAQY,aAAa,KAAK,iBAAiB,OAC3C,cAAc,aAAa,MAC3B,+BACc,WAAW,IAAI,aAAa,EAAE,SAC1C;KAMM;;UAGK;;;;;EAKf;;;;;EAMA,SAAS;;;UAIM,SAAS,eAAe;WAC9B;WACA,QAAQ;WACR,OAAO,aAAa;WACpB,OAAO,aAAa;;;;;WAKpB,UAAU,aAAa;;;;;WAKvB,QAAQ;;EAEjB,OAAO,QAAQ;EACf;;EAEA,SAAS,SAAS,QAAQ;;;;;;;;;;;;;;;;cAiBf,KAAK,eAAe,6BAA6B,SAAS,QAAQ;;WACpE;EAYT,YAAY,QAAQ,QAAQ,gBAAgB,QAAQ,SAAS,SAAS;MAWlE,UAAU;MAIV,SAAS,aAAa;MAItB,SAAS,aAAa;MAItB,YAAY,aAAa;MAIzB,UAAU;EAId,OAAO,QAAQ;EAyBf;;;;;;;;;EAYA,SAAS,KAAK,QAAQ;;;;;;;;cAkBX;;EAMX,SAAS,eAAe,kBAAkB,MAAM,SAAS,QAAQ,UAAU,QAAQ;;;;;;EAqCnF,YAAY;EAeZ;EAYA;;;;;;;;;;;;;;cAsBW;;EAMX,SAAS,eAAe,kBAAkB,MAAM,SAAS,QAAQ,UAAU,QAAQ;;;;;;MA+B/E,WAAW;;;;;;EASf,YAAY;;EAgBZ;EAMA;EAKA;;;;;;;;;;;;;;;;;;KA0BU,WAAW,WAAW,MAAM,SAAS,YAAY"}