Toggle search
Toggle menu
115
248
25
2.7K
SpiritVale Wiki
Toggle preferences menu
Toggle personal menu
Not logged in
Your IP address will be publicly visible if you make any edits.

Join the Playtest on Steam Now: SpiritVale

MediaWiki:Common.js: Difference between revisions

MediaWiki interface page
More actions
← Older edit
No edit summary
No edit summary
Tags: Mobile edit Mobile web edit
 
(19 intermediate revisions by the same user not shown)
Line 1: Line 1:
/* Common.js — Spirit Vale Wiki
/* Common.js — Spirit Vale Wiki
   Standalone Module: Definitions (v1)
   Phase 4.1 — Core client scripts
  - Event-delegated tooltips for .sv-def
  - Desktop: hover + follow cursor
  - Mobile/touch: tap to pin near tap point
  - Blank definitions do nothing (and will close any open tooltip)
  - Future-ready: data-sv-def-link navigation support


   Markup contract (produced by Module:Definitions / Template:def):
   Included (standalone modules):
    <span class="sv-def"
  1) Level Selector / Descriptions (data-series)
          data-sv-def-domain="Stat"
  2) Universal Popups (tips, discloses, definitions)
          data-sv-def-key="Vit"
  3) Tabs
          data-sv-def-tip="Tooltip text (optional)"
          data-sv-def-link="Page Title (optional)">
      ...
    </span>
*/
*/


