tmg-media-player 0.0.1

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

@@ -0,0 +1,592 @@
+"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/volume/index.ts
+var volume_exports = {};
+__export(volume_exports, {
+  VOLUME_BUILD: () => VOLUME_BUILD,
+  VolumePlug: () => VolumePlug
+});
+module.exports = __toCommonJS(volume_exports);
+
+// src/ts/core/controllable.ts
+var import_sia_reactor3 = require("sia-reactor");
+var import_utils12 = 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 isFunc(val) {
+  return "function" === typeof val;
+}
+function capitalize(word = "") {
+  return word.replace(/^(\s*)([a-z])/i, (_, s, l) => s + l.toUpperCase());
+}
+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_utils10 = 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_utils12.nuke)(this);
+  }
+  onDestroy() {
+  }
+};
+
+// src/ts/plugs/base/index.ts
+var import_utils15 = 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_utils14 = 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_utils14.setPath)(CONFIG_BUILD, Plug.fullName, Plug.BUILD);
+  }
+  static unregister(fullName, editBuild = true) {
+    this.instance.unregister(fullName);
+    editBuild && (0, import_utils14.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_utils14.setPath)(CONFIG_BUILD, Pin.Plug.fullName + "." + Pin.pinName, Pin.BUILD);
+  }
+  static unregister(fullName, editBuild = true) {
+    this.instance.unregister(fullName);
+    editBuild && (0, import_utils14.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_utils15.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_utils15.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");
+
+// src/ts/plugs/base/slider.ts
+var import_modules = require("sia-reactor/modules");
+var BaseSliderPlug = class extends BasePlug {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "shouldToggle", false);
+    __publicField(this, "sliderAptValue", 100);
+    __publicField(this, "shouldSetAptValue", false);
+    __publicField(this, "nextToggle", null);
+    __publicField(this, "nextLevel", null);
+  }
+  // ABSTRACT HOOKS: The Child classes will define these to route the math to the right place
+  get prefix() {
+    return this.name;
+  }
+  // e.g., "muted" or "dark"
+  // --- 1. Shared CSS Boost & Limits Math ---
+  handleMin(min) {
+    if (this.media.state[this.prefix] < min) this.media.intent[this.prefix] = min;
+    if (this.state.aptValue < min) this.state.aptValue = min;
+  }
+  handleMax(max) {
+    if (this.media.state[this.prefix] > max) this.media.intent[this.prefix] = max;
+    if (this.state.aptValue > max) this.state.aptValue = max;
+    this.media.container.classList.toggle(`tmg-media-${this.prefix}-boost`, max > 100);
+    this.settings.css[`${this.prefix}SliderPercent`] = Math.round(100 / max * 100);
+    this.settings.css[`max${capitalize(this.prefix)}Ratio`] = max / 100;
+  }
+  handleSliderState(value) {
+    const strLevel = value === 0 ? this.toggleKey : value < 50 ? "low" : value <= 100 ? "high" : "boost", percent = (value - 0) / (this.config.max - 0);
+    this.media.container.dataset[`${this.prefix}Level`] = strLevel;
+    const CSS = this.settings.css, capped = capitalize(this.prefix);
+    if (this.config.max > 100) if (value <= 100) {
+      CSS[`current${capped}SliderPosition`] = value / 100;
+      CSS[`current${capped}SliderBoostPosition`] = CSS[`${this.prefix}SliderBoostPercent`] = 0;
+    } else {
+      CSS[`current${capped}SliderPosition`] = 1;
+      CSS[`current${capped}SliderBoostPosition`] = (value - 100) / (this.config.max - 100);
+      CSS[`${this.prefix}SliderBoostPercent`] = CSS[`${this.prefix}SliderPercent`];
+    }
+    else CSS[`current${capped}SliderPosition`] = percent;
+  }
+  // --- 2. The "Sticky Note" Architecture ---
+  setValueState(value, isNext = this.nextLevel === value) {
+    if (!isNext && value > 0) (0, import_modules.silence)(() => this.media.intent[this.toggleKey] = this.nextToggle = false);
+  }
+  setToggleState(toggled, isNext = this.nextToggle === toggled) {
+    if (toggled) {
+      if (this.media.state[this.prefix]) this.state.aptValue = this.media.state[this.prefix], this.shouldSetAptValue = true;
+      this.shouldToggle = true;
+      if (!isNext && this.media.state[this.prefix]) (0, import_modules.silence)(() => this.media.intent[this.prefix] = this.nextLevel = 0);
+    } else {
+      const restore = this.shouldSetAptValue ? this.state.aptValue : this.media.state[this.prefix];
+      if (!isNext) (0, import_modules.silence)(() => this.media.intent[this.prefix] = this.nextLevel = restore ? restore : this.sliderAptValue);
+      this.shouldToggle = this.shouldSetAptValue = false;
+    }
+  }
+  // --- 3. The Slider UI Input ---
+  handleSliderInput(value) {
+    this.shouldToggle = this.shouldSetAptValue = false;
+    this.media.intent[this.prefix] = value;
+    if (value > 5) this.sliderAptValue = value;
+  }
+  toggle(option) {
+    if (option === "auto" && this.shouldSetAptValue && !this.state.aptValue) this.state.aptValue = this.config.skip;
+    this.media.intent[this.toggleKey] = !(this.media.state[this.toggleKey] || !this.media.state[this.prefix]);
+  }
+  // --- 4. The Mathematical Grid Snapping ---
+  changeAptValue(value) {
+    const sign = value >= 0 ? "+" : "-";
+    value = Math.abs(value);
+    let level = Math.round(this.shouldSetAptValue ? this.state.aptValue : this.media.state[this.prefix]);
+    if (sign === "-") {
+      if (level > this.config.min) level -= level % value || value;
+      this.media.features[this.prefix] && this.ctlr.plug("settings.notifiers")?.notify(level === 0 ? `${this.prefix}${this.toggleKey}` : `${this.prefix}down`);
+    } else {
+      if (level < this.config.max) level += level % value ? value - level % value : value;
+      this.media.features[this.prefix] && this.ctlr.plug("settings.notifiers")?.notify(`${this.prefix}up`);
+    }
+    this.shouldSetAptValue ? this.state.aptValue = level : this.media.intent[this.prefix] = level;
+  }
+};
+
+// src/ts/plugs/settings/volume/build.ts
+var VOLUME_BUILD = {
+  min: 0,
+  max: 300,
+  skip: 5
+};
+
+// src/ts/plugs/settings/volume/index.ts
+var import_sia_reactor6 = require("sia-reactor");
+
+// src/ts/utils/dom.ts
+var import_sia_reactor5 = require("sia-reactor");
+var win = "undefined" !== typeof window ? window : void 0;
+var queryFullscreen = () => Boolean(queryFullscreenEl());
+var queryFullscreenEl = (d = document) => d.fullscreenElement || d.webkitFullscreenElement || d.mozFullScreenElement || d.msFullscreenElement || null;
+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/tools/runtime.ts
+var win2 = "undefined" !== typeof window ? window : void 0;
+var AUDIO_CONTEXT = null;
+var AUDIO_LIMITER = 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: win2?.innerWidth, height: win2?.innerHeight } }, screenOrientation: { type: win2?.screen?.orientation?.type ?? "", angle: win2?.screen?.orientation?.angle ?? win2?.orientation ?? 0 }, docVisibilityState: win2?.document.visibilityState, docInFullscreen: queryFullscreen() };
+function connectMediaToAudioManager(medium) {
+  if (!AUDIO_CONTEXT) return "unavailable";
+  medium.mediaElementSourceNode ?? (medium.mediaElementSourceNode = AUDIO_CONTEXT.createMediaElementSource(medium));
+  medium._tmgGainNode ?? (medium._tmgGainNode = AUDIO_CONTEXT.createGain());
+  medium._tmgDynamicsCompressorNode ?? (medium._tmgDynamicsCompressorNode = AUDIO_CONTEXT.createDynamicsCompressor());
+  medium.mediaElementSourceNode.connect(medium._tmgDynamicsCompressorNode);
+  medium._tmgDynamicsCompressorNode.connect(medium._tmgGainNode);
+  medium._tmgGainNode.connect(AUDIO_LIMITER);
+  AUDIO_LIMITER.connect(AUDIO_CONTEXT.destination);
+}
+
+// src/ts/plugs/settings/volume/index.ts
+var VolumePlug = class extends BaseSliderPlug {
+  constructor(ctlr, config = ctlr.settings.volume) {
+    super(ctlr, config, { aptValue: 0 });
+    __publicField(this, "shadowVolume");
+    __publicField(this, "audioSetup", false);
+    __publicField(this, "gainNode");
+    __publicField(this, "handleKeyMute", () => {
+      this.toggle("auto");
+      this.media.features.volume && this.media.wonce("state.volume", (v) => this.ctlr.plug("settings.notifiers")?.notify(!v ? "volumemuted" : "volumeup"), { signal: this.signal });
+    });
+    __publicField(this, "handleKeyVolumeUp", () => {
+      this.changeAptValue(this.ctlr.plug("settings.keys")?.getModded("volume", "", this.config.skip) ?? this.config.skip);
+    });
+    __publicField(this, "handleKeyVolumeDown", () => {
+      this.changeAptValue(-(this.ctlr.plug("settings.keys")?.getModded("volume", "", this.config.skip) ?? this.config.skip));
+    });
+    __publicField(this, "handleNativeVolumeChange", () => {
+      this.media.element.volume = 1, this.ctlr.isNativeEl && this.media.state.muted !== this.media.element.muted && this.toggle();
+    });
+    this.sliderAptValue = 5;
+  }
+  get ctime() {
+    return AUDIO_CONTEXT?.currentTime ?? 0;
+  }
+  get toggleKey() {
+    return "muted";
+  }
+  mount() {
+    this.ctlr.state.audioContextReady ? this.connectAudio() : this.ctlr.state.once("audioContextReady", this.connectAudio, { signal: this.signal });
+  }
+  wire() {
+    const volume = this.media.intent.volume ?? this.media.state.volume;
+    this.state.aptValue = (0, import_utils4.clamp)(this.config.min, volume, this.config.max);
+    this.shouldToggle = this.shouldSetAptValue = this.media.state.muted ?? false;
+    this.media.intent.volume = this.shouldToggle ? 0 : this.state.aptValue;
+    this.media.element.addEventListener("volumechange", this.handleNativeVolumeChange, { capture: true, signal: this.signal }), this.handleNativeVolumeChange();
+    this.media.set("intent.volume", (v) => (0, import_utils4.clamp)(this.shouldToggle ? 0 : this.config.min, v, this.config.max), { signal: this.signal });
+    this.media.set("state.volume", (v) => this.ctlr.isNativeEl && v !== this.shadowVolume ? import_sia_reactor6.TERMINATOR : v, { signal: this.signal });
+    this.media.watch("tech", () => {
+      var _a, _b, _c;
+      return (_a = this.media.features).volume || (_a.volume = this.ctlr.isNativeEl), (_b = this.media.features).muted || (_b.muted = this.ctlr.isNativeEl), (_c = this.media.features).volumeBoost || (_c.volumeBoost = this.ctlr.isNativeEl);
+    }, { init: true, signal: this.signal });
+    this.media.on("intent.volume", this.handleVolumeIntent, { capture: true, init: this.ctlr.payload.wired, initType: "set", signal: this.signal });
+    this.media.on("intent.muted", this.handleMutedIntent, { capture: true, init: this.ctlr.payload.wired, initType: "set", signal: this.signal });
+    this.media.on("state.volume", (e) => this.handleSliderState(e.value), { init: this.ctlr.payload.wired, signal: this.signal });
+    this.ctlr.config.on("settings.volume.min", (e) => this.handleMin(e.value), { init: true, signal: this.signal });
+    this.ctlr.config.on("settings.volume.max", (e) => this.handleMax(e.value), { init: true, signal: this.signal });
+    this.ctlr.registerAction("mute", { fn: this.handleKeyMute, keyboard: { phase: "keyup" } });
+    this.ctlr.registerAction("volumeUp", { fn: this.handleKeyVolumeUp, keyboard: { phase: "keydown" } });
+    this.ctlr.registerAction("volumeDown", { fn: this.handleKeyVolumeDown, keyboard: { phase: "keydown" } });
+    super.wire();
+  }
+  handleVolumeIntent(e, isNext = this.nextLevel === e.value) {
+    if (e.resolved) return;
+    if (isNext) this.nextLevel = null;
+    this.setValueState(e.value, isNext);
+    this.ctlr.isNativeEl && this.gainNode?.gain.setTargetAtTime(e.value / 100 * 2, this.ctime, 0.05);
+    if (!isNext && e.value > 0) this.media.settings.defaultMuted = false;
+    if (this.ctlr.isNativeEl) this.media.state.volume = this.shadowVolume = e.value;
+  }
+  handleMutedIntent(e, isNext = this.nextToggle === e.value) {
+    if (e.resolved) return;
+    if (isNext) this.nextToggle = null;
+    else if (this.media.state.muted === e.value && !!this.media.state.volume) return e.resolve(this.name);
+    this.setToggleState(e.value, isNext);
+    this.media.state.muted = e.value;
+  }
+  connectAudio() {
+    if (this.audioSetup || connectMediaToAudioManager(this.media.element) === "unavailable") return;
+    this.gainNode = this.media.element._tmgGainNode;
+    const DCN = this.media.element._tmgDynamicsCompressorNode;
+    if (DCN) DCN.threshold.value = -30, DCN.knee.value = 20, DCN.ratio.value = 12, DCN.attack.value = 3e-3, DCN.release.value = 0.25;
+    this.audioSetup = true;
+    if (this.ctlr.isNativeEl) this.gainNode?.gain.setTargetAtTime(this.media.state.volume / 100 * 2, this.ctime, 0.05);
+  }
+  disconnectAudio() {
+    this.media.element.volume = (0, import_utils4.clamp)(0, (this.gainNode?.gain?.value ?? 2) / 2 * 100, 1);
+    this.media.element.mediaElementSourceNode?.disconnect(), this.gainNode?.disconnect();
+    this.audioSetup = false;
+  }
+  onDestroy() {
+    this.disconnectAudio(), super.onDestroy();
+  }
+};
+__publicField(VolumePlug, "plugName", "volume");
+__publicField(VolumePlug, "BUILD", VOLUME_BUILD);
+//# sourceMappingURL=index.cjs.map