tmg-media-player 0.0.1

package/dist/techs/vimeo.cjs

@@ -0,0 +1,731 @@
+"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/vimeo.ts
+var vimeo_exports = {};
+__export(vimeo_exports, {
+  VIMEO_EVENTS: () => VIMEO_EVENTS,
+  VimeoTech: () => VimeoTech
+});
+module.exports = __toCommonJS(vimeo_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 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 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/vimeo.ts
+var import_sia_reactor5 = require("sia-reactor");
+
+// src/ts/utils/num.ts
+function isSafeNum(val) {
+  return isNum(val) && !isNaN(val ?? NaN) && val !== Infinity;
+}
+
+// src/ts/utils/match.ts
+var MATCH_URL_VIMEO = /vimeo\.com\/(?!progressive_redirect).+/;
+
+// src/ts/techs/vimeo.ts
+var VIMEO_EVENTS = ["loaded", "play", "playing", "pause", "ended", "timeupdate", "durationchange", "chapterchange", "progress", "seeking", "seeked", "error", "bufferstart", "bufferend", "volumechange", "playbackratechange", "qualitychange", "texttrackchange", "cuechange", "resize", "enterpictureinpicture", "leavepictureinpicture", "fullscreenchange"];
+var VimeoTech = class extends BaseTech {
+  constructor(ctlr, features) {
+    super(ctlr, {
+      // Engine Inputs
+      volume: true,
+      muted: true,
+      playbackRate: true,
+      // Modes
+      fullscreen: supportsFullscreen(),
+      pictureInPicture: supportsPictureInPicture(),
+      // States
+      autoplay: true,
+      loop: true,
+      playsInline: true,
+      controls: true,
+      crossOrigin: true,
+      live: false,
+      // Lists
+      textTracks: true,
+      audioTracks: true,
+      levels: true,
+      // Currents
+      currentTextTrack: true,
+      currentAudioTrack: true,
+      currentLevel: true,
+      autoLevel: true,
+      // Infos
+      readyState: true,
+      error: true,
+      waiting: true,
+      seeking: true,
+      buffered: true,
+      seekable: true,
+      loadedMetadata: true,
+      loadedData: true,
+      canPlay: true,
+      canPlayThrough: true,
+      activeCue: true,
+      // Settings
+      metadata: true,
+      liveTolerance: true,
+      minDVRWindow: true,
+      ...features
+    });
+    __publicField(this, "host", null);
+    __publicField(this, "hostDiv");
+    __publicField(this, "hostSrc", null);
+    // --- API Exhaustive Logic ---
+    __publicField(this, "durationSeq", 0);
+    __publicField(this, "durationSrc", "");
+    ctlr.config.mediaPlayer = "Vimeo";
+    this.element = this.hostDiv = (0, import_utils.createEl)("div", { className: `tmg-host-div ${this.el.className}`, innerHTML: `<div class="tmg-host-content"></div>` });
+    ctlr.media.status.hostReady = false;
+  }
+  static canPlaySource(src) {
+    return MATCH_URL_VIMEO.test(src);
+  }
+  // --- API Injection ---
+  async initHost(url) {
+    try {
+      this.destroyHost();
+      if (!window.Vimeo) await loadResource(window.TMG_VIMEO_API_SRC, "script");
+      if (this.signal.aborted) return;
+      const base = this.config[this.ctlr.payload.wired ? "state" : "intent"];
+      this.host = new window.Vimeo.Player(this.el.firstElementChild, {
+        url: this.hostSrc = url,
+        autoplay: base.autoplay || !base.paused,
+        controls: base.controls,
+        loop: base.loop,
+        muted: base.muted,
+        playsinline: base.playsInline,
+        dnt: base.crossOrigin === "use-credentials" ? false : true,
+        // Do Not Track = Privacy Mode
+        transparent: true,
+        pip: true
+      });
+      for (const e of VIMEO_EVENTS) this.host.on(e, (data) => this.handleHostStateChange(e, data));
+      await this.host.ready(), this.media.status.hostReady = true;
+      this.element = this.el.querySelector("iframe"), this.el.classList.add("tmg-foreign-host", "tmg-vimeo-host");
+    } catch (err) {
+      this.handleHostError(err);
+    }
+  }
+  // ===========================================================================
+  // WIRING (Connections Only)
+  // ===========================================================================
+  // --- Core Wiring ---
+  wireSrc() {
+    this.config.on("intent.src", this.handleSrcIntent, this.evtOpts.CONFIG);
+  }
+  wireCurrentTime() {
+    this.config.set("intent.currentTime", (t, _, __, d = this.config.status.duration) => isSafeNum(d) ? (0, import_utils4.clamp)(0, t, d - 1) : t, this.evtOpts.CONFIG);
+    this.config.on("intent.currentTime", this.handleCurrentTimeIntent, this.evtOpts.CONFIG);
+  }
+  wireDuration() {
+  }
+  wirePaused() {
+    this.config.on("intent.paused", this.handlePausedIntent, this.evtOpts.CONFIG);
+  }
+  // --- Engine Inputs Wiring ---
+  wireEnded() {
+  }
+  wireVolume() {
+    this.config.on("intent.volume", this.handleVolumeIntent, this.evtOpts.CONFIG);
+  }
+  wireMuted() {
+    this.config.on("intent.muted", this.handleMutedIntent, this.evtOpts.CONFIG);
+  }
+  wirePlaybackRate() {
+    this.config.on("intent.playbackRate", this.handlePlaybackRateIntent, this.evtOpts.CONFIG);
+  }
+  // --- Presentation Modes Wiring ---
+  wireFullscreen() {
+    this.config.on("intent.fullscreen", this.handleFullscreenIntent, this.evtOpts.CONFIG);
+  }
+  wirePictureInPicture() {
+    this.config.on("intent.pictureInPicture", this.handlePictureInPictureIntent, this.evtOpts.CONFIG);
+  }
+  // --- Attributes Wiring ---
+  wireLoop() {
+    this.config.on("intent.loop", this.handleLoopIntent, this.evtOpts.CONFIG);
+  }
+  // --- Track Switching Wiring ---
+  wireCurrentChapter() {
+    this.config.set("intent.currentChapter", (term) => isNum(term) ? term : this.config.settings.metadata.chapterInfo.findIndex((c) => c.title === term || c.startTime === term || c.artwork === term), { signal: this.signal });
+    this.config.on("intent.currentChapter", this.handleCurrentChapterIntent, this.evtOpts.CONFIG);
+  }
+  wireCurrentTextTrack() {
+    this.config.set("intent.currentTextTrack", (term) => isNum(term) ? term : this.config.status.textTracks.find((t) => t.language === term && t.kind === term), { signal: this.signal });
+    this.config.on("intent.currentTextTrack", this.handleCurrentTextTrackIntent, this.evtOpts.CONFIG);
+  }
+  wireCurrentAudioTrack() {
+    this.config.set("intent.currentAudioTrack", (term) => isNum(term) ? term : this.config.status.audioTracks.find((t) => t.language === term && t.kind === term), { signal: this.signal });
+    this.config.on("intent.currentAudioTrack", this.handleCurrentAudioTrackIntent, this.evtOpts.CONFIG);
+  }
+  wireCurrentLevel() {
+    this.config.set("intent.currentLevel", (term) => isNum(term) ? term : Number(term), { signal: this.signal });
+    this.config.on("intent.currentLevel", this.handleCurrentLevelIntent, this.evtOpts.CONFIG);
+  }
+  wireAutoLevel() {
+    this.config.on("intent.autoLevel", this.handleAutoLevelIntent, this.evtOpts.CONFIG);
+  }
+  // --- Live Content Wiring ---
+  wireLive() {
+    this.config.on("intent.live", this.handleLiveIntent, this.evtOpts.CONFIG);
+    this.config.watch("status.isLive", this.onIsLiveStatus, this.evtOpts.CONFIG);
+  }
+  // ===========================================================================
+  // HANDLERS (The Logic - Auto-Guarded)
+  // ===========================================================================
+  // --- Core States ---
+  setLoadStartInfo() {
+    const { state: s, status: st } = this.config;
+    st.error = st.activeCue = null;
+    st.buffered = createTimeRanges([]);
+    st.seekable = createTimeRanges([]);
+    st.duration = NaN;
+    st.waiting = s.paused = true;
+    st.readyState = s.currentTime = 0;
+    st.ended = st.stalled = st.loadedData = st.loadedMetadata = st.canPlay = st.canPlayThrough = false;
+  }
+  // --- Core Intents ---
+  handleSrcIntent(e) {
+    if (e.resolved || isSameURL(this.hostSrc, e.value)) return;
+    this.setLoadStartInfo();
+    this.initHost(e.value);
+    e.resolve(this.name);
+  }
+  handleCurrentTimeIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedData", e, (min = getMediaMin(this.config), max = getMediaMax(this.config)) => {
+      if (e.value < min || e.value > max) e.reject(this.name);
+      this.host.setCurrentTime((0, import_utils4.clamp)(min, e.value, max)).catch((err) => this.ctlr.log(err, "error", true));
+    });
+    e.resolve(this.name);
+  }
+  handlePausedIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => (e.value ? this.host.pause() : this.host.play()).catch((err) => this.ctlr.log(err, "error", true)));
+    e.resolve(this.name);
+  }
+  // --- Feature Intents ---
+  handleVolumeIntent(e) {
+    if (e.resolved) return;
+    if (e.value < 0 || e.value > 100) e.reject(this.name);
+    this.when("hostReady", e, () => this.host.setVolume((0, import_utils4.clamp)(0, e.value / 100, 1)).catch((err) => this.ctlr.log(err, "error", true)));
+    e.resolve(this.name);
+  }
+  handleMutedIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => this.host.setMuted(e.value).catch((err) => this.ctlr.log(err, "error", true)));
+    e.resolve(this.name);
+  }
+  handlePlaybackRateIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => this.host.setPlaybackRate(e.value).catch((err) => this.ctlr.log(err, "error", true)));
+    e.resolve(this.name);
+  }
+  handleFullscreenIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => (e.value ? this.host.requestFullscreen() : this.host.exitFullscreen())?.catch(this.ctlr.notice));
+    e.resolve(this.name);
+  }
+  handlePictureInPictureIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => (e.value ? this.host.requestPictureInPicture() : this.host.exitPictureInPicture()).catch(this.ctlr.notice));
+    e.resolve(this.name);
+  }
+  handleLoopIntent(e) {
+    if (e.resolved) return;
+    this.when("hostReady", e, () => this.host.setLoop(e.value).catch((err) => this.ctlr.log(err, "error", true)));
+    this.config.state.loop = e.value;
+    e.resolve(this.name);
+  }
+  handleCurrentTextTrackIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => {
+      const track = this.config.status.textTracks[e.value];
+      track ? this.host.enableTextTrack(track.language, track.kind).catch((err) => this.ctlr.log(err, "error", true)) : this.host.disableTextTrack().catch((err) => this.ctlr.log(err, "error", true));
+    });
+    e.resolve(this.name);
+  }
+  handleCurrentAudioTrackIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => {
+      const track = this.config.status.audioTracks[e.value];
+      if (track) this.host.selectAudioTrack(track.language, track.kind).catch((err) => this.ctlr.log(err, "error", true));
+    });
+    e.resolve(this.name);
+  }
+  handleCurrentLevelIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => {
+      const quality = this.config.status.levels[e.value];
+      if (quality) this.host.setQuality(quality.id).catch((err) => this.ctlr.log(err, "error", true));
+    });
+    e.resolve(this.name);
+  }
+  handleAutoLevelIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, () => {
+      this.host.setQuality(e.value ? "auto" : this.config.status.levels[0]?.id).catch((err) => this.ctlr.log(err, "error", true));
+      this.config.state.autoLevel = e.value;
+    });
+    e.resolve(this.name);
+  }
+  handleLiveIntent(e) {
+    if (e.resolved) return;
+    this.when("loadedMetadata", e, (seekable = this.config.status.seekable) => e.value && seekable.length && (this.media.intent.currentTime = seekable.end(seekable.length - 1) - 1));
+    e.resolve(this.name);
+  }
+  // --- Dog Feeders ---
+  onIsLiveStatus(v) {
+    this.config.features.live = v;
+  }
+  handleHostStateChange(evt, data) {
+    const { state: s, status: st } = this.config;
+    switch (evt) {
+      case "loaded":
+        this.setInitInfo();
+        (0, import_utils5.setTimeout)(
+          () => {
+            st.readyState = 1;
+            st.waiting = false;
+            st.loadedMetadata = true;
+          },
+          100,
+          // promise abuse effects
+          this.signal
+        );
+        break;
+      case "playing":
+      case "play":
+        st.readyState = 4;
+        st.canPlay = st.canPlayThrough = st.loadedData = true;
+        st.ended = st.waiting = s.paused = false;
+        if (evt === "playing") st.error = null;
+        break;
+      case "pause":
+        s.paused = true;
+        this.host.getPlayed().then((played) => st.played = createTimeRanges(played));
+        st.waiting = false;
+        break;
+      case "ended":
+        return void (s.paused = st.ended = true);
+      case "timeupdate":
+        s.currentTime = data.seconds;
+        if (st.isLive)
+          if (st.seekable.length) {
+            const max = st.seekable.end(st.seekable.length - 1);
+            st.canSeekLive = max - st.seekable.start(0) >= this.config.settings.minDVRWindow;
+            s.live = max - s.currentTime <= this.config.settings.liveTolerance;
+          } else s.live = !(st.canSeekLive = false);
+        else st.ended = s.currentTime === st.duration;
+        break;
+      case "durationchange":
+        if (this.hostSrc !== this.durationSrc) this.durationSeq = 0, this.durationSrc = this.hostSrc;
+        const prev = st.duration;
+        if ((st.duration = data.duration) === Infinity) return void (st.isLive = true);
+        prev === Infinity ? st.isLive = false : prev > 0 && st.duration > prev && ++this.durationSeq > 3 && (st.isLive = true);
+        break;
+      case "progress":
+        this.host.getBuffered().then((buffered) => st.buffered = createTimeRanges(buffered));
+        this.host.getSeekable().then((seekable) => st.seekable = createTimeRanges(seekable));
+        break;
+      case "seeking":
+        st.seeking = true;
+        this.host.getPlayed().then((played) => st.played = createTimeRanges(played));
+        break;
+      case "seeked":
+        s.currentTime = data.seconds;
+        st.seeking = false;
+        break;
+      case "bufferstart":
+        st.waiting = true;
+        st.readyState = 2;
+        break;
+      case "bufferend":
+        st.waiting = false;
+        st.readyState = 4;
+        break;
+      case "volumechange":
+        s.volume = data.volume * 100;
+        this.host.getMuted().then((muted) => s.muted = muted);
+        break;
+      case "playbackratechange":
+        return void (s.playbackRate = data.playbackRate);
+      case "texttrackchange":
+        return void (s.currentTextTrack = st.textTracks.findIndex((t) => t.language === data.language && t.kind === data.kind));
+      case "cuechange":
+        return void (st.activeCue = data.cues[0] || null);
+      case "chapterchange":
+        this.config.state.currentChapter = data.index - 1;
+        break;
+      case "qualitychange":
+        return void (s.currentLevel = st.levels.findIndex((q) => q.id === data.quality));
+      case "resize":
+        return void (st.videoWidth = data.videoWidth, st.videoHeight = data.videoHeight);
+      case "enterpictureinpicture":
+        return void (s.pictureInPicture = true);
+      case "leavepictureinpicture":
+        return void (s.pictureInPicture = false);
+      case "fullscreenchange":
+        return void (s.fullscreen = data.fullscreen);
+      case "error":
+        return void (data.name === "Error" || data.name === "RangeError" || data.name === "TypeError" || data.method ? this.ctlr.log(`Vimeo error occurred: ${data.message}`, "error", true) : this.handleHostError(data));
+    }
+  }
+  handleHostError(err) {
+    this.config.status.error = { ...err, code: err?.code ?? 5, message: err?.message || "Vimeo Video Not Found." };
+    this.config.status.waiting = false;
+  }
+  // --- Lifecycle ---
+  async setInitInfo() {
+    if (!this.host) return;
+    this.autoChapters = !this.config.settings.metadata.allowOverride;
+    this.host.getDuration().then((duration) => this.config.status.isLive = (this.config.status.duration = duration) === Infinity);
+    this.host.getPlayed().then((played) => this.config.status.played = createTimeRanges(played));
+    this.host.getBuffered().then((buffered) => this.config.status.buffered = createTimeRanges(buffered));
+    this.host.getSeekable().then((seekable) => this.config.status.seekable = createTimeRanges(seekable));
+    this.host.getChapters().then((chapters, _meta = this.config.settings.metadata) => _meta.allowOverride && (_meta.chapterInfo = (0, import_sia_reactor5.inert)(chapters)));
+    this.host.getTextTracks().then((tracks) => this.config.status.textTracks = (0, import_sia_reactor5.inert)(tracks));
+    this.host.getAudioTracks().then((tracks) => this.config.status.audioTracks = (0, import_sia_reactor5.inert)(tracks));
+    this.host.getQualities().then((qualities) => this.config.status.levels = (0, import_sia_reactor5.inert)(qualities));
+    Promise.all([this.host.getVideoWidth(), this.host.getVideoHeight()]).then(([w, h]) => (this.config.status.videoWidth = w, this.config.status.videoHeight = h));
+    this.host.getPaused().then((paused) => this.config.state.paused = paused);
+    this.host.getCurrentTime().then((time) => this.config.state.currentTime = time);
+    this.host.getVolume().then((vol) => this.config.state.volume = vol * 100);
+    this.host.getMuted().then((muted) => this.config.state.muted = muted);
+    this.host.getPlaybackRate().then((rate) => this.config.state.playbackRate = rate);
+    this.host.getLoop().then((loop) => this.config.state.loop = loop);
+    this.host.getPictureInPicture().then((pip) => this.config.state.pictureInPicture = pip);
+    this.host.getFullscreen().then((fs) => this.config.state.fullscreen = fs);
+  }
+  destroyHost() {
+    if (!this.host) return;
+    this.host.destroy(), this.host = null, this.media.status.hostReady = false;
+    this.element = this.hostDiv;
+  }
+  onDestroy() {
+    this.destroyHost(), super.onDestroy();
+  }
+};
+__publicField(VimeoTech, "techName", "vimeo");
+//# sourceMappingURL=vimeo.cjs.map