(function () {
(function () {
   // Namespace + per-module guard (no “41”).
   /* ================================================================== */
  /* MODULE: Level Selector / Descriptions (data-series)                */
  /* ================================================================== */
 
  var SV = (window.SV = window.SV || {});
  var COMMON = (SV.common = SV.common || {});
 
  // Versioned init guard (allows safe updates without stale blocks)
  var LEVELS_VERSION = 6; // neutral hooks + bubble styling owned by CSS + no tick/check row
 
  if (typeof COMMON.levelsInit === "number" && COMMON.levelsInit >= LEVELS_VERSION) return;
  COMMON.levelsInit = LEVELS_VERSION;
 
  // Prefer neutral shared hooks; keep legacy class fallbacks for compatibility.
  var CARD_SEL =
    "[data-sv-card='1'], .sv-gi-card, .sv-skill-card, .sv-passive-card";
 
  // Accept the native range input and the custom slider variants.
  var LEVEL_RANGE_SEL =
    "input.sv-level-range[type='range'], .sv-level-range--custom, .sv-level-range[data-sv-slider='1']";
 
  var LEVEL_BOUNDARY_SEL =
    "[data-sv-level-boundary='1'], .sv-skill-level, .sv-gi-level";
 
  var LEVEL_SCOPE_SEL =
    "[data-sv-level-scope='1'], .sv-gi-bottom, .sv-skill-bottom";
 
  var SERIES_SEL = "[data-series]";
  var LEVEL_INIT_ATTR = "data-sv-level-init";
 
  var _seriesCache = typeof WeakMap !== "undefined" ? new WeakMap() : null;
  var _drag = null;
 
  function clampInt(value, min, max, fallback) {
    var n = parseInt(value, 10);
    if (isNaN(n)) n = fallback != null ? fallback : min;
    if (n < min) return min;
    if (n > max) return max;
    return n;
  }
 
  function closest(el, sel) {
    if (!el || el.nodeType !== 1) return null;
    if (el.closest) return el.closest(sel);
    while (el && el.nodeType === 1) {
      if (el.matches && el.matches(sel)) return el;
      el = el.parentElement;
    }
    return null;
  }
 
  function parseSeries(el) {
    if (!el) return null;
 
    if (_seriesCache) {
      if (_seriesCache.has(el)) return _seriesCache.get(el);
    } else if (el._svSeries !== undefined) {
      return el._svSeries;
    }
 
    var raw = el.getAttribute("data-series");
    var parsed = null;
 
    if (raw != null && raw !== "") {
      try {
        parsed = JSON.parse(raw);
        if (!Array.isArray(parsed)) parsed = null;
      } catch (e) {
        parsed = null;
      }
    }
 
    if (_seriesCache) _seriesCache.set(el, parsed);
    else el._svSeries = parsed;
 
    return parsed;
  }
 
  function isAfter(boundaryNode, el) {
    if (!boundaryNode || !el) return true;
    if (boundaryNode === el) return false;
    if (!boundaryNode.compareDocumentPosition) return true;
    return (boundaryNode.compareDocumentPosition(el) & 4) !== 0;
  }
 
  function isRangeInput(el) {
    return !!(el && el.tagName === "INPUT" && el.type === "range");
  }
 
  function isCustomSlider(el) {
    if (!el || !el.getAttribute) return false;
    if (el.getAttribute("data-sv-slider") === "1") return true;
    return !!(el.classList && el.classList.contains("sv-level-range--custom"));
  }
 
  function parseMaxFromUi(card) {
    var ui = card && card.querySelector ? card.querySelector(".sv-level-ui") : null;
    if (!ui) return null;
    var m = String(ui.textContent || "").match(/\/\s*(\d+)/);
    return m ? m[1] : null;
  }
 
  function getCardMaxLevel(card) {
    var raw =
      card.getAttribute("data-max-level") ||
      card.getAttribute("data-maxLevel") ||
      card.getAttribute("data-max") ||
      card.getAttribute("data-level-max") ||
      parseMaxFromUi(card);
 
    return clampInt(raw, 1, 999, 1);
  }
 
  function getCardMinLevel(card, slider, maxLevel) {
    // Prefer explicit neutral hooks, then legacy attrs, then slider attrs.
    var raw =
      card.getAttribute("data-min-level") ||
      card.getAttribute("data-minLevel") ||
      card.getAttribute("data-level-min");
 
    if (raw == null || raw === "") {
      if (slider) {
        if (isRangeInput(slider)) raw = slider.getAttribute("min");
        else if (isCustomSlider(slider))
          raw = slider.getAttribute("aria-valuemin") || slider.getAttribute("data-min");
      }
    }
 
    var min = clampInt(raw, 1, maxLevel, 1);
    if (min > maxLevel) min = maxLevel;
    return min;
  }
 
  function getCardLevel(card, minLevel, maxLevel) {
    var raw =
      card.getAttribute("data-level") ||
      card.getAttribute("data-gi-level") ||
      (card.querySelector && card.querySelector(".sv-level-num")
        ? card.querySelector(".sv-level-num").textContent
        : null);
 
    return clampInt(raw, minLevel, maxLevel, minLevel);
  }
 
  function getStep(slider) {
    // Default = 1. Support future: data-step, or <input step="">
    var raw = null;
    if (slider) raw = slider.getAttribute("data-step") || slider.getAttribute("step");
    var s = parseInt(raw, 10);
    if (!s || isNaN(s) || s < 1) s = 1;
    return s;
  }
 
  function getLevelSlider(card) {
    return card.querySelector(LEVEL_RANGE_SEL);
  }
 
  function getLevelBoundary(slider) {
    if (!slider) return null;
    return closest(slider, LEVEL_BOUNDARY_SEL) || slider;
  }
 
  function getLevelScopeContainer(card, boundary) {
    var scope = card.querySelector(LEVEL_SCOPE_SEL) || card;
    if (boundary && scope !== card && !scope.contains(boundary)) return card;
    return scope;
  }
 
  function setLevelNumber(card, level) {
    var span = card.querySelector(".sv-level-num");
    if (span) span.textContent = String(level);
  }
 
  function setLevelMax(card, maxLevel) {
    var span = card.querySelector(".sv-level-max");
    if (span) span.textContent = String(maxLevel);
  }
 
  function applySeriesToScope(scope, boundary, level) {
    if (!scope) return;
 
    // JS arrays are 0-based; Lua uses 1-based "level".
    var index = level - 1;
    var nodes = scope.querySelectorAll(SERIES_SEL);
 
    for (var i = 0; i < nodes.length; i++) {
      var el = nodes[i];
      if (boundary && !isAfter(boundary, el)) continue;
 
      var series = parseSeries(el);
      if (!series || series.length === 0) continue;
 
      var safeIndex = index;
      if (safeIndex >= series.length) safeIndex = series.length - 1;
      if (safeIndex < 0) safeIndex = 0;
 
      var value = series[safeIndex];
      if (value == null) value = "";
 
      el.textContent = String(value);
    }
  }
 
  function unhide(el) {
    if (!el) return;
    if (el.classList) el.classList.remove("sv-hidden");
    if (el.removeAttribute) el.removeAttribute("hidden");
    if (el.style && el.style.display === "none") el.style.display = "";
  }
 
  function hide(el) {
    if (!el) return;
    if (el.classList) el.classList.add("sv-hidden");
    if (el.setAttribute) el.setAttribute("hidden", "hidden");
  }
 
  /* ================================================================== */
  /* Custom slider helpers (bounds/percent)                              */
  /* ================================================================== */
 
  function getCustomMin(slider, fallback) {
    return clampInt(
      slider.getAttribute("aria-valuemin") || slider.getAttribute("data-min"),
      1,
      999,
      fallback != null ? fallback : 1
    );
  }
 
  function getCustomMax(slider, fallback) {
    return clampInt(
      slider.getAttribute("aria-valuemax") || slider.getAttribute("data-max"),
      1,
      999,
      fallback != null ? fallback : 1
    );
  }
 
  function getCustomBounds(slider, fallbackMin) {
    var min = getCustomMin(slider, fallbackMin != null ? fallbackMin : 1);
    var max = getCustomMax(slider, min);
    if (max < min) max = min;
    return { min: min, max: max };
  }
 
  function getCustomValue(slider, min, max, fallback) {
    return clampInt(
      slider.getAttribute("aria-valuenow") || slider.getAttribute("data-value"),
      min,
      max,
      fallback != null ? fallback : min
    );
  }
 
  function pctFromValue(min, max, value) {
    if (max === min) return 0;
    var pct = (value - min) / (max - min);
    if (pct < 0) pct = 0;
    if (pct > 1) pct = 1;
    return pct;
  }
 
  function setCustomBounds(slider, min, max) {
    slider.setAttribute("aria-valuemin", String(min));
    slider.setAttribute("aria-valuemax", String(max));
    slider.setAttribute("data-min", String(min));
    slider.setAttribute("data-max", String(max));
  }
 
  /* ================================================================== */
  /* Custom slider value bubble                                          */
  /* - JS owns structure + text/position only                            */
  /* - CSS owns visuals                                                  */
  /* ================================================================== */
 
  function ensureValueLabel(slider) {
    if (!slider || !slider.querySelector || !isCustomSlider(slider)) return null;
 
    var bubble = slider.querySelector(".sv-level-bubble");
    if (bubble) return bubble;
 
    bubble = document.createElement("span");
    bubble.className = "sv-level-bubble sv-hidden";
    bubble.setAttribute("hidden", "hidden");
    bubble.setAttribute("aria-hidden", "true");
 
    slider.appendChild(bubble);
    return bubble;
  }
 
  function setValueLabel(slider, value) {
    var bubble = ensureValueLabel(slider);
    if (!bubble) return;
 
    var b = getCustomBounds(slider, 1);
    bubble.textContent = String(value);
    bubble.style.left = pctFromValue(b.min, b.max, value) * 100 + "%";
  }
 
  function showValueLabel(slider) {
    if (!slider) return;
    var bubble = ensureValueLabel(slider);
    if (!bubble) return;
 
    if (slider._svBubbleTimer) {
      clearTimeout(slider._svBubbleTimer);
      slider._svBubbleTimer = null;
    }
 
    unhide(bubble);
  }
 
  function hideValueLabelSoon(slider, delayMs) {
    if (!slider) return;
    var bubble = slider.querySelector ? slider.querySelector(".sv-level-bubble") : null;
    if (!bubble) return;
 
    if (slider._svBubbleTimer) clearTimeout(slider._svBubbleTimer);
    slider._svBubbleTimer = setTimeout(function () {
      hide(bubble);
      slider._svBubbleTimer = null;
    }, delayMs != null ? delayMs : 450);
  }
 
  function updateCustomVisual(slider, value) {
    var b = getCustomBounds(slider, 1);
    var left = pctFromValue(b.min, b.max, value) * 100;
 
    var thumb = slider.querySelector(".sv-level-thumb");
    var fill = slider.querySelector(".sv-level-fill");
 
    if (thumb && thumb.style) thumb.style.left = left + "%";
    if (fill && fill.style) fill.style.width = left + "%";
 
    setValueLabel(slider, value);
  }
 
  function setCustomValue(slider, value, min, max) {
    slider.setAttribute("aria-valuenow", String(value));
    slider.setAttribute("data-value", String(value));
 
    // Helpful SR text (doesn't affect visuals)
    slider.setAttribute("aria-valuetext", "Level " + String(value) + " of " + String(max));
 
    updateCustomVisual(slider, value);
  }
 
  function snapToStep(raw, min, max, step) {
    if (step < 1) step = 1;
    var x = raw;
    if (x < min) x = min;
    if (x > max) x = max;
 
    var snapped = min + Math.round((x - min) / step) * step;
    if (snapped < min) snapped = min;
    if (snapped > max) snapped = max;
    return snapped;
  }
 
  function valueFromClientX(slider, clientX) {
    var rect = slider.getBoundingClientRect();
    var b = getCustomBounds(slider, 1);
 
    var w = rect.width || 1;
    var x = (clientX - rect.left) / w;
    if (x < 0) x = 0;
    if (x > 1) x = 1;
 
    var raw = b.min + x * (b.max - b.min);
    return snapToStep(raw, b.min, b.max, getStep(slider));
  }
 
  /* ================================================================== */
  /* End-of-bar value label (right-side value)                          */
  /* ================================================================== */
 
  function ensureEndValueLabel(card, slider) {
    var wrap = null;
    if (slider) wrap = closest(slider, ".sv-level-slider");
    if (!wrap && card && card.querySelector) wrap = card.querySelector(".sv-level-slider");
    if (!wrap) return null;
 
    var out = wrap.querySelector(".sv-level-endvalue");
    if (out) return out;
 
    out = document.createElement("span");
    out.className = "sv-level-endvalue";
    out.setAttribute("aria-hidden", "true"); // slider already exposes aria-valuetext
    wrap.appendChild(out);
    return out;
  }
 
  function setEndValueLabel(card, slider, value) {
    var out = ensureEndValueLabel(card, slider);
    if (out) out.textContent = String(value);
  }
 
  /* ================================================================== */
  /* Core apply / init                                                    */
  /* ================================================================== */
 
  function scheduleApply(card, rawLevel) {
    if (!card) return;
 
    card._svLevelNext = rawLevel;
    if (card._svLevelRaf) return;
 
    if (window.requestAnimationFrame) {
      card._svLevelRaf = requestAnimationFrame(function () {
        card._svLevelRaf = null;
        var v = card._svLevelNext;
        card._svLevelNext = null;
        applyLevelToCard(card, v);
      });
      return;
    }
 
    card._svLevelRaf = setTimeout(function () {
      card._svLevelRaf = null;
      var v = card._svLevelNext;
      card._svLevelNext = null;
      applyLevelToCard(card, v);
    }, 0);
  }
 
  function applyLevelToCard(card, rawLevel) {
    if (!card) return;
 
    var maxLevel = getCardMaxLevel(card);
    var slider = getLevelSlider(card);
    var minLevel = getCardMinLevel(card, slider, maxLevel);
 
    var level = clampInt(rawLevel, minLevel, maxLevel, getCardLevel(card, minLevel, maxLevel));
 
    card.setAttribute("data-level", String(level));
    setLevelNumber(card, level);
    setLevelMax(card, maxLevel);
 
    if (slider) {
      unhide(slider);
      var wrap = closest(slider, ".sv-level-slider");
      if (wrap) unhide(wrap);
    }
 
    if (slider) {
      if (isRangeInput(slider)) {
        slider.setAttribute("min", String(minLevel));
        slider.setAttribute("max", String(maxLevel));
        slider.setAttribute("step", String(getStep(slider)));
        slider.setAttribute("aria-valuetext", "Level " + String(level) + " of " + String(maxLevel));
        if (String(slider.value) !== String(level)) slider.value = String(level);
      } else if (isCustomSlider(slider)) {
        setCustomBounds(slider, minLevel, maxLevel);
        setCustomValue(slider, level, minLevel, maxLevel);
      }
    }
 
    setEndValueLabel(card, slider, level);
 
    var boundary = getLevelBoundary(slider);
    var scope = getLevelScopeContainer(card, boundary);
    applySeriesToScope(scope, boundary, level);
  }
 
  function initLevels(root) {
    var container = root || document;
    var cards = container.querySelectorAll(CARD_SEL);
 
    for (var i = 0; i < cards.length; i++) {
      var card = cards[i];
 
      var stamped = clampInt(card.getAttribute(LEVEL_INIT_ATTR), 0, 999, 0);
      if (stamped >= LEVELS_VERSION) continue;
 
      var maxLevel = getCardMaxLevel(card);
      var slider = getLevelSlider(card);
      var minLevel = getCardMinLevel(card, slider, maxLevel);
 
      var start = getCardLevel(card, minLevel, maxLevel);
 
      if (slider && maxLevel > minLevel) {
        if (isRangeInput(slider)) start = clampInt(slider.value, minLevel, maxLevel, start);
        else if (isCustomSlider(slider)) start = getCustomValue(slider, minLevel, maxLevel, start);
      }
 
      applyLevelToCard(card, start);
      card.setAttribute(LEVEL_INIT_ATTR, String(LEVELS_VERSION));
    }
  }
 
  /* ================================================================== */
  /* Events                                                              */
  /* ================================================================== */
 
  // Native range inputs
  document.addEventListener(
    "input",
    function (e) {
      var t = e.target;
      if (!t || t.nodeType !== 1) return;
      if (!t.matches || !t.matches("input.sv-level-range[type='range']")) return;
 
      var card = closest(t, CARD_SEL);
      if (!card) return;
 
      scheduleApply(card, t.value);
    },
    true
  );
 
  // Custom slider pointer interaction (click anywhere + drag)
  document.addEventListener(
    "pointerdown",
    function (e) {
      if (e.button != null && e.button !== 0) return; // primary only
 
      var slider =
        e.target && e.target.closest
          ? e.target.closest(".sv-level-range--custom, .sv-level-range[data-sv-slider='1']")
          : null;
      if (!slider) return;
 
      var card = closest(slider, CARD_SEL);
      if (!card) return;
 
      e.preventDefault();
      if (slider.focus) slider.focus();
 
      _drag = { slider: slider, card: card, pointerId: e.pointerId };
 
      if (slider.setPointerCapture) {
        try {
          slider.setPointerCapture(e.pointerId);
        } catch (err) {}
      }
 
      showValueLabel(slider);
      scheduleApply(card, valueFromClientX(slider, e.clientX));
    },
    true
  );
 
  document.addEventListener(
    "pointermove",
    function (e) {
      if (!_drag) return;
      if (e.pointerId !== _drag.pointerId) return;
      e.preventDefault();
 
      showValueLabel(_drag.slider);
      scheduleApply(_drag.card, valueFromClientX(_drag.slider, e.clientX));
    },
    true
  );
 
  function endDrag(e) {
    if (!_drag) return;
    if (e && e.pointerId != null && e.pointerId !== _drag.pointerId) return;
 
    if (_drag.slider && _drag.slider.releasePointerCapture) {
      try {
        _drag.slider.releasePointerCapture(_drag.pointerId);
      } catch (err) {}
    }
 
    hideValueLabelSoon(_drag.slider, 650);
    _drag = null;
  }
 
  document.addEventListener("pointerup", endDrag, true);
  document.addEventListener("pointercancel", endDrag, true);
 
  // Mouse-only slider interaction:
  // - Remove keyboard-driven adjustments on custom sliders
  // - Block native <input type="range"> from changing via keyboard (if present)
  var _SV_BLOCK_KEYS = {
    ArrowLeft: 1,
    ArrowRight: 1,
    ArrowUp: 1,
    ArrowDown: 1,
    Left: 1,
    Right: 1,
    Up: 1,
    Down: 1,
    Home: 1,
    End: 1,
    PageUp: 1,
    PageDown: 1
  };
 
  document.addEventListener(
    "keydown",
    function (e) {
      var key = e && e.key;
      if (!_SV_BLOCK_KEYS[key]) return;
 
      var el = document.activeElement;
      if (!el) return;
 
      // Native range inputs (keep mouse drag, disable keyboard nudges)
      if (isRangeInput(el) && el.classList && el.classList.contains("sv-level-range")) {
        e.preventDefault();
        return;
      }
 
      // Custom sliders (we keep focus behaviors, but no keyboard changes)
      var slider = closest(el, ".sv-level-range--custom, .sv-level-range[data-sv-slider='1']");
      if (slider) {
        e.preventDefault();
        return;
      }
    },
    true
  );
 
  // Show bubble on focus (discoverability), hide on blur
  document.addEventListener(
    "focusin",
    function () {
      var el = document.activeElement;
      if (!el || !el.closest) return;
      var slider = el.closest(".sv-level-range--custom, .sv-level-range[data-sv-slider='1']");
      if (!slider) return;
 
      var b = getCustomBounds(slider, 1);
      var v = getCustomValue(slider, b.min, b.max, b.min);
 
      setValueLabel(slider, v);
      showValueLabel(slider);
    },
    true
  );
 
  document.addEventListener(
    "focusout",
    function (e) {
      var t = e.target;
      if (!t || !t.closest) return;
      var slider = t.closest(".sv-level-range--custom, .sv-level-range[data-sv-slider='1']");
      if (!slider) return;
 
      hideValueLabelSoon(slider, 300);
    },
    true
  );
 
  function initAllLevels(root) {
    initLevels(root);
  }
 
  COMMON.initAllLevels = initAllLevels;
 
  if (window.mw && mw.hook) {
    mw.hook("wikipage.content").add(function ($content) {
      initAllLevels($content && $content[0]);
    });
  }
 
  if (document.readyState === "loading") {
    document.addEventListener("DOMContentLoaded", function () {
      initAllLevels(document);
    });
  } else {
    initAllLevels(document);
  }
})();
 
(function () {
  /* ================================================================== */
  /* MODULE: Universal Popups                                            */
  /* ================================================================== */
 
   var SV = (window.SV = window.SV || {});
   var SV = (window.SV = window.SV || {});
   var COMMON = (SV.common = SV.common || {});
   var COMMON = (SV.common = SV.common || {});
  if (COMMON.definitionsInit) return;
  COMMON.definitionsInit = 1;


   /* ------------------------------------------------------------------ */
   // Bumped only because we changed positioning margins (safe cache-bust).
   /* Selectors / Attributes                                              */
   var UPOP_VERSION = 32; // Universal Popups v3.2
   /* ------------------------------------------------------------------ */
  if (typeof COMMON.universalPopupsInit === "number" && COMMON.universalPopupsInit >= UPOP_VERSION) return;
  COMMON.universalPopupsInit = UPOP_VERSION;
 
   try { document.documentElement.classList.add("sv-uipop-v3"); } catch (e) {}


   var DEF_SEL = ".sv-def";
   var DEF_SEL = ".sv-def";
   var TIP_ATTR = "data-sv-def-tip";
   var DEF_TIP_ATTR = "data-sv-def-tip";
   var LINK_ATTR = "data-sv-def-link";
   var DEF_LINK_ATTR = "data-sv-def-link";


   /* ------------------------------------------------------------------ */
   var TIP_BTN_SEL = ".sv-tip-btn[data-sv-toggle='1'], details.sv-tip > summary";
  /* Capability detection                                                */
  var DISCLOSE_BTN_SEL = ".sv-disclose-btn[data-sv-toggle='1'], details.sv-disclose > summary";
   /* ------------------------------------------------------------------ */
 
   var WRAP_SEL = ".sv-tip, .sv-disclose";
  var POP_SEL = ".sv-tip-pop, .sv-disclose-pop";


   var HOVER_CAPABLE = false;
   var HOVER_CAPABLE = false;
   try {
   try {
     HOVER_CAPABLE =
     HOVER_CAPABLE = !!window.matchMedia && window.matchMedia("(hover:hover) and (pointer:fine)").matches;
      !!window.matchMedia &&
   } catch (e) { HOVER_CAPABLE = false; }
      window.matchMedia("(hover:hover) and (pointer:fine)").matches;
   } catch (e) {
    HOVER_CAPABLE = false;
  }


  /* ------------------------------------------------------------------ */
   var popEl = null;
  /* State                                                              */
  /* ------------------------------------------------------------------ */
 
   var tipEl = null;


   var state = {
   var state = {
     visible: false,
     open: false,
     pinned: false,
     pinned: false,
     anchor: null, // current .sv-def element
     trigger: null,
     lastX: 0,
     hideTimer: 0,
     lastY: 0,
     anchorKind: "trigger", // trigger | finger | center
     suppressClickUntil: 0, // prevents synthetic click after touch pin
    anchorX: 0,
     anchorY: 0
   };
   };
  /* ------------------------------------------------------------------ */
  /* Utilities                                                          */
  /* ------------------------------------------------------------------ */


   function closest(el, sel) {
   function closest(el, sel) {
Line 74: Line 728:
   }
   }


   function getTipText(defEl) {
   function clamp(n, min, max) {
    if (n < min) return min;
    if (n > max) return max;
    return n;
  }
 
  function safeIdSelector(id) {
    return "#" + String(id).replace(/([ !"#$%&'()*+,.\/:;<=>?@[\\\]^`{|}~])/g, "\\$1");
  }
 
  function isInsidePopup(target) {
    return !!(popEl && (target === popEl || (popEl.contains && popEl.contains(target))));
  }
 
  function isSummaryTrigger(trigger) {
    return !!(trigger && trigger.tagName === "SUMMARY");
  }
 
  function ensurePopEl() {
    if (popEl) return popEl;
 
    var el = document.createElement("div");
    el.className = "sv-uipop sv-uipop--sm";
    el.setAttribute("role", "dialog");
    el.setAttribute("aria-hidden", "true");
    document.body.appendChild(el);
 
    el.addEventListener("mouseenter", function () {
      if (!HOVER_CAPABLE) return;
      if (!state.open || state.pinned) return;
      clearTimeout(state.hideTimer);
      state.hideTimer = 0;
    });
 
    el.addEventListener("mouseleave", function () {
      if (!HOVER_CAPABLE) return;
      if (!state.open || state.pinned) return;
      clearTimeout(state.hideTimer);
      state.hideTimer = setTimeout(function () {
        if (state.open && !state.pinned) hidePopup();
      }, 80);
    });
 
    popEl = el;
    return popEl;
  }
 
  function setHidden(el, hidden) {
    if (!el) return;
    el.setAttribute("aria-hidden", hidden ? "true" : "false");
  }
 
  function stripIds(root) {
    if (!root || root.nodeType !== 1) return;
    if (root.hasAttribute && root.hasAttribute("id")) root.removeAttribute("id");
    var nodes = root.querySelectorAll ? root.querySelectorAll("[id]") : [];
    for (var i = 0; i < nodes.length; i++) nodes[i].removeAttribute("id");
  }
 
  function unhideTree(root) {
    if (!root || root.nodeType !== 1) return;
 
    if (root.hasAttribute && root.hasAttribute("hidden")) root.removeAttribute("hidden");
    if (root.classList) root.classList.remove("sv-hidden");
    if (root.style && root.style.display === "none") root.style.display = "";
 
    var kids = root.children || [];
    for (var i = 0; i < kids.length; i++) unhideTree(kids[i]);
  }
 
  function isBlankContent(node) {
    if (!node) return true;
    var t = node.textContent;
    if (t == null) return true;
    var compact = String(t).replace(/\s+/g, "").replace(/[—–-]+/g, "").trim();
    return !compact;
  }
 
  function getDefTipText(defEl) {
     if (!defEl || !defEl.getAttribute) return "";
     if (!defEl || !defEl.getAttribute) return "";
     var t = defEl.getAttribute(TIP_ATTR);
     var t = defEl.getAttribute(DEF_TIP_ATTR);
     if (t == null) return "";
     if (t == null) return "";
    // Treat pure-whitespace as empty.
     t = String(t);
     t = String(t);
    t = t.replace(/\\r\\n/g, "\n").replace(/\\n/g, "\n").replace(/\\r/g, "\n");
     if (!t.replace(/\s+/g, "")) return "";
     if (!t.replace(/\s+/g, "")) return "";
     return t;
     return t;
   }
   }


   function getLinkTitle(defEl) {
   function getDefLinkTitle(defEl) {
     if (!defEl || !defEl.getAttribute) return "";
     if (!defEl || !defEl.getAttribute) return "";
     var t = defEl.getAttribute(LINK_ATTR);
     var t = defEl.getAttribute(DEF_LINK_ATTR);
     if (t == null) return "";
     if (t == null) return "";
     t = String(t).trim();
     return String(t).trim();
    return t;
   }
   }


   function ensureTipEl() {
   function getContentNodeFromTrigger(trigger) {
     if (tipEl) return tipEl;
     if (!trigger) return null;
 
    if (trigger.tagName === "SUMMARY") {
      var det = closest(trigger, "details.sv-tip, details.sv-disclose");
      if (!det) return null;
      var pop0 = det.querySelector(POP_SEL);
      if (!pop0) return null;
      return (
        pop0.querySelector(".sv-tip-pop-body") ||
        pop0.querySelector(".sv-disclose-pop-body") ||
        pop0.querySelector(".sv-disclose-list") ||
        pop0
      );
    }
 
    var id = trigger.getAttribute ? trigger.getAttribute("aria-controls") : "";
    if (id) {
      var wrap = closest(trigger, WRAP_SEL);
      if (wrap) {
        try {
          var local = wrap.querySelector(safeIdSelector(id));
          if (local) {
            return (
              local.querySelector(".sv-tip-pop-body") ||
              local.querySelector(".sv-disclose-pop-body") ||
              local.querySelector(".sv-disclose-list") ||
              local
            );
          }
        } catch (e) {}
      }


    var el = document.createElement("div");
      var global = document.getElementById(id);
    el.className = "sv-def-tip sv-hidden";
      if (global) {
    el.setAttribute("role", "tooltip");
        return (
    el.setAttribute("aria-hidden", "true");
          global.querySelector(".sv-tip-pop-body") ||
          global.querySelector(".sv-disclose-pop-body") ||
          global.querySelector(".sv-disclose-list") ||
          global
        );
      }
    }


     // Minimal inline safety styling (CSS can override via .sv-def-tip).
     var w = closest(trigger, WRAP_SEL);
     // This is intentionally conservative so it still works even if site CSS
     if (w) {
    // hasn’t loaded yet.
      var pop = w.querySelector(POP_SEL);
    el.style.position = "fixed";
      if (pop) {
    el.style.zIndex = "99999";
        return (
    el.style.maxWidth = "360px";
          pop.querySelector(".sv-tip-pop-body") ||
    el.style.boxSizing = "border-box";
          pop.querySelector(".sv-disclose-pop-body") ||
    el.style.padding = "8px 10px";
          pop.querySelector(".sv-disclose-list") ||
    el.style.borderRadius = "10px";
          pop
    el.style.background = "rgba(10, 14, 22, 0.92)";
        );
    el.style.color = "#fff";
      }
    el.style.fontSize = "14px";
     }
    el.style.lineHeight = "1.25";
    el.style.whiteSpace = "pre-line";
    el.style.pointerEvents = "none"; // enabled only when pinned
     el.style.display = "none";


    document.body.appendChild(el);
     return null;
    tipEl = el;
     return tipEl;
   }
   }


   function setHidden(el, hidden) {
   function guessTitle(trigger, sourceNode) {
     if (!el) return;
    var pop = null;
     if (hidden) {
     if (sourceNode && sourceNode.nodeType === 1) pop = closest(sourceNode, POP_SEL);
       el.classList.add("sv-hidden");
     if (pop) {
      el.setAttribute("aria-hidden", "true");
       var t = pop.querySelector(".sv-tip-pop-title") || pop.querySelector(".sv-disclose-pop-title");
       el.style.display = "none";
       if (t && t.textContent) return String(t.textContent).trim();
    } else {
      el.classList.remove("sv-hidden");
      el.setAttribute("aria-hidden", "false");
      el.style.display = "block";
     }
     }
    var aria = trigger && trigger.getAttribute ? trigger.getAttribute("aria-label") : "";
    if (aria) return String(aria).trim();
    var txt = trigger && trigger.textContent ? String(trigger.textContent).trim() : "";
    if (txt) return txt.replace(/\s+/g, " ").trim();
    return "Info";
  }
  function buildHeaderLink(linkTitle, displayText) {
    if (!linkTitle) return null;
    var a = document.createElement("a");
    a.className = "sv-uipop-title-link";
    a.textContent = displayText || String(linkTitle);
    if (window.mw && mw.util && typeof mw.util.getUrl === "function") a.href = mw.util.getUrl(linkTitle);
    else a.href = String(linkTitle);
    a.addEventListener("click", function (e) { e.stopPropagation(); });
    return a;
   }
   }


   function clamp(n, min, max) {
   function fireContentHook(el) {
     if (n < min) return min;
     if (!el) return;
     if (n > max) return max;
     if (window.mw && mw.hook && window.jQuery) {
     return n;
      try { mw.hook("wikipage.content").fire(window.jQuery(el)); } catch (e) {}
     }
   }
   }


   function positionTipAt(clientX, clientY) {
   function renderPopup(opts) {
     var el = ensureTipEl();
     var el = ensurePopEl();
     if (!el) return;
     if (!el) return;


     // First, ensure it’s measurable.
     el.classList.remove("sv-uipop--sm", "sv-uipop--lg");
     // (If we just turned it on, width/height might be 0 until next frame.)
    el.classList.add(opts.size === "lg" ? "sv-uipop--lg" : "sv-uipop--sm");
     var vw = window.innerWidth || document.documentElement.clientWidth || 0;
 
     var vh = window.innerHeight || document.documentElement.clientHeight || 0;
     while (el.firstChild) el.removeChild(el.firstChild);
 
    var head = document.createElement("div");
    head.className = "sv-uipop-head" + (opts.pinned ? " sv-uipop-head--clickable" : "");
 
     var title = document.createElement("div");
    title.className = "sv-uipop-title";
    if (opts.titleLink) title.appendChild(opts.titleLink);
    else title.textContent = opts.title || "Info";
 
    head.appendChild(title);
    el.appendChild(head);
 
    var body = document.createElement("div");
    body.className = "sv-uipop-body";
    if (opts.bodyPre) body.classList.add("sv-uipop-body--pre");
 
     if (opts.bodyNode) {
      var clone = opts.bodyNode.cloneNode(true);
      stripIds(clone);
      unhideTree(clone);
      body.appendChild(clone);
    } else if (opts.bodyText != null) {
      body.textContent = String(opts.bodyText);
    }
 
    el.appendChild(body);
 
    if (opts.pinned) {
      head.addEventListener(
        "click",
        function (e) {
          e.preventDefault();
          hidePopup();
        },
        { once: true }
      );
    }
 
    fireContentHook(el);
  }


    // Gap rules:
  function positionPopup(trigger) {
    // - hover: larger vertical gap so cursor doesn’t cover it
     var el = ensurePopEl();
    // - pinned: tighter but still separated from the tap point
     if (!el) return;
     var gapY = state.pinned ? 10 : 16;
     var gapX = 12;


    // Two-pass: set an initial position, then refine once we have rect.
     el.style.left = "0px";
     el.style.left = "0px";
     el.style.top = "0px";
     el.style.top = "0px";
    setHidden(el, false);


    // Defer measuring to allow layout to settle.
     requestAnimationFrame(function () {
     requestAnimationFrame(function () {
       if (!state.visible) return;
       if (!state.open) return;
 
      var vw = window.innerWidth || document.documentElement.clientWidth || 0;
      var vh = window.innerHeight || document.documentElement.clientHeight || 0;


       var r = el.getBoundingClientRect();
       var tight = vw <= 520;
       var w = r.width || 240;
       var margin = tight ? 18 : 10;
       var h = r.height || 60;
       var gap = tight ? 14 : 12;


       // Prefer above cursor/tap.
       var pr = el.getBoundingClientRect();
       var left = clientX - w / 2;
       var w = pr.width || 240;
       var top = clientY - h - gapY;
       var h = pr.height || 180;


       // Clamp horizontally.
       var left = margin;
       left = clamp(left, gapX, Math.max(gapX, vw - w - gapX));
       var top = margin;


       // If not enough space above, flip below.
       if (state.anchorKind === "center") {
      if (top < gapY) top = clientY + gapY;
        left = (vw - w) / 2;
        top = (vh - h) / 2;
      } else if (state.anchorKind === "finger") {
        left = (vw - w) / 2;
        var y = state.anchorY || vh / 2;
        top = y - h - gap;
        if (top < margin) top = y + gap;
      } else {
        if (!trigger || !trigger.getBoundingClientRect) return;
        var tr = trigger.getBoundingClientRect();
        var isIconish = (tr.width || 0) <= 40;
        left = isIconish ? tr.right - w : tr.left;
        top = tr.bottom + gap;
        left = clamp(left, margin, Math.max(margin, vw - w - margin));
        if (top + h + margin > vh) top = tr.top - h - gap;
      }


       // Clamp vertically.
       left = clamp(left, margin, Math.max(margin, vw - w - margin));
       top = clamp(top, gapY, Math.max(gapY, vh - h - gapY));
       top = clamp(top, margin, Math.max(margin, vh - h - margin));


       el.style.left = Math.round(left) + "px";
       el.style.left = Math.round(left) + "px";
Line 186: Line 1,022:
   }
   }


   function showTip(defEl, text, clientX, clientY, pinned) {
   function setExpanded(trigger, expanded) {
     var el = ensureTipEl();
     if (!trigger || !trigger.setAttribute) return;
     if (!el) return;
    trigger.setAttribute("aria-expanded", expanded ? "true" : "false");
  }
 
  function hidePopup() {
     if (!state.open) return;


     state.visible = true;
     clearTimeout(state.hideTimer);
    state.pinned = !!pinned;
     state.hideTimer = 0;
    state.anchor = defEl || null;
    state.lastX = clientX || 0;
     state.lastY = clientY || 0;


     // Text-only (safe).
     setExpanded(state.trigger, false);
    el.textContent = text;


     // Pointer events only when pinned (so pinned tooltip can be interacted with later if needed).
     state.open = false;
     el.style.pointerEvents = state.pinned ? "auto" : "none";
     state.pinned = false;
     el.classList.toggle("sv-def-tip--pinned", state.pinned);
    state.trigger = null;
     state.anchorKind = "trigger";


     setHidden(el, false);
     setHidden(ensurePopEl(), true);
    positionTipAt(state.lastX, state.lastY);
   }
   }


   function hideTip() {
   function openPopup(trigger, opts) {
     if (!tipEl) return;
     if (!trigger) return;
 
    if (state.open && state.trigger && state.trigger !== trigger) hidePopup();
 
    state.open = true;
    state.pinned = !!opts.pinned;
    state.trigger = trigger;


     state.visible = false;
     setExpanded(trigger, true);
    state.pinned = false;
    state.anchor = null;


     setHidden(tipEl, true);
    renderPopup(opts);
     setHidden(popEl, false);
    positionPopup(trigger);
   }
   }


   function navigateToTitle(title) {
   function findTrigger(t) {
     if (!title) return;
     if (!t) return null;
    if (isInsidePopup(t)) return null;
 
    var defEl = closest(t, DEF_SEL);
    if (defEl && defEl.getAttribute && defEl.getAttribute(DEF_TIP_ATTR) != null) return defEl;


     // MediaWiki-friendly navigation if available.
     var tip = closest(t, TIP_BTN_SEL);
     if (window.mw && mw.util && typeof mw.util.getUrl === "function") {
     if (tip) return tip;
      window.location.href = mw.util.getUrl(title);
      return;
    }


     // Fallback: treat as relative.
     var dis = closest(t, DISCLOSE_BTN_SEL);
     window.location.href = String(title);
     if (dis) return dis;
  }


  function sameAnchor(el) {
     return null;
     return !!(el && state.anchor && el === state.anchor);
   }
   }


   function shouldSuppressClick() {
   function resolveOpts(trigger) {
     return Date.now() < state.suppressClickUntil;
     var isDef = trigger && trigger.matches && trigger.matches(DEF_SEL);
  }
    var isTip = trigger && trigger.matches && trigger.matches(TIP_BTN_SEL);
    var isDisclose = trigger && trigger.matches && trigger.matches(DISCLOSE_BTN_SEL);


  /* ------------------------------------------------------------------ */
    var mode = "hover";
  /* Desktop hover behavior (only when hover-capable)                    */
    var size = "sm";
  /* ------------------------------------------------------------------ */


  if (HOVER_CAPABLE) {
     var attrMode = trigger.getAttribute && trigger.getAttribute("data-sv-pop");
     document.addEventListener(
    if (attrMode === "hover" || attrMode === "click") mode = attrMode;
      "mouseover",
      function (e) {
        if (state.pinned) return; // pinned wins


        var defEl = closest(e.target, DEF_SEL);
    var attrSize = trigger.getAttribute && trigger.getAttribute("data-sv-pop-size");
        if (!defEl) {
    if (attrSize === "sm" || attrSize === "lg") size = attrSize;
          // If moving over non-def content, close hover tooltip (if any).
          if (state.visible && !state.pinned) hideTip();
          return;
        }


        // Avoid re-triggering within the same element.
    if (!attrMode) {
        var rel = e.relatedTarget;
      if (isDisclose) mode = "click";
        if (rel && defEl.contains(rel)) return;
      else if (isTip) mode = "hover";
      else if (isDef) mode = getDefLinkTitle(trigger) ? "click" : "hover";
    }


        var text = getTipText(defEl);
    if (!attrSize) size = mode === "click" ? "lg" : "sm";
        if (!text) {
          // Blank tip closes any active hover tooltip.
          if (state.visible && !state.pinned) hideTip();
          return;
        }


        showTip(defEl, text, e.clientX, e.clientY, false);
    if (!HOVER_CAPABLE && mode === "hover") {
       },
       mode = "click";
       true
       size = "sm";
     );
     }


     document.addEventListener(
     if (isDef) {
      "mousemove",
      var tipText = getDefTipText(trigger);
      function (e) {
      if (!tipText) return null;
        if (!state.visible || state.pinned) return;
        // Only track if we’re still “on” the same anchor.
        var defEl = closest(e.target, DEF_SEL);
        if (!defEl || !sameAnchor(defEl)) return;


        state.lastX = e.clientX;
      var linkTitle = getDefLinkTitle(trigger);
        state.lastY = e.clientY;
        positionTipAt(state.lastX, state.lastY);
      },
      true
    );


    document.addEventListener(
      var label = trigger.querySelector ? trigger.querySelector(".sv-def-text") : null;
       "mouseout",
       var titleText = label ? String(label.textContent || "").trim() : String(trigger.textContent || "").trim();
      function (e) {
      if (!titleText) titleText = "Definition";
        if (!state.visible || state.pinned) return;


         var defEl = closest(e.target, DEF_SEL);
      return {
         if (!defEl || !sameAnchor(defEl)) return;
         pinned: mode === "click",
        size: size,
        title: titleText,
        titleLink: linkTitle ? buildHeaderLink(linkTitle, titleText) : null,
        bodyText: tipText,
        bodyPre: true,
         bodyNode: null
      };
    }


        var rel = e.relatedTarget;
    var source = getContentNodeFromTrigger(trigger);
        if (rel && defEl.contains(rel)) return; // still within the definition element
    if (isBlankContent(source)) return null;


        hideTip();
    return {
       },
      pinned: mode === "click",
       true
      size: size,
     );
      title: guessTitle(trigger, source),
      titleLink: null,
      bodyNode: source,
       bodyPre: false,
       bodyText: null
     };
   }
   }


   /* ------------------------------------------------------------------ */
   window.addEventListener(
  /* Touch / click behavior                                              */
  /* ------------------------------------------------------------------ */
 
  // Pointerdown is the best universal “tap” detector.
  document.addEventListener(
     "pointerdown",
     "pointerdown",
     function (e) {
     function (e) {
       var defEl = closest(e.target, DEF_SEL);
      if (!e) return;
       if (!defEl) return;
 
      if (isInsidePopup(e.target)) return;
 
       var trigger = findTrigger(e.target);
       if (!trigger) return;
 
      var opts = resolveOpts(trigger);
      if (!opts) return;
 
      if (isSummaryTrigger(trigger)) e.preventDefault();
 
      state.anchorKind = !HOVER_CAPABLE || (e.pointerType && e.pointerType !== "mouse") ? "finger" : "trigger";
      state.anchorX = typeof e.clientX === "number" ? e.clientX : 0;
      state.anchorY = typeof e.clientY === "number" ? e.clientY : 0;


       var text = getTipText(defEl);
       if (HOVER_CAPABLE && !opts.pinned && (e.pointerType === "mouse" || !e.pointerType)) {
      if (!text) {
         e.stopPropagation();
         // Blank def: close if open.
        if (state.visible) hideTip();
         return;
         return;
       }
       }


       // Touch/pen: pin tooltip near tap.
       e.preventDefault();
      // Mouse: we don’t pin on pointerdown (let hover handle it); clicking can toggle pin.
       e.stopPropagation();
       var isTouchLike = e.pointerType && e.pointerType !== "mouse";
      if (!isTouchLike) return;
 
      // Prevent synthetic click immediately after a touch pin (avoids double-toggling).
      state.suppressClickUntil = Date.now() + 450;


      // If already pinned on same anchor and it has a link, a second tap navigates.
       if (state.open && state.pinned && state.trigger === trigger) {
      var link = getLinkTitle(defEl);
         hidePopup();
       if (state.pinned && sameAnchor(defEl) && link) {
         e.preventDefault();
        navigateToTitle(link);
         return;
         return;
       }
       }


       e.preventDefault();
       openPopup(trigger, opts);
      showTip(defEl, text, e.clientX, e.clientY, true);
     },
     },
     true
     true
   );
   );


   // Click: desktop toggle pin (no link) OR navigate (has link).
   window.addEventListener(
  document.addEventListener(
     "mouseover",
     "click",
     function (e) {
     function (e) {
       if (shouldSuppressClick()) return;
       if (!HOVER_CAPABLE) return;
 
       if (isInsidePopup(e.target)) return;
       var defEl = closest(e.target, DEF_SEL);
      if (!defEl) return;


       var text = getTipText(defEl);
       var trigger = findTrigger(e.target);
       if (!text) {
       if (!trigger) {
         if (state.visible) hideTip();
         if (state.open && !state.pinned) hidePopup();
         return;
         return;
       }
       }


       var link = getLinkTitle(defEl);
       var opts = resolveOpts(trigger);
      if (!opts || opts.pinned) return;


       // If link exists: navigate.
       state.anchorKind = "trigger";
      if (link) {
        // If tooltip is pinned on this item, allow click to navigate (expected “future” behavior).
        e.preventDefault();
        navigateToTitle(link);
        return;
      }


       // No link: toggle pinned state on desktop.
       e.stopPropagation();
       e.preventDefault();
      clearTimeout(state.hideTimer);
       state.hideTimer = 0;


       if (state.pinned && sameAnchor(defEl)) {
       openPopup(trigger, opts);
        hideTip();
      } else {
        showTip(defEl, text, e.clientX, e.clientY, true);
      }
     },
     },
     true
     true
   );
   );


   /* ------------------------------------------------------------------ */
   window.addEventListener(
  /* Dismissal behavior                                                  */
    "mouseout",
   /* ------------------------------------------------------------------ */
    function (e) {
      if (!HOVER_CAPABLE) return;
      if (!state.open || state.pinned) return;
 
      var trigger = findTrigger(e.target);
      if (!trigger || trigger !== state.trigger) return;
 
      e.stopPropagation();
 
      clearTimeout(state.hideTimer);
      state.hideTimer = setTimeout(function () {
        if (state.open && !state.pinned) hidePopup();
      }, 80);
    },
    true
   );


   // Click outside closes pinned tooltip.
   window.addEventListener(
  document.addEventListener(
     "click",
     "click",
     function (e) {
     function (e) {
       if (!state.visible || !state.pinned) return;
       if (!state.open) return;
      if (isInsidePopup(e.target)) return;


       // Click inside tooltip should not close it.
       var trigger = findTrigger(e.target);
       if (tipEl && (e.target === tipEl || (tipEl.contains && tipEl.contains(e.target)))) return;
       if (trigger) {
        e.stopPropagation();
        return;
      }


      // Click on a definition is handled by the click handler above.
       if (state.pinned || !HOVER_CAPABLE) {
       if (closest(e.target, DEF_SEL)) return;
        hidePopup();
 
        e.stopPropagation();
      hideTip();
      }
     },
     },
     true
     true
   );
   );


   // Escape closes any tooltip (pinned or hover).
   window.addEventListener(
  document.addEventListener(
     "keydown",
     "keydown",
     function (e) {
     function (e) {
       if (e.key !== "Escape") return;
       if (e.key !== "Escape") return;
       if (state.visible) hideTip();
       if (state.open) {
        hidePopup();
        e.stopPropagation();
      }
     },
     },
     true
     true
   );
   );


  // If the page scrolls while pinned, keep it near the last anchor/tap point.
   window.addEventListener(
   window.addEventListener(
     "scroll",
     "scroll",
     function () {
     function () {
       if (!state.visible) return;
       if (!state.open || !state.trigger) return;
       positionTipAt(state.lastX, state.lastY);
       positionPopup(state.trigger);
     },
     },
     true
     true
Line 424: Line 1,263:
     "resize",
     "resize",
     function () {
     function () {
       if (!state.visible) return;
       if (!state.open || !state.trigger) return;
       positionTipAt(state.lastX, state.lastY);
       positionPopup(state.trigger);
    },
    true
  );
 
  function stripDefTitles(root) {
    var container = root || document;
    var defs = container.querySelectorAll(DEF_SEL + "[title]");
    for (var i = 0; i < defs.length; i++) defs[i].removeAttribute("title");
  }
 
  if (window.mw && mw.hook) {
    mw.hook("wikipage.content").add(function ($content) {
      stripDefTitles($content && $content[0]);
    });
  }
 
  if (document.readyState === "loading") {
    document.addEventListener("DOMContentLoaded", function () {
      stripDefTitles(document);
    });
  } else {
    stripDefTitles(document);
  }
})();
 
(function () {
  /* ================================================================== */
  /* MODULE: Tabs                                                      */
  /* ================================================================== */
 
  var SV = (window.SV = window.SV || {});
  var COMMON = (SV.common = SV.common || {});
  if (COMMON.tabsInit) return;
  COMMON.tabsInit = 1;
 
  var TABS_ROOT_SEL = ".sv-tabs[data-tabs='1']";
  var TAB_SEL = ".sv-tab";
  var PANEL_SEL = ".sv-tabpanel";
 
  var _tabsUidCounter = 0;
 
  function closest(el, sel) {
    if (!el || el.nodeType !== 1) return null;
    if (el.closest) return el.closest(sel);
    while (el && el.nodeType === 1) {
      if (el.matches && el.matches(sel)) return el;
      el = el.parentElement;
    }
    return null;
  }
 
  function getTabs(root) {
    return root.querySelectorAll(TAB_SEL);
  }
 
  function getPanels(root) {
    return root.querySelectorAll(PANEL_SEL);
  }
 
  function getPanelByKey(root, key) {
    var panels = getPanels(root);
    for (var i = 0; i < panels.length; i++) {
      if (panels[i].getAttribute("data-panel") === key) return panels[i];
    }
    return null;
  }
 
  function ensureUniqueTabIds(root) {
    var uid = root.getAttribute("data-tabs-uid");
    if (!uid) {
      _tabsUidCounter++;
      uid = (root.getAttribute("data-tabs-root") || "sv-tabs") + "-" + _tabsUidCounter;
      root.setAttribute("data-tabs-uid", uid);
    }
 
    var tabs = getTabs(root);
    for (var i = 0; i < tabs.length; i++) {
      var tab = tabs[i];
      var key = tab.getAttribute("data-tab") || String(i + 1);
      var panel = getPanelByKey(root, key);
 
      var tabId = uid + "-tab-" + key;
      tab.id = tabId;
 
      if (panel) {
        var panelId = uid + "-panel-" + key;
        panel.id = panelId;
        tab.setAttribute("aria-controls", panelId);
        panel.setAttribute("aria-labelledby", tabId);
      }
    }
  }
 
  function showPanel(panel) {
    if (!panel) return;
    panel.setAttribute("data-active", "1");
    if (panel.classList) panel.classList.remove("sv-hidden");
    panel.removeAttribute("hidden");
  }
 
  function hidePanel(panel) {
    if (!panel) return;
    panel.setAttribute("data-active", "0");
    if (panel.classList) panel.classList.add("sv-hidden");
    panel.setAttribute("hidden", "hidden");
  }
 
  function activateTab(root, btn) {
    if (!root || !btn) return;
 
    var tabs = getTabs(root);
    var key = btn.getAttribute("data-tab") || "";
 
    for (var i = 0; i < tabs.length; i++) {
      var t = tabs[i];
      var active = t === btn;
      t.setAttribute("aria-selected", active ? "true" : "false");
      t.setAttribute("tabindex", active ? "0" : "-1");
      if (t.classList) t.classList.toggle("sv-tab--active", active);
    }
 
    var panels = getPanels(root);
    for (var j = 0; j < panels.length; j++) {
      var p = panels[j];
      var isTarget = p.getAttribute("data-panel") === key;
      if (isTarget) showPanel(p);
      else hidePanel(p);
    }
 
    root.setAttribute("data-active-tab", key);
  }
 
  function focusTab(tabs, idx) {
    if (idx < 0) idx = 0;
    if (idx >= tabs.length) idx = tabs.length - 1;
    var t = tabs[idx];
    if (t && t.focus) t.focus();
    return t;
  }
 
  function indexOfTab(tabs, btn) {
    for (var i = 0; i < tabs.length; i++) {
      if (tabs[i] === btn) return i;
    }
    return -1;
  }
 
  function normalizeTabsRoot(root) {
    if (!root) return;
    if (root.getAttribute("data-gi-tabs-init") === "1") return;
 
    ensureUniqueTabIds(root);
 
    var tabs = getTabs(root);
    var panels = getPanels(root);
    if (!tabs.length || !panels.length) {
      root.setAttribute("data-gi-tabs-init", "1");
      return;
    }
 
    var activeBtn = null;
    for (var i = 0; i < tabs.length; i++) {
      if (tabs[i].getAttribute("aria-selected") === "true") {
        activeBtn = tabs[i];
        break;
      }
    }
    if (!activeBtn) activeBtn = tabs[0];
 
    activateTab(root, activeBtn);
    root.setAttribute("data-gi-tabs-init", "1");
  }
 
  function initTabs(root) {
    var container = root || document;
    var roots = container.querySelectorAll(TABS_ROOT_SEL);
    for (var i = 0; i < roots.length; i++) normalizeTabsRoot(roots[i]);
  }
 
  document.addEventListener(
    "click",
    function (e) {
      var btn = e.target && e.target.closest ? e.target.closest(TAB_SEL) : null;
      if (!btn) return;
 
      var root = closest(btn, ".sv-tabs");
      if (!root || root.getAttribute("data-tabs") !== "1") return;
 
      e.preventDefault();
      activateTab(root, btn);
     },
     },
     true
     true
   );
   );


   /* ------------------------------------------------------------------ */
   document.addEventListener(
  /* Init hook                                                          */
    "keydown",
   /* ------------------------------------------------------------------ */
    function (e) {
      var btn =
        document.activeElement && document.activeElement.closest
          ? document.activeElement.closest(TAB_SEL)
          : null;
      if (!btn) return;
 
      var root = closest(btn, ".sv-tabs");
      if (!root || root.getAttribute("data-tabs") !== "1") return;
 
      var tabs = getTabs(root);
      if (!tabs || !tabs.length) return;
 
      var idx = indexOfTab(tabs, btn);
      if (idx < 0) return;
 
      if (e.key === "ArrowLeft" || e.key === "Left") {
        e.preventDefault();
        activateTab(root, focusTab(tabs, idx - 1));
        return;
      }
      if (e.key === "ArrowRight" || e.key === "Right") {
        e.preventDefault();
        activateTab(root, focusTab(tabs, idx + 1));
        return;
      }
      if (e.key === "Home") {
        e.preventDefault();
        activateTab(root, focusTab(tabs, 0));
        return;
      }
      if (e.key === "End") {
        e.preventDefault();
        activateTab(root, focusTab(tabs, tabs.length - 1));
        return;
      }
      if (e.key === "Enter" || e.key === " ") {
        e.preventDefault();
        activateTab(root, btn);
        return;
      }
    },
    true
   );


  // This module is fully event-delegated; no per-node init required.
   function initAllTabs(root) {
  // Still, we keep the MediaWiki hook so this file matches your site pattern.
     initTabs(root);
   function initAll(root) {
     // No-op on purpose (delegated listeners already installed once).
    // Placeholder for future expansions (e.g., prewarming tooltip element).
    void root;
   }
   }


   if (window.mw && mw.hook) {
   if (window.mw && mw.hook) {
     mw.hook("wikipage.content").add(function ($content) {
     mw.hook("wikipage.content").add(function ($content) {
       initAll($content && $content[0]);
       initAllTabs($content && $content[0]);
     });
     });
   }
   }
Line 450: Line 1,518:
   if (document.readyState === "loading") {
   if (document.readyState === "loading") {
     document.addEventListener("DOMContentLoaded", function () {
     document.addEventListener("DOMContentLoaded", function () {
       initAll(document);
       initAllTabs(document);
     });
     });
   } else {
   } else {
     initAll(document);
     initAllTabs(document);
   }
   }
})();
})();
Retrieved from "https://spiritvale.info/wiki/MediaWiki:Common.js"