tmg-media-player 0.0.1

package/dist/techs/youtube.cjs

@@ -0,0 +1,730 @@
+"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/youtube.ts
+var youtube_exports = {};
+__export(youtube_exports, {
+  YouTubeTech: () => YouTubeTech
+});
+module.exports = __toCommonJS(youtube_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 } = {}, win2 = window) {
+  var _a;
+  win2.t007 ?? (win2.t007 = {}), (_a = win2.t007)._resourceCache ?? (_a._resourceCache = {});
+  if (req === VIRTUAL_RESOURCE || isSym(req)) return Promise.resolve();
+  const src = req;
+  if (win2.t007._resourceCache[src]) return win2.t007._resourceCache[src];
+  const existing = type === "script" ? Array.prototype.find.call(win2.document.scripts, (s) => isSameURL(s.src, src)) : type === "style" ? Array.prototype.find.call(win2.document.styleSheets, (s) => isSameURL(s.href, src)) : null;
+  if (existing) return win2.t007._resourceCache[src] = Promise.resolve(existing);
+  win2.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 win2.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") win2.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") win2.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 win2.t007._resourceCache[src];
+}
+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 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);
+}
+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/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_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 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;
+
+// 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;
+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;
+}
+var DUMMY_VID = (0, import_utils.createEl)("video");
+var DUMMY_AUD = (0, import_utils.createEl)("audio");
+
+// 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/youtube.ts
+var import_sia_reactor5 = require("sia-reactor");
+
+// src/ts/utils/match.ts
+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\//;
+
+// src/ts/techs/youtube.ts
+var import_modules2 = require("sia-reactor/modules");
+var import_utils23 = 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_utils.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_reactor5.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_utils4.clamp)(min, e.value, max), true), this.media.state.paused && this.host.pauseVideo();
+      const check = (0, import_utils5.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_utils5.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_utils4.clamp)(0, e.value, 100));
+      this.config.state.volume = (0, import_utils4.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_utils4.clamp)(0.25, e.value, 2));
+      this.config.state.playbackRate = (0, import_utils4.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_modules2.silence)(() => this.media.intent.currentTime = (0, import_utils4.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_utils5.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_utils23.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_utils.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");
+//# sourceMappingURL=youtube.cjs.map