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
 
(30 intermediate revisions by the same user not shown)
Line 1: Line 1:
/* Any JavaScript here will be loaded for all users on every page load. */
/* Common.js — Spirit Vale Wiki
  Phase 4.1 — Core client scripts


/*
  Included (standalone modules):
  SpiritVale Skill Slider
  1) Level Selector / Descriptions (data-series)
 
  2) Universal Popups (tips, discloses, definitions)
  What this does:
  3) Tabs
  - Finds every skill card:        <div class="sv-skill-card" data-max-level="10" data-level="10">
  - Inserts a slider into:        <div class="sv-level-slider"></div>
  - Updates any element inside the card that has:
        data-series='["Lv1 text","Lv2 text", ...]'
    so that it shows the correct value for the chosen level.
*/
*/


(function () {
(function () {
  /* ================================================================== */
  /* 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']";


    // Ensure a number stays between a minimum and maximum.
  var LEVEL_BOUNDARY_SEL =
     function clampNumber(value, min, max) {
     "[data-sv-level-boundary='1'], .sv-skill-level, .sv-gi-level";
        var n = parseInt(value, 10);


        // If value is not a valid number, fall back to min.
  var LEVEL_SCOPE_SEL =
        if (isNaN(n)) {
    "[data-sv-level-scope='1'], .sv-gi-bottom, .sv-skill-bottom";
            return min;
        }


        if (n < min) return min;
  var SERIES_SEL = "[data-series]";
        if (n > max) return max;
  var LEVEL_INIT_ATTR = "data-sv-level-init";
        return n;
 
  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;
  }


     // Initialize skill cards found under `root`.
  function isAfter(boundaryNode, el) {
     // `root` is usually the page, but MediaWiki sometimes gives us just a section of HTML.
     if (!boundaryNode || !el) return true;
     function initSkillCards(root) {
    if (boundaryNode === el) return false;
        var container = root || document;
     if (!boundaryNode.compareDocumentPosition) return true;
     return (boundaryNode.compareDocumentPosition(el) & 4) !== 0;
  }


        // Only pick cards we haven't initialized yet (data-sv-init is our marker).
  function isRangeInput(el) {
        var cards = container.querySelectorAll(
    return !!(el && el.tagName === "INPUT" && el.type === "range");
            ".sv-skill-card:not([data-sv-init]), .sv-passive-card:not([data-sv-init])"
  }
        );


        cards.forEach(function (card) {
  function isCustomSlider(el) {
            // Read max level from HTML attribute (default 1 if missing).
    if (!el || !el.getAttribute) return false;
            var maxLevel = clampNumber(card.getAttribute("data-max-level"), 1, 999);
    if (el.getAttribute("data-sv-slider") === "1") return true;
    return !!(el.classList && el.classList.contains("sv-level-range--custom"));
  }


            // If max level is 1, there's no reason to create a slider.
  function parseMaxFromUi(card) {
            if (maxLevel <= 1) {
    var ui = card && card.querySelector ? card.querySelector(".sv-level-ui") : null;
                card.setAttribute("data-sv-init", "1");
    if (!ui) return null;
                return;
    var m = String(ui.textContent || "").match(/\/\s*(\d+)/);
            }
    return m ? m[1] : null;
  }


            // Read the starting level; if missing, default to max level.
  function getCardMaxLevel(card) {
            var startLevel = card.getAttribute("data-level");
    var raw =
            if (startLevel == null || startLevel === "") {
      card.getAttribute("data-max-level") ||
                startLevel = maxLevel;
      card.getAttribute("data-maxLevel") ||
            }
      card.getAttribute("data-max") ||
            startLevel = clampNumber(startLevel, 1, maxLevel);
      card.getAttribute("data-level-max") ||
      parseMaxFromUi(card);


            // Find where we should place the slider.
    return clampInt(raw, 1, 999, 1);
            var sliderHost = card.querySelector(".sv-level-slider");
  }
            if (!sliderHost) {
                // No placeholder = nothing to do.
                card.setAttribute("data-sv-init", "1");
                return;
            }


            // Optional: element that shows the current level number in text.
  function getCardMinLevel(card, slider, maxLevel) {
            var levelNumberSpan = card.querySelector(".sv-level-num");
    // 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");


            // Find all dynamic elements that contain a data-series list.
    if (raw == null || raw === "") {
            var dynamicElements = card.querySelectorAll("[data-series]");
      if (slider) {
        if (isRangeInput(slider)) raw = slider.getAttribute("min");
        else if (isCustomSlider(slider))
          raw = slider.getAttribute("aria-valuemin") || slider.getAttribute("data-min");
      }
    }


            // Parse the JSON data-series once and store it on the element for reuse.
    var min = clampInt(raw, 1, maxLevel, 1);
            dynamicElements.forEach(function (el) {
    if (min > maxLevel) min = maxLevel;
                var raw = el.getAttribute("data-series");
    return min;
                try {
  }
                    el._svSeries = JSON.parse(raw);
                } catch (e) {
                    el._svSeries = null;
                }
            });


            // Create the slider element.
  function getCardLevel(card, minLevel, maxLevel) {
            var slider = document.createElement("input");
    var raw =
            slider.type = "range";
      card.getAttribute("data-level") ||
            slider.min = "1";
      card.getAttribute("data-gi-level") ||
            slider.max = String(maxLevel);
      (card.querySelector && card.querySelector(".sv-level-num")
            slider.value = String(startLevel);
        ? card.querySelector(".sv-level-num").textContent
            slider.className = "sv-level-range";
        : null);


            // Clear any existing content in the host, then add the slider.
    return clampInt(raw, minLevel, maxLevel, minLevel);
            sliderHost.textContent = "";
  }
            sliderHost.appendChild(slider);


            // Apply a given level to this card:
  function getStep(slider) {
            // - update the level number text
    // Default = 1. Support future: data-step, or <input step="">
            // - update all dynamic elements to show the correct series value
    var raw = null;
            function applyLevel(level) {
    if (slider) raw = slider.getAttribute("data-step") || slider.getAttribute("step");
                var lv = clampNumber(level, 1, maxLevel);
    var s = parseInt(raw, 10);
    if (!s || isNaN(s) || s < 1) s = 1;
    return s;
  }


                // Store the chosen level on the card (optional, but useful for debugging).
  function getLevelSlider(card) {
                card.setAttribute("data-level", String(lv));
    return card.querySelector(LEVEL_RANGE_SEL);
  }


                // Update the visible "current level" number if present.
  function getLevelBoundary(slider) {
                if (levelNumberSpan) {
    if (!slider) return null;
                    levelNumberSpan.textContent = String(lv);
    return closest(slider, LEVEL_BOUNDARY_SEL) || slider;
                }
  }


                // Update each dynamic element:
  function getLevelScopeContainer(card, boundary) {
                // Level 1 => index 0, Level 2 => index 1, etc.
    var scope = card.querySelector(LEVEL_SCOPE_SEL) || card;
                var index = lv - 1;
    if (boundary && scope !== card && !scope.contains(boundary)) return card;
    return scope;
  }


                dynamicElements.forEach(function (el) {
  function setLevelNumber(card, level) {
                    var series = el._svSeries;
    var span = card.querySelector(".sv-level-num");
    if (span) span.textContent = String(level);
  }


                    // If series is missing or not a proper list, skip it.
  function setLevelMax(card, maxLevel) {
                    if (!series || !Array.isArray(series) || series.length === 0) {
    var span = card.querySelector(".sv-level-max");
                        return;
    if (span) span.textContent = String(maxLevel);
                    }
  }
 
  function applySeriesToScope(scope, boundary, level) {
    if (!scope) return;


                    // If the series is shorter than maxLevel, clamp index to last element.
    // JS arrays are 0-based; Lua uses 1-based "level".
                    var safeIndex = index;
    var index = level - 1;
                    if (safeIndex >= series.length) {
    var nodes = scope.querySelectorAll(SERIES_SEL);
                        safeIndex = series.length - 1;
                    }


                    var value = series[safeIndex];
    for (var i = 0; i < nodes.length; i++) {
      var el = nodes[i];
      if (boundary && !isAfter(boundary, el)) continue;


                    // Put the chosen value into the element.
      var series = parseSeries(el);
                    // Use an empty string if it's null/undefined.
      if (!series || series.length === 0) continue;
                    if (value == null) {
                        el.textContent = "";
                    } else {
                        el.textContent = String(value);
                    }
                });
            }


            // When the slider moves, update the card live.
      var safeIndex = index;
            slider.addEventListener("input", function () {
      if (safeIndex >= series.length) safeIndex = series.length - 1;
                applyLevel(slider.value);
      if (safeIndex < 0) safeIndex = 0;
            });


            // Apply the starting level right away.
      var value = series[safeIndex];
            applyLevel(startLevel);
      if (value == null) value = "";


            // Mark this card as initialized so we don't do it twice.
      el.textContent = String(value);
            card.setAttribute("data-sv-init", "1");
        });
     }
     }
  }
  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;


     // MediaWiki hook:
     var b = getCustomBounds(slider, 1);
     // Runs when page content is ready (and also after AJAX updates).
     bubble.textContent = String(value);
     if (window.mw && mw.hook) {
     bubble.style.left = pctFromValue(b.min, b.max, value) * 100 + "%";
        mw.hook("wikipage.content").add(function ($content) {
  }
            // $content is usually a jQuery object; $content[0] is the real DOM node.
 
            initSkillCards($content && $content[0]);
  function showValueLabel(slider) {
        });
    if (!slider) return;
    var bubble = ensureValueLabel(slider);
    if (!bubble) return;
 
    if (slider._svBubbleTimer) {
      clearTimeout(slider._svBubbleTimer);
      slider._svBubbleTimer = null;
     }
     }


     // Also run on normal page load as a fallback.
     unhide(bubble);
     if (document.readyState === "loading") {
  }
        document.addEventListener("DOMContentLoaded", function () {
 
            initSkillCards(document);
  function hideValueLabelSoon(slider, delayMs) {
        });
    if (!slider) return;
     } else {
    var bubble = slider.querySelector ? slider.querySelector(".sv-level-bubble") : null;
         initSkillCards(document);
    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 () {
  function applyLevelToCard(card, rawLevel) {
     let pop = null;
     if (!card) return;
    let activeBtn = null;
    let openMode = null; // "hover" | "click"


     function ensurePop() {
     var maxLevel = getCardMaxLevel(card);
        if (pop) return pop;
    var slider = getLevelSlider(card);
        pop = document.createElement("div");
    var minLevel = getCardMinLevel(card, slider, maxLevel);
        pop.className = "sv-tip-pop";
        pop.setAttribute("role", "dialog");
        pop.setAttribute("id", "sv-tip-pop");
        pop.style.display = "none";
        document.body.appendChild(pop);
        return pop;
    }


     function findContent(btn) {
     var level = clampInt(rawLevel, minLevel, maxLevel, getCardLevel(card, minLevel, maxLevel));
        const kind = btn.getAttribute("data-sv-tip");
        if (!kind) return null;


        const scope = btn.closest(".sv-tip-scope")
    card.setAttribute("data-level", String(level));
            || btn.closest(".sv-slot-card")
    setLevelNumber(card, level);
            || btn.closest(".sv-skill-card")
    setLevelMax(card, maxLevel);
            || btn.closest(".sv-passive-card")
            || btn.parentElement;
        if (!scope) return null;


        return scope.querySelector(`.sv-tip-content[data-sv-tip-content="${CSS.escape(kind)}"]`);
    if (slider) {
      unhide(slider);
      var wrap = closest(slider, ".sv-level-slider");
      if (wrap) unhide(wrap);
     }
     }


     function setExpanded(btn, expanded) {
     if (slider) {
         if (!btn) return;
      if (isRangeInput(slider)) {
         btn.setAttribute("aria-expanded", expanded ? "true" : "false");
        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);
      }
     }
     }


     function positionPop(btn) {
     setEndValueLabel(card, slider, level);
        if (!pop || !btn) return;


        const r = btn.getBoundingClientRect();
    var boundary = getLevelBoundary(slider);
        const margin = 8;
    var scope = getLevelScopeContainer(card, boundary);
    applySeriesToScope(scope, boundary, level);
  }


        const pw = pop.offsetWidth;
  function initLevels(root) {
        const ph = pop.offsetHeight;
    var container = root || document;
    var cards = container.querySelectorAll(CARD_SEL);


        let left = r.left + (r.width / 2) - (pw / 2);
    for (var i = 0; i < cards.length; i++) {
        left = Math.max(margin, Math.min(left, window.innerWidth - pw - margin));
      var card = cards[i];


        let top = r.bottom + margin;
      var stamped = clampInt(card.getAttribute(LEVEL_INIT_ATTR), 0, 999, 0);
        if (top + ph > window.innerHeight - margin) {
      if (stamped >= LEVELS_VERSION) continue;
            top = r.top - ph - margin;
        }


         pop.style.left = `${Math.round(left)}px`;
      var maxLevel = getCardMaxLevel(card);
        pop.style.top  = `${Math.round(top)}px`;
      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 closeTip() {
  function endDrag(e) {
        if (!pop) return;
    if (!_drag) return;
        setExpanded(activeBtn, false);
    if (e && e.pointerId != null && e.pointerId !== _drag.pointerId) return;
        activeBtn = null;
 
        openMode = null;
    if (_drag.slider && _drag.slider.releasePointerCapture) {
        pop.style.display = "none";
      try {
         pop.innerHTML = "";
         _drag.slider.releasePointerCapture(_drag.pointerId);
      } catch (err) {}
     }
     }


     function openTip(btn, mode) {
     hideValueLabelSoon(_drag.slider, 650);
        const content = findContent(btn);
    _drag = null;
        if (!content) {
  }
            closeTip();
            return;
        }


        ensurePop();
  document.addEventListener("pointerup", endDrag, true);
  document.addEventListener("pointercancel", endDrag, true);


        if (activeBtn === btn && pop.style.display !== "none") {
  // Mouse-only slider interaction:
            openMode = mode || openMode;
  // - Remove keyboard-driven adjustments on custom sliders
            positionPop(btn);
  // - Block native <input type="range"> from changing via keyboard (if present)
            return;
  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.querySelectorAll(".sv-tip-btn[aria-expanded='true']").forEach(function (b) { setExpanded(b, false); });
  document.addEventListener(
    "keydown",
    function (e) {
      var key = e && e.key;
      if (!_SV_BLOCK_KEYS[key]) return;


        activeBtn = btn;
      var el = document.activeElement;
        openMode = mode || null;
      if (!el) return;
        btn.setAttribute("aria-controls", "sv-tip-pop");
        setExpanded(btn, true);


         pop.innerHTML = content.innerHTML;
      // Native range inputs (keep mouse drag, disable keyboard nudges)
         pop.style.display = "block";
      if (isRangeInput(el) && el.classList && el.classList.contains("sv-level-range")) {
        positionPop(btn);
        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);
  }


    document.addEventListener("click", function (e) {
  COMMON.initAllLevels = initAllLevels;
        const btn = e.target.closest(".sv-tip-btn");
        if (btn) {
            e.preventDefault();
            if (activeBtn === btn && pop && pop.style.display !== "none") {
                if (openMode === "click") {
                    closeTip();
                } else {
                    openTip(btn, "click");
                }
                return;
            }


            openTip(btn, "click");
  if (window.mw && mw.hook) {
            return;
    mw.hook("wikipage.content").add(function ($content) {
        }
      initAllLevels($content && $content[0]);
    });
  }


        if (pop && pop.style.display !== "none") {
  if (document.readyState === "loading") {
            if (!e.target.closest(".sv-tip-pop")) closeTip();
    document.addEventListener("DOMContentLoaded", function () {
        }
      initAllLevels(document);
     });
     });
  } else {
    initAllLevels(document);
  }
})();
(function () {
  /* ================================================================== */
  /* MODULE: Universal Popups                                            */
  /* ================================================================== */
  var SV = (window.SV = window.SV || {});
  var COMMON = (SV.common = SV.common || {});
  // Bumped only because we changed positioning margins (safe cache-bust).
  var UPOP_VERSION = 32; // Universal Popups v3.2
  if (typeof COMMON.universalPopupsInit === "number" && COMMON.universalPopupsInit >= UPOP_VERSION) return;
  COMMON.universalPopupsInit = UPOP_VERSION;


    const hoverCapable = window.matchMedia && window.matchMedia("(hover: hover) and (pointer: fine)").matches;
  try { document.documentElement.classList.add("sv-uipop-v3"); } catch (e) {}
    if (hoverCapable) {
        document.addEventListener("mouseover", function (e) {
            const btn = e.target.closest(".sv-tip-btn");
            if (!btn) return;
            if (openMode === "click") return;
            openTip(btn, "hover");
        });


        document.addEventListener("mouseout", function (e) {
  var DEF_SEL = ".sv-def";
            if (openMode !== "hover" || !activeBtn || !pop || pop.style.display === "none") return;
  var DEF_TIP_ATTR = "data-sv-def-tip";
  var DEF_LINK_ATTR = "data-sv-def-link";


            const from = e.target;
  var TIP_BTN_SEL = ".sv-tip-btn[data-sv-toggle='1'], details.sv-tip > summary";
            if (!(activeBtn.contains(from) || pop.contains(from))) return;
  var DISCLOSE_BTN_SEL = ".sv-disclose-btn[data-sv-toggle='1'], details.sv-disclose > summary";


            const to = e.relatedTarget;
  var WRAP_SEL = ".sv-tip, .sv-disclose";
            if (to && (activeBtn.contains(to) || pop.contains(to))) return;
  var POP_SEL = ".sv-tip-pop, .sv-disclose-pop";


            const toBtn = to && to.closest ? to.closest(".sv-tip-btn") : null;
  var HOVER_CAPABLE = false;
            if (toBtn && toBtn !== activeBtn) return;
  try {
    HOVER_CAPABLE = !!window.matchMedia && window.matchMedia("(hover:hover) and (pointer:fine)").matches;
  } catch (e) { HOVER_CAPABLE = false; }


            closeTip();
  var popEl = null;
        });
 
  var state = {
    open: false,
    pinned: false,
    trigger: null,
    hideTimer: 0,
    anchorKind: "trigger", // trigger | finger | center
    anchorX: 0,
    anchorY: 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;
  }


    document.addEventListener("keydown", function (e) {
  function clamp(n, min, max) {
        if (e.key === "Escape") {
    if (n < min) return min;
            closeTip();
    if (n > max) return max;
            return;
    return n;
        }
  }


        const btn = document.activeElement && document.activeElement.closest
  function safeIdSelector(id) {
            ? document.activeElement.closest(".sv-tip-btn")
    return "#" + String(id).replace(/([ !"#$%&'()*+,.\/:;<=>?@[\\\]^`{|}~])/g, "\\$1");
            : null;
  }


        if (!btn) return;
  function isInsidePopup(target) {
    return !!(popEl && (target === popEl || (popEl.contains && popEl.contains(target))));
  }


        if (e.key === "Enter" || e.key === " ") {
  function isSummaryTrigger(trigger) {
            e.preventDefault();
    return !!(trigger && trigger.tagName === "SUMMARY");
            if (activeBtn === btn && pop && pop.style.display !== "none") {
  }
                if (openMode === "click") {
                    closeTip();
                } else {
                    openTip(btn, "click");
                }
                return;
            }


            openTip(btn, "click");
  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;
     });
     });


     if (window.mw && mw.hook) {
     el.addEventListener("mouseleave", function () {
        mw.hook("wikipage.content").add(function () {
      if (!HOVER_CAPABLE) return;
            closeTip();
      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 "";
    var t = defEl.getAttribute(DEF_TIP_ATTR);
    if (t == null) return "";
    t = String(t);
    t = t.replace(/\\r\\n/g, "\n").replace(/\\n/g, "\n").replace(/\\r/g, "\n");
    if (!t.replace(/\s+/g, "")) return "";
    return t;
  }
 
  function getDefLinkTitle(defEl) {
    if (!defEl || !defEl.getAttribute) return "";
    var t = defEl.getAttribute(DEF_LINK_ATTR);
    if (t == null) return "";
    return String(t).trim();
  }
 
  function getContentNodeFromTrigger(trigger) {
    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
      );
     }
     }


     window.addEventListener("resize", function () { if (activeBtn) positionPop(activeBtn); });
     var id = trigger.getAttribute ? trigger.getAttribute("aria-controls") : "";
    window.addEventListener("scroll",  function () { if (activeBtn) positionPop(activeBtn); }, true);
    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 global = document.getElementById(id);
* SV Definitions v1 — tooltips for .sv-def
      if (global) {
* - Reads: data-sv-def-tip, data-sv-def-link
        return (
* - Works with spans output by Module:Definitions
          global.querySelector(".sv-tip-pop-body") ||
* ========================================================================== */
          global.querySelector(".sv-disclose-pop-body") ||
(function (mw) {
          global.querySelector(".sv-disclose-list") ||
  "use strict";
          global
  if (!mw || window.SV_DEF_INIT) return;
        );
  window.SV_DEF_INIT = true;
      }
    }


  var tipEl = null;
    var w = closest(trigger, WRAP_SEL);
  var tipInner = null;
    if (w) {
  var activeEl = null;
      var pop = w.querySelector(POP_SEL);
  var pinned = false;
      if (pop) {
        return (
          pop.querySelector(".sv-tip-pop-body") ||
          pop.querySelector(".sv-disclose-pop-body") ||
          pop.querySelector(".sv-disclose-list") ||
          pop
        );
      }
    }


  function qTipText(el) {
     return null;
    var s = (el && el.getAttribute("data-sv-def-tip")) || "";
     return (s || "").trim();
   }
   }


   function qLink(el) {
   function guessTitle(trigger, sourceNode) {
     var s = (el && el.getAttribute("data-sv-def-link")) || "";
     var pop = null;
     return (s || "").trim();
    if (sourceNode && sourceNode.nodeType === 1) pop = closest(sourceNode, POP_SEL);
    if (pop) {
      var t = pop.querySelector(".sv-tip-pop-title") || pop.querySelector(".sv-disclose-pop-title");
      if (t && t.textContent) return String(t.textContent).trim();
    }
 
    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 ensureTip() {
   function buildHeaderLink(linkTitle, displayText) {
     if (tipEl) return;
     if (!linkTitle) return null;


     tipEl = document.createElement("div");
     var a = document.createElement("a");
     tipEl.id = "sv-def-tip";
     a.className = "sv-uipop-title-link";
     tipEl.className = "sv-def-tip";
     a.textContent = displayText || String(linkTitle);
    tipEl.setAttribute("role", "tooltip");
    tipEl.setAttribute("aria-hidden", "true");


     // Minimal inline styling so it works even without CSS.
     if (window.mw && mw.util && typeof mw.util.getUrl === "function") a.href = mw.util.getUrl(linkTitle);
    // You can override in CSS later using #sv-def-tip / .sv-def-tip.
     else a.href = String(linkTitle);
    tipEl.style.position = "fixed";
    tipEl.style.zIndex = "99999";
    tipEl.style.display = "none";
    tipEl.style.maxWidth = "340px";
    tipEl.style.padding = "8px 10px";
    tipEl.style.borderRadius = "8px";
    tipEl.style.background = "rgba(15, 18, 24, 0.96)";
    tipEl.style.color = "#fff";
     tipEl.style.fontSize = "13px";
    tipEl.style.lineHeight = "1.25";
    tipEl.style.boxShadow = "0 8px 24px rgba(0,0,0,0.35)";
    tipEl.style.pointerEvents = "none";


     tipInner = document.createElement("div");
     a.addEventListener("click", function (e) { e.stopPropagation(); });
    tipInner.className = "sv-def-tip-inner";
    tipEl.appendChild(tipInner);


     document.body.appendChild(tipEl);
     return a;
   }
   }


   function suppressTitle(el) {
   function fireContentHook(el) {
    // Prevent double-tooltips (browser title tooltip + our custom tooltip).
     if (!el) return;
     if (!el) return;
    var t = el.getAttribute("title");
     if (window.mw && mw.hook && window.jQuery) {
     if (t && !el.getAttribute("data-sv-def-title")) {
       try { mw.hook("wikipage.content").fire(window.jQuery(el)); } catch (e) {}
       el.setAttribute("data-sv-def-title", t);
      el.removeAttribute("title");
     }
     }
   }
   }


   function restoreTitle(el) {
   function renderPopup(opts) {
    var el = ensurePopEl();
     if (!el) return;
     if (!el) return;
     var t = el.getAttribute("data-sv-def-title");
 
     if (t) {
    el.classList.remove("sv-uipop--sm", "sv-uipop--lg");
      el.setAttribute("title", t);
    el.classList.add(opts.size === "lg" ? "sv-uipop--lg" : "sv-uipop--sm");
      el.removeAttribute("data-sv-def-title");
 
    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);
  }
  function positionPopup(trigger) {
    var el = ensurePopEl();
    if (!el) return;
    el.style.left = "0px";
    el.style.top = "0px";
    setHidden(el, false);
    requestAnimationFrame(function () {
      if (!state.open) return;
      var vw = window.innerWidth || document.documentElement.clientWidth || 0;
      var vh = window.innerHeight || document.documentElement.clientHeight || 0;
      var tight = vw <= 520;
      var margin = tight ? 18 : 10;
      var gap = tight ? 14 : 12;
      var pr = el.getBoundingClientRect();
      var w = pr.width || 240;
      var h = pr.height || 180;
      var left = margin;
      var top = margin;
      if (state.anchorKind === "center") {
        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;
      }
      left = clamp(left, margin, Math.max(margin, vw - w - margin));
      top = clamp(top, margin, Math.max(margin, vh - h - margin));
      el.style.left = Math.round(left) + "px";
      el.style.top = Math.round(top) + "px";
    });
  }
  function setExpanded(trigger, expanded) {
    if (!trigger || !trigger.setAttribute) return;
    trigger.setAttribute("aria-expanded", expanded ? "true" : "false");
  }
  function hidePopup() {
    if (!state.open) return;
    clearTimeout(state.hideTimer);
    state.hideTimer = 0;
    setExpanded(state.trigger, false);
    state.open = false;
    state.pinned = false;
    state.trigger = null;
    state.anchorKind = "trigger";
    setHidden(ensurePopEl(), true);
   }
   }


   function clamp(n, lo, hi) {
   function openPopup(trigger, opts) {
     return Math.max(lo, Math.min(hi, n));
     if (!trigger) return;
 
    if (state.open && state.trigger && state.trigger !== trigger) hidePopup();
 
    state.open = true;
    state.pinned = !!opts.pinned;
    state.trigger = trigger;
 
    setExpanded(trigger, true);
 
    renderPopup(opts);
    setHidden(popEl, false);
    positionPopup(trigger);
   }
   }


   function positionTip(el) {
   function findTrigger(t) {
     if (!tipEl || !el) 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;
 
    var tip = closest(t, TIP_BTN_SEL);
    if (tip) return tip;


     var r = el.getBoundingClientRect();
     var dis = closest(t, DISCLOSE_BTN_SEL);
    if (dis) return dis;


     // Ensure we can measure tip size
     return null;
    tipEl.style.left = "0px";
  }
    tipEl.style.top = "0px";
    tipEl.style.display = "block";


     var tr = tipEl.getBoundingClientRect();
  function resolveOpts(trigger) {
     var pad = 8;
     var isDef = trigger && trigger.matches && trigger.matches(DEF_SEL);
     var gap = 8;
     var isTip = trigger && trigger.matches && trigger.matches(TIP_BTN_SEL);
     var isDisclose = trigger && trigger.matches && trigger.matches(DISCLOSE_BTN_SEL);


     var x = r.left + (r.width / 2) - (tr.width / 2);
     var mode = "hover";
     x = clamp(x, pad, window.innerWidth - tr.width - pad);
     var size = "sm";


     var y = r.bottom + gap;
     var attrMode = trigger.getAttribute && trigger.getAttribute("data-sv-pop");
     if (y + tr.height > window.innerHeight - pad) {
     if (attrMode === "hover" || attrMode === "click") mode = attrMode;
       y = r.top - tr.height - gap;
 
    var attrSize = trigger.getAttribute && trigger.getAttribute("data-sv-pop-size");
    if (attrSize === "sm" || attrSize === "lg") size = attrSize;
 
    if (!attrMode) {
       if (isDisclose) mode = "click";
      else if (isTip) mode = "hover";
      else if (isDef) mode = getDefLinkTitle(trigger) ? "click" : "hover";
     }
     }
    y = clamp(y, pad, window.innerHeight - tr.height - pad);


     tipEl.style.left = Math.round(x) + "px";
     if (!attrSize) size = mode === "click" ? "lg" : "sm";
     tipEl.style.top = Math.round(y) + "px";
 
    if (!HOVER_CAPABLE && mode === "hover") {
      mode = "click";
      size = "sm";
    }
 
    if (isDef) {
      var tipText = getDefTipText(trigger);
      if (!tipText) return null;
 
      var linkTitle = getDefLinkTitle(trigger);
 
      var label = trigger.querySelector ? trigger.querySelector(".sv-def-text") : null;
      var titleText = label ? String(label.textContent || "").trim() : String(trigger.textContent || "").trim();
      if (!titleText) titleText = "Definition";
 
      return {
        pinned: mode === "click",
        size: size,
        title: titleText,
        titleLink: linkTitle ? buildHeaderLink(linkTitle, titleText) : null,
        bodyText: tipText,
        bodyPre: true,
        bodyNode: null
      };
     }
 
    var source = getContentNodeFromTrigger(trigger);
    if (isBlankContent(source)) return null;
 
    return {
      pinned: mode === "click",
      size: size,
      title: guessTitle(trigger, source),
      titleLink: null,
      bodyNode: source,
      bodyPre: false,
      bodyText: null
    };
   }
   }


   function show(el) {
   window.addEventListener(
    ensureTip();
    "pointerdown",
    function (e) {
      if (!e) return;


    var txt = qTipText(el);
      if (isInsidePopup(e.target)) return;
    if (!txt) return;


    activeEl = el;
      var trigger = findTrigger(e.target);
    tipInner.textContent = txt;
      if (!trigger) return;
    tipEl.setAttribute("aria-hidden", "false");
    tipEl.style.display = "block";


     suppressTitle(el);
      var opts = resolveOpts(trigger);
     positionTip(el);
      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;
 
      if (HOVER_CAPABLE && !opts.pinned && (e.pointerType === "mouse" || !e.pointerType)) {
        e.stopPropagation();
        return;
      }
 
      e.preventDefault();
      e.stopPropagation();
 
      if (state.open && state.pinned && state.trigger === trigger) {
        hidePopup();
        return;
      }
 
      openPopup(trigger, opts);
     },
    true
  );
 
  window.addEventListener(
    "mouseover",
    function (e) {
      if (!HOVER_CAPABLE) return;
      if (isInsidePopup(e.target)) return;
 
      var trigger = findTrigger(e.target);
      if (!trigger) {
        if (state.open && !state.pinned) hidePopup();
        return;
      }
 
      var opts = resolveOpts(trigger);
      if (!opts || opts.pinned) return;
 
      state.anchorKind = "trigger";
 
      e.stopPropagation();
      clearTimeout(state.hideTimer);
      state.hideTimer = 0;
 
      openPopup(trigger, opts);
     },
    true
  );
 
  window.addEventListener(
    "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
  );
 
  window.addEventListener(
    "click",
    function (e) {
      if (!state.open) return;
      if (isInsidePopup(e.target)) return;
 
      var trigger = findTrigger(e.target);
      if (trigger) {
        e.stopPropagation();
        return;
      }
 
      if (state.pinned || !HOVER_CAPABLE) {
        hidePopup();
        e.stopPropagation();
      }
    },
    true
  );
 
  window.addEventListener(
    "keydown",
    function (e) {
      if (e.key !== "Escape") return;
      if (state.open) {
        hidePopup();
        e.stopPropagation();
      }
    },
    true
  );
 
  window.addEventListener(
    "scroll",
    function () {
      if (!state.open || !state.trigger) return;
      positionPopup(state.trigger);
    },
    true
  );
 
  window.addEventListener(
    "resize",
    function () {
      if (!state.open || !state.trigger) return;
      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]);
    });
   }
   }


   function hide() {
   if (document.readyState === "loading") {
     if (!tipEl) return;
    document.addEventListener("DOMContentLoaded", function () {
      stripDefTitles(document);
     });
  } else {
    stripDefTitles(document);
  }
})();


    tipEl.style.display = "none";
(function () {
    tipEl.setAttribute("aria-hidden", "true");
  /* ================================================================== */
  /* MODULE: Tabs                                                      */
  /* ================================================================== */


    if (activeEl) restoreTitle(activeEl);
  var SV = (window.SV = window.SV || {});
  var COMMON = (SV.common = SV.common || {});
  if (COMMON.tabsInit) return;
  COMMON.tabsInit = 1;


     activeEl = null;
  var TABS_ROOT_SEL = ".sv-tabs[data-tabs='1']";
     pinned = false;
  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 isEntering(container, relatedTarget) {
   function getTabs(root) {
     return relatedTarget && container && container.contains(relatedTarget);
     return root.querySelectorAll(TAB_SEL);
   }
   }


   function closestDef(target) {
   function getPanels(root) {
     if (!target || !target.closest) return null;
     return root.querySelectorAll(PANEL_SEL);
    return target.closest(".sv-def");
   }
   }


   // Hover in/out (desktop)
   function getPanelByKey(root, key) {
  document.addEventListener("mouseover", function (e) {
    var panels = getPanels(root);
     if (pinned) return;
    for (var i = 0; i < panels.length; i++) {
     var el = closestDef(e.target);
      if (panels[i].getAttribute("data-panel") === key) return panels[i];
     if (!el) return;
    }
     if (isEntering(el, e.relatedTarget)) return;
    return null;
     if (activeEl === el) return;
  }
     show(el);
 
   }, true);
  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");
   }


   document.addEventListener("mouseout", function (e) {
   function activateTab(root, btn) {
     if (pinned) return;
     if (!root || !btn) return;
    var el = closestDef(e.target);
    if (!el) return;
    if (isEntering(el, e.relatedTarget)) return;
    if (activeEl === el) hide();
  }, true);


  // Tap/click behavior:
    var tabs = getTabs(root);
  // - If data-sv-def-link is set, navigate (future-ready).
    var key = btn.getAttribute("data-tab") || "";
  // - Otherwise toggle a pinned tooltip (mobile-friendly).
  document.addEventListener("click", function (e) {
    var el = closestDef(e.target);


     // Click outside closes a pinned tooltip
     for (var i = 0; i < tabs.length; i++) {
    if (!el) {
       var t = tabs[i];
       if (pinned) hide();
      var active = t === btn;
       return;
      t.setAttribute("aria-selected", active ? "true" : "false");
      t.setAttribute("tabindex", active ? "0" : "-1");
       if (t.classList) t.classList.toggle("sv-tab--active", active);
     }
     }


     var link = qLink(el);
     var panels = getPanels(root);
     if (link) {
     for (var j = 0; j < panels.length; j++) {
       // Let it act like a link to a page title
       var p = panels[j];
       window.location.href = mw.util.getUrl(link);
       var isTarget = p.getAttribute("data-panel") === key;
       return;
      if (isTarget) showPanel(p);
       else hidePanel(p);
     }
     }


     var txt = qTipText(el);
     root.setAttribute("data-active-tab", key);
    if (!txt) return;
  }


     // Toggle pin
  function focusTab(tabs, idx) {
     e.preventDefault();
     if (idx < 0) idx = 0;
     e.stopPropagation();
     if (idx >= tabs.length) idx = tabs.length - 1;
     var t = tabs[idx];
    if (t && t.focus) t.focus();
    return t;
  }


     if (pinned && activeEl === el) {
  function indexOfTab(tabs, btn) {
       hide();
     for (var i = 0; i < tabs.length; i++) {
      return;
       if (tabs[i] === btn) return i;
     }
     }
    return -1;
  }


     pinned = true;
  function normalizeTabsRoot(root) {
     show(el);
     if (!root) return;
  }, true);
     if (root.getAttribute("data-gi-tabs-init") === "1") return;


  // Close on Escape
    ensureUniqueTabIds(root);
  document.addEventListener("keydown", function (e) {
 
     if (e.key === "Escape" && (pinned || activeEl)) {
    var tabs = getTabs(root);
       hide();
    var panels = getPanels(root);
     if (!tabs.length || !panels.length) {
       root.setAttribute("data-gi-tabs-init", "1");
      return;
     }
     }
  }, true);


  // Reposition if visible
    var activeBtn = null;
  window.addEventListener("resize", function () {
    for (var i = 0; i < tabs.length; i++) {
    if (activeEl && tipEl && tipEl.style.display === "block") {
      if (tabs[i].getAttribute("aria-selected") === "true") {
       positionTip(activeEl);
        activeBtn = tabs[i];
        break;
       }
     }
     }
  }, true);
    if (!activeBtn) activeBtn = tabs[0];
 
    activateTab(root, activeBtn);
    root.setAttribute("data-gi-tabs-init", "1");
  }


   // Capture scroll events from containers too
   function initTabs(root) {
   window.addEventListener("scroll", function () {
    var container = root || document;
     if (activeEl && tipEl && tipEl.style.display === "block") {
    var roots = container.querySelectorAll(TABS_ROOT_SEL);
       positionTip(activeEl);
    for (var i = 0; i < roots.length; i++) normalizeTabsRoot(roots[i]);
     }
  }
   }, true);
 
   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
  );
 
  document.addEventListener(
    "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
  );
 
  function initAllTabs(root) {
     initTabs(root);
  }
 
   if (window.mw && mw.hook) {
    mw.hook("wikipage.content").add(function ($content) {
      initAllTabs($content && $content[0]);
    });
  }


   // Support dynamic page content (VisualEditor, etc.)
   if (document.readyState === "loading") {
  mw.hook("wikipage.content").add(function () {
    document.addEventListener("DOMContentLoaded", function () {
     // No-op: event delegation already covers new content.
      initAllTabs(document);
   });
     });
})(window.mw);
   } else {
    initAllTabs(document);
  }
})();
Retrieved from "https://spiritvale.info/wiki/MediaWiki:Common.js"