tmg-media-player 0.0.1

package/dist/techs/hls.cjs

@@ -0,0 +1,1164 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/ts/techs/hls.ts
+var hls_exports = {};
+__export(hls_exports, {
+  HLSTech: () => HLSTech
+});
+module.exports = __toCommonJS(hls_exports);
+
+// src/ts/core/controllable.ts
+var import_sia_reactor3 = require("sia-reactor");
+var import_utils14 = require("sia-reactor/utils");
+
+// ../t007-tools/packages/utils/dist/chunk-ZALPHCSJ.js
+var import_utils = require("sia-reactor/utils");
+var import_utils2 = require("sia-reactor/utils");
+var import_sia_reactor = require("sia-reactor");
+var import_sia_reactor2 = require("sia-reactor");
+var import_utils3 = require("sia-reactor/utils");
+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 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_utils.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_utils.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_reactor.NOOP, destroyNode = import_sia_reactor.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_utils11 = 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_utils7.guardAllMethods)(this, ctlr.guard);
+    this.signal = AbortSignal.any([this.signal, ctlr.signal]);
+    this.ctlr = ctlr;
+    this.media = ctlr.media;
+    this.state = (0, import_utils3.isObj)(state) ? (0, import_sia_reactor3.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_utils14.nuke)(this);
+  }
+  onDestroy() {
+  }
+};
+
+// src/ts/techs/base.ts
+var import_utils21 = require("sia-reactor/utils");
+var import_modules = require("sia-reactor/modules");
+
+// src/ts/utils/dom.ts
+var import_sia_reactor4 = 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_utils20 = 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_utils.createEl)("video");
+var DUMMY_AUD = (0, import_utils.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_utils21.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_utils21.fanout)(this.config.status, getMediaStatus(this.el, void 0, void 0, true), { skipUndefined: true });
+    (0, import_modules.silence)(() => ((0, import_utils21.fanout)(this.config.intent, this.config[this.ctlr.techTruth]), (0, import_utils21.fanout)(this.config.settings, this.config.settings)));
+    !this.ctlr.payload.wired && (0, import_utils21.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_reactor5 = require("sia-reactor");
+
+// src/ts/utils/match.ts
+var AUDIO_EXTENSIONS = /\.(m4a|m4b|mp4a|mpga|mp2|mp2a|mp3|m2a|m3a|wav|weba|aac|oga|spx|flac|wma|opus|midi?)($|\?)/i;
+var VIDEO_EXTENSIONS = /\.(mp4|mkv|avi|mov|webm|mpg|mpeg|og[gv]|m4v|flv|wmv|3gp|3g2|ts)(#t=[,\d+]+)?($|\?)/i;
+var HLS_EXTENSIONS = /\.(m3u8)($|\?)/i;
+
+// src/ts/utils/env.ts
+var win2 = "undefined" !== typeof window ? window : void 0;
+var nav = win2?.navigator;
+var ua = nav?.userAgent || "";
+var uaData = nav?.userAgentData;
+var IS_ANDROID = false;
+var IS_WINDOWS = false;
+var IS_FIREFOX = false;
+var IS_EDGE = false;
+var IS_CHROME = false;
+var IS_CHROMIUM = false;
+var IS_SAFARI = false;
+var IS_IE = false;
+var IS_TIZEN = false;
+var IS_WEBOS = false;
+var IS_IPOD = false;
+var IS_IPAD = false;
+var IS_IPHONE = false;
+var IOS_VERSION = null;
+var ANDROID_VERSION = null;
+var CHROME_VERSION = null;
+var CHROMIUM_VERSION = null;
+var IE_VERSION = null;
+var IS_IOS = false;
+var IS_MOBILE = false;
+var IS_SMART_TV = false;
+var IS_CHROMECAST_RECEIVER = Boolean(win2?.cast?.framework?.CastReceiverContext);
+var MSE_ENABLED = Boolean(win2 && ("MediaSource" in win2 || "webkitMediaSource" in win2));
+var TOUCH_ENABLED = Boolean(win2 && ("ontouchstart" in win2 || nav?.maxTouchPoints || win2.DocumentTouch && win2.document instanceof win2.DocumentTouch));
+if (uaData?.platform && uaData?.brands) {
+  const pickVersion = (brands, needle) => brands.find((b) => b.brand === needle && b.version)?.version || null;
+  IS_ANDROID = uaData.platform === "Android";
+  IS_WINDOWS = uaData.platform === "Windows";
+  IS_EDGE = uaData.brands.some((b) => b.brand === "Microsoft Edge");
+  IS_CHROMIUM = uaData.brands.some((b) => b.brand === "Chromium" || b.brand === "Google Chrome");
+  IS_CHROME = IS_CHROMIUM && !IS_EDGE;
+  CHROMIUM_VERSION = CHROME_VERSION = pickVersion(uaData.brands, "Chromium") || pickVersion(uaData.brands, "Google Chrome");
+}
+if (true) {
+  IS_ANDROID || (IS_ANDROID = /Android/i.test(ua));
+  IS_WINDOWS || (IS_WINDOWS = /Windows/i.test(ua));
+  IS_FIREFOX = /Firefox|FxiOS/i.test(ua);
+  IS_EDGE || (IS_EDGE = /Edg|EdgiOS/i.test(ua));
+  IS_CHROMIUM || (IS_CHROMIUM = /Chrome|CriOS/i.test(ua));
+  IS_CHROME = IS_CHROMIUM && !IS_EDGE;
+  IS_SAFARI = /Safari/i.test(ua) && !IS_CHROME && !IS_FIREFOX && !IS_EDGE;
+  IS_IE = /MSIE|(Trident\/7.0)|(rv:11.0)/i.test(ua);
+  IS_TIZEN = /Tizen/i.test(ua);
+  IS_WEBOS = /Web0S/i.test(ua);
+  IS_IPOD = /iPod/i.test(ua);
+  IS_IPAD = /iPad/i.test(ua) || IS_SAFARI && TOUCH_ENABLED && !/iPhone/i.test(ua);
+  IS_IPHONE = /iPhone/i.test(ua) && !IS_IPAD;
+  IOS_VERSION = ua.match(/OS (\d+)_/i)?.[1] ?? null;
+  ANDROID_VERSION = ua.match(/Android\s(\d+(?:\.\d+)+)/i)?.[1] ?? null;
+  CHROMIUM_VERSION = CHROME_VERSION = ua.match(/(?:Chrome|CriOS)\/(\d+)/)?.[1] ?? CHROMIUM_VERSION;
+  IE_VERSION = ua.match(/MSIE\s(\d+)\.\d/)?.[1] || (/Trident\/7.0/i.test(ua) && /rv:11.0/.test(ua) ? "11.0" : null);
+}
+IS_IOS = IS_IPHONE || IS_IPAD || IS_IPOD;
+IS_MOBILE = Boolean(IS_ANDROID || IS_IPHONE || IS_IPOD || IS_IPAD);
+IS_SMART_TV = IS_TIZEN || IS_WEBOS;
+
+// src/ts/techs/html5.ts
+var import_modules2 = require("sia-reactor/modules");
+var import_utils23 = 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_utils23.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_utils23.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_utils23.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_utils4.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_reactor5.inert)(getSources(this.el));
+        if (nodes.some(({ nodeName: nm }) => nm === "TRACK")) state.tracks = (0, import_sia_reactor5.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_utils4.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_utils23.createEl)("source", s), updateNode: (el, s) => (0, import_utils23.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_utils23.createEl)("track", t), updateNode: (el, t) => (0, import_utils23.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_utils23.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/hls.ts
+var import_sia_reactor6 = 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_reactor6.inert)(data.subtitleTracks);
+        this.config.status.audioTracks = (0, import_sia_reactor6.inert)(data.audioTracks);
+        this.config.status.levels = (0, import_sia_reactor6.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");
+//# sourceMappingURL=hls.cjs.map