tmg-media-player 0.0.1

package/dist/techs/z-register.cjs

@@ -0,0 +1,2354 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// 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_utils15 = 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 } = {}, win3 = window) {
+  var _a;
+  win3.t007 ?? (win3.t007 = {}), (_a = win3.t007)._resourceCache ?? (_a._resourceCache = {});
+  if (req === VIRTUAL_RESOURCE || isSym(req)) return Promise.resolve();
+  const src = req;
+  if (win3.t007._resourceCache[src]) return win3.t007._resourceCache[src];
+  const existing = type === "script" ? Array.prototype.find.call(win3.document.scripts, (s) => isSameURL(s.src, src)) : type === "style" ? Array.prototype.find.call(win3.document.styleSheets, (s) => isSameURL(s.href, src)) : null;
+  if (existing) return win3.t007._resourceCache[src] = Promise.resolve(existing);
+  win3.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 win3.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") win3.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") win3.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 win3.t007._resourceCache[src];
+}
+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 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 capitalize(word = "") {
+  return word.replace(/^(\s*)([a-z])/i, (_, s, l) => s + l.toUpperCase());
+}
+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 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/utils/obj.ts
+var import_utils12 = require("sia-reactor/utils");
+
+// 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_utils15.nuke)(this);
+  }
+  onDestroy() {
+  }
+};
+
+// src/ts/techs/base.ts
+var import_utils23 = 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/utils/dom.ts
+var import_sia_reactor5 = require("sia-reactor");
+var win = "undefined" !== typeof window ? window : void 0;
+var queryFullscreenEl = (d = document) => d.fullscreenElement || d.webkitFullscreenElement || d.mozFullScreenElement || d.msFullscreenElement || null;
+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 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_utils22 = require("sia-reactor/utils");
+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 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 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_utils23.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_utils23.fanout)(this.config.status, getMediaStatus(this.el, void 0, void 0, true), { skipUndefined: true });
+    (0, import_modules.silence)(() => ((0, import_utils23.fanout)(this.config.intent, this.config[this.ctlr.techTruth]), (0, import_utils23.fanout)(this.config.settings, this.config.settings)));
+    !this.ctlr.payload.wired && (0, import_utils23.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;
+var DASH_EXTENSIONS = /\.(mpd)($|\?)/i;
+var MATCH_URL_YOUTUBE = /(?:youtu\.be\/|youtube(?:-nocookie|education)?\.com\/(?:embed\/|v\/|watch\/|watch\?v=|watch\?.+&v=|shorts\/|live\/))((\w|-){11})|youtube\.com\/playlist\?list=|youtube\.com\/user\//;
+var MATCH_URL_VIMEO = /vimeo\.com\/(?!progressive_redirect).+/;
+
+// 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/utils/num.ts
+function isSafeNum(val) {
+  return isNum(val) && !isNaN(val ?? NaN) && val !== Infinity;
+}
+
+// src/ts/techs/html5.ts
+var import_modules2 = require("sia-reactor/modules");
+var import_utils25 = 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_utils25.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_utils25.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_utils25.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_utils25.createEl)("source", s), updateNode: (el, s) => (0, import_utils25.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_utils25.createEl)("track", t), updateNode: (el, t) => (0, import_utils25.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_utils25.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, init = 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);
+    !init && (0, import_modules2.silence)(() => this.config.intent[`current${type}Track`] = this.config.state[`current${type}Track`]);
+    !init && 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/techs/dash.ts
+var import_sia_reactor7 = require("sia-reactor");
+var DashTech = class extends HTML5Tech {
+  constructor(ctlr, features) {
+    const isVid = ctlr.media.type === "video";
+    super(ctlr, {
+      // States & Lists
+      sources: false,
+      tracks: false,
+      textTracks: true,
+      audioTracks: true,
+      videoTracks: isVid,
+      levels: true,
+      // States & Currents (DASH.js specific)
+      currentAudioTrack: true,
+      currentVideoTrack: isVid,
+      currentLevel: true,
+      autoLevel: true,
+      // Status & Settings
+      bandwidth: true,
+      protection: true,
+      srcObject: false,
+      ...features
+    });
+    __publicField(this, "host", null);
+    __publicField(this, "strictTracks", true);
+    __publicField(this, "hostSrc", null);
+    ctlr.media.status.hostReady = false;
+  }
+  static canPlaySource(src) {
+    return MSE_ENABLED && DASH_EXTENSIONS.test(src);
+  }
+  // --- API Injection ---
+  async initHost(src = "") {
+    try {
+      this.destroyDash();
+      const DASHJS = window.dashjs ?? (await loadResource(window.TMG_DASH_JS_SRC, "script"), window.dashjs);
+      if (this.signal.aborted) return;
+      if (!DASHJS?.supportsMediaSource()) return this.ctlr.notice("DASH is not supported in this browser", "error", null);
+      const base = this.config[this.ctlr.techTruth];
+      this.hostSrc = src;
+      this.host = DASHJS.MediaPlayer().create();
+      if (this.config.type === "audio") this.host.updateSettings({ streaming: { abr: { autoSwitchBitrate: { video: false } }, trackSwitchMode: { audio: "alwaysReplace", video: "alwaysReplace" }, buffer: { fastSwitchEnabled: true } } });
+      if (this.config.settings.metadata.allowOverride) this.config.settings.metadata.chapterInfo = [];
+      this.host.on(DASHJS.MediaPlayer.events.STREAM_INITIALIZED, () => {
+        this.config.status.isLive = this.host.isDynamic();
+        const autoSwitch = this.host.getSettings().streaming?.abr?.autoSwitchBitrate;
+        this.config.state.autoLevel = typeof autoSwitch === "boolean" ? autoSwitch : autoSwitch?.video ?? true;
+        for (const t of ["text", "audio", "video"]) this.config.status[`${t}Tracks`] = (0, import_sia_reactor7.inert)(this.host.getTracksFor(t));
+        this.config.status.levels = (0, import_sia_reactor7.inert)(this.host.getBitrateInfoListFor("video"));
+        this.media.status.hostReady = true;
+      });
+      this.host.on(DASHJS.MediaPlayer.events.TRACK_CHANGE_RENDERED, (ev) => {
+        const i = this.host?.getTracksFor(ev.mediaType)?.findIndex((t) => t.id === ev.newMediaInfo?.id || t.index === ev.newMediaInfo?.index);
+        this.config.state[`current${capitalize(ev.mediaType)}Track`] = i ?? -1;
+      });
+      this.host.on(DASHJS.MediaPlayer.events.QUALITY_CHANGE_RENDERED, (ev) => ev.mediaType === "video" && (this.config.state.currentLevel = ev.newQuality ?? ev.index));
+      this.host.on(DASHJS.MediaPlayer.events.FRAGMENT_LOADING_COMPLETED, (ev) => this.ctlr.throttle("dashBandWidth", () => ev.request?.mediaType === "video" && (this.config.status.bandwidth = Math.round(this.host.getAverageThroughput("video") / 1e3 * 10) / 10), 2e3));
+      this.host.on(DASHJS.MediaPlayer.events.EVENT_MODE_ON_RECEIVE, (ev) => {
+        if (!this.config.settings.metadata.allowOverride) return;
+        if (!ev.schemeIdUri?.includes("chapter") && !ev.schemeIdUri?.includes("title")) return;
+        const chapters = this.config.settings.metadata.chapterInfo;
+        if (chapters.find((c) => c.startTime === ev.presentationTime)) return;
+        chapters.push({ title: new TextDecoder("utf-8").decode(ev.messageData).replace(/\0/g, "").trim(), startTime: ev.presentationTime });
+        this.config.settings.metadata.chapterInfo = chapters.sort((a, b) => a.startTime - b.startTime);
+      });
+      this.host.on(DASHJS.MediaPlayer.events.ERROR, (ev) => {
+        if (ev.error === "download") return this.ctlr.notice(`DASH Download error occurred: ${ev.event}`, "error", `Download failed for "${ev.event?.url}"`);
+        if (ev.error !== "mediasource") return;
+        this.handleHostError(ev);
+      });
+      this.config.settings.protection && this.host.setProtectionData(this.config.settings.protection);
+      this.host.initialize(this.el, src, base.autoplay || !base.paused, base.currentTime);
+    } catch (err) {
+      this.handleHostError(err);
+    }
+  }
+  // ===========================================================================
+  // WIRING OVERRIDES
+  // ===========================================================================
+  wireCurrentTrack(type, _type = type.toLowerCase()) {
+    this.config.set(`intent.current${type}Track`, (term) => isNum(term) ? term : this.config.status[`${_type}Tracks`].findIndex((t) => t.id === term || t.lang === term), { signal: this.signal });
+    this.config.on(`intent.current${type}Track`, (e) => this.handleCurrentHostTrackIntent(e, _type), this.evtOpts.CONFIG);
+  }
+  wireCurrentLevel() {
+    this.config.set("intent.currentLevel", (term) => isNum(term) ? term : Number(term), { signal: this.signal });
+    this.config.on("intent.currentLevel", this.handleCurrentLevelIntent, this.evtOpts.CONFIG);
+  }
+  wireAutoLevel() {
+    this.config.on("intent.autoLevel", this.handleAutoLevelIntent, this.evtOpts.CONFIG);
+  }
+  // ===========================================================================
+  // HANDLERS
+  // ===========================================================================
+  handleSrcIntent(e) {
+    if (e.resolved || isSameURL(this.hostSrc, e.value)) return;
+    this.initHost(e.value);
+    e.resolve(this.name);
+  }
+  handleCurrentLevelIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => {
+      this.host.updateSettings({ streaming: { abr: { autoSwitchBitrate: { video: false } } } });
+      if (e.value > -1 && e.value < this.config.status.levels.length) {
+        this.host.setQualityFor("video", e.value);
+        this.config.state.autoLevel = false;
+      }
+    });
+    e.resolve(this.name);
+  }
+  handleAutoLevelIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => {
+      this.host.updateSettings({ streaming: { abr: { autoSwitchBitrate: { video: e.value } } } });
+      this.config.state.autoLevel = e.value;
+    });
+    e.resolve(this.name);
+  }
+  handleCurrentHostTrackIntent(e, type) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => {
+      const track = this.config.status[`${type}Tracks`][e.value];
+      if (track) this.host.setCurrentTrack(track);
+    });
+    e.resolve(this.name);
+  }
+  handleHostError(err) {
+    this.config.status.error = { ...err, code: err?.code ?? 5, message: err.error ?? err.message ?? "Fatal DASH error" };
+    this.config.status.waiting = false;
+  }
+  // --- Lifecycle ---
+  destroyDash() {
+    this.host?.reset(), this.host = null, this.media.status.hostReady = false;
+  }
+  onDestroy() {
+    this.destroyDash(), super.onDestroy();
+  }
+};
+__publicField(DashTech, "techName", "dash");
+
+// src/ts/techs/hls.ts
+var import_sia_reactor8 = require("sia-reactor");
+var HLSTech = class extends HTML5Tech {
+  constructor(ctlr, features) {
+    super(ctlr, {
+      // Lists & States
+      sources: false,
+      tracks: false,
+      audioTracks: true,
+      levels: true,
+      // States & Currents (HLS.js specific)
+      currentAudioTrack: true,
+      currentLevel: true,
+      autoLevel: true,
+      // Status & Settings
+      bandwidth: true,
+      srcObject: false,
+      ...features
+    });
+    __publicField(this, "host", null);
+    __publicField(this, "strictTracks", true);
+    __publicField(this, "hostSrc", null);
+    ctlr.media.status.hostReady = false;
+  }
+  static canPlaySource(src) {
+    return MSE_ENABLED && HLS_EXTENSIONS.test(src);
+  }
+  // --- API Injection ---
+  async initHost(src = "") {
+    try {
+      this.destroyHls();
+      const isAudio = this.config.type === "audio", HLS = window.Hls ?? (await loadResource(window.TMG_HLS_JS_SRC, "script"), window.Hls);
+      if (this.signal.aborted) return;
+      if (!HLS?.isSupported()) return this.ctlr.notice("HLS is not supported in this browser", "error", null);
+      this.hostSrc = src;
+      this.host = new HLS({ autoStartLoad: true, startPosition: this.config[this.ctlr.techTruth].currentTime, enableWorker: isAudio, defaultAudioCodec: isAudio ? "mp4a.40.2" : void 0 });
+      if (this.config.settings.metadata.allowOverride) this.config.settings.metadata.chapterInfo = [];
+      this.host.on(HLS.Events.MEDIA_ATTACHED, () => this.host.loadSource(src));
+      this.host.on(HLS.Events.MANIFEST_PARSED, (_, data) => {
+        this.config.state.currentTextTrack = this.host.subtitleTrack;
+        this.config.state.currentAudioTrack = this.host.audioTrack;
+        this.config.state.currentLevel = this.host.currentLevel;
+        this.config.state.autoLevel = this.host.autoLevelEnabled;
+        this.config.status.textTracks = (0, import_sia_reactor8.inert)(data.subtitleTracks);
+        this.config.status.audioTracks = (0, import_sia_reactor8.inert)(data.audioTracks);
+        this.config.status.levels = (0, import_sia_reactor8.inert)(data.levels);
+        this.media.status.hostReady = true;
+      });
+      this.host.on(HLS.Events.SUBTITLE_TRACK_SWITCH, (_, data) => this.config.state.currentTextTrack = data.id);
+      this.host.on(HLS.Events.AUDIO_TRACK_SWITCHED, (_, data) => this.config.state.currentAudioTrack = data.id);
+      this.host.on(HLS.Events.LEVEL_SWITCHED, (_, data) => this.config.state.currentLevel = data.level);
+      this.host.on(HLS.Events.LEVEL_LOADED, (_, data) => this.config.status.isLive = data.details.live);
+      this.host.on(HLS.Events.FRAG_PARSING_METADATA, (_, data) => {
+        if (!this.config.settings.metadata.allowOverride) return;
+        const chapters = this.config.settings.metadata.chapterInfo;
+        let updated = false;
+        for (const s of data.samples) if (s.type === "TIT2" || s.info === "TIT2" || s.key === "T1T2") {
+          if (!chapters.find((c) => c.startTime === s.pts)) chapters.push({ title: new TextDecoder("utf-8").decode(s.data).replace(/\0/g, "").trim(), startTime: s.pts }), updated = true;
+        }
+        if (updated) this.config.settings.metadata.chapterInfo = chapters.sort((a, b) => a.startTime - b.startTime);
+      });
+      this.host.on(HLS.Events.FRAG_LOADED, () => this.ctlr.throttle("hlsBandwidth", () => this.config.status.bandwidth = Math.round(this.host.bandwidthEstimate / 1e6 * 10) / 10, 2e3));
+      this.host.on(HLS.Events.ERROR, (_, data) => {
+        if (!data.fatal) return;
+        switch (data.type) {
+          case HLS.ErrorTypes.NETWORK_ERROR:
+            return this.host.startLoad();
+          case HLS.ErrorTypes.MEDIA_ERROR:
+            return this.host.recoverMediaError();
+          default:
+            this.handleHostError(data);
+        }
+      });
+      this.host.attachMedia(this.el);
+    } catch (err) {
+      this.handleHostError(err);
+    }
+  }
+  // ===========================================================================
+  // WIRING OVERRIDES
+  // ===========================================================================
+  wireCurrentTrack(type, _type = type.toLowerCase()) {
+    if (type === "Video" || _type === "video") return super.wireCurrentTrack(type);
+    this.config.set(`intent.current${type}Track`, (term) => isNum(term) ? term : this.config.status[`${_type}Tracks`].findIndex((t) => t.id === term || t.name === term || t.lang === term), { signal: this.signal });
+    this.config.on(`intent.current${type}Track`, (e) => this.handleCurrentHostTrackIntent(e, _type), this.evtOpts.CONFIG);
+  }
+  wireCurrentLevel() {
+    this.config.set("intent.currentLevel", (term) => isNum(term) ? term : Number(term), { signal: this.signal });
+    this.config.on("intent.currentLevel", this.handleCurrentLevelIntent, this.evtOpts.CONFIG);
+  }
+  wireAutoLevel() {
+    this.config.on("intent.autoLevel", this.handleAutoLevelIntent, this.evtOpts.CONFIG);
+  }
+  // ===========================================================================
+  // HANDLERS
+  // ===========================================================================
+  handleSrcIntent(e) {
+    if (e.resolved || isSameURL(this.hostSrc, e.value)) return;
+    this.initHost(e.value);
+    e.resolve(this.name);
+  }
+  handleCurrentLevelIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => {
+      if (e.value < this.config.status.levels.length) {
+        this.host.currentLevel = e.value;
+        this.config.state.autoLevel = false;
+      }
+    });
+    e.resolve(this.name);
+  }
+  handleAutoLevelIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => {
+      this.host.currentLevel = e.value ? -1 : this.host.currentLevel;
+      this.config.state.autoLevel = e.value;
+    });
+    e.resolve(this.name);
+  }
+  handleCurrentHostTrackIntent(e, type) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => {
+      if (e.value < this.config.status[`${type}Tracks`].length) this.host[`${type === "text" ? "subtitle" : type}Track`] = e.value;
+    });
+    e.resolve(this.name);
+  }
+  handleLiveIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => e.value && (this.host.liveSyncPosition ? this.media.intent.currentTime = this.host.liveSyncPosition : super.handleLiveIntent(e)));
+    e.resolve(this.name);
+  }
+  handleHostError(err) {
+    this.config.status.error = { ...err, code: err?.code ?? 5, message: err.message ?? "Fatal HLS error" };
+    this.config.status.waiting = false;
+  }
+  // --- Lifecycle ---
+  destroyHls() {
+    this.host?.destroy(), this.host = null, this.media.status.hostReady = false;
+  }
+  onDestroy() {
+    this.destroyHls(), super.onDestroy();
+  }
+};
+__publicField(HLSTech, "techName", "hls");
+
+// src/ts/techs/youtube.ts
+var import_sia_reactor9 = require("sia-reactor");
+var import_modules3 = require("sia-reactor/modules");
+var import_utils26 = require("sia-reactor/utils");
+var YouTubeTech = class extends BaseTech {
+  constructor(ctlr, features) {
+    super(ctlr, {
+      // Engine Inputs
+      volume: true,
+      muted: true,
+      playbackRate: true,
+      // Modes
+      fullscreen: supportsFullscreen(),
+      // States (YouTube loads these via intent, but we claim support)
+      autoplay: true,
+      loop: true,
+      playsInline: true,
+      controls: true,
+      crossOrigin: true,
+      live: false,
+      // Lists
+      textTracks: true,
+      levels: true,
+      // Currents
+      currentTextTrack: true,
+      currentLevel: true,
+      textVisible: true,
+      autoLevel: true,
+      // Infos
+      readyState: true,
+      error: true,
+      waiting: true,
+      seeking: true,
+      buffered: true,
+      seekable: true,
+      loadedMetadata: true,
+      loadedData: true,
+      canPlay: true,
+      canPlayThrough: true,
+      // Settings
+      liveTolerance: true,
+      minDVRWindow: true,
+      ...features
+    });
+    __publicField(this, "host", null);
+    __publicField(this, "hostDiv");
+    __publicField(this, "hostSrc", null);
+    __publicField(this, "intervalId", -1);
+    ctlr.config.mediaPlayer = "YouTube";
+    this.element = this.hostDiv = (0, import_utils2.createEl)("div", { className: `tmg-host-div ${this.el.className}`, innerHTML: `<div class="tmg-host-content"><div></div></div>` });
+    ctlr.media.status.hostReady = false;
+  }
+  static canPlaySource(src) {
+    return MATCH_URL_YOUTUBE.test(src);
+  }
+  // --- API Injection ---
+  async initHost(url, videoId) {
+    try {
+      const base = this.config[this.ctlr.techTruth];
+      if (this.host) return this.host.loadVideoById(videoId, base.currentTime, this.config.status.levels[base.currentLevel] || "default");
+      if (!window.YT) await loadResource(window.TMG_YT_API_SRC, "script"), await new Promise((res, _, _prev = window.onYouTubeIframeAPIReady) => window.YT?.Player ? res() : window.onYouTubeIframeAPIReady = () => (_prev?.(), res()));
+      if (this.signal.aborted) return;
+      this.hostSrc = url;
+      this.host = new window.YT.Player(this.el.firstElementChild.firstElementChild, {
+        videoId,
+        host: base.crossOrigin === "use-credentials" ? void 0 : "https://www.youtube-nocookie.com",
+        playerVars: {
+          autoplay: +(base.autoplay || !base.paused),
+          controls: +base.controls,
+          playsinline: +base.playsInline,
+          loop: +base.loop,
+          start: base.currentTime,
+          rel: +base.controls,
+          modestbranding: +base.controls,
+          fs: +base.controls,
+          iv_load_policy: base.controls ? 1 : 3,
+          cc_load_policy: 1,
+          disablekb: 1
+        },
+        events: {
+          onReady: () => {
+            this.media.status.hostReady = true;
+            this.element = this.host.getIframe(), this.el.classList.add("tmg-foreign-host", "tmg-youtube-host"), this.el.toggleAttribute("data-hide-ui", !base.controls);
+            this.setInitInfo();
+          },
+          onStateChange: this.handleHostStateChange,
+          onPlaybackQualityChange: (e) => {
+            if (!this.config.status.levels.length) this.config.status.levels = (0, import_sia_reactor9.inert)(this.host.getAvailableQualityLevels());
+            this.config.state.currentLevel = this.config.status.levels.findIndex((q) => q === e.data);
+          },
+          onPlaybackRateChange: (e) => void (this.config.state.playbackRate = e.data),
+          onApiChange: () => {
+            this.config.status.textTracks = (this.host.getOption("captions", "tracklist") ?? []).map((t) => ({ id: `yt-cc-${t.languageCode}`, kind: "captions", label: t.languageName || t.displayName, srclang: t.languageCode }));
+            if (this.state.hostReady) this.config.intent.currentTextTrack = this.config.state.currentTextTrack;
+            this.host.setOption("captions", "fontSize", this.settings.captions.font.size.value / 100);
+          },
+          // Fired when modules like Captions load
+          onError: this.handleHostError
+        }
+      });
+    } catch (err) {
+      this.handleHostError(err);
+    }
+  }
+  // ===========================================================================
+  // WIRING (Connections Only)
+  // ===========================================================================
+  // --- Core Wiring ---
+  wireSrc() {
+    this.config.on("intent.src", this.handleSrcIntent, this.evtOpts.CONFIG);
+  }
+  wireCurrentTime() {
+    this.config.get("state.currentTime", (v) => (this.config.status.ended ? this.config.status.duration : this.host?.getCurrentTime()) ?? v, { signal: this.signal });
+    this.config.on("intent.currentTime", this.handleCurrentTimeIntent, this.evtOpts.CONFIG);
+  }
+  wireDuration() {
+  }
+  // Polled dynamically in sync loop; YT emits no explicit duration event
+  wirePaused() {
+    this.config.on("intent.paused", this.handlePausedIntent, this.evtOpts.CONFIG);
+  }
+  wireEnded() {
+  }
+  // Handled strictly within handleHostStateChange
+  wireFeatures() {
+    super.wireFeatures();
+    this.ctlr.config.on("settings.captions.font.size.value", ({ value }) => this.host?.setOption("captions", "fontSize", value / 100), { signal: this.signal });
+  }
+  // --- Engine Inputs Wiring ---
+  wireVolume() {
+    this.config.on("intent.volume", this.handleVolumeIntent, this.evtOpts.CONFIG);
+  }
+  wireMuted() {
+    this.config.on("intent.muted", this.handleMutedIntent, this.evtOpts.CONFIG);
+  }
+  wirePlaybackRate() {
+    this.config.on("intent.playbackRate", this.handlePlaybackRateIntent, this.evtOpts.CONFIG);
+  }
+  // --- Presentation Modes Wiring ---
+  wireFullscreen() {
+    this.ctlr.state.watch("docInFullscreen", this.setFullscreenChangeState, this.evtOpts.CONFIG);
+    this.config.on("intent.fullscreen", this.handleFullscreenIntent, this.evtOpts.CONFIG);
+  }
+  // --- Attributes Wiring ---
+  wireLoop() {
+    this.config.on("intent.loop", this.handleLoopIntent, this.evtOpts.CONFIG);
+  }
+  // --- Track Switching Wiring ---
+  wireCurrentTextTrack() {
+    this.config.set("intent.currentTextTrack", (term) => isNum(term) ? term : this.config.status.textTracks.findIndex((t) => t.srclang === term), { signal: this.signal });
+    this.config.on("intent.currentTextTrack", this.handleCurrentTextTrackIntent, this.evtOpts.CONFIG);
+  }
+  wireCurrentLevel() {
+    this.config.set("intent.currentLevel", (term) => isNum(term) ? term : Number(term), { signal: this.signal });
+    this.config.on("intent.currentLevel", this.handleCurrentLevelIntent, this.evtOpts.CONFIG);
+  }
+  wireTextVisible() {
+    this.config.on("intent.textVisible", this.handleTextVisibleIntent, this.evtOpts.CONFIG);
+    this.config.watch("status.textTracks", this.onTracksStatus, this.evtOpts.CONFIG);
+  }
+  wireAutoLevel() {
+    this.config.on("intent.autoLevel", this.handleAutoLevelIntent, this.evtOpts.CONFIG);
+  }
+  // --- Live Content Wiring ---
+  wireLive() {
+    this.config.on("intent.live", this.handleLiveIntent, this.evtOpts.CONFIG);
+    this.config.watch("status.isLive", this.onIsLiveStatus, this.evtOpts.CONFIG);
+  }
+  // ===========================================================================
+  // HANDLERS (The Logic - Auto-Guarded)
+  // ===========================================================================
+  // --- Core States ---
+  setLoadStartInfo() {
+    const { state: s, status: st } = this.config;
+    st.error = st.activeCue = null;
+    st.buffered = createTimeRanges([]);
+    st.seekable = createTimeRanges([]);
+    st.duration = NaN;
+    st.waiting = s.paused = true;
+    st.readyState = s.currentTime = 0;
+    st.ended = st.stalled = st.loadedData = st.loadedMetadata = st.canPlay = st.canPlayThrough = false;
+  }
+  // --- Core Intents ---
+  handleSrcIntent(e) {
+    if (e.resolved || isSameURL(this.hostSrc, e.value)) return;
+    const videoId = e.value.match(/(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|shorts\/|live\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/i)?.[1];
+    if (!videoId) return;
+    this.setLoadStartInfo();
+    this.setHighResPoster(videoId);
+    this.initHost(e.value, videoId);
+    e.resolve(this.name);
+  }
+  handleCurrentTimeIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, (min = getMediaMin(this.config), max = getMediaMax(this.config)) => {
+      this.config.status.seeking = true;
+      const prev = this.media.state.currentTime;
+      if (e.value < min || e.value > max) e.reject(this.name);
+      this.host.seekTo((0, import_utils5.clamp)(min, e.value, max), true), this.media.state.paused && this.host.pauseVideo();
+      const check = (0, import_utils6.setInterval)(() => (!this.config.state.paused || this.host.getCurrentTime() !== prev) && (clearInterval(check), this.syncCurrentTime(), this.config.status.seeking = false), 100, this.signal);
+    });
+    e.resolve(this.name);
+  }
+  handlePausedIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => (e.value ? this.host.pauseVideo() : this.host.playVideo(), this.media.status.ended && (0, import_utils6.setTimeout)(() => this.host.playVideo(), 0, this.signal)));
+    e.resolve(this.name);
+  }
+  // --- Feature States ---
+  setFullscreenChangeState(docInFs) {
+    this.config.state.fullscreen = docInFs ? queryFullscreenEl() === this.element : false;
+  }
+  // --- Feature Intents ---
+  handleVolumeIntent(e) {
+    if (e.resolved) return;
+    if (e.value < 0 || e.value > 100) e.reject(this.name);
+    this.when("hostReady", e, () => {
+      this.host.setVolume((0, import_utils5.clamp)(0, e.value, 100));
+      this.config.state.volume = (0, import_utils5.clamp)(0, e.value, 100);
+    });
+    e.resolve(this.name);
+  }
+  handleMutedIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => {
+      e.value ? this.host.mute() : this.host.unMute();
+      this.config.state.muted = e.value;
+    });
+    e.resolve(this.name);
+  }
+  handlePlaybackRateIntent(e) {
+    if (e.resolved) return;
+    if (e.value < 0.25 || e.value > 2) e.reject(this.name);
+    this.when("hostReady", e, () => {
+      this.host.setPlaybackRate((0, import_utils5.clamp)(0.25, e.value, 2));
+      this.config.state.playbackRate = (0, import_utils5.clamp)(0.25, e.value, 2);
+    });
+    e.resolve(this.name);
+  }
+  handleFullscreenIntent(e) {
+    if (e.resolved) return;
+    (e.value ? enterFullscreen(this.element) : exitFullscreen(this.element))?.catch(this.ctlr.notice);
+    e.resolve(this.name);
+  }
+  handleLoopIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => {
+      this.host.setLoop(e.value);
+      this.config.state.loop = e.value;
+    });
+    e.resolve(this.name);
+  }
+  handleCurrentTextTrackIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => {
+      if (e.value === -1) this.host.unloadModule("captions"), this.el.setAttribute("data-hide-ui", ""), this.config.state.currentTextTrack = -1;
+      else {
+        this.host.loadModule("captions"), this.el.toggleAttribute("data-hide-ui", !this.config.state.textVisible);
+        const track = this.config.status.textTracks[e.value];
+        if (track) this.host.setOption("captions", "track", { languageCode: track.srclang }), this.config.state.currentTextTrack = e.value;
+      }
+    });
+    e.resolve(this.name);
+  }
+  handleCurrentLevelIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => {
+      const quality = this.config.status.levels[e.value];
+      if (quality) {
+        this.host.setPlaybackQuality(quality);
+        this.config.state.autoLevel = false;
+      }
+    });
+    e.resolve(this.name);
+  }
+  handleTextVisibleIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, (should = this.host.getOptions().includes("captions") && e.value) => {
+      this.el.toggleAttribute("data-hide-ui", !should);
+      this.config.state.textVisible = should;
+    });
+    e.resolve(this.name);
+  }
+  handleAutoLevelIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => {
+      this.host.setPlaybackQuality(e.value ? "default" : this.config.status.levels[0]);
+      this.config.state.autoLevel = e.value;
+    });
+    e.resolve(this.name);
+  }
+  handleLiveIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => e.value && (this.media.intent.currentTime = this.config.status.duration - 1));
+    e.resolve(this.name);
+  }
+  // --- Dog Feeders ---
+  onIsLiveStatus(v) {
+    this.config.features.live = v;
+  }
+  onTracksStatus(v) {
+    this.config.features.textVisible = v.length > 0;
+  }
+  // --- API Logic ---
+  handleHostStateChange(e) {
+    const { state: s, status: st } = this.config, STATE = window.YT.PlayerState;
+    switch (e.data) {
+      case STATE.UNSTARTED:
+        (0, import_modules3.silence)(() => this.media.intent.currentTime = (0, import_utils5.clamp)(0, this.media.state.currentTime, this.media.status.duration - 1));
+        break;
+      case STATE.CUED:
+        st.duration = this.host.getDuration();
+        st.readyState = 1;
+        break;
+      case STATE.BUFFERING:
+        st.waiting = true;
+        st.readyState = 2;
+        break;
+      case STATE.PLAYING:
+        st.error = null;
+        st.ended = st.seeking = st.waiting = s.paused = false;
+        st.canPlay = st.canPlayThrough = true;
+        st.duration = this.host.getDuration();
+        st.isLive = this.host.getVideoData().isLive ?? false;
+        st.readyState = 4;
+        st.loadedData = true;
+        this.syncMetadata(), clearInterval(this.intervalId), this.intervalId = (0, import_utils6.setInterval)(this.syncCurrentTime, 100, this.signal);
+        break;
+      case STATE.PAUSED:
+      case STATE.ENDED:
+        s.paused = true;
+        st.ended = e.data === STATE.ENDED;
+        st.seeking = st.waiting = false;
+        clearInterval(this.intervalId), this.syncCurrentTime();
+        break;
+    }
+  }
+  handleHostError(err) {
+    let msg = "Unknown YouTube Error";
+    if (err.data === 2 || err.data === 100) msg = "YouTube Video Not Found";
+    else if (err.data === 101 || err.data === 150) msg = "Playback disabled by owner";
+    else if (err.data === 5) msg = "HTML5 Player Error";
+    this.config.status.error = { ...err, code: err.data, message: err.message || msg };
+    this.config.status.waiting = false;
+  }
+  syncCurrentTime() {
+    if (!this.host) return;
+    const { status: st, settings: set, state: s } = this.config;
+    s.currentTime = st.ended ? st.duration : this.host.getCurrentTime();
+    st.buffered = createTimeRanges([[0, this.host.getVideoLoadedFraction() * st.duration]]);
+    st.seekable = createTimeRanges([[st.isLive ? Math.max(0, st.duration - 43200) : 0, st.duration]]);
+    if (st.isLive) {
+      st.canSeekLive = true;
+      st.duration = this.host.getDuration() - 3600;
+      s.live = st.duration - s.currentTime <= set.liveTolerance;
+    } else st.ended = s.currentTime === st.duration;
+  }
+  syncMetadata(data = this.host.getVideoData()) {
+    data && this.config.settings.metadata.allowOverride && (0, import_utils26.fanout)(this.media.settings.metadata, { id: data.video_id, title: data.title, artist: data.author || void 0 }, { skipUndefined: true });
+  }
+  // --- Lifecycle ---
+  setInitInfo(data = this.host.getVideoData(), isShort = this.hostSrc?.includes("/shorts/")) {
+    this.config.status.readyState = 1;
+    this.config.status.duration = this.host.getDuration();
+    this.config.status.isLive = data.isLive || this.config.status.duration === 0;
+    this.config.status.videoWidth = isShort ? 1080 : 1920, this.config.status.videoHeight = isShort ? 1920 : 1080;
+    this.config.status.textTracks = [];
+    this.config.status.waiting = false;
+    this.config.status.loadedMetadata = true;
+    this.syncCurrentTime();
+    this.config.state.volume = this.host.getVolume();
+    this.config.state.muted = this.host.isMuted();
+    this.config.state.playbackRate = this.host.getPlaybackRate();
+    this.syncMetadata(data);
+  }
+  setHighResPoster(videoId) {
+    if (!this.config.settings.metadata.allowOverride) return;
+    const hq = `https://img.youtube.com/vi/${videoId}/hqdefault.jpg`, img = (0, import_utils2.createEl)("img", { src: hq, onload: () => this.config.intent.poster = img.naturalWidth <= 120 ? hq : `https://img.youtube.com/vi/${videoId}/maxresdefault.jpg`, onerror: () => this.config.intent.poster = hq });
+  }
+  destroyHost() {
+    if (!this.host) return;
+    clearInterval(this.intervalId);
+    this.host.destroy(), this.host = null, this.media.status.hostReady = false;
+    this.element = this.hostDiv, this.hostDiv.innerHTML = `<div class="tmg-host-content"><div></div></div>`;
+  }
+  onDestroy() {
+    this.destroyHost(), super.onDestroy();
+  }
+};
+__publicField(YouTubeTech, "techName", "youtube");
+
+// src/ts/techs/vimeo.ts
+var import_sia_reactor10 = require("sia-reactor");
+var VIMEO_EVENTS = ["loaded", "play", "playing", "pause", "ended", "timeupdate", "durationchange", "chapterchange", "progress", "seeking", "seeked", "error", "bufferstart", "bufferend", "volumechange", "playbackratechange", "qualitychange", "texttrackchange", "cuechange", "resize", "enterpictureinpicture", "leavepictureinpicture", "fullscreenchange"];
+var VimeoTech = class extends BaseTech {
+  constructor(ctlr, features) {
+    super(ctlr, {
+      // Engine Inputs
+      volume: true,
+      muted: true,
+      playbackRate: true,
+      // Modes
+      fullscreen: supportsFullscreen(),
+      pictureInPicture: supportsPictureInPicture(),
+      // States
+      autoplay: true,
+      loop: true,
+      playsInline: true,
+      controls: true,
+      crossOrigin: true,
+      live: false,
+      // Lists
+      textTracks: true,
+      audioTracks: true,
+      levels: true,
+      // Currents
+      currentTextTrack: true,
+      currentAudioTrack: true,
+      currentLevel: true,
+      autoLevel: true,
+      // Infos
+      readyState: true,
+      error: true,
+      waiting: true,
+      seeking: true,
+      buffered: true,
+      seekable: true,
+      loadedMetadata: true,
+      loadedData: true,
+      canPlay: true,
+      canPlayThrough: true,
+      activeCue: true,
+      // Settings
+      metadata: true,
+      liveTolerance: true,
+      minDVRWindow: true,
+      ...features
+    });
+    __publicField(this, "host", null);
+    __publicField(this, "hostDiv");
+    __publicField(this, "hostSrc", null);
+    // --- API Exhaustive Logic ---
+    __publicField(this, "durationSeq", 0);
+    __publicField(this, "durationSrc", "");
+    ctlr.config.mediaPlayer = "Vimeo";
+    this.element = this.hostDiv = (0, import_utils2.createEl)("div", { className: `tmg-host-div ${this.el.className}`, innerHTML: `<div class="tmg-host-content"></div>` });
+    ctlr.media.status.hostReady = false;
+  }
+  static canPlaySource(src) {
+    return MATCH_URL_VIMEO.test(src);
+  }
+  // --- API Injection ---
+  async initHost(url) {
+    try {
+      this.destroyHost();
+      if (!window.Vimeo) await loadResource(window.TMG_VIMEO_API_SRC, "script");
+      if (this.signal.aborted) return;
+      const base = this.config[this.ctlr.payload.wired ? "state" : "intent"];
+      this.host = new window.Vimeo.Player(this.el.firstElementChild, {
+        url: this.hostSrc = url,
+        autoplay: base.autoplay || !base.paused,
+        controls: base.controls,
+        loop: base.loop,
+        muted: base.muted,
+        playsinline: base.playsInline,
+        dnt: base.crossOrigin === "use-credentials" ? false : true,
+        // Do Not Track = Privacy Mode
+        transparent: true,
+        pip: true
+      });
+      for (const e of VIMEO_EVENTS) this.host.on(e, (data) => this.handleHostStateChange(e, data));
+      await this.host.ready(), this.media.status.hostReady = true;
+      this.element = this.el.querySelector("iframe"), this.el.classList.add("tmg-foreign-host", "tmg-vimeo-host");
+    } catch (err) {
+      this.handleHostError(err);
+    }
+  }
+  // ===========================================================================
+  // WIRING (Connections Only)
+  // ===========================================================================
+  // --- Core Wiring ---
+  wireSrc() {
+    this.config.on("intent.src", this.handleSrcIntent, this.evtOpts.CONFIG);
+  }
+  wireCurrentTime() {
+    this.config.set("intent.currentTime", (t, _, __, d = this.config.status.duration) => isSafeNum(d) ? (0, import_utils5.clamp)(0, t, d - 1) : t, this.evtOpts.CONFIG);
+    this.config.on("intent.currentTime", this.handleCurrentTimeIntent, this.evtOpts.CONFIG);
+  }
+  wireDuration() {
+  }
+  wirePaused() {
+    this.config.on("intent.paused", this.handlePausedIntent, this.evtOpts.CONFIG);
+  }
+  // --- Engine Inputs Wiring ---
+  wireEnded() {
+  }
+  wireVolume() {
+    this.config.on("intent.volume", this.handleVolumeIntent, this.evtOpts.CONFIG);
+  }
+  wireMuted() {
+    this.config.on("intent.muted", this.handleMutedIntent, this.evtOpts.CONFIG);
+  }
+  wirePlaybackRate() {
+    this.config.on("intent.playbackRate", this.handlePlaybackRateIntent, this.evtOpts.CONFIG);
+  }
+  // --- Presentation Modes Wiring ---
+  wireFullscreen() {
+    this.config.on("intent.fullscreen", this.handleFullscreenIntent, this.evtOpts.CONFIG);
+  }
+  wirePictureInPicture() {
+    this.config.on("intent.pictureInPicture", this.handlePictureInPictureIntent, this.evtOpts.CONFIG);
+  }
+  // --- Attributes Wiring ---
+  wireLoop() {
+    this.config.on("intent.loop", this.handleLoopIntent, this.evtOpts.CONFIG);
+  }
+  // --- 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);
+  }
+  wireCurrentTextTrack() {
+    this.config.set("intent.currentTextTrack", (term) => isNum(term) ? term : this.config.status.textTracks.find((t) => t.language === term && t.kind === term), { signal: this.signal });
+    this.config.on("intent.currentTextTrack", this.handleCurrentTextTrackIntent, this.evtOpts.CONFIG);
+  }
+  wireCurrentAudioTrack() {
+    this.config.set("intent.currentAudioTrack", (term) => isNum(term) ? term : this.config.status.audioTracks.find((t) => t.language === term && t.kind === term), { signal: this.signal });
+    this.config.on("intent.currentAudioTrack", this.handleCurrentAudioTrackIntent, this.evtOpts.CONFIG);
+  }
+  wireCurrentLevel() {
+    this.config.set("intent.currentLevel", (term) => isNum(term) ? term : Number(term), { signal: this.signal });
+    this.config.on("intent.currentLevel", this.handleCurrentLevelIntent, this.evtOpts.CONFIG);
+  }
+  wireAutoLevel() {
+    this.config.on("intent.autoLevel", this.handleAutoLevelIntent, this.evtOpts.CONFIG);
+  }
+  // --- Live Content Wiring ---
+  wireLive() {
+    this.config.on("intent.live", this.handleLiveIntent, this.evtOpts.CONFIG);
+    this.config.watch("status.isLive", this.onIsLiveStatus, this.evtOpts.CONFIG);
+  }
+  // ===========================================================================
+  // HANDLERS (The Logic - Auto-Guarded)
+  // ===========================================================================
+  // --- Core States ---
+  setLoadStartInfo() {
+    const { state: s, status: st } = this.config;
+    st.error = st.activeCue = null;
+    st.buffered = createTimeRanges([]);
+    st.seekable = createTimeRanges([]);
+    st.duration = NaN;
+    st.waiting = s.paused = true;
+    st.readyState = s.currentTime = 0;
+    st.ended = st.stalled = st.loadedData = st.loadedMetadata = st.canPlay = st.canPlayThrough = false;
+  }
+  // --- Core Intents ---
+  handleSrcIntent(e) {
+    if (e.resolved || isSameURL(this.hostSrc, e.value)) return;
+    this.setLoadStartInfo();
+    this.initHost(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.host.setCurrentTime((0, import_utils5.clamp)(min, e.value, max)).catch((err) => this.ctlr.log(err, "error", true));
+    });
+    e.resolve(this.name);
+  }
+  handlePausedIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => (e.value ? this.host.pause() : this.host.play()).catch((err) => this.ctlr.log(err, "error", true)));
+    e.resolve(this.name);
+  }
+  // --- Feature Intents ---
+  handleVolumeIntent(e) {
+    if (e.resolved) return;
+    if (e.value < 0 || e.value > 100) e.reject(this.name);
+    this.when("hostReady", e, () => this.host.setVolume((0, import_utils5.clamp)(0, e.value / 100, 1)).catch((err) => this.ctlr.log(err, "error", true)));
+    e.resolve(this.name);
+  }
+  handleMutedIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => this.host.setMuted(e.value).catch((err) => this.ctlr.log(err, "error", true)));
+    e.resolve(this.name);
+  }
+  handlePlaybackRateIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => this.host.setPlaybackRate(e.value).catch((err) => this.ctlr.log(err, "error", true)));
+    e.resolve(this.name);
+  }
+  handleFullscreenIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => (e.value ? this.host.requestFullscreen() : this.host.exitFullscreen())?.catch(this.ctlr.notice));
+    e.resolve(this.name);
+  }
+  handlePictureInPictureIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => (e.value ? this.host.requestPictureInPicture() : this.host.exitPictureInPicture()).catch(this.ctlr.notice));
+    e.resolve(this.name);
+  }
+  handleLoopIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => this.host.setLoop(e.value).catch((err) => this.ctlr.log(err, "error", true)));
+    this.config.state.loop = e.value;
+    e.resolve(this.name);
+  }
+  handleCurrentTextTrackIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => {
+      const track = this.config.status.textTracks[e.value];
+      track ? this.host.enableTextTrack(track.language, track.kind).catch((err) => this.ctlr.log(err, "error", true)) : this.host.disableTextTrack().catch((err) => this.ctlr.log(err, "error", true));
+    });
+    e.resolve(this.name);
+  }
+  handleCurrentAudioTrackIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => {
+      const track = this.config.status.audioTracks[e.value];
+      if (track) this.host.selectAudioTrack(track.language, track.kind).catch((err) => this.ctlr.log(err, "error", true));
+    });
+    e.resolve(this.name);
+  }
+  handleCurrentLevelIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => {
+      const quality = this.config.status.levels[e.value];
+      if (quality) this.host.setQuality(quality.id).catch((err) => this.ctlr.log(err, "error", true));
+    });
+    e.resolve(this.name);
+  }
+  handleAutoLevelIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => {
+      this.host.setQuality(e.value ? "auto" : this.config.status.levels[0]?.id).catch((err) => this.ctlr.log(err, "error", true));
+      this.config.state.autoLevel = e.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);
+  }
+  // --- Dog Feeders ---
+  onIsLiveStatus(v) {
+    this.config.features.live = v;
+  }
+  handleHostStateChange(evt, data) {
+    const { state: s, status: st } = this.config;
+    switch (evt) {
+      case "loaded":
+        this.setInitInfo();
+        (0, import_utils6.setTimeout)(
+          () => {
+            st.readyState = 1;
+            st.waiting = false;
+            st.loadedMetadata = true;
+          },
+          100,
+          // promise abuse effects
+          this.signal
+        );
+        break;
+      case "playing":
+      case "play":
+        st.readyState = 4;
+        st.canPlay = st.canPlayThrough = st.loadedData = true;
+        st.ended = st.waiting = s.paused = false;
+        if (evt === "playing") st.error = null;
+        break;
+      case "pause":
+        s.paused = true;
+        this.host.getPlayed().then((played) => st.played = createTimeRanges(played));
+        st.waiting = false;
+        break;
+      case "ended":
+        return void (s.paused = st.ended = true);
+      case "timeupdate":
+        s.currentTime = data.seconds;
+        if (st.isLive)
+          if (st.seekable.length) {
+            const max = st.seekable.end(st.seekable.length - 1);
+            st.canSeekLive = max - st.seekable.start(0) >= this.config.settings.minDVRWindow;
+            s.live = max - s.currentTime <= this.config.settings.liveTolerance;
+          } else s.live = !(st.canSeekLive = false);
+        else st.ended = s.currentTime === st.duration;
+        break;
+      case "durationchange":
+        if (this.hostSrc !== this.durationSrc) this.durationSeq = 0, this.durationSrc = this.hostSrc;
+        const prev = st.duration;
+        if ((st.duration = data.duration) === Infinity) return void (st.isLive = true);
+        prev === Infinity ? st.isLive = false : prev > 0 && st.duration > prev && ++this.durationSeq > 3 && (st.isLive = true);
+        break;
+      case "progress":
+        this.host.getBuffered().then((buffered) => st.buffered = createTimeRanges(buffered));
+        this.host.getSeekable().then((seekable) => st.seekable = createTimeRanges(seekable));
+        break;
+      case "seeking":
+        st.seeking = true;
+        this.host.getPlayed().then((played) => st.played = createTimeRanges(played));
+        break;
+      case "seeked":
+        s.currentTime = data.seconds;
+        st.seeking = false;
+        break;
+      case "bufferstart":
+        st.waiting = true;
+        st.readyState = 2;
+        break;
+      case "bufferend":
+        st.waiting = false;
+        st.readyState = 4;
+        break;
+      case "volumechange":
+        s.volume = data.volume * 100;
+        this.host.getMuted().then((muted) => s.muted = muted);
+        break;
+      case "playbackratechange":
+        return void (s.playbackRate = data.playbackRate);
+      case "texttrackchange":
+        return void (s.currentTextTrack = st.textTracks.findIndex((t) => t.language === data.language && t.kind === data.kind));
+      case "cuechange":
+        return void (st.activeCue = data.cues[0] || null);
+      case "chapterchange":
+        this.config.state.currentChapter = data.index - 1;
+        break;
+      case "qualitychange":
+        return void (s.currentLevel = st.levels.findIndex((q) => q.id === data.quality));
+      case "resize":
+        return void (st.videoWidth = data.videoWidth, st.videoHeight = data.videoHeight);
+      case "enterpictureinpicture":
+        return void (s.pictureInPicture = true);
+      case "leavepictureinpicture":
+        return void (s.pictureInPicture = false);
+      case "fullscreenchange":
+        return void (s.fullscreen = data.fullscreen);
+      case "error":
+        return void (data.name === "Error" || data.name === "RangeError" || data.name === "TypeError" || data.method ? this.ctlr.log(`Vimeo error occurred: ${data.message}`, "error", true) : this.handleHostError(data));
+    }
+  }
+  handleHostError(err) {
+    this.config.status.error = { ...err, code: err?.code ?? 5, message: err?.message || "Vimeo Video Not Found." };
+    this.config.status.waiting = false;
+  }
+  // --- Lifecycle ---
+  async setInitInfo() {
+    if (!this.host) return;
+    this.autoChapters = !this.config.settings.metadata.allowOverride;
+    this.host.getDuration().then((duration) => this.config.status.isLive = (this.config.status.duration = duration) === Infinity);
+    this.host.getPlayed().then((played) => this.config.status.played = createTimeRanges(played));
+    this.host.getBuffered().then((buffered) => this.config.status.buffered = createTimeRanges(buffered));
+    this.host.getSeekable().then((seekable) => this.config.status.seekable = createTimeRanges(seekable));
+    this.host.getChapters().then((chapters, _meta = this.config.settings.metadata) => _meta.allowOverride && (_meta.chapterInfo = (0, import_sia_reactor10.inert)(chapters)));
+    this.host.getTextTracks().then((tracks) => this.config.status.textTracks = (0, import_sia_reactor10.inert)(tracks));
+    this.host.getAudioTracks().then((tracks) => this.config.status.audioTracks = (0, import_sia_reactor10.inert)(tracks));
+    this.host.getQualities().then((qualities) => this.config.status.levels = (0, import_sia_reactor10.inert)(qualities));
+    Promise.all([this.host.getVideoWidth(), this.host.getVideoHeight()]).then(([w, h]) => (this.config.status.videoWidth = w, this.config.status.videoHeight = h));
+    this.host.getPaused().then((paused) => this.config.state.paused = paused);
+    this.host.getCurrentTime().then((time) => this.config.state.currentTime = time);
+    this.host.getVolume().then((vol) => this.config.state.volume = vol * 100);
+    this.host.getMuted().then((muted) => this.config.state.muted = muted);
+    this.host.getPlaybackRate().then((rate) => this.config.state.playbackRate = rate);
+    this.host.getLoop().then((loop) => this.config.state.loop = loop);
+    this.host.getPictureInPicture().then((pip) => this.config.state.pictureInPicture = pip);
+    this.host.getFullscreen().then((fs) => this.config.state.fullscreen = fs);
+  }
+  destroyHost() {
+    if (!this.host) return;
+    this.host.destroy(), this.host = null, this.media.status.hostReady = false;
+    this.element = this.hostDiv;
+  }
+  onDestroy() {
+    this.destroyHost(), super.onDestroy();
+  }
+};
+__publicField(VimeoTech, "techName", "vimeo");
+
+// src/ts/techs/z-register.ts
+for (const Tech of [
+  // Priority Order
+  HTML5Tech,
+  // ShakaTech,
+  HLSTech,
+  DashTech,
+  YouTubeTech,
+  VimeoTech
+])
+  TechRegistry.register(Tech);
+//# sourceMappingURL=z-register.cjs.map