tmg-media-player 0.0.1

package/dist/tools/runtime.cjs

@@ -0,0 +1,1919 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/ts/tools/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  AUDIO_CONTEXT: () => AUDIO_CONTEXT,
+  AUDIO_LIMITER: () => AUDIO_LIMITER,
+  Controllers: () => Controllers,
+  IS_DOC_TRANSIENT: () => IS_DOC_TRANSIENT,
+  STATE_BUILD: () => STATE_BUILD,
+  connectMediaToAudioManager: () => connectMediaToAudioManager,
+  handleDOMMutation: () => handleDOMMutation,
+  handleVidMutation: () => handleVidMutation,
+  init: () => init,
+  mountMedia: () => mountMedia,
+  startAudioManager: () => startAudioManager,
+  unmountMedia: () => unmountMedia
+});
+module.exports = __toCommonJS(runtime_exports);
+
+// src/ts/consts/config.ts
+var import_sia_reactor = require("sia-reactor");
+
+// src/ts/consts/actions.ts
+var ACTIONS_BUILD = {
+  // --- Keyboard-only actions (no default voice triggers; path router covers voice) ---
+  playPause: { label: "Play / Pause" },
+  skipFwd: { label: "Skip Forward", notify: "fwd" },
+  skipBwd: { label: "Skip Back", notify: "bwd" },
+  volumeUp: { label: "Volume Up", notify: "volumeup" },
+  volumeDown: { label: "Volume Down", notify: "volumedown" },
+  brightnessUp: { label: "Brightness Up", notify: "brightnessup" },
+  brightnessDown: { label: "Brightness Down", notify: "brightnessdown" },
+  playbackRateUp: { label: "Playback Rate Up", notify: "playbackrateup" },
+  playbackRateDown: { label: "Playback Rate Down", notify: "playbackratedown" },
+  stepFwd: { label: "Step Forward", notify: "fwd" },
+  stepBwd: { label: "Step Back", notify: "bwd" },
+  prev: { label: "Previous", notify: "mediaprev" },
+  next: { label: "Next", notify: "medianext" },
+  captions: { label: "Captions", notify: "captions" },
+  captionsFontSizeUp: { label: "Captions: Font Size Up" },
+  captionsFontSizeDown: { label: "Captions: Font Size Down" },
+  captionsFontFamily: { label: "Captions: Font Family" },
+  captionsFontWeight: { label: "Captions: Font Weight" },
+  captionsFontVariant: { label: "Captions: Font Variant" },
+  captionsFontOpacity: { label: "Captions: Font Opacity" },
+  captionsBackgroundOpacity: { label: "Captions: Background Opacity" },
+  captionsWindowOpacity: { label: "Captions: Window Opacity" },
+  captionsCharacterEdgeStyle: { label: "Captions: Character Edge" },
+  captionsTextAlignment: { label: "Captions: Text Alignment" },
+  objectFit: { label: "Object Fit" },
+  capture: { label: "Capture Frame", notify: "capture" },
+  cast: { label: "Cast", notify: "cast" },
+  airplay: { label: "AirPlay", notify: "airplay" },
+  dark: { label: "Dark Mode" },
+  settings: { label: "Settings", zen: true },
+  // --- Logic-expressible actions (logic[] + keyboard, no default voice triggers) ---
+  mute: { label: "Mute", notify: "volumemuted" },
+  fullscreen: { label: "Fullscreen", notify: "fullscreen", logic: [{ path: "media.intent.fullscreen", op: "toggle" }] },
+  theater: { label: "Theater", notify: "theater", logic: [{ path: "media.intent.theater", op: "toggle" }] },
+  pictureInPicture: { label: "Picture in Picture", notify: "pictureinpicture", logic: [{ path: "media.intent.pictureInPicture", op: "toggle" }] },
+  timeFormat: { label: "Time Format" },
+  timeMode: { label: "Time Mode" },
+  // --- Compound (voice|time)-only actions (voice engine meta, path router can't reach these) ---
+  timeTravelUndo: { label: "Time Travel: Undo", zen: true },
+  timeTravelRedo: { label: "Time Travel: Redo", zen: true },
+  voiceQuit: { label: "Voice: Quit", zen: true },
+  voiceSleep: { label: "Voice: Sleep", zen: true },
+  voiceSubmit: { label: "Voice: Submit", zen: true },
+  voiceHistoryFirst: { label: "Voice: Go to Root", zen: true },
+  voiceHistoryPrev: { label: "Voice: Go Back", zen: true },
+  voiceHistoryNext: { label: "Voice: Go Forward", zen: true },
+  voiceHistoryLast: { label: "Voice: Go to Leaf", zen: true },
+  voiceHistoryClear: { label: "Voice: Clear History", zen: true },
+  voiceToggleOn: { label: "Voice: Toggle On", zen: true },
+  voiceToggleOff: { label: "Voice: Toggle Off", zen: true }
+};
+
+// src/ts/consts/config.ts
+var CONFIG_BUILD = {
+  mediaType: "video",
+  mediaPlayer: "TMG",
+  media: { intent: { playsInline: true, textVisible: true, brightness: 100 } },
+  actions: Object.fromEntries(Object.entries(ACTIONS_BUILD).map(([k, v]) => [k, { id: k, ...v }])),
+  logicPathBlacklist: ["media.state", "media.status", "media.tech", "media.features", "media.type", "media.element", "media.pseudoElement", "media.container", "media.pseudoContainer"],
+  settings: {
+    // techOrder: [
+    //   "youtube", // 1. Black-box (Regex must catch these URLs instantly)
+    //   "vimeo", // 2. Black-box (Regex must catch these URLs instantly)
+    //   "shaka", // 3. THE APEX PREDATOR (Catches .mpd and .m3u8 first)
+    //   "hls", // 4. Fallback (Catches .m3u8 ONLY if Shaka is disabled/fails)
+    //   "dash", // 5. Fallback (Catches .mpd ONLY if Shaka is disabled/fails)
+    //   "html5", // 6. The Native Floor (Catches raw .mp4, .webm, .mp3, etc.)
+    // ],
+  },
+  debug: true,
+  devMode: import_sia_reactor.CTX.isDevEnv,
+  noPlugList: []
+  // dev: "settings.persist"
+};
+
+// src/ts/core/registries.ts
+var import_utils = require("sia-reactor/utils");
+var BaseRegistry = class {
+  constructor() {
+    __publicField(this, "items", []);
+  }
+  register(name, value, config) {
+    return this.unregister(name), this.items.push({ name, value, config }), this;
+  }
+  unregister(name, idx = this.items.findIndex((i) => i.name === name)) {
+    return idx !== -1 && this.items.splice(idx, 1), this;
+  }
+  get(name) {
+    return this.items.find((i) => i.name === name)?.value;
+  }
+  getAll(order) {
+    if (!order) return this.items.map((i) => i.value);
+    return this.items.sort((a, b, ai = order.indexOf(a.name), bi = order.indexOf(b.name)) => ai === -1 && bi === -1 ? 0 : ai === -1 ? 1 : bi === -1 ? -1 : ai - bi).map((i) => i.value);
+  }
+  clear() {
+    return this.items = [], this;
+  }
+};
+var OrderedRegistry = class extends BaseRegistry {
+  registerFirst(name, value, config) {
+    return this.unregister(name), this.items.unshift({ name, value, config }), this;
+  }
+  registerBefore(key, name, value, config) {
+    this.unregister(name);
+    const idx = this.items.findIndex((i) => i.name === key);
+    return idx !== -1 ? (this.items.splice(idx, 0, { name, value, config }), this) : this.register(name, value, config);
+  }
+  registerAfter(key, name, value, config) {
+    this.unregister(name);
+    const idx = this.items.findIndex((i) => i.name === key);
+    return idx !== -1 ? (this.items.splice(idx + 1, 0, { name, value, config }), this) : this.register(name, value, config);
+  }
+};
+var _TechRegistry = class _TechRegistry extends OrderedRegistry {
+  static get(name) {
+    return this.instance.get(name);
+  }
+  static register(Tech) {
+    this.instance.register(Tech.techName, Tech);
+  }
+  static unregister(name) {
+    this.instance.unregister(name);
+  }
+  static registerBefore(key, Tech) {
+    this.instance.registerBefore(key, Tech.techName, Tech);
+  }
+  static registerAfter(key, Tech) {
+    this.instance.registerAfter(key, Tech.techName, Tech);
+  }
+  static pick(src, techOrder) {
+    return this.instance.getAll(techOrder).find((Tech) => Tech.canPlaySource(src)) || null;
+  }
+};
+__publicField(_TechRegistry, "instance", new _TechRegistry());
+var TechRegistry = _TechRegistry;
+var _PlugRegistry = class _PlugRegistry extends OrderedRegistry {
+  static get(name) {
+    return this.instance.get(name);
+  }
+  static register(Plug, editBuild = Plug.BUILD !== void 0) {
+    this.instance.register(Plug.fullName, Plug);
+    editBuild && (0, import_utils.setPath)(CONFIG_BUILD, Plug.fullName, Plug.BUILD);
+  }
+  static unregister(fullName, editBuild = true) {
+    this.instance.unregister(fullName);
+    editBuild && (0, import_utils.deletePath)(CONFIG_BUILD, fullName);
+  }
+  static registerBefore(key, Plug) {
+    this.instance.registerBefore(key, Plug.fullName, Plug);
+  }
+  static registerAfter(key, Plug) {
+    this.instance.registerAfter(key, Plug.fullName, Plug);
+  }
+  static getOrdered() {
+    return this.instance.getAll();
+  }
+};
+__publicField(_PlugRegistry, "instance", new _PlugRegistry());
+var PlugRegistry = _PlugRegistry;
+var _PinRegistry = class _PinRegistry extends BaseRegistry {
+  static get(name) {
+    return this.instance.get(name);
+  }
+  static register(Pin, editBuild = Pin.BUILD !== void 0) {
+    this.instance.register(Pin.fullName, Pin);
+    editBuild && (0, import_utils.setPath)(CONFIG_BUILD, Pin.Plug.fullName + "." + Pin.pinName, Pin.BUILD);
+  }
+  static unregister(fullName, editBuild = true) {
+    this.instance.unregister(fullName);
+    editBuild && (0, import_utils.deletePath)(fullName.slice(0, fullName.indexOf(".")) in CONFIG_BUILD ? CONFIG_BUILD : CONFIG_BUILD.settings, fullName);
+  }
+};
+__publicField(_PinRegistry, "instance", new _PinRegistry());
+var PinRegistry = _PinRegistry;
+var _MenuRegistry = class _MenuRegistry extends BaseRegistry {
+  static get(name) {
+    return this.instance.get(name);
+  }
+  static register(name, factory) {
+    this.instance.register(name, factory);
+  }
+  static unregister(name) {
+    this.instance.unregister(name);
+  }
+};
+__publicField(_MenuRegistry, "instance", new _MenuRegistry());
+var MenuRegistry = _MenuRegistry;
+var _ComponentRegistry = class _ComponentRegistry extends BaseRegistry {
+  static get(name) {
+    return this.instance.get(name);
+  }
+  static register(Comp) {
+    this.instance.register(Comp.componentName, Comp);
+  }
+  static unregister(name) {
+    this.instance.unregister(name);
+  }
+  static init(name, ctlr, config = {}) {
+    const Comp = this.instance.get(name);
+    if (!Comp) return null;
+    const instance = new Comp(ctlr, config);
+    return instance.create(), instance.setup();
+  }
+  static getAll() {
+    return this.instance.getAll();
+  }
+};
+__publicField(_ComponentRegistry, "instance", new _ComponentRegistry());
+var ComponentRegistry = _ComponentRegistry;
+var _IconRegistry = class _IconRegistry extends BaseRegistry {
+  static get(name, raw = false, token = /\btmg-media-[^\s"']+\s*/g) {
+    return (raw ? this.instance.get(name)?.replace(token, "") : this.instance.get(name)) || `<svg></svg>`;
+  }
+  static register(name, svg) {
+    this.instance.register(name, svg);
+  }
+  static unregister(name) {
+    this.instance.unregister(name);
+  }
+  // Bulk register a map of icons { play: "<svg...>", pause: "<svg...>" }
+  static registerAll(icons) {
+    for (const k of Object.keys(icons)) this.instance.register(k, icons[k]);
+  }
+};
+__publicField(_IconRegistry, "instance", new _IconRegistry());
+var IconRegistry = _IconRegistry;
+
+// src/ts/core/controllable.ts
+var import_sia_reactor4 = require("sia-reactor");
+var import_utils16 = require("sia-reactor/utils");
+
+// ../t007-tools/packages/utils/dist/chunk-ZALPHCSJ.js
+var import_utils2 = require("sia-reactor/utils");
+var import_utils3 = require("sia-reactor/utils");
+var import_sia_reactor2 = require("sia-reactor");
+var import_sia_reactor3 = require("sia-reactor");
+var import_utils4 = require("sia-reactor/utils");
+var import_utils5 = require("sia-reactor/utils");
+var import_utils6 = require("sia-reactor/utils");
+var import_utils7 = require("sia-reactor/utils");
+var import_utils8 = require("sia-reactor/utils");
+var VIRTUAL_RESOURCE = /* @__PURE__ */ Symbol.for("T007_VIRTUAL_RESOURCE");
+function loadResource(req, type = "style", { module: module2, media, crossOrigin, integrity, referrerPolicy, nonce, fetchPriority, attempts = 3, retryKey = false } = {}, win4 = window) {
+  var _a;
+  win4.t007 ?? (win4.t007 = {}), (_a = win4.t007)._resourceCache ?? (_a._resourceCache = {});
+  if (req === VIRTUAL_RESOURCE || isSym(req)) return Promise.resolve();
+  const src = req;
+  if (win4.t007._resourceCache[src]) return win4.t007._resourceCache[src];
+  const existing = type === "script" ? Array.prototype.find.call(win4.document.scripts, (s) => isSameURL(s.src, src)) : type === "style" ? Array.prototype.find.call(win4.document.styleSheets, (s) => isSameURL(s.href, src)) : null;
+  if (existing) return win4.t007._resourceCache[src] = Promise.resolve(existing);
+  win4.t007._resourceCache[src] = new Promise((resolve, reject) => {
+    (function tryLoad(remaining, el) {
+      const onerror = () => {
+        el?.remove?.();
+        if (remaining > 1) {
+          setTimeout(tryLoad, 1e3, remaining - 1);
+          console.warn(`Retrying ${type} load for "${src}" (${attempts - remaining + 1})...`);
+        } else {
+          delete win4.t007._resourceCache[src];
+          reject(new Error(`${capitalize(type)} load failed for "${src}" after ${attempts - 1} attempts`));
+        }
+      };
+      const url = retryKey && remaining < attempts ? `${src}${src.includes("?") ? "&" : "?"}_${retryKey}=${Date.now()}` : src;
+      if (type === "script") win4.document.body.append(el = (0, import_utils2.createEl)("script", { src: url, type: module2 ? "module" : "text/javascript", crossOrigin, integrity, referrerPolicy, nonce, fetchPriority, onload: () => resolve(el), onerror }) || "");
+      else if (type === "style") win4.document.head.append(el = (0, import_utils2.createEl)("link", { rel: "stylesheet", href: url, media, crossOrigin, integrity, referrerPolicy, nonce, fetchPriority, onload: () => resolve(el), onerror }) || "");
+      else reject(new Error(`Unsupported resource type: ${type}`));
+    })(attempts);
+  });
+  return win4.t007._resourceCache[src];
+}
+function getWindow(el = window) {
+  return el?.ownerDocument?.defaultView ?? el?.defaultView ?? window;
+}
+function createListRenderer({ container, getKey, createNode, updateNode = import_sia_reactor2.NOOP, destroyNode = import_sia_reactor2.NOOP, initNode }) {
+  let nodeRegistry = /* @__PURE__ */ new Map();
+  if (initNode) {
+    const children = Array.from(container.children);
+    for (let i = 0, len = children.length; i < len; i++) initNode(children[i], (key) => nodeRegistry.set(key, children[i]));
+  }
+  return function syncDOM(array, strict = true) {
+    const newRegistry = /* @__PURE__ */ new Map(), seenKeys = /* @__PURE__ */ new Set(), oldPositions = /* @__PURE__ */ new WeakMap(), children = Array.from(container.children);
+    for (let i = 0, len = children.length; i < len; i++) oldPositions.set(children[i], i);
+    const futureNodes = [], oldIndices = [];
+    for (let i = 0, len = array.length; i < len; i++) {
+      const item = array[i], key = getKey(item);
+      if (seenKeys.has(key)) throw new Error(`[List Renderer] Duplicate key "${key}" detected`);
+      let node = nodeRegistry.get(key);
+      if (!node) {
+        node = createNode(item);
+        if (!node) {
+          if (strict) throw new Error(`[List Renderer] No HTMLElement for key "${key}"`);
+          continue;
+        }
+        oldIndices.push(-1);
+      } else updateNode(node, item), oldIndices.push(oldPositions.get(node) ?? -1);
+      seenKeys.add(key), futureNodes.push(node), newRegistry.set(key, node);
+    }
+    for (const [key, node] of nodeRegistry.entries()) !seenKeys.has(key) && node.parentElement === container && (destroyNode(node, key), node.remove());
+    const sequence = longestIncreasingSubsequence(oldIndices), stable = new Set(sequence);
+    let anchor = null;
+    for (let i = futureNodes.length - 1; i >= 0; i--) {
+      const node = futureNodes[i];
+      if (oldIndices[i] !== -1 && stable.has(i)) {
+        anchor = node;
+        continue;
+      }
+      container.insertBefore(node, anchor), anchor = node;
+    }
+    nodeRegistry = newRegistry;
+  };
+}
+function isSym(val) {
+  return "symbol" === typeof val;
+}
+function isNum(val) {
+  return "number" === typeof val;
+}
+function isStr(val) {
+  return "string" === typeof val;
+}
+function isIter(obj) {
+  return obj != null && "function" === typeof obj[Symbol.iterator];
+}
+function isFunc(val) {
+  return "function" === typeof val;
+}
+function longestIncreasingSubsequence(array) {
+  const n = array.length, parent = new Array(n), tails = [];
+  for (let i = 0; i < n; i++) {
+    const value = array[i];
+    if (value === -1) continue;
+    let left = 0;
+    let right = tails.length;
+    while (left < right) {
+      const mid = left + right >> 1;
+      if (array[tails[mid]] < value) left = mid + 1;
+      else right = mid;
+    }
+    if (left > 0) parent[i] = tails[left - 1];
+    else parent[i] = -1;
+    tails[left] = i;
+  }
+  if (!tails.length) return [];
+  const result = [];
+  let k = tails[tails.length - 1];
+  while (k >= 0) result.push(k), k = parent[k];
+  return result.reverse(), result;
+}
+function uid(prefix = "") {
+  return prefix + Date.now().toString(36) + "_" + performance.now().toString(36).replace(".", "") + "_" + Math.random().toString(36).slice(2);
+}
+function capitalize(word = "") {
+  return word.replace(/^(\s*)([a-z])/i, (_, s, l) => s + l.toUpperCase());
+}
+function camelize(str = "", { source } = /[\s_-]+/, { preserveInnerCase: pIC = true, upperFirst: uF = false } = {}) {
+  return (pIC ? str : str.toLowerCase()).replace(new RegExp(source + "(\\w)", "g"), (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c[uF ? "toUpperCase" : "toLowerCase"]());
+}
+function uncamelize(str, separator = " ") {
+  return str.replace(/([a-z])([A-Z])/g, `$1${separator}$2`).toLowerCase();
+}
+function cleanURL(url) {
+  try {
+    const u = new URL(url, window.location.href);
+    return decodeURIComponent(u.origin + u.pathname);
+  } catch {
+    return url.replace(/\\/g, "/").split("?")[0].trim();
+  }
+}
+function isSameURL(url1, url2) {
+  if (url1 === url2) return true;
+  if (!isStr(url1) || !isStr(url2) || !url1 || !url2) return false;
+  return cleanURL(url1) === cleanURL(url2);
+}
+function throttle(key, fn, delay = 30, strict = true, signal, win4) {
+  const throttleMap = t007._throttlers ?? (t007._throttlers = /* @__PURE__ */ new Map());
+  if (strict === true) {
+    const now = performance.now();
+    return now - (throttleMap.get(key) ?? 0) < delay ? void 0 : (throttleMap.set(key, now), fn());
+  }
+  if (throttleMap.has(key)) return;
+  const id = strict === false ? (0, import_utils6.setTimeout)(() => throttleMap.delete(key), delay, signal, win4) : strict(() => throttleMap.delete(key));
+  return throttleMap.set(key, id), fn();
+}
+function debounce(key, fn, delay = 30, strict = true, signal, win4) {
+  const debounceMap = t007._debouncers ?? (t007._debouncers = /* @__PURE__ */ new Map());
+  if (strict) {
+    const now = performance.now(), prev = debounceMap.get(key) ?? 0;
+    return debounceMap.set(key, now), now - prev < delay ? void 0 : fn();
+  }
+  const prevId = debounceMap.get(key);
+  prevId !== void 0 && (win4 ?? window).clearTimeout(prevId);
+  const id = (0, import_utils6.setTimeout)(() => (debounceMap.delete(key), fn()), delay, signal, win4);
+  return void debounceMap.set(key, id);
+}
+function RAFLoop(key, fn, signal, win4) {
+  const rafLoopMap = t007._RAFLoopers ?? (t007._RAFLoopers = /* @__PURE__ */ new Map());
+  if (rafLoopMap.has(key)) return void rafLoopMap.set(key, fn);
+  rafLoopMap.set(key, fn);
+  const loop = (_ = 0, fn2 = rafLoopMap.get(key)) => fn2 && (fn2(), (0, import_utils6.requestAnimationFrame)(loop, signal, win4));
+  loop();
+}
+var cancelRAFLoop = (key) => t007._RAFLoopers ? t007._RAFLoopers.delete(key) : false;
+var mockAsync = (timeout = 250) => new Promise((resolve) => (0, import_utils6.setTimeout)(resolve, timeout));
+function bindCleanupToSignal(cleanup, signal) {
+  signal?.aborted ? cleanup() : signal?.addEventListener("abort", cleanup, { once: true });
+  if (signal && !signal.aborted) cleanup = (() => (signal.removeEventListener("abort", cleanup), cleanup()));
+  return cleanup;
+}
+if ("undefined" !== typeof window) {
+  (window.t007 ?? (window.t007 = {})).VIRTUAL_RESOURCE = VIRTUAL_RESOURCE;
+  window.T007_TOAST_JS_SRC ?? (window.T007_TOAST_JS_SRC = `https://cdn.jsdelivr.net/npm/@t007/toast@latest`);
+  window.T007_INPUT_JS_SRC ?? (window.T007_INPUT_JS_SRC = `https://cdn.jsdelivr.net/npm/@t007/input@latest`);
+  window.T007_DIALOG_JS_SRC ?? (window.T007_DIALOG_JS_SRC = `https://cdn.jsdelivr.net/npm/@t007/dialog@latest`);
+  window.T007_TOAST_CSS_SRC ?? (window.T007_TOAST_CSS_SRC = `https://cdn.jsdelivr.net/npm/@t007/toast@latest/dist/index.min.css`);
+  window.T007_INPUT_CSS_SRC ?? (window.T007_INPUT_CSS_SRC = `https://cdn.jsdelivr.net/npm/@t007/input@latest/dist/index.min.css`);
+  window.T007_DIALOG_CSS_SRC ?? (window.T007_DIALOG_CSS_SRC = `https://cdn.jsdelivr.net/npm/@t007/dialog@latest/dist/index.min.css`);
+}
+
+// src/ts/consts/generics.ts
+var LUID_KEY = "tmg_local_uid";
+
+// src/ts/utils/str.ts
+var uid2 = (prefix = "tmg_") => uid(prefix);
+function luid(key = LUID_KEY, prefix = "tmg_local_") {
+  let id = localStorage.getItem(key);
+  return !id && localStorage.setItem(key, id = uid2(prefix)), id || "";
+}
+
+// src/ts/utils/obj.ts
+var import_utils13 = require("sia-reactor/utils");
+function setHTMLConfig(target, attr, value) {
+  value = value.trim();
+  const path = attr.replace("tmg--", "");
+  const parsedValue = (() => {
+    if (value.includes(",")) return value.split(",")?.map((v) => v.trim());
+    if (value === "true") return true;
+    if (value === "false") return false;
+    if (value === "null") return null;
+    if (/^\d+$/.test(value)) return Number(value);
+    return value;
+  })();
+  (0, import_utils13.setPath)(target, path, parsedValue, "--", (p) => camelize(p));
+}
+
+// src/ts/core/controllable.ts
+var Controllable = class {
+  // for easy reach, better devx
+  constructor(ctlr, config, state) {
+    __publicField(this, "ac", new AbortController());
+    __publicField(this, "signal", this.ac.signal);
+    __publicField(this, "ctlr");
+    __publicField(this, "media");
+    __publicField(this, "state");
+    // for reactivity needs of those who pass it up
+    __publicField(this, "config");
+    (0, import_utils8.guardAllMethods)(this, ctlr.guard);
+    this.signal = AbortSignal.any([this.signal, ctlr.signal]);
+    this.ctlr = ctlr;
+    this.media = ctlr.media;
+    this.state = (0, import_utils4.isObj)(state) ? (0, import_sia_reactor4.reactive)(state) : state;
+    this.config = config;
+  }
+  // may be a reactive obj node or the obj itself
+  get settings() {
+    return this.ctlr.settings;
+  }
+  setup() {
+    return this.onSetup(), this;
+  }
+  destroy() {
+    !this.signal.aborted && this.ac.abort(`[TMG Controllable] Instance is being destroyed`);
+    this.onDestroy(), this.state?.destroy?.(), this.config !== this.media && isFunc(this.config?.destroy) && this.config?.destroy?.();
+    (0, import_utils16.nuke)(this);
+  }
+  onDestroy() {
+  }
+};
+
+// src/ts/techs/base.ts
+var import_utils25 = require("sia-reactor/utils");
+var import_modules = require("sia-reactor/modules");
+
+// src/ts/utils/time.ts
+function createTimeRanges(ranges) {
+  if (ranges instanceof TimeRanges) return ranges;
+  if (!ranges)
+    return Object.create(TimeRanges.prototype, {
+      length: { value: 0 },
+      start: {
+        value: () => {
+          throw new DOMException("Index out of bounds", "IndexSizeError");
+        }
+      },
+      end: {
+        value: () => {
+          throw new DOMException("Index out of bounds", "IndexSizeError");
+        }
+      }
+    });
+  const rawPairs = (Array.isArray(ranges) ? ranges : Array.from(ranges)).sort((a, b) => a[0] - b[0]);
+  const pairs = [];
+  for (const current of rawPairs) {
+    const last = pairs[pairs.length - 1];
+    if (!last || current[0] > last[1]) pairs.push([current[0], current[1]]);
+    else last[1] = Math.max(last[1], current[1]);
+  }
+  return Object.create(TimeRanges.prototype, {
+    length: { value: pairs.length },
+    start: {
+      value: (i) => {
+        if (i < 0 || i >= pairs.length) throw new DOMException("Index out of bounds", "IndexSizeError");
+        return pairs[i][0];
+      }
+    },
+    end: {
+      value: (i) => {
+        if (i < 0 || i >= pairs.length) throw new DOMException("Index out of bounds", "IndexSizeError");
+        return pairs[i][1];
+      }
+    }
+  });
+}
+
+// src/ts/consts/media.ts
+var MEDIA_STATE_BUILD = {
+  // Core
+  src: "",
+  // 1st for correct fanout sequence
+  currentTime: 0,
+  paused: true,
+  // Engine
+  volume: 100,
+  muted: false,
+  brightness: 100,
+  dark: false,
+  playbackRate: 1,
+  // Modes
+  pictureInPicture: false,
+  fullscreen: false,
+  theater: false,
+  miniplayer: false,
+  locked: false,
+  // Casting
+  airplay: false,
+  cast: false,
+  // VR / XR
+  xrSession: false,
+  xrMode: "inline",
+  xrReferenceSpace: "local",
+  projection: "flat",
+  stereoMode: "none",
+  fieldOfView: 90,
+  // Standard FOV
+  viewRatio: 16 / 9,
+  // Standard Aspect Ratio
+  panningX: 0,
+  panningY: 0,
+  panningZ: 0,
+  xrInputSource: [],
+  // Tracks & Streaming
+  currentChapter: -1,
+  currentTextTrack: -1,
+  currentAudioTrack: -1,
+  currentVideoTrack: -1,
+  currentLevel: -1,
+  textVisible: true,
+  autoLevel: true,
+  // Adaptive Streaming on by default
+  // HTML Attributes
+  poster: "",
+  autoplay: false,
+  loop: false,
+  preload: "auto",
+  playsInline: true,
+  crossOrigin: null,
+  controls: false,
+  // We disable native controls
+  controlsList: "",
+  disablePictureInPicture: false,
+  // HTML Lists
+  sources: [],
+  tracks: [],
+  // Live Content
+  live: true,
+  // Misc
+  objectFit: "contain"
+};
+var MEDIA_INTENT_BUILD = MEDIA_STATE_BUILD;
+var MEDIA_STATUS_BUILD = {
+  // Network
+  readyState: 0,
+  // HAVE_NOTHING
+  networkState: 0,
+  // EMPTY
+  error: null,
+  bandwidth: null,
+  // Buffering
+  waiting: false,
+  stalled: false,
+  seeking: false,
+  buffered: createTimeRanges(),
+  played: createTimeRanges(),
+  seekable: createTimeRanges(),
+  duration: NaN,
+  // HTML5 Standard for "Unknown"
+  ended: false,
+  // Dimensions
+  videoWidth: 0,
+  videoHeight: 0,
+  // Gates
+  loadedMetadata: false,
+  loadedData: false,
+  canPlay: false,
+  canPlayThrough: false,
+  // Lists (We start with empty lists or nulls)
+  textTracks: [],
+  audioTracks: [],
+  videoTracks: [],
+  levels: [],
+  // Active
+  activeCue: null,
+  // VR
+  xrCapabilities: null,
+  // Live Content
+  isLive: false,
+  canSeekLive: false
+};
+var MEDIA_SETTINGS_BUILD = {
+  // Defaults
+  defaultMuted: false,
+  defaultPlaybackRate: 1,
+  // Streams
+  srcObject: null,
+  // Metadata
+  metadata: {
+    title: "",
+    artist: "",
+    profile: "",
+    album: "",
+    artwork: [],
+    chapterInfo: [],
+    links: {
+      title: "",
+      artist: "",
+      profile: ""
+    },
+    allowOverride: true
+  },
+  protection: null,
+  // Live Content
+  liveTolerance: 6,
+  minDVRWindow: 60
+};
+
+// src/ts/utils/dom.ts
+var import_sia_reactor5 = require("sia-reactor");
+var win = "undefined" !== typeof window ? window : void 0;
+var queryFullscreen = () => Boolean(queryFullscreenEl());
+var queryFullscreenEl = (d = document) => d.fullscreenElement || d.webkitFullscreenElement || d.mozFullScreenElement || d.msFullscreenElement || null;
+var queryPictureInPictureEl = () => document.pictureInPictureElement;
+var supportsFullscreen = (vp = HTMLVideoElement.prototype, d = document) => Boolean(d.fullscreenEnabled || d.mozFullscreenEnabled || d.msFullscreenEnabled || d.webkitFullscreenEnabled || d.webkitSupportsFullscreen || vp.webkitEnterFullscreen);
+var supportsPictureInPicture = (vp = HTMLVideoElement.prototype, d = document, w = window) => Boolean(d.pictureInPictureEnabled || vp.requestPictureInPicture || w.documentPictureInPicture);
+var enterFullscreen = (el) => el.webkitEnterFullscreen ? el.webkitEnterFullscreen() : el.requestFullscreen ? el.requestFullscreen() : el.mozRequestFullScreen ? el.mozRequestFullScreen() : el.webkitRequestFullscreen ? el.webkitRequestFullscreen() : el.msRequestFullscreen ? el.msRequestFullscreen() : Promise.reject(new Error("Fullscreen API is not supported"));
+var exitFullscreen = (el, d = document) => queryFullscreenEl(d) === el ? el.webkitExitFullscreen ? el.webkitExitFullscreen() : d.exitFullscreen ? d.exitFullscreen() : d.mozCancelFullScreen ? d.mozCancelFullScreen() : d.webkitExitFullscreen ? d.webkitExitFullscreen() : d.msExitFullscreen ? d.msExitFullscreen() : Promise.reject(new Error("Fullscreen API is not supported")) : Promise.resolve();
+var intersectionObserver = win ? new IntersectionObserver(
+  (entries) => {
+    for (const entry of entries) if (entry.target._intersectCbs) for (const cb of entry.target._intersectCbs) cb(entry);
+  },
+  { root: null, rootMargin: "0px", threshold: 0.3 }
+) : null;
+var resizeObserver = win ? new ResizeObserver((entries) => {
+  for (const entry of entries) if (entry.target._resizeCbs) for (const cb of entry.target._resizeCbs) cb(entry);
+}) : null;
+var mutationObserver = win ? new MutationObserver((mutations) => {
+  const target = mutations[0].target;
+  if (target._mutationCbs) for (const cb of target._mutationCbs) cb(mutations);
+}) : null;
+function observeResize(el, cb, sig) {
+  (el._resizeCbs ?? (el._resizeCbs = /* @__PURE__ */ new Set())).add(cb);
+  resizeObserver?.observe(el);
+  return bindCleanupToSignal(() => (el._resizeCbs?.delete(cb), !el._resizeCbs?.size && resizeObserver?.unobserve(el)), sig);
+}
+function observeIntersection(el, cb, sig) {
+  (el._intersectCbs ?? (el._intersectCbs = /* @__PURE__ */ new Set())).add(cb);
+  intersectionObserver?.observe(el);
+  return bindCleanupToSignal(() => (el._intersectCbs?.delete(cb), !el._intersectCbs?.size && intersectionObserver?.unobserve(el)), sig);
+}
+function observeMutation(el, cb, options, sig) {
+  (el._mutationCbs ?? (el._mutationCbs = /* @__PURE__ */ new Set())).add(cb);
+  mutationObserver?.observe(el, options);
+  return bindCleanupToSignal(() => el._mutationCbs?.delete(cb), sig);
+}
+
+// src/ts/utils/media.ts
+var import_utils24 = require("sia-reactor/utils");
+function getMediaReport(m, isVid = m instanceof HTMLVideoElement, opts = { skipUndefined: true }) {
+  const txtTrackIdx = getTrackIdx(m, "Text"), report = { state: getMediaState(m, isVid, txtTrackIdx), status: getMediaStatus(m, isVid, txtTrackIdx), settings: getMediaSettings(m) };
+  return { state: (0, import_utils24.mergeObjs)(MEDIA_STATE_BUILD, report.state, opts), intent: (0, import_utils24.mergeObjs)(MEDIA_INTENT_BUILD, report.state, opts), status: (0, import_utils24.mergeObjs)(MEDIA_STATUS_BUILD, report.status, opts), settings: (0, import_utils24.mergeObjs)(MEDIA_SETTINGS_BUILD, report.settings, opts) };
+}
+var getMediaState = (m, isVid = m instanceof HTMLVideoElement, _txtTrackIdx = getTrackIdx(m, "Text")) => ({ src: m.src, currentTime: m.currentTime, paused: m.paused, volume: m.volume * 100, muted: m.muted, playbackRate: m.playbackRate, pictureInPicture: queryPictureInPictureEl() === m, fullscreen: queryFullscreenEl() === m, currentTextTrack: _txtTrackIdx, currentAudioTrack: getTrackIdx(m, "Audio"), currentVideoTrack: getTrackIdx(m, "Video"), poster: isVid ? m.poster : "", autoplay: m.autoplay, loop: m.loop, preload: m.preload, playsInline: isVid ? m.playsInline : false, crossOrigin: m.crossOrigin, controls: m.controls, controlsList: m.controlsList ?? m.getAttribute("controlsList"), disablePictureInPicture: isVid ? m.disablePictureInPicture ?? m.hasAttribute("disablePictureInPicture") : false, sources: getSources(m), tracks: getTracks(m) });
+var getMediaStatus = (m, isVid = m instanceof HTMLVideoElement, _txtTrackIdx = getTrackIdx(m, "Text"), _flagsOnly = false) => ({ readyState: m.readyState, networkState: m.networkState, error: m.error, seeking: m.seeking, buffered: m.buffered, played: m.played, seekable: m.seekable, duration: m.duration, ended: m.ended, loadedMetadata: m.readyState >= 1, loadedData: m.readyState >= 2, canPlay: m.readyState >= 3, canPlayThrough: m.readyState >= 4, videoWidth: isVid ? m.videoWidth : 0, videoHeight: isVid ? m.videoHeight : 0, textTracks: _flagsOnly ? void 0 : m.textTracks, audioTracks: _flagsOnly ? void 0 : m.audioTracks, videoTracks: _flagsOnly ? void 0 : m.videoTracks, activeCue: _flagsOnly ? void 0 : m.textTracks[_txtTrackIdx]?.activeCues?.[0] || null });
+var getMediaSettings = (m) => ({ defaultMuted: m.defaultMuted, defaultPlaybackRate: m.defaultPlaybackRate, srcObject: m.srcObject });
+var getMediaMin = ({ status: st, state: s }) => st.isLive ? st.seekable.length ? st.canSeekLive ? st.seekable.start(0) : st.seekable.end(st.seekable.length - 1) : s.currentTime : 0;
+var getMediaMax = ({ status: st, state: s }) => st.isLive ? st.seekable.length ? st.seekable.end(st.seekable.length - 1) : s.currentTime : st.duration;
+function getSizeTier(container, { offsetWidth: w, offsetHeight: h } = container) {
+  return { width: w, height: h, tier: h <= 130 ? "xxxxx" : w <= 280 ? "xxxx" : w <= 380 ? "xxx" : w <= 480 ? "xx" : w <= 630 ? "x" : "" };
+}
+function cloneMedia(v) {
+  const newV = v.cloneNode(true);
+  newV.tmgPlayer = v.tmgPlayer;
+  v.parentElement?.replaceChild(newV, v);
+  if (v.currentTime) newV.currentTime = v.currentTime;
+  if (v.playbackRate !== 1) newV.playbackRate = v.playbackRate;
+  if (v.defaultPlaybackRate !== 1) newV.defaultPlaybackRate = v.defaultPlaybackRate;
+  if (v.volume !== 1) newV.volume = v.volume;
+  if (v.muted) newV.muted = true;
+  if (v.defaultMuted) newV.defaultMuted = true;
+  if (v.srcObject) newV.srcObject = v.srcObject;
+  if (v.autoplay) newV.autoplay = true;
+  if (v.loop) newV.loop = true;
+  if (v.controls) newV.controls = true;
+  if (v.crossOrigin) newV.crossOrigin = v.crossOrigin;
+  if (v.playsInline) newV.playsInline = true;
+  if (v.controlsList?.length) newV.controlsList = v.controlsList;
+  if (v.disablePictureInPicture) newV.disablePictureInPicture = true;
+  if (!v.paused && newV.isConnected) newV.play();
+  return newV;
+}
+function putSourceDetails(source, el) {
+  if (source.src) el.src = source.src;
+  if (source.type) el.type = source.type;
+  if (source.media) el.media = source.media;
+}
+function getSources(medium) {
+  const sources = medium.querySelectorAll("source"), _sources = [];
+  for (const source of sources) {
+    const obj = {};
+    putSourceDetails(source, obj);
+    _sources.push(obj);
+  }
+  return _sources;
+}
+function isSameSources(a, b) {
+  if (!a || !b || a.length !== b.length) return false;
+  const set = new Set(b.map((s) => `${cleanURL(s.src)}|${s.type}|${s.media}`));
+  return a.every((s) => set.has(`${cleanURL(s.src)}|${s.type}|${s.media}`));
+}
+function putTrackDetails(track, el) {
+  if (track.id) el.id = track.id;
+  if (track.kind) el.kind = track.kind;
+  if (track.label) el.label = track.label;
+  if (track.srclang) el.srclang = track.srclang;
+  if (track.src) el.src = track.src;
+  if (track.default) el.default = track.default;
+}
+function getTracks(medium, cues = false) {
+  const tracks = medium.querySelectorAll(!cues ? "track" : "track:is([kind='captions'], [kind='subtitles'])"), _tracks = [];
+  for (const track of tracks) {
+    const obj = {};
+    putTrackDetails(track, obj), _tracks.push(obj);
+  }
+  return _tracks;
+}
+function isSameTracks(a, b) {
+  if (!a || !b || a.length !== b.length) return false;
+  const set = new Set(b.map((t) => `${cleanURL(t.src)}|${t.kind}|${t.label}|${t.srclang}|${t.default}`));
+  return a.every((t) => set.has(`${cleanURL(t.src)}|${t.kind}|${t.label}|${t.srclang}|${t.default}`));
+}
+var isTrack = (type, term) => `${type}Track` in window && term instanceof window[`${type}Track`];
+function getTrackIdx(medium, type = "Text", term = "active", list = medium[`${type.toLowerCase()}Tracks`]) {
+  if (isNum(term)) return term;
+  if (list && term === "active") {
+    if (type === "Text") {
+      for (let i = 0; i < +list.length; i++) if (list[i].mode === "showing") return i;
+    }
+    if (type === "Audio") {
+      for (let i = 0; i < +list.length; i++) if (list[i].enabled) return i;
+    }
+    if (type === "Video") return list.selectedIndex ?? -1;
+  }
+  if (list && isTrack(type, term)) return Array.prototype.indexOf.call(list, term);
+  if (list && isStr(term)) {
+    term = term.toLowerCase();
+    return !isNaN(+term) ? +term : Array.prototype.findIndex.call(list, (t) => t.id.toLowerCase() === term || t.label.toLowerCase() === term || t.srclang?.toLowerCase() === term || t.language.toLowerCase() === term || isSameURL(t.src, term));
+  }
+  return -1;
+}
+function setCurrentTrack(medium, type = "Text", term, flush = false, list = medium[`${type.toLowerCase()}Tracks`]) {
+  const idx = getTrackIdx(medium, type, term, list);
+  if (list && type !== "Video") for (let i = 0; i < list.length; i++) type === "Text" ? list[i].mode = i === idx ? "showing" : flush ? "disabled" : "hidden" : list[i].enabled = i === idx;
+  else list?.[idx] && (list[idx].selected = true);
+}
+var DUMMY_VID = (0, import_utils2.createEl)("video");
+var DUMMY_AUD = (0, import_utils2.createEl)("audio");
+function canUseVolume(type = "video", dummy = type === "video" ? DUMMY_VID : DUMMY_AUD) {
+  try {
+    const prev = dummy.volume;
+    dummy.volume = 0.5;
+    const works = dummy.volume === 0.5;
+    return dummy.volume = prev, works;
+  } catch {
+    return false;
+  }
+}
+var canMuteVolume = (type = "video", dummy = type === "video" ? DUMMY_VID : DUMMY_AUD) => !!dummy && "muted" in dummy;
+function canUseRate(type = "video", dummy = type === "video" ? DUMMY_VID : DUMMY_AUD) {
+  try {
+    const prev = dummy.playbackRate;
+    dummy.playbackRate = 0.5;
+    const works = dummy.playbackRate === 0.5;
+    return dummy.playbackRate = prev, works;
+  } catch {
+    return false;
+  }
+}
+var canTextTracks = (type = "video", dummy = type === "video" ? DUMMY_VID : DUMMY_AUD) => !!dummy && "textTracks" in dummy;
+var canVideoTracks = (type = "video", dummy = type === "video" ? DUMMY_VID : DUMMY_AUD) => !!dummy && "videoTracks" in dummy;
+var canAudioTracks = (type = "video", dummy = type === "video" ? DUMMY_VID : DUMMY_AUD) => !!dummy && "audioTracks" in dummy;
+
+// src/ts/techs/base.ts
+var BaseTech = class extends Controllable {
+  constructor(ctlr, features = {}) {
+    ctlr.media.tech.destroy?.(), ctlr.log(`Using ${new.target.techName} media technology.`);
+    super(ctlr, ctlr.media);
+    __publicField(this, "element");
+    __publicField(this, "evtOpts", { EL: { capture: true, signal: this.signal }, CONFIG: { capture: true, signal: this.signal } });
+    // "set" -> Avengers(Resolution lineup) assemble!;
+    __publicField(this, "wiredFeatures", /* @__PURE__ */ new Set());
+    // Tracking to avoid rewiring
+    __publicField(this, "wired", false);
+    // for light status checks where needed
+    __publicField(this, "pending", /* @__PURE__ */ new Map());
+    __publicField(this, "autoChapters", false);
+    ctlr.config.mediaPlayer = "TMG";
+    this.element = ctlr.media.element;
+    for (const key of Object.keys(ctlr.media.features)) ctlr.media.features[key] = false;
+    (0, import_utils25.fanout)(ctlr.media.features, features);
+  }
+  static canPlaySource(_src) {
+    return false;
+  }
+  get name() {
+    return this.constructor.techName;
+  }
+  get el() {
+    return this.element;
+  }
+  onSetup() {
+    this.mount();
+    this.ctlr.state.readyState ? this.wire() : this.ctlr.state.wonce("readyState", this.wire, { signal: this.signal });
+  }
+  onDestroy() {
+    this.unmount(), this.config.status.hostReady = false;
+  }
+  mount() {
+    this.el !== this.config.element && this.config.element.replaceWith(this.el);
+  }
+  unmount() {
+    this.el !== this.config.element && this.el.replaceWith(this.config.element);
+  }
+  wire() {
+    this.el.tmgPlayer = this.config.element.tmgPlayer;
+    this.config.watch("state.currentTime", this.onCurrentTime, this.evtOpts.CONFIG);
+    this.config.on("intent", this.handleWrite, this.evtOpts.CONFIG);
+    this.config.on("settings", this.handleWrite, this.evtOpts.CONFIG);
+    this.wireSrc(), this.wireCurrentTime(), this.wireDuration(), this.wirePaused(), this.wireEnded(), this.wireFeatures();
+    !this.ctlr.payload.wired && this.ctlr.isNativeEl && (0, import_utils25.fanout)(this.config.status, getMediaStatus(this.el, void 0, void 0, true), { skipUndefined: true });
+    (0, import_modules.silence)(() => ((0, import_utils25.fanout)(this.config.intent, this.config[this.ctlr.techTruth]), (0, import_utils25.fanout)(this.config.settings, this.config.settings)));
+    !this.ctlr.payload.wired && (0, import_utils25.force)(() => this.config.tick());
+    this.wired = true;
+  }
+  // --- THE EXTENSIONS & WIRING ---
+  wireFeatures() {
+    this.media.on("features", this.handleFeatures, { init: true, signal: this.signal });
+  }
+  wireFeature(feature) {
+    !this.wiredFeatures.has(feature) && (this.wiredFeatures.add(feature), this[`wire${capitalize(feature)}`]?.());
+  }
+  // Track Switching Wiring
+  wireCurrentChapter() {
+    this.config.set("intent.currentChapter", (term) => isNum(term) ? term : this.config.settings.metadata.chapterInfo.findIndex((c) => c.title === term || c.startTime === term || c.artwork === term), { signal: this.signal });
+    this.config.on("intent.currentChapter", this.handleCurrentChapterIntent, this.evtOpts.CONFIG);
+  }
+  // --- THE HANDLERS ---
+  handleFeatures({ type, target }) {
+    if (type === "update") this.wireFeature(target.key);
+    else if (type === "init") for (const feature of Object.keys(target.value)) this.wireFeature(feature);
+  }
+  handleWrite(e) {
+    if (e.type === "update" && this.config.features[e.target.key] === false && e.value) return e.reject(this.name), e.stopImmediatePropagation();
+  }
+  handleCurrentChapterIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, (chapter = this.config.settings.metadata.chapterInfo[e.value]) => chapter && (this.media.intent.currentTime = chapter.startTime));
+    e.resolve(this.name);
+  }
+  // Dog Feeders
+  onCurrentTime(v) {
+    if (!this.autoChapters) return;
+    const chapters = this.config.settings.metadata.chapterInfo;
+    if (chapters?.length) {
+      for (let len = chapters.length, i = len - 1; i >= 0; i--) if (v >= chapters[i].startTime) return void (this.config.state.currentChapter = i);
+    }
+    this.media.state.currentChapter = -1;
+  }
+  // --- THE HELPERS ---
+  when(status, e, task, always = true, _key = status + e.path, _value = !always && !(this.ctlr.state.readyState < 3) ? true : this.config.status[status], _log = !this.config.status[status]) {
+    const callback = this.ctlr.guard((v, __, late = true) => v && (late && this.pending.get(_key)?.(), this.pending.delete(_key), task(), _log && console.log(`Pending task for ${status} ${e.path} executed with ${e.value}.`, this.config.status[status], this.ctlr.payload.readyState)));
+    this.pending.get(_key)?.(), _value ? callback(_value, null, false) : this.pending.set(_key, this.config.watch(`status.${status}`, callback, { signal: this.signal }));
+  }
+  // #PATIENT: only after first play (`always`)
+};
+__publicField(BaseTech, "techName");
+
+// src/ts/techs/html5.ts
+var import_sia_reactor6 = require("sia-reactor");
+
+// src/ts/utils/match.ts
+var AUDIO_EXTENSIONS = /\.(m4a|m4b|mp4a|mpga|mp2|mp2a|mp3|m2a|m3a|wav|weba|aac|oga|spx|flac|wma|opus|midi?)($|\?)/i;
+var VIDEO_EXTENSIONS = /\.(mp4|mkv|avi|mov|webm|mpg|mpeg|og[gv]|m4v|flv|wmv|3gp|3g2|ts)(#t=[,\d+]+)?($|\?)/i;
+var HLS_EXTENSIONS = /\.(m3u8)($|\?)/i;
+
+// src/ts/utils/env.ts
+var win2 = "undefined" !== typeof window ? window : void 0;
+var nav = win2?.navigator;
+var ua = nav?.userAgent || "";
+var uaData = nav?.userAgentData;
+var IS_ANDROID = false;
+var IS_WINDOWS = false;
+var IS_FIREFOX = false;
+var IS_EDGE = false;
+var IS_CHROME = false;
+var IS_CHROMIUM = false;
+var IS_SAFARI = false;
+var IS_IE = false;
+var IS_TIZEN = false;
+var IS_WEBOS = false;
+var IS_IPOD = false;
+var IS_IPAD = false;
+var IS_IPHONE = false;
+var IOS_VERSION = null;
+var ANDROID_VERSION = null;
+var CHROME_VERSION = null;
+var CHROMIUM_VERSION = null;
+var IE_VERSION = null;
+var IS_IOS = false;
+var IS_MOBILE = false;
+var IS_SMART_TV = false;
+var IS_CHROMECAST_RECEIVER = Boolean(win2?.cast?.framework?.CastReceiverContext);
+var MSE_ENABLED = Boolean(win2 && ("MediaSource" in win2 || "webkitMediaSource" in win2));
+var TOUCH_ENABLED = Boolean(win2 && ("ontouchstart" in win2 || nav?.maxTouchPoints || win2.DocumentTouch && win2.document instanceof win2.DocumentTouch));
+if (uaData?.platform && uaData?.brands) {
+  const pickVersion = (brands, needle) => brands.find((b) => b.brand === needle && b.version)?.version || null;
+  IS_ANDROID = uaData.platform === "Android";
+  IS_WINDOWS = uaData.platform === "Windows";
+  IS_EDGE = uaData.brands.some((b) => b.brand === "Microsoft Edge");
+  IS_CHROMIUM = uaData.brands.some((b) => b.brand === "Chromium" || b.brand === "Google Chrome");
+  IS_CHROME = IS_CHROMIUM && !IS_EDGE;
+  CHROMIUM_VERSION = CHROME_VERSION = pickVersion(uaData.brands, "Chromium") || pickVersion(uaData.brands, "Google Chrome");
+}
+if (true) {
+  IS_ANDROID || (IS_ANDROID = /Android/i.test(ua));
+  IS_WINDOWS || (IS_WINDOWS = /Windows/i.test(ua));
+  IS_FIREFOX = /Firefox|FxiOS/i.test(ua);
+  IS_EDGE || (IS_EDGE = /Edg|EdgiOS/i.test(ua));
+  IS_CHROMIUM || (IS_CHROMIUM = /Chrome|CriOS/i.test(ua));
+  IS_CHROME = IS_CHROMIUM && !IS_EDGE;
+  IS_SAFARI = /Safari/i.test(ua) && !IS_CHROME && !IS_FIREFOX && !IS_EDGE;
+  IS_IE = /MSIE|(Trident\/7.0)|(rv:11.0)/i.test(ua);
+  IS_TIZEN = /Tizen/i.test(ua);
+  IS_WEBOS = /Web0S/i.test(ua);
+  IS_IPOD = /iPod/i.test(ua);
+  IS_IPAD = /iPad/i.test(ua) || IS_SAFARI && TOUCH_ENABLED && !/iPhone/i.test(ua);
+  IS_IPHONE = /iPhone/i.test(ua) && !IS_IPAD;
+  IOS_VERSION = ua.match(/OS (\d+)_/i)?.[1] ?? null;
+  ANDROID_VERSION = ua.match(/Android\s(\d+(?:\.\d+)+)/i)?.[1] ?? null;
+  CHROMIUM_VERSION = CHROME_VERSION = ua.match(/(?:Chrome|CriOS)\/(\d+)/)?.[1] ?? CHROMIUM_VERSION;
+  IE_VERSION = ua.match(/MSIE\s(\d+)\.\d/)?.[1] || (/Trident\/7.0/i.test(ua) && /rv:11.0/.test(ua) ? "11.0" : null);
+}
+IS_IOS = IS_IPHONE || IS_IPAD || IS_IPOD;
+IS_MOBILE = Boolean(IS_ANDROID || IS_IPHONE || IS_IPOD || IS_IPAD);
+IS_SMART_TV = IS_TIZEN || IS_WEBOS;
+
+// src/ts/techs/html5.ts
+var import_modules2 = require("sia-reactor/modules");
+var import_utils27 = require("sia-reactor/utils");
+var HTML5Tech = class extends BaseTech {
+  constructor(ctlr, features) {
+    const isAudio = ctlr.media.type === "audio", canTxtTrack = canTextTracks(ctlr.media.type), canVidTrack = !isAudio && canVideoTracks(ctlr.media.type), canAudTrack = canAudioTracks(ctlr.media.type);
+    super(ctlr, {
+      // Kinda Core
+      volume: canUseVolume(ctlr.media.type),
+      muted: canMuteVolume(ctlr.media.type),
+      playbackRate: canUseRate(ctlr.media.type),
+      // Modes
+      pictureInPicture: !isAudio && supportsPictureInPicture() && !ctlr.media.state.disablePictureInPicture,
+      fullscreen: !isAudio && supportsFullscreen(),
+      // Markup & States
+      poster: !isAudio,
+      autoplay: true,
+      loop: true,
+      playsInline: !isAudio,
+      preload: true,
+      crossOrigin: true,
+      controls: true,
+      controlsList: true,
+      disablePictureInPicture: true,
+      sources: true,
+      tracks: true,
+      live: false,
+      // Lists
+      textTracks: canTxtTrack,
+      videoTracks: !isAudio && canVidTrack,
+      audioTracks: canAudTrack,
+      // Currents
+      currentChapter: canTxtTrack,
+      currentTextTrack: canTxtTrack,
+      currentVideoTrack: canVidTrack,
+      currentAudioTrack: canAudTrack,
+      textVisible: canTxtTrack,
+      activeCue: canTxtTrack,
+      // Infos
+      readyState: true,
+      networkState: true,
+      error: true,
+      waiting: true,
+      stalled: true,
+      seeking: true,
+      buffered: true,
+      played: true,
+      seekable: true,
+      videoWidth: !isAudio,
+      videoHeight: !isAudio,
+      loadedMetadata: true,
+      loadedData: true,
+      canPlay: true,
+      canPlayThrough: true,
+      isLive: true,
+      canSeekLive: true,
+      // Settings
+      defaultMuted: true,
+      defaultPlaybackRate: true,
+      srcObject: true,
+      metadata: canTxtTrack,
+      liveTolerance: true,
+      minDVRWindow: true,
+      ...features
+    });
+    __publicField(this, "strictTracks", false);
+    // --- Active Cue Wiring ---
+    __publicField(this, "textTrack", null);
+    __publicField(this, "chapterTrack", null);
+    __publicField(this, "durationSeq", 0);
+    __publicField(this, "durationSrc", "");
+    __publicField(this, "renderSources");
+    __publicField(this, "renderTracks");
+    ctlr.media.status.hostReady = true;
+  }
+  static canPlaySource(src) {
+    return VIDEO_EXTENSIONS.test(src) || AUDIO_EXTENSIONS.test(src) || !!(!MSE_ENABLED && DUMMY_VID.canPlayType("application/vnd.apple.mpegurl") && HLS_EXTENSIONS.test(src));
+  }
+  // ===========================================================================
+  // WIRING (Connections Only)
+  // ===========================================================================
+  // --- Core Wiring ---
+  wireSrc() {
+    this.el.addEventListener("loadstart", this.setLoadStartInfo, this.evtOpts.EL);
+    this.config.on("intent.src", this.handleSrcIntent, this.evtOpts.CONFIG);
+  }
+  wireCurrentTime() {
+    this.el.addEventListener("timeupdate", this.setTimeUpdateState, this.evtOpts.EL);
+    this.el.addEventListener("seeking", this.setSeekingState, this.evtOpts.EL);
+    this.el.addEventListener("seeked", this.setSeekedState, this.evtOpts.EL);
+    this.config.get("state.currentTime", () => this.el.currentTime, { signal: this.signal });
+    this.config.on("intent.currentTime", this.handleCurrentTimeIntent, this.evtOpts.CONFIG);
+  }
+  wireDuration() {
+    this.el.addEventListener("durationchange", this.setDurationChangeState, this.evtOpts.EL);
+  }
+  wirePaused() {
+    this.el.addEventListener("play", this.setPlayState, this.evtOpts.EL);
+    this.el.addEventListener("pause", this.setPauseState, this.evtOpts.EL);
+    this.config.on("intent.paused", this.handlePausedIntent, this.evtOpts.CONFIG);
+  }
+  wireEnded() {
+    this.el.addEventListener("ended", this.setEndedState, this.evtOpts.EL);
+  }
+  // --- Features Wiring ---
+  wireFeatures() {
+    super.wireFeatures();
+    this.wireHTMLState();
+    const loadEvents = ["loadstart", "progress", "suspend", "abort", "emptied", "stalled"];
+    for (const e of loadEvents) this.el.addEventListener(e, this.handleLoadStatus, this.evtOpts.CONFIG);
+    this.el.addEventListener("error", this.handleErrorStatus, this.evtOpts.CONFIG);
+    this.el.addEventListener("waiting", this.handleWaitingStatus, this.evtOpts.CONFIG);
+    this.el.addEventListener("playing", this.handlePlayingStatus, this.evtOpts.CONFIG);
+    this.el.addEventListener("stalled", this.handleStalledStatus, this.evtOpts.CONFIG);
+    this.el.addEventListener("loadedmetadata", this.handleLoadedMetadataStatus, this.evtOpts.CONFIG);
+    this.el.addEventListener("loadeddata", this.handleLoadedDataStatus, this.evtOpts.CONFIG);
+    this.el.addEventListener("canplay", this.handleCanPlayStatus, this.evtOpts.CONFIG);
+    this.el.addEventListener("canplaythrough", this.handleCanPlayThroughStatus, this.evtOpts.CONFIG);
+  }
+  // --- Engine Inputs Wiring ---
+  wireVolume() {
+    this.el.addEventListener("volumechange", this.setVolumeChangeState, this.evtOpts.EL);
+    this.config.on("intent.volume", this.handleVolumeIntent, this.evtOpts.CONFIG);
+  }
+  wireMuted() {
+    this.config.on("intent.muted", this.handleMutedIntent, this.evtOpts.CONFIG);
+  }
+  wirePlaybackRate() {
+    this.el.addEventListener("ratechange", this.setRateChangeState, this.evtOpts.EL);
+    this.config.on("intent.playbackRate", this.handlePlaybackRateIntent, this.evtOpts.CONFIG);
+  }
+  // --- Presentation Modes Wiring ---
+  wirePictureInPicture() {
+    this.el.addEventListener("enterpictureinpicture", this.setEnterPiPState, this.evtOpts.EL);
+    this.el.addEventListener("leavepictureinpicture", this.setLeavePiPState, this.evtOpts.EL);
+    this.config.on("intent.pictureInPicture", this.handlePictureInPictureIntent, this.evtOpts.CONFIG);
+  }
+  wireFullscreen() {
+    this.el.addEventListener("webkitbeginfullscreen", this.setWebkitBeginFullscreenState, this.evtOpts.CONFIG);
+    this.el.addEventListener("webkitendfullscreen", this.setWebkitEndFullscreenState, this.evtOpts.CONFIG);
+    this.ctlr.state.watch("docInFullscreen", this.setFullscreenChangeState, this.evtOpts.CONFIG);
+    this.config.on("intent.fullscreen", this.handleFullscreenIntent, this.evtOpts.CONFIG);
+  }
+  // --- Track Switching Wiring ---
+  wireCurrentTrack(type) {
+    this.config.set(`intent.current${type}Track`, (term) => getTrackIdx(this.el, type, term, this.config.status[`${type.toLowerCase()}Tracks`]), { signal: this.signal });
+    this.el[`${type.toLowerCase()}Tracks`]?.addEventListener("change", () => this.setCurrentTrackState(type), this.evtOpts.CONFIG);
+    this.config.on(`intent.current${type}Track`, (e) => this.handleCurrentTrackIntent(e, type), this.evtOpts.CONFIG);
+  }
+  wireCurrentTextTrack() {
+    this.wireCurrentTrack("Text");
+  }
+  wireCurrentAudioTrack() {
+    this.wireCurrentTrack("Audio");
+  }
+  wireCurrentVideoTrack() {
+    this.wireCurrentTrack("Video");
+  }
+  wireTextVisible() {
+    this.config.on("intent.textVisible", this.handleTextVisibleIntent, this.evtOpts.CONFIG);
+  }
+  // --- HTML (Bulk Wiring) ---
+  wireHTMLState() {
+    observeMutation(this.el, this.setHTMLStateFromMutation, { attributes: true, childList: true, subtree: false }, this.signal);
+  }
+  // --- Attribute Wiring ---
+  bindAttribute(key, isBool2 = false) {
+    this.config.on(`intent.${key}`, (e) => this.handleAttributeIntent(e, key, isBool2), this.evtOpts.CONFIG);
+  }
+  wirePoster() {
+    this.bindAttribute("poster");
+  }
+  wireAutoplay() {
+    this.bindAttribute("autoplay", true);
+  }
+  wireLoop() {
+    this.bindAttribute("loop", true);
+  }
+  wirePreload() {
+    this.bindAttribute("preload");
+  }
+  wirePlaysInline() {
+    this.bindAttribute("playsInline", true);
+  }
+  wireCrossOrigin() {
+    this.bindAttribute("crossOrigin");
+  }
+  wireControls() {
+    this.bindAttribute("controls", true);
+  }
+  wireControlsList() {
+    this.bindAttribute("controlsList");
+  }
+  wireDisablePictureInPicture() {
+    this.bindAttribute("disablePictureInPicture", true);
+    this.config.watch("state.disablePictureInPicture", this.onDisablePiPState);
+  }
+  // --- Lists Wiring ---
+  wireSources() {
+    this.config.on("intent.sources", this.handleSourcesIntent, this.evtOpts.CONFIG);
+  }
+  wireTracks() {
+    this.config.on("intent.tracks", this.handleTracksIntent, this.evtOpts.CONFIG);
+  }
+  // --- Status Tracks Wiring ---
+  wireMediaTracks(type, list = this.el[`${type.toLowerCase()}Tracks`]) {
+    if (list) for (const e of ["addtrack", "removetrack"]) list.addEventListener(e, () => this.handleTracksStatus(type, list), this.evtOpts.CONFIG);
+    if (list) this.handleTracksStatus(type, list, true);
+  }
+  wireTextTracks() {
+    this.wireMediaTracks("Text");
+  }
+  wireAudioTracks() {
+    this.wireMediaTracks("Audio");
+  }
+  wireVideoTracks() {
+    this.wireMediaTracks("Video");
+  }
+  wireActiveCue() {
+    const onChange = () => {
+      const track = this.media.status.textTracks[!this.strictTracks ? this.config.state.currentTextTrack : getTrackIdx(this.el, "Text", this.config.status.textTracks[this.config.state.currentTextTrack]?.id, this.config.status.textTracks)];
+      if (this.textTrack && this.textTrack !== track) this.textTrack.removeEventListener("cuechange", this.handleActiveCueChange, this.evtOpts.EL);
+      (this.textTrack = track)?.addEventListener("cuechange", this.handleActiveCueChange, this.evtOpts.EL), this.handleActiveCueChange({ target: track });
+    };
+    this.config.on("state.currentTextTrack", onChange, this.evtOpts.CONFIG), this.config.on("status.textTracks", onChange, this.evtOpts.CONFIG);
+  }
+  wireChapterCue(track) {
+    if (this.chapterTrack && this.chapterTrack !== track) this.chapterTrack.removeEventListener("cuechange", this.handleChapterCueChange, this.evtOpts.EL);
+    (this.chapterTrack = track).addEventListener("cuechange", this.handleChapterCueChange, this.evtOpts.EL), this.handleChapterCueChange({ target: track });
+  }
+  // --- Live Content Wiring ---
+  wireLive() {
+    this.config.on("intent.live", this.handleLiveIntent, this.evtOpts.CONFIG);
+    this.config.watch("status.isLive", this.onIsLiveStatus, this.evtOpts.CONFIG);
+  }
+  // --- Settings Wiring ---
+  wireDefaultMuted() {
+    this.config.on("settings.defaultMuted", this.handleDefaultMutedSetting, this.evtOpts.CONFIG);
+  }
+  wireDefaultPlaybackRate() {
+    this.config.on("settings.defaultPlaybackRate", this.handleDefaultPlaybackRateSetting, this.evtOpts.CONFIG);
+  }
+  wireSrcObject() {
+    this.config.on("settings.srcObject", this.handleSrcObjectSetting, this.evtOpts.CONFIG);
+  }
+  // ===========================================================================
+  // HANDLERS (The Logic - Auto-Guarded)
+  // ===========================================================================
+  // --- Core States ---
+  setLoadStartInfo() {
+    const { state: s, status: st } = this.config;
+    st.error = st.activeCue = null;
+    (0, import_utils27.force)(() => (st.buffered = this.el.buffered, st.seekable = this.el.seekable));
+    st.duration = this.el.duration;
+    s.paused = this.el.paused;
+    st.ended = st.stalled = st.loadedData = st.loadedMetadata = st.canPlay = st.canPlayThrough = false;
+  }
+  setTimeUpdateState() {
+    const { status: st, settings: set, state: s } = this.config;
+    s.currentTime = this.el.currentTime;
+    if (st.isLive)
+      if (st.seekable.length) {
+        const max = st.seekable.end(st.seekable.length - 1);
+        st.canSeekLive = max - st.seekable.start(0) >= set.minDVRWindow;
+        s.live = max - s.currentTime <= set.liveTolerance;
+      } else s.live = !(st.canSeekLive = false);
+    else this.config.status.ended = this.el.currentTime === this.el.duration;
+  }
+  setSeekingState() {
+    this.config.status.seeking = true;
+    (0, import_utils27.force)(() => this.config.status.played = this.el.played);
+  }
+  setSeekedState() {
+    this.config.status.seeking = false;
+  }
+  setDurationChangeState() {
+    if (this.el.currentSrc !== this.durationSrc) this.durationSeq = 0, this.durationSrc = this.el.currentSrc;
+    const prev = this.config.status.duration;
+    if ((this.config.status.duration = this.el.duration) === Infinity) return void (this.config.status.isLive = true);
+    prev === Infinity ? this.config.status.isLive = false : prev > 0 && this.el.duration > prev && ++this.durationSeq > 3 && (this.config.status.isLive = true);
+  }
+  setPlayState() {
+    this.config.status.ended = this.config.state.paused = false;
+  }
+  setPauseState() {
+    this.config.state.paused = true;
+    (0, import_utils27.force)(() => this.config.status.played = this.el.played);
+    this.config.status.waiting = false;
+  }
+  setEndedState() {
+    this.config.status.ended = this.config.state.paused = true;
+  }
+  // --- Core Intents ---
+  handleSrcIntent(e) {
+    if (e.resolved || this.wired && isSameURL(this.el.currentSrc, e.value)) return;
+    this.el.src = e.value;
+    e.resolve(this.name);
+  }
+  handleCurrentTimeIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedData", e, (min = getMediaMin(this.config), max = getMediaMax(this.config)) => {
+      if (e.value < min || e.value > max) e.reject(this.name);
+      this.el.currentTime = (0, import_utils5.clamp)(min, e.value, max);
+    });
+    e.resolve(this.name);
+  }
+  handlePausedIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => (e.value ? this.el.pause() : this.el.play())?.catch?.((e2) => this.ctlr.log(e2, "error", true)), false);
+    e.resolve(this.name);
+  }
+  // --- Feature States ---
+  setVolumeChangeState() {
+    this.config.state.volume = this.el.volume * 100;
+    this.config.state.muted = this.el.muted;
+  }
+  setRateChangeState() {
+    this.config.state.playbackRate = this.el.playbackRate;
+  }
+  setEnterPiPState() {
+    this.config.state.pictureInPicture = true;
+  }
+  setLeavePiPState() {
+    this.config.state.pictureInPicture = false;
+  }
+  setFullscreenChangeState(docInFs) {
+    this.config.state.fullscreen = docInFs ? queryFullscreenEl() === this.el : false;
+  }
+  setWebkitBeginFullscreenState() {
+    this.config.state.fullscreen = true;
+  }
+  setWebkitEndFullscreenState() {
+    this.config.state.fullscreen = false;
+  }
+  setCurrentTrackState(type, list = this.media.status[`${type.toLowerCase()}Tracks`]) {
+    this.config.state[`current${type}Track`] = getTrackIdx(this.el, type, "active", list);
+  }
+  setHTMLStateFromMutation(mutations) {
+    for (const m of mutations) {
+      const { state, settings } = this.config;
+      if (m.type === "childList") {
+        const nodes = [...m.addedNodes, ...m.removedNodes];
+        if (nodes.some(({ nodeName: nm }) => nm === "SOURCE")) state.sources = (0, import_sia_reactor6.inert)(getSources(this.el));
+        if (nodes.some(({ nodeName: nm }) => nm === "TRACK")) state.tracks = (0, import_sia_reactor6.inert)(getTracks(this.el));
+      } else if (m.type !== "attributes" || !m.attributeName) return;
+      switch (m.attributeName) {
+        case "poster":
+          return void (state.poster = this.el.poster);
+        case "autoplay":
+          return void (state.autoplay = this.el.autoplay);
+        case "loop":
+          return void (state.loop = this.el.loop);
+        case "preload":
+          return void (state.preload = this.el.preload);
+        case "crossorigin":
+          return void (state.crossOrigin = this.el.crossOrigin);
+        case "controls":
+          return void (state.controls = this.el.controls);
+        case "playsinline":
+        case "webkit-playsinline":
+          return void (state.playsInline = this.el.playsInline);
+        case "controlslist":
+          return void (state.controlsList = this.el.controlsList ?? this.el.getAttribute(m.attributeName));
+        case "disablepictureinpicture":
+          return void (state.disablePictureInPicture = this.el.disablePictureInPicture ?? this.el.hasAttribute(m.attributeName));
+        case "muted":
+          return void (state.muted = this.el.muted, settings.defaultMuted = this.el.defaultMuted);
+      }
+    }
+  }
+  // --- Feature Intents ---
+  handleVolumeIntent(e) {
+    if (e.resolved) return;
+    if (e.value < 0 || e.value > 100) e.reject(this.name);
+    this.el.volume = (0, import_utils5.clamp)(0, e.value / 100, 1);
+    e.resolve(this.name);
+  }
+  handleMutedIntent(e) {
+    if (e.resolved) return;
+    this.el.muted = e.value;
+    e.resolve(this.name);
+  }
+  handlePlaybackRateIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => this.el.playbackRate = e.value);
+    e.resolve(this.name);
+  }
+  handlePictureInPictureIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => e.value ? this.el.requestPictureInPicture()?.catch(this.ctlr.notice) : document.pictureInPictureElement === this.el && document.exitPictureInPicture()?.catch(this.ctlr.notice), true);
+    e.resolve(this.name);
+  }
+  handleFullscreenIntent(e) {
+    if (e.resolved) return;
+    (e.value ? enterFullscreen(this.el) : exitFullscreen(this.el))?.catch(this.ctlr.notice);
+    e.resolve(this.name);
+  }
+  handleCurrentTrackIntent(e, type) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, (list = this.config.status[`${type.toLowerCase()}Tracks`]) => {
+      if (e.value < list.length) {
+        setCurrentTrack(this.el, type, e.value, true, list);
+        this.setCurrentTrackState(type, list);
+      }
+    });
+    e.resolve(this.name);
+  }
+  handleTextVisibleIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => {
+      if (e.value && this.media.status.textTracks.length && this.media.state.currentTextTrack === -1) (0, import_modules2.silence)(() => this.media.intent.currentTextTrack = Math.max(0, getTrackIdx(this.media.element, "Text", this.media.state.tracks.find((t) => t.default)?.id, this.media.status.textTracks)));
+      if (this.textTrack) this.textTrack.mode = e.value ? "showing" : "hidden";
+      this.config.state.textVisible = e.value;
+    });
+    e.resolve(this.name);
+  }
+  handleAttributeIntent(e, key, isBool2, attr = key.toLowerCase()) {
+    if (e.resolved || key === "poster" && isSameURL(this.el.poster, e.value)) return;
+    isBool2 ? this.el.toggleAttribute(attr, Boolean(e.value)) : e.value ? this.el.setAttribute(attr, e.value) : this.el.removeAttribute(attr);
+    if (key === "playsInline") this.el.toggleAttribute("webkit-playsinline", Boolean(e.value));
+    e.resolve(this.name);
+  }
+  handleSourcesIntent(e) {
+    if (e.resolved || isSameSources(Array.from(this.el.querySelectorAll("source")), e.value)) return;
+    (this.renderSources ?? (this.renderSources = createListRenderer({ container: this.el, getKey: (s) => `${cleanURL(s.src)}|${s.type}${s.media}`, createNode: (s) => (0, import_utils27.createEl)("source", s), updateNode: (el, s) => (0, import_utils27.assignEl)(el, s, void 0, void 0, false), initNode: (el, register) => el instanceof HTMLSourceElement && register(`${cleanURL(el.src)}|${el.type}${el.media}`) })))(e.currentTarget.value);
+    e.resolve(this.name);
+  }
+  handleTracksIntent(e) {
+    if (e.resolved || isSameTracks(Array.from(this.el.querySelectorAll("track")), e.value)) return;
+    (this.renderTracks ?? (this.renderTracks = createListRenderer({ container: this.el, getKey: (t) => `${cleanURL(t.src)}|${t.kind}|${t.label}|${t.srclang}|${t.default}`, createNode: (t) => (0, import_utils27.createEl)("track", t), updateNode: (el, t) => (0, import_utils27.assignEl)(el, t, void 0, void 0, false), initNode: (el, register) => el instanceof HTMLTrackElement && register(`${cleanURL(el.src)}|${el.kind}|${el.label}|${el.srclang}|${el.default}`) })))(e.currentTarget.value);
+    e.resolve(this.name);
+  }
+  handleLiveIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, (seekable = this.config.status.seekable) => e.value && seekable.length && (this.media.intent.currentTime = seekable.end(seekable.length - 1) - 1));
+    e.resolve(this.name);
+  }
+  // --- Status (Bulk) ---
+  handleLoadStatus() {
+    this.config.status.readyState = this.el.readyState;
+    this.config.status.networkState = this.el.networkState;
+    (0, import_utils27.force)(() => (this.config.status.buffered = this.el.buffered, this.config.status.seekable = this.el.seekable));
+  }
+  handleLoadedMetadataStatus() {
+    this.config.status.videoWidth = this.config.type === "video" ? this.config.element.videoWidth : 0, this.config.status.videoHeight = this.config.type === "video" ? this.config.element.videoHeight : 0;
+    this.config.status.isLive = (this.config.status.duration = this.el.duration) === Infinity;
+    this.handleLoadStatus();
+    this.config.status.loadedMetadata = true;
+  }
+  handleLoadedDataStatus() {
+    this.config.status.loadedData = true;
+  }
+  handleCanPlayStatus() {
+    this.config.status.canPlay = true;
+  }
+  handleCanPlayThroughStatus() {
+    this.config.status.canPlayThrough = true;
+  }
+  handleStalledStatus() {
+    this.config.status.stalled = true;
+  }
+  handleWaitingStatus() {
+    this.config.status.waiting = true;
+  }
+  handlePlayingStatus() {
+    this.config.status.error = null;
+    this.config.status.waiting = this.config.status.stalled = false;
+  }
+  handleErrorStatus(e, target = e?.target) {
+    if (target && target !== this.el) return this.ctlr.log({ message: `Media ${target.nodeName || "Child"} element error occurred!`, event: e, target }, "error", true);
+    this.config.status.error = this.el.error ?? { message: isStr(e) && e || e?.message };
+    this.config.status.waiting = false;
+  }
+  handleTracksStatus(type, list, init2 = false) {
+    this.config.status[`${type.toLowerCase()}Tracks`] = Array.prototype.filter.call(list, (t) => type === "Text" ? t.kind === "subtitles" || t.kind === "captions" : true);
+    type === "Text" && (this.autoChapters = this.config.settings.metadata.allowOverride) && this.handleChaptersStatus(list);
+    !init2 && (0, import_modules2.silence)(() => this.config.intent[`current${type}Track`] = this.config.state[`current${type}Track`]);
+    !init2 && type === "Text" && (0, import_modules2.silence)(() => this.config.intent.textVisible = this.config.state.textVisible);
+  }
+  handleChaptersStatus(list = this.el.textTracks) {
+    const track = Array.prototype.find.call(list, (t) => t.kind === "chapters") || null;
+    if (!track) return void (this.config.settings.metadata.chapterInfo = [], this.config.state.currentChapter = -1);
+    if (track.mode === "disabled") track.mode = "hidden";
+    const extract = () => this.config.settings.metadata.chapterInfo = track.cues?.length ? Array.from(track.cues, (cue) => ({ title: cue.text, startTime: cue.startTime, artwork: [] })) : [];
+    track.cues.length ? extract() : track.addEventListener("cuechange", extract, { ...this.evtOpts.EL, once: true }), this.wireChapterCue(track);
+  }
+  handleActiveCueChange(e, strict = false, track = e?.target) {
+    if (!strict || track && getTrackIdx(this.el, "Text", track, this.config.status.textTracks) === this.config.state.currentTextTrack) this.config.status.activeCue = track?.activeCues?.[0] || null;
+  }
+  handleChapterCueChange(e, track = e?.target, cue = track?.activeCues?.[0] || null) {
+    this.config.state.currentChapter = cue ? this.config.settings.metadata.chapterInfo?.findIndex((c) => c.startTime === cue.startTime) ?? -1 : -1;
+  }
+  // --- Settings ---
+  handleDefaultMutedSetting(e) {
+    this.el.defaultMuted = e.value;
+  }
+  handleDefaultPlaybackRateSetting(e) {
+    this.el.defaultPlaybackRate = e.value;
+  }
+  handleSrcObjectSetting(e) {
+    this.el.srcObject = e.value;
+  }
+  // --- Dog Feeders ---
+  onDisablePiPState(v) {
+    this.media.intent.pictureInPicture = false;
+    this.config.features.pictureInPicture = !v;
+  }
+  onIsLiveStatus(v) {
+    this.config.features.live = v;
+  }
+  // --- Lifecycle ---
+  onDestroy() {
+    this.el.removeAttribute("src");
+  }
+};
+__publicField(HTML5Tech, "techName", "html5");
+
+// src/ts/core/controller.ts
+var import_sia_reactor7 = require("sia-reactor");
+var import_utils28 = require("sia-reactor/utils");
+var import_modules3 = require("sia-reactor/modules");
+var Controller = class {
+  // mutatingDOMMedia: for external watchers that need to know
+  constructor(medium, build) {
+    // --- CORE SYSTEM ---
+    __publicField(this, "ac", new AbortController());
+    __publicField(this, "signal", this.ac.signal);
+    __publicField(this, "plugs", /* @__PURE__ */ new Map());
+    // --- RUNTIME (Global Controller States) ---
+    __publicField(this, "media");
+    __publicField(this, "state");
+    // runtime state and states to be populated for easy reach
+    __publicField(this, "config");
+    // --- MEMORY ---
+    __publicField(this, "payload", { instance: this });
+    __publicField(this, "_build");
+    // Build Cache
+    // DOM References (Utilized by Externals)
+    __publicField(this, "DOM", {});
+    // To be populated with common elements for easy reach
+    __publicField(this, "mutatingDOMM", true);
+    __publicField(this, "guard", (fn, silent = false) => (0, import_utils8.guardMethod)(fn, (e) => this.notice(e, "error", !silent)));
+    __publicField(this, "zenlist", ["settings"]);
+    __publicField(this, "altImg");
+    (0, import_utils8.guardAllMethods)(this, this.guard);
+    const defs = (0, import_utils28.mergeObjs)(getMediaReport(medium), build.media);
+    this.config = (0, import_sia_reactor7.reactive)((0, import_sia_reactor7.volatile)(build), { referenceTracking: true, smartCloning: true, debug: false });
+    this.state = (0, import_sia_reactor7.reactive)(structuredClone(STATE_BUILD), { debug: false });
+    this.state.watch("readyState", (v) => (this.payload.readyState = v, this.payload.initialized = v > 0, this.payload.wired = v > 1, this.payload.destroyed = v < 0), { signal: this.signal });
+    this.media = (0, import_sia_reactor7.reactive)({ intent: (0, import_sia_reactor7.volatile)((0, import_sia_reactor7.intent)(defs.intent)), state: defs.state, status: defs.status, settings: (0, import_sia_reactor7.volatile)((0, import_sia_reactor7.intent)(defs.settings)), tech: (0, import_sia_reactor7.inert)({}), features: {}, type: build.mediaType, element: medium, pseudoElement: (0, import_utils2.createEl)(build.mediaType), container: (0, import_utils2.createEl)("div"), pseudoContainer: (0, import_utils2.createEl)("div") }, { debug: false });
+    this.media.set("tech", (t) => (0, import_sia_reactor7.inert)(t), { signal: this.signal });
+    this.log(this._build = this.config.snapshot()), delete this.config.media;
+    this.setReadyState(0), this.boot();
+  }
+  get settings() {
+    return this.config.settings;
+  }
+  // for easy reach, better devx
+  get actions() {
+    return this.config.actions;
+  }
+  async boot() {
+    this.connectPlugs(), this.wireTechHandler(), this.wireStateHandler();
+    await mockAsync(0), this.setReadyState(1);
+    this.state.wonce("readyState", () => !this.media.state.paused ? this.setReadyState(3) : this.media.wonce("state.paused", () => this.setReadyState(3), { signal: this.signal }), { signal: this.signal });
+    await mockAsync(0), this.setReadyState(2);
+    (0, import_utils6.setTimeout)(() => this.mutatingDOMM = false, 0, this.signal);
+  }
+  connectPlugs(Plugs = PlugRegistry.getOrdered()) {
+    if (!this.payload.wired) for (const Plug of Plugs) this.plugIn(Plug);
+    const plugs = this.payload.wired && Plugs.filter((Plug) => this.config.noPlugList !== "*" && (!this.config.noPlugList.includes(Plug.fullName) || Plug.isCore)).map((Plug) => new Plug(this));
+    if (plugs) plugs.forEach((plug) => plug.mount?.()), plugs.forEach((plug) => plug.wire?.());
+  }
+  disconnectPlugs() {
+    for (const plug of [...this.plugs.values()].reverse()) plug.destroy();
+  }
+  plugIn(Plug, config) {
+    return this.config.noPlugList !== "*" && (!this.config.noPlugList.includes(Plug.fullName) || Plug.isCore) && new Plug(this, config).setup(), this;
+  }
+  plug(fullName) {
+    return this.plugs.get(fullName);
+  }
+  wireTechHandler() {
+    this.media.on("intent.src", this.handleTech, { capture: true, signal: this.signal, init: true });
+    this.media.on("intent.sources", this.handleTech, { capture: true, signal: this.signal });
+    this.media.on("settings.srcObject", this.handleTech, { capture: true, signal: this.signal });
+  }
+  handleTech() {
+    const { src, sources } = this.media.intent;
+    if (this.media.settings.srcObject) return this.useTech();
+    let selectedTech = TechRegistry.pick(src, this.config.settings.techOrder), selectedSource = selectedTech ? src : null;
+    if (!selectedTech && !isSameSources(sources, this.media.state.sources))
+      for (const source of sources) {
+        selectedTech = TechRegistry.pick(source.src, this.config.settings.techOrder);
+        if (selectedTech) {
+          selectedSource = source.src;
+          break;
+        }
+      }
+    (0, import_sia_reactor7.getRaw)(this.media.state).src = src, (0, import_sia_reactor7.getRaw)(this.media.state).sources = (0, import_sia_reactor7.inert)(sources);
+    this.useTech(selectedTech || void 0);
+    if (selectedSource !== src && !this.media.features.sources) (0, import_modules3.silence)(() => this.media.intent.src = selectedSource);
+  }
+  useTech(TechClass = HTML5Tech) {
+    TechClass !== this.media.tech.constructor && (this.media.tech = new TechClass(this)).setup();
+  }
+  get techTruth() {
+    return this.payload.wired ? "state" : "intent";
+  }
+  get isNativeEl() {
+    return this.media.element === this.media.tech.element;
+  }
+  wireStateHandler() {
+    observeIntersection(this.media.container.parentElement, (entry) => this.state.mediaParentIntersecting = entry.isIntersecting, this.signal);
+    observeIntersection(this.media.container, (entry) => this.state.mediaIntersecting = entry.isIntersecting, this.signal);
+    observeResize(this.media.container, () => (0, import_utils28.fanout)(this.state.dimensions.container, getSizeTier(this.media.container)), this.signal);
+    observeResize(this.media.pseudoContainer, () => (0, import_utils28.fanout)(this.state.dimensions.pseudoContainer, getSizeTier(this.media.pseudoContainer)), this.signal);
+  }
+  setReadyState(state) {
+    this.state.readyState = !this.state ? 0 : state ?? this.state.readyState + 1;
+    const rS = this.state.readyState;
+    this.fire("tmgreadystatechange", this.payload), this.fire(rS === 0 ? "tmgcreate" : rS === 1 ? "tmginit" : rS === 2 ? "tmgwire" : rS === 3 ? "tmgfirstplay" : rS === -1 ? "tmgdestroy" : "", this.payload);
+  }
+  // `()=>{}`: needs to be bounded even before initialization
+  notice(mssg, type = "error", toast, swallow = true) {
+    this.log(mssg, type, swallow), toast !== false && (type === "log" || type === "error" && swallow && !this.config.devMode ? this.plug("settings.toasts")?.toast : this.plug("settings.toasts")?.toast?.[type])?.(toast === null || this.config.devMode ? mssg : isStr(toast) ? toast : "Something went wrong", { tag: "tmg-stwr" });
+  }
+  log(mssg, type = "log", swallow = false) {
+    if (!this.config.debug) return;
+    if (type === "error") return swallow && !this.config.devMode ? console.warn(`[TMG Controller] Error swallowed:`, mssg) : console.error(`[TMG Controller] Error occurred:`, mssg);
+    else type === "warn" ? console.warn(`[TMG Controller] Warning:`, mssg) : console.log(`[TMG Controller] Log:`, mssg);
+  }
+  fire(eN, detail = null, el = this.media.element, bubbles = true, cancelable = true) {
+    eN && el?.dispatchEvent(new CustomEvent(eN, { detail, bubbles, cancelable }));
+  }
+  // plugs append here to block actions while their UI is active
+  registerAction(key, action) {
+    const existing = this.actions[key] ?? {};
+    this.actions[key] = { ...action, ...existing, id: key, fn: action.fn };
+    this.config.on(`actions.${key}`, () => this.actions[key] && this.actions[key].fn !== action.fn && (this.actions[key].fn = action.fn), { signal: this.signal });
+  }
+  unregisterAction(key) {
+    delete this.actions[key];
+  }
+  runAction(id, ...args) {
+    const action = this.actions[id];
+    if (!action || !action.zen && this.zenlist.some(this.isUIActive)) return;
+    (0, import_modules3.transaction)(() => {
+      if (action.logic?.length) {
+        const root = { media: this.media, settings: this.config.settings };
+        for (const step of action.logic) {
+          const cur = (0, import_utils28.getPath)(root, step.path);
+          step.op === "toggle" ? (0, import_utils28.setPath)(root, step.path, !cur) : step.op === "increment" ? (0, import_utils28.setPath)(root, step.path, cur + (step.value ?? 1)) : step.op === "decrement" ? (0, import_utils28.setPath)(root, step.path, cur - (step.value ?? 1)) : (0, import_utils28.setPath)(root, step.path, step.value);
+        }
+      }
+      action.fn?.(...args), action.notify && this.plug("settings.notifiers")?.notify(action.notify), action.toast && this.plug("settings.toasts")?.toast?.((isFunc(action.toast.render) ? action.toast.render() : action.toast.render) || "Action Triggered", action.toast);
+    }, action.label ?? action.id);
+  }
+  isLogicPath(path) {
+    return this.config.logicPathBlacklist.some((b) => path === b || path.startsWith(b + ".")) || path.startsWith("media.intent.") && !this.media.features[path.split(".").pop()] ? false : true;
+  }
+  throttle(key, fn, delay = 30, strict = true, signal = this.signal) {
+    throttle(this.config.id + key, fn, delay, strict, signal, getWindow(this.media.container));
+  }
+  debounce(key, fn, delay = 30, strict = true, signal = this.signal) {
+    debounce(this.config.id + key, fn, delay, strict, signal, getWindow(this.media.container));
+  }
+  RAFLoop(key, fn, signal = this.signal) {
+    RAFLoop(this.config.id + key, fn, signal, getWindow(this.media.container));
+  }
+  cancelRAFLoop(key) {
+    cancelRAFLoop(this.config.id + key);
+  }
+  cancelAllLoops() {
+    if (t007._RAFLoopers) for (const k of t007._RAFLoopers.keys()) k.startsWith(this.config.id) && cancelRAFLoop(k);
+  }
+  isUIActive(mode) {
+    return this.media.container.classList.contains(`tmg-media-${uncamelize(mode === "settings" ? "settings-view" : mode, "-")}`);
+  }
+  queryDOM(query, all = false, isPseudo = false) {
+    return all ? (isPseudo ? this.media.pseudoContainer : this.media.container).querySelectorAll(query) : (isPseudo ? this.media.pseudoContainer : this.media.container).querySelector(query);
+  }
+  syncImgLoadState(img, now = true) {
+    return ["load", "error"].forEach((ev) => img.addEventListener(ev, this.setImgLoadState, { signal: this.signal })), now && this.setImgLoadState({ target: img }), img;
+  }
+  setImgLoadState({ target: img }) {
+    img instanceof HTMLImageElement && img?.setAttribute("data-loaded", String(img.complete && img.naturalWidth > 0));
+  }
+  setImgFallback({ target: img }) {
+    img instanceof HTMLImageElement && img.src !== window.TMG_MEDIA_ALT_IMG_SRC && (img.src = window.TMG_MEDIA_ALT_IMG_SRC);
+  }
+  setCanvasFallback(canvas, context, _callback = (img = this.altImg) => context?.drawImage(this.altImg = img, 0, 0, canvas.width, canvas.height)) {
+    const _img = canvas && (this.altImg && this.altImg.src === window.TMG_MEDIA_ALT_IMG_SRC ? _callback() : (0, import_utils2.createEl)("img", { src: window.TMG_MEDIA_ALT_IMG_SRC, onload: () => _callback(_img) }));
+  }
+  destroy() {
+    this.mutatingDOMM = true;
+    this.setReadyState(-1);
+    this.ac.abort("[TMG Controller] Instance is being destroyed"), this.cancelAllLoops();
+    this.disconnectPlugs(), this.media.tech.destroy();
+    const el = this.config.cloneOnDetach ? cloneMedia(this.media.element) : this.media.element;
+    this.state.destroy(), this.config.destroy(), this.media.destroy();
+    return (0, import_utils28.nuke)(this), el;
+  }
+};
+
+// src/ts/tools/player.ts
+var import_utils29 = require("sia-reactor/utils");
+var Player = class {
+  constructor(build = {}) {
+    __publicField(this, "medium", null);
+    __publicField(this, "active", false);
+    __publicField(this, "_build", structuredClone(CONFIG_BUILD));
+    __publicField(this, "controller", null);
+    this.configure({ ...build, id: build.id ?? `${luid()}_Controller_${Controllers.length + 1}` });
+  }
+  get Controller() {
+    return this.controller;
+  }
+  get build() {
+    return this._build;
+  }
+  set build(build) {
+    this.configure(build);
+  }
+  queryBuild() {
+    return !this.active || (this.notice({ error: "Already deployed the custom controls of your build configuration", tip: "Consider setting your build configuration before attaching your media element" }), false);
+  }
+  configure(build) {
+    if (this.queryBuild() && (0, import_utils4.isObj)(build)) this._build = (0, import_utils29.mergeObjs)(this._build, (0, import_utils29.parsePathObj)(build));
+  }
+  async attach(medium) {
+    if (isIter(medium)) return this.notice({ error: "An iterable argument cannot be attached to the TMG media player", tip: "Consider looping the iterable argument to instantiate a new 'tmg.Player' for each" });
+    if (this.active) return medium;
+    medium.tmgPlayer?.detach();
+    Controllers.push(this.build.id);
+    this.build.debug && console.time(`TMG Controller ${Controllers.length} Attach`);
+    medium.tmgPlayer = this;
+    this.medium = medium;
+    await this.fetchOptions(), await this.deployController();
+    this.build.debug && console.timeEnd(`TMG Controller ${Controllers.indexOf(this.controller) + 1} Attach`);
+    return this.controller?.fire("tmgattach", this.controller.payload), medium;
+  }
+  detach() {
+    if (!this.active) return;
+    const medium = this.controller?.destroy() ?? {};
+    this.controller && Controllers.splice(Controllers.indexOf(this.controller), 1);
+    medium.classList?.remove(`tmg-${this.build.mediaType}`, "tmg-media", "tmg-host");
+    medium.tmgcontrols = this.active = false;
+    return medium.tmgPlayer = this.controller = this.medium = null, medium;
+  }
+  async fetchOptions() {
+    if (!this.medium) return;
+    if (this.medium.getAttribute("tmg")?.includes(".json"))
+      await fetch(this.medium.getAttribute("tmg")).then((res) => {
+        if (!res.ok) throw new Error(`JSON file not found at provided URL!. Status: ${res.status}`);
+        return res.json();
+      }).then((json) => this.configure(json)).catch(({ message }) => this.notice({ error: message, tip: "A valid JSON file is required for parsing your build configuration" }));
+    const build = {}, attributes = this.medium.getAttributeNames().filter((attr) => attr.startsWith("tmg--"));
+    for (const attr of attributes) setHTMLConfig(build, attr, this.medium.getAttribute(attr));
+    this.configure(build);
+  }
+  async deployController() {
+    if (this.active || !this.medium?.isConnected) return;
+    if (!(this.medium instanceof HTMLMediaElement)) return this.notice({ error: `Could not deploy custom controls on the '${this.medium.tagName}' element as it is not supported`, warning: "Only the 'VIDEO' and 'AUDIO' elements are currently supported", tip: "" });
+    this.build.mediaType = this.medium.tagName.toLowerCase();
+    this.medium.controls = false;
+    this.medium.tmgcontrols = this.active = true;
+    this.medium.classList.add(`tmg-${this.build.mediaType}`, "tmg-media", "tmg-host");
+    await Promise.all([loadResource(window.TMG_MEDIA_CSS_SRC), loadResource(window.T007_TOAST_JS_SRC, "script", { module: true }), loadResource(window.T007_INPUT_JS_SRC, "script")]);
+    Controllers[Controllers.indexOf(this.build.id)] = this.controller = new Controller(this.medium, this._build);
+  }
+  notice({ error, warning, tip }) {
+    if (this.build.debug) error && console.error(`[TMG Player] ${error}`), warning && console.warn(`[TMG Player] ${warning}`), tip && console.info(`[TMG Player] ${tip}`);
+  }
+};
+
+// src/ts/tools/runtime.ts
+var win3 = "undefined" !== typeof window ? window : void 0;
+var flagMutationSet = /* @__PURE__ */ new WeakSet();
+var flagMutationId;
+var AUDIO_CONTEXT = null;
+var AUDIO_LIMITER = null;
+var IS_DOC_TRANSIENT = false;
+var STATE_BUILD = { readyState: 0, audioContextReady: !!AUDIO_CONTEXT, mediaIntersecting: true, mediaParentIntersecting: true, dimensions: { container: { width: 0, height: 0, tier: "x" }, pseudoContainer: { width: 0, height: 0, tier: "x" }, window: { width: win3?.innerWidth, height: win3?.innerHeight } }, screenOrientation: { type: win3?.screen?.orientation?.type ?? "", angle: win3?.screen?.orientation?.angle ?? win3?.orientation ?? 0 }, docVisibilityState: win3?.document.visibilityState, docInFullscreen: queryFullscreen() };
+var Controllers = [];
+function handleVidMutation(mutations) {
+  for (const mutation of mutations) {
+    if (mutation.type !== "attributes") continue;
+    const target = mutation.target;
+    if (mutation.attributeName === "tmgcontrols") !flagMutationSet.has(target) && (target.tmgcontrols = target.hasAttribute("tmgcontrols"));
+    else if (mutation.attributeName?.startsWith("tmg")) target.hasAttribute(mutation.attributeName) && target.tmgPlayer?.fetchOptions();
+    else if (mutation.attributeName === "controls") target.hasAttribute("tmgcontrols") && target.removeAttribute("controls");
+  }
+}
+function handleDOMMutation(mutations) {
+  for (const mutation of mutations) {
+    for (const node of Array.from(mutation.addedNodes)) {
+      if (!(node instanceof HTMLElement)) continue;
+      const els = node.matches(":is(video,audio):not(.tmg-host)") ? [node] : node.querySelectorAll(":is(video,audio):not(.tmg-host)");
+      for (const el of els) {
+        observeMutation(el, handleVidMutation, { attributes: true });
+        el.tmgcontrols = el.hasAttribute("tmgcontrols");
+      }
+    }
+    for (const node of Array.from(mutation.removedNodes)) {
+      if (!(node instanceof HTMLElement)) continue;
+      const els = node.matches(".tmg-host") ? [node] : node.querySelectorAll(".tmg-host");
+      for (const el of els) !el.tmgPlayer?.Controller?.mutatingDOMM && el.tmgPlayer?.detach();
+    }
+  }
+}
+function flagMutation(m, check = true) {
+  !flagMutationSet.has(m) && check && flagMutationSet.add(m);
+}
+function freeMutation(m) {
+  clearTimeout(flagMutationId);
+  flagMutationId = (0, import_utils6.setTimeout)(() => !(flagMutationId = void 0) && flagMutationSet.delete(m));
+}
+function mountMedia() {
+  if ("undefined" === typeof HTMLMediaElement) return;
+  for (const el of [HTMLVideoElement, HTMLAudioElement])
+    Object.defineProperty(el.prototype, "tmgcontrols", {
+      get: function() {
+        return this.hasAttribute("tmgcontrols");
+      },
+      set: async function(value) {
+        if (value) {
+          flagMutation(this);
+          await (this.tmgPlayer || new Player()).attach(this);
+          this.setAttribute("tmgcontrols", "");
+          freeMutation(this);
+        } else {
+          flagMutation(this, this.hasAttribute("tmgcontrols"));
+          this.removeAttribute("tmgcontrols");
+          this.tmgPlayer?.detach();
+          freeMutation(this);
+        }
+      },
+      enumerable: true,
+      configurable: true
+    });
+}
+function unmountMedia() {
+  for (const el of [HTMLVideoElement, HTMLAudioElement]) delete el.prototype.tmgcontrols;
+}
+function startAudioManager() {
+  if (!AUDIO_CONTEXT && IS_DOC_TRANSIENT) {
+    AUDIO_CONTEXT = new (win3.AudioContext || win3.webkitAudioContext)();
+    const L = AUDIO_LIMITER = AUDIO_CONTEXT.createDynamicsCompressor();
+    L.threshold.value = -1, L.knee.value = 0, L.ratio.value = 20, L.attack.value = 1e-3, L.release.value = 0.05;
+    for (const c of Controllers) if (c.state) c.state.audioContextReady = true;
+  } else if (AUDIO_CONTEXT?.state === "suspended") AUDIO_CONTEXT.resume();
+}
+function connectMediaToAudioManager(medium) {
+  if (!AUDIO_CONTEXT) return "unavailable";
+  medium.mediaElementSourceNode ?? (medium.mediaElementSourceNode = AUDIO_CONTEXT.createMediaElementSource(medium));
+  medium._tmgGainNode ?? (medium._tmgGainNode = AUDIO_CONTEXT.createGain());
+  medium._tmgDynamicsCompressorNode ?? (medium._tmgDynamicsCompressorNode = AUDIO_CONTEXT.createDynamicsCompressor());
+  medium.mediaElementSourceNode.connect(medium._tmgDynamicsCompressorNode);
+  medium._tmgDynamicsCompressorNode.connect(medium._tmgGainNode);
+  medium._tmgGainNode.connect(AUDIO_LIMITER);
+  AUDIO_LIMITER.connect(AUDIO_CONTEXT.destination);
+}
+function init() {
+  mountMedia();
+  for (const e of ["click", "pointerdown", "keydown"]) document.addEventListener(e, () => (IS_DOC_TRANSIENT = true, startAudioManager()), true);
+  for (const medium of document.querySelectorAll("video,audio")) {
+    observeMutation(medium, handleVidMutation, { attributes: true });
+    medium.tmgcontrols = medium.hasAttribute("tmgcontrols");
+  }
+  observeMutation(document.documentElement, handleDOMMutation, { childList: true, subtree: true });
+  win3.addEventListener("resize", () => {
+    for (const c of Controllers) if (c.state) c.state.dimensions.window.width = win3.innerWidth, c.state.dimensions.window.height = win3.innerHeight;
+  });
+  if (win3?.screen?.orientation)
+    win3.screen.orientation.addEventListener("change", ({ target }, t = target) => {
+      for (const c of Controllers) if (c.state) c.state.screenOrientation.type = t.type, c.state.screenOrientation.angle = t.angle;
+    });
+  else
+    win3?.addEventListener("orientationchange", () => {
+      for (const c of Controllers) if (c.state) c.state.screenOrientation.angle = win3.orientation || 0;
+    });
+  document.addEventListener("visibilitychange", () => {
+    for (const c of Controllers) if (c.state) c.state.docVisibilityState = document.visibilityState;
+  });
+  for (const e of ["fullscreenchange", "webkitfullscreenchange", "mozfullscreenchange", "msfullscreenchange"])
+    document.addEventListener(e, (_, inFs = queryFullscreen()) => {
+      for (const c of Controllers) if (c.state) c.state.docInFullscreen = inFs;
+    });
+}
+//# sourceMappingURL=runtime.cjs.map