tmg-media-player 0.0.1

package/dist/plugs/settings/modes/index.cjs

@@ -0,0 +1,1031 @@
+"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/plugs/settings/modes/index.ts
+var modes_exports = {};
+__export(modes_exports, {
+  MODES_BUILD: () => MODES_BUILD,
+  MODES_FULLSCREEN_BUILD: () => MODES_FULLSCREEN_BUILD,
+  MODES_MINIPLAYER_BUILD: () => MODES_MINIPLAYER_BUILD,
+  MODES_PICTURE_IN_PICTURE_BUILD: () => MODES_PICTURE_IN_PICTURE_BUILD,
+  MODES_THEATER_BUILD: () => MODES_THEATER_BUILD,
+  ModesFullscreenPin: () => ModesFullscreenPin,
+  ModesMiniplayerPin: () => ModesMiniplayerPin,
+  ModesPictureInPicturePin: () => ModesPictureInPicturePin,
+  ModesPlug: () => ModesPlug,
+  ModesTheaterPin: () => ModesTheaterPin,
+  ORIENTATION_OPTIONS: () => ORIENTATION_OPTIONS
+});
+module.exports = __toCommonJS(modes_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 INTERACTIVE_SELECTOR = ":is(button,[href],input:not([type='hidden']),select,textarea,details>summary,[contenteditable],iframe,audio[controls],video[controls],[tabindex]):not([disabled],[tabindex='-1'],[data-focus-guard],[inert],[inert] *)";
+var VIRTUAL_RESOURCE = /* @__PURE__ */ Symbol.for("T007_VIRTUAL_RESOURCE");
+function loadResource(req, type = "style", { module: module2, media, crossOrigin, integrity, referrerPolicy, nonce, fetchPriority, attempts = 3, retryKey = false } = {}, win4 = window) {
+  var _a;
+  win4.t007 ?? (win4.t007 = {}), (_a = win4.t007)._resourceCache ?? (_a._resourceCache = {});
+  if (req === VIRTUAL_RESOURCE || isSym(req)) return Promise.resolve();
+  const src = req;
+  if (win4.t007._resourceCache[src]) return win4.t007._resourceCache[src];
+  const existing = type === "script" ? Array.prototype.find.call(win4.document.scripts, (s) => isSameURL(s.src, src)) : type === "style" ? Array.prototype.find.call(win4.document.styleSheets, (s) => isSameURL(s.href, src)) : null;
+  if (existing) return win4.t007._resourceCache[src] = Promise.resolve(existing);
+  win4.t007._resourceCache[src] = new Promise((resolve, reject) => {
+    (function tryLoad(remaining, el) {
+      const onerror = () => {
+        el?.remove?.();
+        if (remaining > 1) {
+          setTimeout(tryLoad, 1e3, remaining - 1);
+          console.warn(`Retrying ${type} load for "${src}" (${attempts - remaining + 1})...`);
+        } else {
+          delete win4.t007._resourceCache[src];
+          reject(new Error(`${capitalize(type)} load failed for "${src}" after ${attempts - 1} attempts`));
+        }
+      };
+      const url = retryKey && remaining < attempts ? `${src}${src.includes("?") ? "&" : "?"}_${retryKey}=${Date.now()}` : src;
+      if (type === "script") win4.document.body.append(el = (0, import_utils.createEl)("script", { src: url, type: module2 ? "module" : "text/javascript", crossOrigin, integrity, referrerPolicy, nonce, fetchPriority, onload: () => resolve(el), onerror }) || "");
+      else if (type === "style") win4.document.head.append(el = (0, import_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 win4.t007._resourceCache[src];
+}
+function getWindow(el = window) {
+  return el?.ownerDocument?.defaultView ?? el?.defaultView ?? window;
+}
+function isSym(val) {
+  return "symbol" === typeof val;
+}
+function isBool(val) {
+  return "boolean" === 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 uncamelize(str, separator = " ") {
+  return str.replace(/([a-z])([A-Z])/g, `$1${separator}$2`).toLowerCase();
+}
+function cleanURL(url) {
+  try {
+    const u = new URL(url, window.location.href);
+    return decodeURIComponent(u.origin + u.pathname);
+  } catch {
+    return url.replace(/\\/g, "/").split("?")[0].trim();
+  }
+}
+function isSameURL(url1, url2) {
+  if (url1 === url2) return true;
+  if (!isStr(url1) || !isStr(url2) || !url1 || !url2) return false;
+  return cleanURL(url1) === cleanURL(url2);
+}
+var mockAsync = (timeout = 250) => new Promise((resolve) => (0, import_utils5.setTimeout)(resolve, timeout));
+var breath = (w = window) => new Promise((res) => w.requestAnimationFrame(res));
+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/plugs/base/index.ts
+var import_utils17 = require("sia-reactor/utils");
+
+// src/ts/consts/config.ts
+var import_sia_reactor4 = require("sia-reactor");
+
+// src/ts/consts/actions.ts
+var ACTIONS_BUILD = {
+  // --- Keyboard-only actions (no default voice triggers; path router covers voice) ---
+  playPause: { label: "Play / Pause" },
+  skipFwd: { label: "Skip Forward", notify: "fwd" },
+  skipBwd: { label: "Skip Back", notify: "bwd" },
+  volumeUp: { label: "Volume Up", notify: "volumeup" },
+  volumeDown: { label: "Volume Down", notify: "volumedown" },
+  brightnessUp: { label: "Brightness Up", notify: "brightnessup" },
+  brightnessDown: { label: "Brightness Down", notify: "brightnessdown" },
+  playbackRateUp: { label: "Playback Rate Up", notify: "playbackrateup" },
+  playbackRateDown: { label: "Playback Rate Down", notify: "playbackratedown" },
+  stepFwd: { label: "Step Forward", notify: "fwd" },
+  stepBwd: { label: "Step Back", notify: "bwd" },
+  prev: { label: "Previous", notify: "mediaprev" },
+  next: { label: "Next", notify: "medianext" },
+  captions: { label: "Captions", notify: "captions" },
+  captionsFontSizeUp: { label: "Captions: Font Size Up" },
+  captionsFontSizeDown: { label: "Captions: Font Size Down" },
+  captionsFontFamily: { label: "Captions: Font Family" },
+  captionsFontWeight: { label: "Captions: Font Weight" },
+  captionsFontVariant: { label: "Captions: Font Variant" },
+  captionsFontOpacity: { label: "Captions: Font Opacity" },
+  captionsBackgroundOpacity: { label: "Captions: Background Opacity" },
+  captionsWindowOpacity: { label: "Captions: Window Opacity" },
+  captionsCharacterEdgeStyle: { label: "Captions: Character Edge" },
+  captionsTextAlignment: { label: "Captions: Text Alignment" },
+  objectFit: { label: "Object Fit" },
+  capture: { label: "Capture Frame", notify: "capture" },
+  cast: { label: "Cast", notify: "cast" },
+  airplay: { label: "AirPlay", notify: "airplay" },
+  dark: { label: "Dark Mode" },
+  settings: { label: "Settings", zen: true },
+  // --- Logic-expressible actions (logic[] + keyboard, no default voice triggers) ---
+  mute: { label: "Mute", notify: "volumemuted" },
+  fullscreen: { label: "Fullscreen", notify: "fullscreen", logic: [{ path: "media.intent.fullscreen", op: "toggle" }] },
+  theater: { label: "Theater", notify: "theater", logic: [{ path: "media.intent.theater", op: "toggle" }] },
+  pictureInPicture: { label: "Picture in Picture", notify: "pictureinpicture", logic: [{ path: "media.intent.pictureInPicture", op: "toggle" }] },
+  timeFormat: { label: "Time Format" },
+  timeMode: { label: "Time Mode" },
+  // --- Compound (voice|time)-only actions (voice engine meta, path router can't reach these) ---
+  timeTravelUndo: { label: "Time Travel: Undo", zen: true },
+  timeTravelRedo: { label: "Time Travel: Redo", zen: true },
+  voiceQuit: { label: "Voice: Quit", zen: true },
+  voiceSleep: { label: "Voice: Sleep", zen: true },
+  voiceSubmit: { label: "Voice: Submit", zen: true },
+  voiceHistoryFirst: { label: "Voice: Go to Root", zen: true },
+  voiceHistoryPrev: { label: "Voice: Go Back", zen: true },
+  voiceHistoryNext: { label: "Voice: Go Forward", zen: true },
+  voiceHistoryLast: { label: "Voice: Go to Leaf", zen: true },
+  voiceHistoryClear: { label: "Voice: Clear History", zen: true },
+  voiceToggleOn: { label: "Voice: Toggle On", zen: true },
+  voiceToggleOff: { label: "Voice: Toggle Off", zen: true }
+};
+
+// src/ts/consts/config.ts
+var CONFIG_BUILD = {
+  mediaType: "video",
+  mediaPlayer: "TMG",
+  media: { intent: { playsInline: true, textVisible: true, brightness: 100 } },
+  actions: Object.fromEntries(Object.entries(ACTIONS_BUILD).map(([k, v]) => [k, { id: k, ...v }])),
+  logicPathBlacklist: ["media.state", "media.status", "media.tech", "media.features", "media.type", "media.element", "media.pseudoElement", "media.container", "media.pseudoContainer"],
+  settings: {
+    // techOrder: [
+    //   "youtube", // 1. Black-box (Regex must catch these URLs instantly)
+    //   "vimeo", // 2. Black-box (Regex must catch these URLs instantly)
+    //   "shaka", // 3. THE APEX PREDATOR (Catches .mpd and .m3u8 first)
+    //   "hls", // 4. Fallback (Catches .m3u8 ONLY if Shaka is disabled/fails)
+    //   "dash", // 5. Fallback (Catches .mpd ONLY if Shaka is disabled/fails)
+    //   "html5", // 6. The Native Floor (Catches raw .mp4, .webm, .mp3, etc.)
+    // ],
+  },
+  debug: true,
+  devMode: import_sia_reactor4.CTX.isDevEnv,
+  noPlugList: []
+  // dev: "settings.persist"
+};
+
+// src/ts/core/registries.ts
+var import_utils16 = require("sia-reactor/utils");
+var BaseRegistry = class {
+  constructor() {
+    __publicField(this, "items", []);
+  }
+  register(name, value, config) {
+    return this.unregister(name), this.items.push({ name, value, config }), this;
+  }
+  unregister(name, idx = this.items.findIndex((i) => i.name === name)) {
+    return idx !== -1 && this.items.splice(idx, 1), this;
+  }
+  get(name) {
+    return this.items.find((i) => i.name === name)?.value;
+  }
+  getAll(order) {
+    if (!order) return this.items.map((i) => i.value);
+    return this.items.sort((a, b, ai = order.indexOf(a.name), bi = order.indexOf(b.name)) => ai === -1 && bi === -1 ? 0 : ai === -1 ? 1 : bi === -1 ? -1 : ai - bi).map((i) => i.value);
+  }
+  clear() {
+    return this.items = [], this;
+  }
+};
+var OrderedRegistry = class extends BaseRegistry {
+  registerFirst(name, value, config) {
+    return this.unregister(name), this.items.unshift({ name, value, config }), this;
+  }
+  registerBefore(key, name, value, config) {
+    this.unregister(name);
+    const idx = this.items.findIndex((i) => i.name === key);
+    return idx !== -1 ? (this.items.splice(idx, 0, { name, value, config }), this) : this.register(name, value, config);
+  }
+  registerAfter(key, name, value, config) {
+    this.unregister(name);
+    const idx = this.items.findIndex((i) => i.name === key);
+    return idx !== -1 ? (this.items.splice(idx + 1, 0, { name, value, config }), this) : this.register(name, value, config);
+  }
+};
+var _TechRegistry = class _TechRegistry extends OrderedRegistry {
+  static get(name) {
+    return this.instance.get(name);
+  }
+  static register(Tech) {
+    this.instance.register(Tech.techName, Tech);
+  }
+  static unregister(name) {
+    this.instance.unregister(name);
+  }
+  static registerBefore(key, Tech) {
+    this.instance.registerBefore(key, Tech.techName, Tech);
+  }
+  static registerAfter(key, Tech) {
+    this.instance.registerAfter(key, Tech.techName, Tech);
+  }
+  static pick(src, techOrder) {
+    return this.instance.getAll(techOrder).find((Tech) => Tech.canPlaySource(src)) || null;
+  }
+};
+__publicField(_TechRegistry, "instance", new _TechRegistry());
+var TechRegistry = _TechRegistry;
+var _PlugRegistry = class _PlugRegistry extends OrderedRegistry {
+  static get(name) {
+    return this.instance.get(name);
+  }
+  static register(Plug, editBuild = Plug.BUILD !== void 0) {
+    this.instance.register(Plug.fullName, Plug);
+    editBuild && (0, import_utils16.setPath)(CONFIG_BUILD, Plug.fullName, Plug.BUILD);
+  }
+  static unregister(fullName, editBuild = true) {
+    this.instance.unregister(fullName);
+    editBuild && (0, import_utils16.deletePath)(CONFIG_BUILD, fullName);
+  }
+  static registerBefore(key, Plug) {
+    this.instance.registerBefore(key, Plug.fullName, Plug);
+  }
+  static registerAfter(key, Plug) {
+    this.instance.registerAfter(key, Plug.fullName, Plug);
+  }
+  static getOrdered() {
+    return this.instance.getAll();
+  }
+};
+__publicField(_PlugRegistry, "instance", new _PlugRegistry());
+var PlugRegistry = _PlugRegistry;
+var _PinRegistry = class _PinRegistry extends BaseRegistry {
+  static get(name) {
+    return this.instance.get(name);
+  }
+  static register(Pin, editBuild = Pin.BUILD !== void 0) {
+    this.instance.register(Pin.fullName, Pin);
+    editBuild && (0, import_utils16.setPath)(CONFIG_BUILD, Pin.Plug.fullName + "." + Pin.pinName, Pin.BUILD);
+  }
+  static unregister(fullName, editBuild = true) {
+    this.instance.unregister(fullName);
+    editBuild && (0, import_utils16.deletePath)(fullName.slice(0, fullName.indexOf(".")) in CONFIG_BUILD ? CONFIG_BUILD : CONFIG_BUILD.settings, fullName);
+  }
+};
+__publicField(_PinRegistry, "instance", new _PinRegistry());
+var PinRegistry = _PinRegistry;
+var _MenuRegistry = class _MenuRegistry extends BaseRegistry {
+  static get(name) {
+    return this.instance.get(name);
+  }
+  static register(name, factory) {
+    this.instance.register(name, factory);
+  }
+  static unregister(name) {
+    this.instance.unregister(name);
+  }
+};
+__publicField(_MenuRegistry, "instance", new _MenuRegistry());
+var MenuRegistry = _MenuRegistry;
+var _ComponentRegistry = class _ComponentRegistry extends BaseRegistry {
+  static get(name) {
+    return this.instance.get(name);
+  }
+  static register(Comp) {
+    this.instance.register(Comp.componentName, Comp);
+  }
+  static unregister(name) {
+    this.instance.unregister(name);
+  }
+  static init(name, ctlr, config = {}) {
+    const Comp = this.instance.get(name);
+    if (!Comp) return null;
+    const instance = new Comp(ctlr, config);
+    return instance.create(), instance.setup();
+  }
+  static getAll() {
+    return this.instance.getAll();
+  }
+};
+__publicField(_ComponentRegistry, "instance", new _ComponentRegistry());
+var ComponentRegistry = _ComponentRegistry;
+var _IconRegistry = class _IconRegistry extends BaseRegistry {
+  static get(name, raw = false, token = /\btmg-media-[^\s"']+\s*/g) {
+    return (raw ? this.instance.get(name)?.replace(token, "") : this.instance.get(name)) || `<svg></svg>`;
+  }
+  static register(name, svg) {
+    this.instance.register(name, svg);
+  }
+  static unregister(name) {
+    this.instance.unregister(name);
+  }
+  // Bulk register a map of icons { play: "<svg...>", pause: "<svg...>" }
+  static registerAll(icons) {
+    for (const k of Object.keys(icons)) this.instance.register(k, icons[k]);
+  }
+};
+__publicField(_IconRegistry, "instance", new _IconRegistry());
+var IconRegistry = _IconRegistry;
+
+// src/ts/plugs/base/index.ts
+var BasePlug = class extends Controllable {
+  static get surname() {
+    return this.isMain ? "" : "settings.";
+  }
+  static get fullName() {
+    return this.surname + this.plugName;
+  }
+  get name() {
+    return this.constructor.plugName;
+  }
+  constructor(ctlr, config = (0, import_utils17.getPath)(ctlr.config, new.target.fullName), state) {
+    ctlr.plug(new.target.fullName)?.destroy();
+    super(ctlr, config, state);
+    const path = new.target.fullName;
+    this.ctlr.config.watch(path, () => this.config = (0, import_utils17.getPath)(this.ctlr.config, path), { signal: this.signal });
+    ctlr.plugs.set(new.target.fullName, this);
+  }
+  onSetup() {
+    this.mount?.();
+    this.ctlr.state.readyState ? this.wire?.() : this.wire && this.ctlr.state.wonce("readyState", this.wire, { signal: this.signal });
+  }
+  onDestroy() {
+    this.unmount?.();
+    this.ctlr.plugs.delete(this.constructor.fullName);
+  }
+  mount() {
+  }
+  unmount() {
+  }
+  wire() {
+    this.registerMenu();
+  }
+  registerMenu() {
+    this.ctlr.plug("settings.settingsView")?.menu.register(MenuRegistry.get(this.constructor.fullName)?.(this));
+  }
+  // override to configure positioning
+};
+__publicField(BasePlug, "plugName");
+__publicField(BasePlug, "isCore", false);
+__publicField(BasePlug, "isMain", false);
+__publicField(BasePlug, "BUILD");
+var BasePin = class extends Controllable {
+  static get surname() {
+    return this.Plug.plugName;
+  }
+  static get fullName() {
+    return this.surname + "." + this.pinName;
+  }
+  get name() {
+    return this.constructor.Plug.fullName;
+  }
+  get plug() {
+    return this.ctlr.plug(this.constructor.Plug.fullName);
+  }
+  constructor(ctlr, config, state) {
+    super(ctlr, config, state);
+    const path = new.target.Plug.fullName + "." + new.target.pinName;
+    this.ctlr.config.watch(path, () => this.config = (0, import_utils17.getPath)(this.ctlr.config, path), { signal: this.signal });
+  }
+  onSetup() {
+  }
+  // plug handles mount and wire
+  onDestroy() {
+    this.unmount?.();
+  }
+  mount() {
+  }
+  unmount() {
+  }
+  wire() {
+  }
+};
+__publicField(BasePin, "pinName");
+__publicField(BasePin, "Plug");
+__publicField(BasePin, "BUILD");
+
+// src/ts/utils/env.ts
+var win = "undefined" !== typeof window ? window : void 0;
+var nav = win?.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(win?.cast?.framework?.CastReceiverContext);
+var MSE_ENABLED = Boolean(win && ("MediaSource" in win || "webkitMediaSource" in win));
+var TOUCH_ENABLED = Boolean(win && ("ontouchstart" in win || nav?.maxTouchPoints || win.DocumentTouch && win.document instanceof win.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/plugs/settings/modes/build.ts
+var ORIENTATION_OPTIONS = ["auto", "landscape", "portrait", "portrait-primary", "portrait-secondary", "landscape-primary", "landscape-secondary"];
+var MODES_FULLSCREEN_BUILD = {
+  disabled: false,
+  orientationLock: {
+    value: "auto",
+    options: [{ value: false, display: "Off" }, ...ORIENTATION_OPTIONS.map((o) => ({ value: o, display: capitalize(uncamelize(o)) }))]
+  },
+  onRotate: {
+    value: 90,
+    options: [
+      { value: false, display: "Off" },
+      { value: 0, display: "0\xB0 Portrait" },
+      { value: 90, display: "90\xB0 Landscape" },
+      { value: 180, display: "180\xB0 Inverted" },
+      { value: 270, display: "270\xB0 Landscape" }
+    ]
+  }
+};
+var MODES_THEATER_BUILD = {
+  disabled: IS_MOBILE
+};
+var MODES_PICTURE_IN_PICTURE_BUILD = {
+  disabled: false,
+  floatingPlayer: {
+    disabled: false,
+    width: 500,
+    height: 280,
+    disallowReturnToOpener: false,
+    preferInitialWindowPlacement: false
+  }
+};
+var MODES_MINIPLAYER_BUILD = {
+  disabled: false,
+  minWindowWidth: 240
+};
+var MODES_BUILD = {
+  // fullscreen: MODES_FULLSCREEN_BUILD,
+  // theater: MODES_THEATER_BUILD,
+  // pictureInPicture: MODES_PICTURE_IN_PICTURE_BUILD,
+  // miniplayer: MODES_MINIPLAYER_BUILD,
+};
+
+// src/ts/plugs/settings/modes/fullscreen.ts
+var import_sia_reactor6 = require("sia-reactor");
+
+// src/ts/utils/dom.ts
+var import_sia_reactor5 = require("sia-reactor");
+var win2 = "undefined" !== typeof window ? window : void 0;
+function inDocView(el, axis = "y") {
+  const rect = el.getBoundingClientRect(), inX = rect.left + win2.scrollX >= 0 && rect.right + win2.scrollX <= win2.scrollX + (win2.innerWidth || win2.document.documentElement.clientWidth), inY = rect.top + win2.scrollY >= 0 && rect.bottom + win2.scrollY <= win2.scrollY + (win2.innerHeight || win2.document.documentElement.clientHeight);
+  return axis === "x" ? inY : axis === "y" ? inX : inY && inX;
+}
+var queryFullscreen = () => Boolean(queryFullscreenEl());
+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 = win2 ? 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 = win2 ? new ResizeObserver((entries) => {
+  for (const entry of entries) if (entry.target._resizeCbs) for (const cb of entry.target._resizeCbs) cb(entry);
+}) : null;
+var mutationObserver = win2 ? 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/plugs/settings/modes/fullscreen.ts
+var import_modules = require("sia-reactor/modules");
+var ModesFullscreenPin = class extends BasePin {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "inFullscreen", false);
+    // a quick notice flag for external deps
+    __publicField(this, "shadowFullscreen", false);
+  }
+  static get Plug() {
+    return ModesPlug;
+  }
+  wire() {
+    this.media.watch("tech", this.syncFeatures, { init: true, signal: this.signal });
+    this.ctlr.state.watch("docInFullscreen", this.onDocInFullscreen, { signal: this.signal });
+    this.ctlr.state.watch("screenOrientation", this.onScreenOrientation, { signal: this.signal });
+    this.media.on("intent.fullscreen", this.handleFullscreenIntent, { capture: true, init: this.ctlr.payload.wired, initType: "set", signal: this.signal });
+    this.media.set("state.fullscreen", (v) => v !== this.shadowFullscreen && !IS_IOS ? import_sia_reactor6.TERMINATOR : v, { signal: this.signal });
+    this.ctlr.config.on("settings.modes.fullscreen.disabled", this.handleDisabled, { init: true, signal: this.signal });
+    this.ctlr.registerAction("fullscreen", { keyboard: { phase: "keyup" } });
+  }
+  handleDisabled({ value }) {
+    this.syncFeatures();
+    if (value && this.ctlr.isUIActive("fullscreen")) this.media.intent.fullscreen = false;
+  }
+  handleFullscreenIntent(e) {
+    if (e.resolved || IS_IOS) return;
+    if (e.value && !this.inFullscreen) {
+      const fW = this.ctlr.plug("settings.modes")?.pictureInPicture?.floatingWindow;
+      if (this.ctlr.isUIActive("floatingPlayer")) return fW?.addEventListener("pagehide", this.enter, { signal: this.signal }), fW?.close(), e.resolve(this.name);
+      if (this.ctlr.isUIActive("pictureInPicture")) (0, import_modules.silence)(() => this.media.intent.pictureInPicture = false);
+      if (this.ctlr.isUIActive("miniplayer")) (0, import_modules.silence)(() => this.media.intent.miniplayer = false);
+      this.enter();
+    } else if (this.inFullscreen) {
+      exitFullscreen(this.media.container);
+      this.inFullscreen = this.shadowFullscreen = false;
+    }
+    e.resolve(this.name);
+  }
+  async enter() {
+    await enterFullscreen(this.media.container);
+    this.inFullscreen = true;
+  }
+  // #STANDALONE: needs scoped behavior
+  onDocInFullscreen(docInFs) {
+    const inFs = docInFs && queryFullscreenEl() === this.media.container;
+    if (inFs) {
+      this.media.container.classList.add("tmg-media-fullscreen");
+      this.media.state.fullscreen = this.shadowFullscreen = true;
+      if (IS_MOBILE) this.changeScreenOrientation(this.config.orientationLock.value);
+    } else if (this.ctlr.isUIActive("fullscreen")) {
+      this.media.container.classList.remove("tmg-media-fullscreen");
+      this.inFullscreen = this.media.intent.locked = false;
+      this.ctlr.plug("settings.modes")?.miniplayer?.toggle();
+      this.media.state.fullscreen = this.shadowFullscreen = false;
+    }
+  }
+  onScreenOrientation(orientation) {
+    if (!this.ctlr.state.mediaParentIntersecting || !IS_MOBILE || this.ctlr.state.readyState < 3 || this.config.onRotate.value === false || this.ctlr.isUIActive("fullscreen") || this.ctlr.isUIActive("miniplayer")) return;
+    const deg = isBool(this.config.onRotate.value) ? 90 : parseInt(this.config.onRotate.value);
+    if (orientation.angle === deg || orientation.angle === 360 - deg) this.media.intent.fullscreen = !this.media.state.fullscreen;
+  }
+  async changeScreenOrientation(option = true) {
+    const orientation = screen.orientation;
+    option === false ? orientation?.unlock?.() : await orientation?.lock?.(option === "auto" ? this.media.status.videoHeight > this.media.status.videoWidth ? "portrait" : "landscape" : option !== true ? option : orientation?.angle === 0 ? "landscape" : "portrait");
+  }
+  syncFeatures() {
+    var _a, _b;
+    if (this.config.disabled) return void (this.media.features.fullscreen = this.media.features.fullscreenOrientation = false);
+    (_a = this.media.features).fullscreen || (_a.fullscreen = supportsFullscreen());
+    (_b = this.media.features).fullscreenOrientation || (_b.fullscreenOrientation = this.media.features.fullscreen && IS_MOBILE && isFunc(screen.orientation?.lock));
+  }
+};
+__publicField(ModesFullscreenPin, "pinName", "fullscreen");
+__publicField(ModesFullscreenPin, "BUILD", MODES_FULLSCREEN_BUILD);
+
+// src/ts/plugs/settings/modes/theater.ts
+var ModesTheaterPin = class extends BasePin {
+  static get Plug() {
+    return ModesPlug;
+  }
+  wire() {
+    this.media.watch("tech", this.syncFeatures, { init: true, signal: this.signal });
+    this.media.on("intent.theater", this.handleTheaterIntent, { capture: true, init: this.ctlr.payload.wired, initType: "set", signal: this.signal });
+    this.ctlr.config.on("settings.modes.theater.disabled", this.handleDisabled, { init: true, signal: this.signal });
+    this.ctlr.registerAction("theater", { keyboard: { phase: "keyup" } });
+  }
+  handleDisabled({ value }) {
+    this.syncFeatures();
+    if (value && this.ctlr.isUIActive("theater")) this.media.intent.theater = false;
+  }
+  handleTheaterIntent(e) {
+    if (e.resolved || e.value && (this.ctlr.isUIActive("fullscreen") || this.ctlr.isUIActive("miniplayer") || this.ctlr.isUIActive("floatingPlayer"))) return;
+    this.media.container.classList.toggle("tmg-media-theater", e.value);
+    this.media.state.theater = e.value;
+    e.resolve(this.name);
+  }
+  syncFeatures() {
+    var _a;
+    if (this.config.disabled) return void (this.media.features.theater = false);
+    (_a = this.media.features).theater || (_a.theater = true);
+  }
+};
+__publicField(ModesTheaterPin, "pinName", "theater");
+__publicField(ModesTheaterPin, "BUILD", MODES_THEATER_BUILD);
+
+// src/ts/tools/runtime.ts
+var win3 = "undefined" !== typeof window ? window : void 0;
+var flagMutationSet = /* @__PURE__ */ new WeakSet();
+var AUDIO_CONTEXT = null;
+var STATE_BUILD = { readyState: 0, audioContextReady: !!AUDIO_CONTEXT, mediaIntersecting: true, mediaParentIntersecting: true, dimensions: { container: { width: 0, height: 0, tier: "x" }, pseudoContainer: { width: 0, height: 0, tier: "x" }, window: { width: win3?.innerWidth, height: win3?.innerHeight } }, screenOrientation: { type: win3?.screen?.orientation?.type ?? "", angle: win3?.screen?.orientation?.angle ?? win3?.orientation ?? 0 }, docVisibilityState: win3?.document.visibilityState, docInFullscreen: queryFullscreen() };
+function handleVidMutation(mutations) {
+  for (const mutation of mutations) {
+    if (mutation.type !== "attributes") continue;
+    const target = mutation.target;
+    if (mutation.attributeName === "tmgcontrols") !flagMutationSet.has(target) && (target.tmgcontrols = target.hasAttribute("tmgcontrols"));
+    else if (mutation.attributeName?.startsWith("tmg")) target.hasAttribute(mutation.attributeName) && target.tmgPlayer?.fetchOptions();
+    else if (mutation.attributeName === "controls") target.hasAttribute("tmgcontrols") && target.removeAttribute("controls");
+  }
+}
+function handleDOMMutation(mutations) {
+  for (const mutation of mutations) {
+    for (const node of Array.from(mutation.addedNodes)) {
+      if (!(node instanceof HTMLElement)) continue;
+      const els = node.matches(":is(video,audio):not(.tmg-host)") ? [node] : node.querySelectorAll(":is(video,audio):not(.tmg-host)");
+      for (const el of els) {
+        observeMutation(el, handleVidMutation, { attributes: true });
+        el.tmgcontrols = el.hasAttribute("tmgcontrols");
+      }
+    }
+    for (const node of Array.from(mutation.removedNodes)) {
+      if (!(node instanceof HTMLElement)) continue;
+      const els = node.matches(".tmg-host") ? [node] : node.querySelectorAll(".tmg-host");
+      for (const el of els) !el.tmgPlayer?.Controller?.mutatingDOMM && el.tmgPlayer?.detach();
+    }
+  }
+}
+
+// src/ts/plugs/settings/modes/pictureInPicture.ts
+var import_modules2 = require("sia-reactor/modules");
+var ModesPictureInPicturePin = class extends BasePin {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "inFloatingPlayer", false);
+    // a quick notice flag for external deps
+    __publicField(this, "floatingWindow", null);
+    __publicField(this, "placeholder", null);
+    __publicField(this, "pseudoPlaceholder", null);
+    __publicField(this, "whitelist", []);
+    __publicField(this, "blacklist", []);
+  }
+  static get Plug() {
+    return ModesPlug;
+  }
+  mount() {
+    this.placeholder = ComponentRegistry.init("pipplaceholder", this.ctlr);
+    if (window.documentPictureInPicture) this.pseudoPlaceholder = ComponentRegistry.init("pipplaceholder", this.ctlr);
+    this.placeholder?.mount(), this.pseudoPlaceholder && this.media.pseudoContainer.prepend(this.pseudoPlaceholder.el);
+  }
+  wire() {
+    this.media.watch("tech", this.syncFeatures, { init: true, signal: this.signal });
+    this.media.on("intent.pictureInPicture", this.handlePictureInPictureIntent, { capture: true, init: this.ctlr.payload.wired, initType: "set", signal: this.signal });
+    this.media.on("state.pictureInPicture", this.handlePictureInPictureState, { init: this.ctlr.payload.wired, signal: this.signal });
+    this.media.on("state.disablePictureInPicture", this.syncFeatures, { signal: this.signal });
+    this.ctlr.config.on("settings.modes.pictureInPicture.disabled", this.handleDisabled, { init: true, signal: this.signal });
+    this.ctlr.config.on("settings.modes.pictureInPicture.floatingPlayer.disabled", this.handleDisabled, { signal: this.signal });
+    this.ctlr.registerAction("pictureInPicture", { keyboard: { phase: "keyup" } });
+  }
+  handleDisabled({ value }) {
+    this.syncFeatures();
+    if (value && (this.ctlr.isUIActive("pictureInPicture") || this.ctlr.isUIActive("floatingPlayer"))) this.media.intent.pictureInPicture = false;
+  }
+  handlePictureInPictureIntent(e) {
+    if (e.resolved) return;
+    const pipActive = this.ctlr.isUIActive("pictureInPicture");
+    if (!this.ctlr.isNativeEl && this.config.floatingPlayer.disabled) return e.reject(this.name);
+    if (this.ctlr.plug("settings.modes")?.fullscreen?.inFullscreen) (0, import_modules2.silence)(() => this.media.intent.fullscreen = false);
+    if (!pipActive && this.media.features.floatingPlayer) {
+      e.value && !this.inFloatingPlayer ? this.initFloatingPlayer() : this.floatingWindow?.close();
+      e.resolve(this.name);
+    }
+  }
+  async handlePictureInPictureState({ value }) {
+    if (this.floatingWindow) return;
+    if (value) {
+      this.media.container.classList.add("tmg-media-picture-in-picture"), this.media.pseudoContainer.classList.add("tmg-media-in-picture-in-picture");
+      this.ctlr.plug("settings.overlay")?.show();
+      (0, import_modules2.silence)(() => this.media.intent.miniplayer = false);
+      this.ctlr.plug("settings.metadata")?.syncSession();
+    } else {
+      await mockAsync(180);
+      this.media.container.classList.remove("tmg-media-picture-in-picture"), this.media.pseudoContainer.classList.remove("tmg-media-in-picture-in-picture");
+      this.ctlr.plug("settings.modes")?.miniplayer?.toggle();
+      this.ctlr.plug("settings.overlay")?.delay();
+    }
+  }
+  async initFloatingPlayer() {
+    if (this.inFloatingPlayer) return;
+    window.documentPictureInPicture?.window?.close?.();
+    (0, import_modules2.silence)(() => this.media.intent.miniplayer = false);
+    this.floatingWindow = await window.documentPictureInPicture.requestWindow(this.config.floatingPlayer);
+    this.inFloatingPlayer = true;
+    this.floatingWindow.document.documentElement.style.cssText = `height:100%; background:url(${this.media.settings.metadata.profile}) center / 32px no-repeat, url(${this.media.state.poster}) center / ${this.settings.css.bgObjectFit} no-repeat, black;`;
+    await breath(this.floatingWindow);
+    const cssTexts = [], parse = (src) => isStr(src) ? src : null, whitelist = this.whitelist.concat([parse(window.TMG_MEDIA_CSS_SRC), parse(window.T007_TOAST_CSS_SRC), parse(window.T007_INPUT_CSS_SRC), parse(window.T007_DIALOG_CSS_SRC)].filter(Boolean));
+    for (const sheet of document.styleSheets) {
+      try {
+        const nope = (src) => isSameURL(src, sheet.href);
+        if (!whitelist.some(nope) && !this.blacklist.some(nope)) {
+          for (const cssRule of sheet.cssRules) if (cssRule.selectorText?.includes(":root") || cssRule.cssText.includes("tmg") || cssRule.cssText.includes("t007")) cssTexts.push(cssRule.cssText);
+        }
+      } catch {
+        continue;
+      }
+    }
+    this.floatingWindow.document.head.append((0, import_utils.createEl)("style", { textContent: cssTexts.join("\n") }));
+    await Promise.all(whitelist.map((href) => href.includes(".css") && loadResource(href, "style", void 0, this.floatingWindow)));
+    this.ctlr.plug("skeleton")?.enterPseudoMode();
+    this.media.container.classList.add("tmg-media-floating-player", "tmg-media-progress-bar"), this.media.pseudoContainer.classList.add("tmg-media-in-floating-player");
+    this.floatingWindow.document.body.append(this.media.container);
+    this.floatingWindow.document.documentElement.id = document.documentElement.id;
+    this.floatingWindow.document.documentElement.className = document.documentElement.className;
+    for (const attr of document.documentElement.getAttributeNames()) this.floatingWindow.document.documentElement.setAttribute(attr, document.documentElement.getAttribute(attr));
+    this.signal.addEventListener("abort", observeMutation(this.floatingWindow.document.documentElement, handleDOMMutation, { childList: true, subtree: true }), { once: true });
+    this.floatingWindow.addEventListener("resize", this.handleFloatingPlayerResize, { signal: this.signal });
+    this.floatingWindow.addEventListener("pagehide", this.handleFloatingPlayerClose, { signal: this.signal });
+    this.ctlr.plug("settings.keys")?.setEventListeners();
+    this.media.state.pictureInPicture = true;
+  }
+  // #STANDALONE: needs scoped behavior
+  handleFloatingPlayerResize() {
+    if (!this.config.floatingPlayer.preferInitialWindowPlacement) return;
+    this.config.floatingPlayer.width = this.floatingWindow?.innerWidth ?? this.config.floatingPlayer.width;
+    this.config.floatingPlayer.height = this.floatingWindow?.innerHeight ?? this.config.floatingPlayer.height;
+  }
+  handleFloatingPlayerClose() {
+    this.inFloatingPlayer = false;
+    this.floatingWindow = null;
+    this.media.container.classList.toggle("tmg-media-progress-bar", this.settings.controlPanel.progressBar);
+    this.media.container.classList.remove("tmg-media-floating-player"), this.media.pseudoContainer.classList.remove("tmg-media-in-floating-player");
+    this.ctlr.plug("skeleton")?.leavePseudoMode();
+    this.ctlr.plug("settings.modes")?.miniplayer?.toggle();
+    this.media.state.pictureInPicture = false;
+  }
+  syncFeatures() {
+    var _a, _b;
+    if (this.config.disabled) return void (this.media.features.pictureInPicture = this.media.features.floatingPlayer = false);
+    if (!this.config.floatingPlayer.disabled) (_a = this.media.features).floatingPlayer || (_a.floatingPlayer = window.documentPictureInPicture && this.ctlr.isNativeEl);
+    else this.media.features.floatingPlayer = false;
+    (_b = this.media.features).pictureInPicture || (_b.pictureInPicture = this.ctlr.isNativeEl && (supportsPictureInPicture() && !this.media.state.disablePictureInPicture || this.media.features.floatingPlayer));
+  }
+  onDestroy() {
+    this.floatingWindow?.close(), this.placeholder?.destroy(), this.pseudoPlaceholder?.destroy(), super.onDestroy();
+  }
+};
+__publicField(ModesPictureInPicturePin, "pinName", "pictureInPicture");
+__publicField(ModesPictureInPicturePin, "BUILD", MODES_PICTURE_IN_PICTURE_BUILD);
+
+// src/ts/plugs/settings/modes/miniplayer.ts
+var import_modules3 = require("sia-reactor/modules");
+var ModesMiniplayerPin = class extends BasePin {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "lastMiniplayerPosX", 0);
+    __publicField(this, "lastMiniplayerPosY", 0);
+    __publicField(this, "lastMiniplayerPtrX", 0);
+    __publicField(this, "lastMiniplayerPtrY", 0);
+    __publicField(this, "nextMiniplayerX", "");
+    __publicField(this, "nextMiniplayerY", "");
+    __publicField(this, "wildMiniplayerX", "");
+    __publicField(this, "wildMiniplayerY", "");
+    __publicField(this, "prevEX");
+    __publicField(this, "prevEY");
+  }
+  static get Plug() {
+    return ModesPlug;
+  }
+  wire() {
+    this.media.watch("tech", this.syncFeatures, { init: true, signal: this.signal });
+    this.ctlr.state.watch("dimensions.window.width", () => !this.ctlr.isUIActive("fullscreen") && this.toggle(), { signal: this.signal });
+    this.media.on("intent.miniplayer", this.handleMiniplayerIntent, { capture: true, init: this.ctlr.payload.wired, initType: "set", signal: this.signal });
+    this.media.on("state.paused", ({ value }) => !value && this.toggle(), { init: this.ctlr.payload.wired, signal: this.signal });
+    this.ctlr.state.on("mediaParentIntersecting", () => this.ctlr.payload.wired && this.toggle(), { signal: this.signal });
+    this.ctlr.config.on("settings.modes.miniplayer.disabled", this.handleDisabled, { init: true, signal: this.signal });
+  }
+  handleDisabled({ value }) {
+    this.syncFeatures();
+    if (value && this.ctlr.isUIActive("miniplayer")) this.media.intent.miniplayer = false;
+  }
+  handleMiniplayerIntent(e) {
+    if (e.resolved) return;
+    const active = this.ctlr.isUIActive("miniplayer");
+    e.value && !active ? this.enter() : active && this.exit();
+    e.resolve(this.name);
+  }
+  enter() {
+    this.ctlr.plug("skeleton")?.enterPseudoMode();
+    this.media.container.classList.add("tmg-media-miniplayer", "tmg-media-progress-bar"), this.media.pseudoContainer.classList.add("tmg-media-in-miniplayer");
+    for (const type of ["mousedown", "touchstart"]) this.media.container.addEventListener(type, this.handleDragStart, { signal: this.signal });
+    this.media.state.miniplayer = true;
+  }
+  // #STANDALONE: partner courtesy
+  exit(behavior) {
+    if (behavior && inDocView(this.media.pseudoContainer)) this.media.pseudoContainer.scrollIntoView({ behavior, block: "center", inline: "center" });
+    this.ctlr.plug("skeleton")?.leavePseudoMode();
+    this.media.container.classList.remove("tmg-media-miniplayer"), this.media.pseudoContainer.classList.remove("tmg-media-in-miniplayer");
+    this.media.container.classList.toggle("tmg-media-progress-bar", this.settings.controlPanel.progressBar);
+    for (const type of ["mousedown", "touchstart"]) this.media.container.removeEventListener(type, this.handleDragStart);
+    this.media.state.miniplayer = false;
+  }
+  // #STANDALONE: needs scoped behavior
+  expand() {
+    this.media.container.classList.contains("tmg-media-miniplayer") && this.exit("smooth");
+  }
+  remove() {
+    (0, import_modules3.silence)(() => this.media.intent.paused = true), this.exit();
+  }
+  toggle(bool) {
+    const active = this.ctlr.isUIActive("miniplayer");
+    if (!active && (bool === true || this.shouldEnter())) this.media.intent.miniplayer = true;
+    else if (active && (bool === false || this.shouldExit())) this.media.intent.miniplayer = false;
+  }
+  shouldEnter() {
+    const modes = this.ctlr.plug("settings.modes");
+    return !this.ctlr.isUIActive("pictureInPicture") && !modes?.pictureInPicture?.inFloatingPlayer && !modes?.fullscreen?.inFullscreen && !this.ctlr.state.mediaParentIntersecting && getWindow(this.media.container).innerWidth >= this.config.minWindowWidth && !this.media.state.paused;
+  }
+  shouldExit() {
+    return this.ctlr.state.mediaParentIntersecting || getWindow(this.media.container).innerWidth < this.config.minWindowWidth;
+  }
+  handleDragStart(e) {
+    const target = e.target, clientX = e.clientX ?? e.targetTouches?.[0]?.clientX ?? 0, clientY = e.clientY ?? e.targetTouches?.[0]?.clientY ?? 0;
+    if (!this.ctlr.isUIActive("miniplayer") || target.scrollWidth >= target.clientWidth + 3 || [this.ctlr.DOM.topControlsWrapper, this.ctlr.DOM.bottomControlsWrapper, this.ctlr.DOM.captionsContainer].some((w) => w?.contains(target)) || target.closest(`:is(${INTERACTIVE_SELECTOR},[class$='toast-container'])`)) return;
+    const { left, bottom } = getComputedStyle(this.media.container);
+    this.lastMiniplayerPosX = parseFloat(left), this.lastMiniplayerPosY = parseFloat(bottom);
+    this.lastMiniplayerPtrX = clientX, this.lastMiniplayerPtrY = clientY;
+    this.nextMiniplayerX = this.settings.css.currentMiniplayerX, this.nextMiniplayerY = this.settings.css.currentMiniplayerY;
+    this.wildMiniplayerX = this.nextMiniplayerX, this.wildMiniplayerY = this.nextMiniplayerY;
+    document.addEventListener("mousemove", this.handleDragging, { signal: this.signal });
+    document.addEventListener("touchmove", this.handleDragging, { passive: false, signal: this.signal });
+    for (const type of ["mouseup", "mouseleave", "touchend", "touchcancel"]) document.addEventListener(type, this.handleDragEnd, { signal: this.signal });
+    this.media.container.style.setProperty("transition", "none", "important");
+  }
+  handleDragging(e) {
+    if (e.touches?.length > 1) return;
+    e.preventDefault();
+    this.ctlr.plug("settings.overlay")?.hide("force");
+    this.media.container.classList.add("tmg-media-player-dragging");
+    this.ctlr.RAFLoop("miniplayerDragging", () => {
+      const x = e.clientX ?? e.changedTouches?.[0]?.clientX ?? 0, y = e.clientY ?? e.changedTouches?.[0]?.clientY ?? 0;
+      if (this.prevEX === x && this.prevEY === y) return;
+      this.prevEX = x, this.prevEY = y;
+      const { innerWidth: ww, innerHeight: wh } = window, { offsetWidth: w, offsetHeight: h } = this.media.container, newX = this.lastMiniplayerPosX + (x - this.lastMiniplayerPtrX), newY = this.lastMiniplayerPosY - (y - this.lastMiniplayerPtrY), posX = (0, import_utils4.clamp)(w / 2, newX, ww - w / 2), posY = (0, import_utils4.clamp)(h / 2, newY, wh - h / 2);
+      this.media.container.style.setProperty("transform", `translate(${x - this.lastMiniplayerPtrX}px, ${y - this.lastMiniplayerPtrY}px)`, "important");
+      this.nextMiniplayerX = `${posX / ww * 100}%`, this.nextMiniplayerY = `${posY / wh * 100}%`;
+      this.wildMiniplayerX = `${newX / ww * 100}%`, this.wildMiniplayerY = `${newY / wh * 100}%`;
+    });
+  }
+  handleDragEnd() {
+    this.ctlr.cancelRAFLoop("miniplayerDragging");
+    this.media.container.classList.remove("tmg-media-player-dragging");
+    this.media.container.style.setProperty("left", this.wildMiniplayerX, "important");
+    this.media.container.style.setProperty("bottom", this.wildMiniplayerY, "important");
+    this.media.container.style.removeProperty("transform");
+    (0, import_utils5.setTimeout)(() => (this.settings.css.currentMiniplayerX = this.nextMiniplayerX, this.settings.css.currentMiniplayerY = this.nextMiniplayerY, ["transition", "left", "bottom"].forEach((prop) => this.media.container.style.removeProperty(prop))), 0, this.signal);
+    document.removeEventListener("mousemove", this.handleDragging);
+    document.removeEventListener("touchmove", this.handleDragging);
+    for (const type of ["mouseup", "mouseleave", "touchend", "touchcancel"]) document.removeEventListener(type, this.handleDragEnd);
+  }
+  syncFeatures() {
+    var _a;
+    if (this.config.disabled) return void (this.media.features.miniplayer = false);
+    (_a = this.media.features).miniplayer || (_a.miniplayer = this.ctlr.isNativeEl);
+  }
+  onDestroy() {
+    document.removeEventListener("mousemove", this.handleDragging);
+    document.removeEventListener("touchmove", this.handleDragging);
+    for (const type of ["mouseup", "mouseleave", "touchend", "touchcancel"]) document.removeEventListener(type, this.handleDragEnd);
+    for (const type of ["mousedown", "touchstart"]) this.media.container.removeEventListener(type, this.handleDragStart);
+    super.onDestroy();
+  }
+};
+__publicField(ModesMiniplayerPin, "pinName", "miniplayer");
+__publicField(ModesMiniplayerPin, "BUILD", MODES_MINIPLAYER_BUILD);
+
+// src/ts/plugs/settings/modes/index.ts
+var ModesPlug = class extends BasePlug {
+  constructor(ctlr, config = ctlr.settings.modes) {
+    super(ctlr, config);
+    __publicField(this, "fullscreen");
+    __publicField(this, "theater");
+    __publicField(this, "pictureInPicture");
+    __publicField(this, "miniplayer");
+    const FullscreenPin = PinRegistry.get("modes.fullscreen"), TheaterPin = PinRegistry.get("modes.theater"), PictureInPicturePin = PinRegistry.get("modes.pictureInPicture"), MiniplayerPin = PinRegistry.get("modes.miniplayer");
+    FullscreenPin && (this.fullscreen = new FullscreenPin(this.ctlr, this.config.fullscreen)), TheaterPin && (this.theater = new TheaterPin(this.ctlr, this.config.theater)), PictureInPicturePin && (this.pictureInPicture = new PictureInPicturePin(this.ctlr, this.config.pictureInPicture)), MiniplayerPin && (this.miniplayer = new MiniplayerPin(this.ctlr, this.config.miniplayer));
+  }
+  mount() {
+    this.fullscreen?.mount?.(), this.theater?.mount?.(), this.pictureInPicture?.mount?.(), this.miniplayer?.mount?.();
+  }
+  wire() {
+    this.fullscreen?.wire(), this.theater?.wire(), this.pictureInPicture?.wire(), this.miniplayer?.wire();
+    super.wire();
+  }
+  onDestroy() {
+    this.fullscreen?.destroy(), this.theater?.destroy(), this.pictureInPicture?.destroy(), this.miniplayer?.destroy(), super.onDestroy();
+  }
+};
+__publicField(ModesPlug, "plugName", "modes");
+__publicField(ModesPlug, "BUILD", MODES_BUILD);
+//# sourceMappingURL=index.cjs.map