查看“︁MediaWiki:Common.js”︁的源代码

function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
(function () {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __require = /* @__PURE__ */function (x) {
    return typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
      get: function get(a, b) {
        return (typeof require !== "undefined" ? require : a)[b];
      }
    }) : x;
  }(function (x) {
    if (typeof require !== "undefined") return require.apply(this, arguments);
    throw Error('Dynamic require of "' + x + '" is not supported');
  });
  var __commonJS = function __commonJS(cb, mod) {
    return function __require2() {
      try {
        return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
          exports: {}
        }).exports, mod), mod.exports;
      } catch (e) {
        throw mod = 0, e;
      }
    };
  };
  var __copyProps = function __copyProps(to, from, except, desc) {
    if (from && _typeof(from) === "object" || typeof from === "function") {
      var _iterator = _createForOfIteratorHelper(__getOwnPropNames(from)),
        _step;
      try {
        var _loop = function _loop() {
          var key = _step.value;
          if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
            get: function get() {
              return from[key];
            },
            enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
          });
        };
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
          _loop();
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }
    }
    return to;
  };
  var __toESM = function __toESM(mod, isNodeMode, target) {
    return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. "__esModule" has not been set), then set
    // "default" to the CommonJS "module.exports" for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
      value: mod,
      enumerable: true
    }) : target, mod);
  };

  // node_modules/.pnpm/parallax-js@3.1.0/node_modules/parallax-js/dist/parallax.js
  var require_parallax = __commonJS({
    "node_modules/.pnpm/parallax-js@3.1.0/node_modules/parallax-js/dist/parallax.js": function node_modules_Pnpm_parallaxJs310_node_modules_parallaxJs_dist_parallaxJs(exports, module) {
      (function (f) {
        if (_typeof(exports) === "object" && typeof module !== "undefined") {
          module.exports = f();
        } else if (typeof define === "function" && define.amd) {
          define([], f);
        } else {
          var g;
          if (typeof window !== "undefined") {
            g = window;
          } else if (typeof global !== "undefined") {
            g = global;
          } else if (typeof self !== "undefined") {
            g = self;
          } else {
            g = this;
          }
          g.Parallax = f();
        }
      })(function () {
        var define2, module2, exports2;
        return function e(t, n, r) {
          function s(o2, u) {
            if (!n[o2]) {
              if (!t[o2]) {
                var a = typeof __require == "function" && __require;
                if (!u && a) return a(o2, true);
                if (i) return i(o2, true);
                var f = new Error("Cannot find module '" + o2 + "'");
                throw f.code = "MODULE_NOT_FOUND", f;
              }
              var l = n[o2] = {
                exports: {}
              };
              t[o2][0].call(l.exports, function (e2) {
                var n2 = t[o2][1][e2];
                return s(n2 ? n2 : e2);
              }, l, l.exports, e, t, n, r);
            }
            return n[o2].exports;
          }
          var i = typeof __require == "function" && __require;
          for (var o = 0; o < r.length; o++) s(r[o]);
          return s;
        }({
          1: [function (require2, module3, exports3) {
            "use strict";

            var getOwnPropertySymbols = Object.getOwnPropertySymbols;
            var hasOwnProperty = Object.prototype.hasOwnProperty;
            var propIsEnumerable = Object.prototype.propertyIsEnumerable;
            function toObject(val) {
              if (val === null || val === void 0) {
                throw new TypeError("Object.assign cannot be called with null or undefined");
              }
              return Object(val);
            }
            function shouldUseNative() {
              try {
                if (!Object.assign) {
                  return false;
                }
                var test1 = new String("abc");
                test1[5] = "de";
                if (Object.getOwnPropertyNames(test1)[0] === "5") {
                  return false;
                }
                var test2 = {};
                for (var i = 0; i < 10; i++) {
                  test2["_" + String.fromCharCode(i)] = i;
                }
                var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
                  return test2[n];
                });
                if (order2.join("") !== "0123456789") {
                  return false;
                }
                var test3 = {};
                "abcdefghijklmnopqrst".split("").forEach(function (letter) {
                  test3[letter] = letter;
                });
                if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
                  return false;
                }
                return true;
              } catch (err) {
                return false;
              }
            }
            module3.exports = shouldUseNative() ? Object.assign : function (target, source) {
              var from;
              var to = toObject(target);
              var symbols;
              for (var s = 1; s < arguments.length; s++) {
                from = Object(arguments[s]);
                for (var key in from) {
                  if (hasOwnProperty.call(from, key)) {
                    to[key] = from[key];
                  }
                }
                if (getOwnPropertySymbols) {
                  symbols = getOwnPropertySymbols(from);
                  for (var i = 0; i < symbols.length; i++) {
                    if (propIsEnumerable.call(from, symbols[i])) {
                      to[symbols[i]] = from[symbols[i]];
                    }
                  }
                }
              }
              return to;
            };
          }, {}],
          2: [function (require2, module3, exports3) {
            (function (process) {
              (function () {
                var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;
                if (typeof performance !== "undefined" && performance !== null && performance.now) {
                  module3.exports = function () {
                    return performance.now();
                  };
                } else if (typeof process !== "undefined" && process !== null && process.hrtime) {
                  module3.exports = function () {
                    return (getNanoSeconds() - nodeLoadTime) / 1e6;
                  };
                  hrtime = process.hrtime;
                  getNanoSeconds = function getNanoSeconds() {
                    var hr;
                    hr = hrtime();
                    return hr[0] * 1e9 + hr[1];
                  };
                  moduleLoadTime = getNanoSeconds();
                  upTime = process.uptime() * 1e9;
                  nodeLoadTime = moduleLoadTime - upTime;
                } else if (Date.now) {
                  module3.exports = function () {
                    return Date.now() - loadTime;
                  };
                  loadTime = Date.now();
                } else {
                  module3.exports = function () {
                    return (/* @__PURE__ */new Date()).getTime() - loadTime;
                  };
                  loadTime = (/* @__PURE__ */new Date()).getTime();
                }
              }).call(this);
            }).call(this, require2("_process"));
          }, {
            "_process": 3
          }],
          3: [function (require2, module3, exports3) {
            var process = module3.exports = {};
            var cachedSetTimeout;
            var cachedClearTimeout;
            function defaultSetTimout() {
              throw new Error("setTimeout has not been defined");
            }
            function defaultClearTimeout() {
              throw new Error("clearTimeout has not been defined");
            }
            (function () {
              try {
                if (typeof setTimeout === "function") {
                  cachedSetTimeout = setTimeout;
                } else {
                  cachedSetTimeout = defaultSetTimout;
                }
              } catch (e) {
                cachedSetTimeout = defaultSetTimout;
              }
              try {
                if (typeof clearTimeout === "function") {
                  cachedClearTimeout = clearTimeout;
                } else {
                  cachedClearTimeout = defaultClearTimeout;
                }
              } catch (e) {
                cachedClearTimeout = defaultClearTimeout;
              }
            })();
            function runTimeout(fun) {
              if (cachedSetTimeout === setTimeout) {
                return setTimeout(fun, 0);
              }
              if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
                cachedSetTimeout = setTimeout;
                return setTimeout(fun, 0);
              }
              try {
                return cachedSetTimeout(fun, 0);
              } catch (e) {
                try {
                  return cachedSetTimeout.call(null, fun, 0);
                } catch (e2) {
                  return cachedSetTimeout.call(this, fun, 0);
                }
              }
            }
            function runClearTimeout(marker) {
              if (cachedClearTimeout === clearTimeout) {
                return clearTimeout(marker);
              }
              if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
                cachedClearTimeout = clearTimeout;
                return clearTimeout(marker);
              }
              try {
                return cachedClearTimeout(marker);
              } catch (e) {
                try {
                  return cachedClearTimeout.call(null, marker);
                } catch (e2) {
                  return cachedClearTimeout.call(this, marker);
                }
              }
            }
            var queue = [];
            var draining = false;
            var currentQueue;
            var queueIndex = -1;
            function cleanUpNextTick() {
              if (!draining || !currentQueue) {
                return;
              }
              draining = false;
              if (currentQueue.length) {
                queue = currentQueue.concat(queue);
              } else {
                queueIndex = -1;
              }
              if (queue.length) {
                drainQueue();
              }
            }
            function drainQueue() {
              if (draining) {
                return;
              }
              var timeout = runTimeout(cleanUpNextTick);
              draining = true;
              var len = queue.length;
              while (len) {
                currentQueue = queue;
                queue = [];
                while (++queueIndex < len) {
                  if (currentQueue) {
                    currentQueue[queueIndex].run();
                  }
                }
                queueIndex = -1;
                len = queue.length;
              }
              currentQueue = null;
              draining = false;
              runClearTimeout(timeout);
            }
            process.nextTick = function (fun) {
              var args = new Array(arguments.length - 1);
              if (arguments.length > 1) {
                for (var i = 1; i < arguments.length; i++) {
                  args[i - 1] = arguments[i];
                }
              }
              queue.push(new Item(fun, args));
              if (queue.length === 1 && !draining) {
                runTimeout(drainQueue);
              }
            };
            function Item(fun, array) {
              this.fun = fun;
              this.array = array;
            }
            Item.prototype.run = function () {
              this.fun.apply(null, this.array);
            };
            process.title = "browser";
            process.browser = true;
            process.env = {};
            process.argv = [];
            process.version = "";
            process.versions = {};
            function noop() {}
            process.on = noop;
            process.addListener = noop;
            process.once = noop;
            process.off = noop;
            process.removeListener = noop;
            process.removeAllListeners = noop;
            process.emit = noop;
            process.prependListener = noop;
            process.prependOnceListener = noop;
            process.listeners = function (name) {
              return [];
            };
            process.binding = function (name) {
              throw new Error("process.binding is not supported");
            };
            process.cwd = function () {
              return "/";
            };
            process.chdir = function (dir) {
              throw new Error("process.chdir is not supported");
            };
            process.umask = function () {
              return 0;
            };
          }, {}],
          4: [function (require2, module3, exports3) {
            (function (global2) {
              var now = require2("performance-now"),
                root = typeof window === "undefined" ? global2 : window,
                vendors = ["moz", "webkit"],
                suffix = "AnimationFrame",
                raf = root["request" + suffix],
                caf = root["cancel" + suffix] || root["cancelRequest" + suffix];
              for (var i = 0; !raf && i < vendors.length; i++) {
                raf = root[vendors[i] + "Request" + suffix];
                caf = root[vendors[i] + "Cancel" + suffix] || root[vendors[i] + "CancelRequest" + suffix];
              }
              if (!raf || !caf) {
                var last = 0,
                  id = 0,
                  queue = [],
                  frameDuration = 1e3 / 60;
                raf = function raf(callback) {
                  if (queue.length === 0) {
                    var _now = now(),
                      next = Math.max(0, frameDuration - (_now - last));
                    last = next + _now;
                    setTimeout(function () {
                      var cp = queue.slice(0);
                      queue.length = 0;
                      var _loop2 = function _loop2() {
                        if (!cp[i2].cancelled) {
                          try {
                            cp[i2].callback(last);
                          } catch (e) {
                            setTimeout(function () {
                              throw e;
                            }, 0);
                          }
                        }
                      };
                      for (var i2 = 0; i2 < cp.length; i2++) {
                        _loop2();
                      }
                    }, Math.round(next));
                  }
                  queue.push({
                    handle: ++id,
                    callback: callback,
                    cancelled: false
                  });
                  return id;
                };
                caf = function caf(handle) {
                  for (var i2 = 0; i2 < queue.length; i2++) {
                    if (queue[i2].handle === handle) {
                      queue[i2].cancelled = true;
                    }
                  }
                };
              }
              module3.exports = function (fn) {
                return raf.call(root, fn);
              };
              module3.exports.cancel = function () {
                caf.apply(root, arguments);
              };
              module3.exports.polyfill = function () {
                root.requestAnimationFrame = raf;
                root.cancelAnimationFrame = caf;
              };
            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
          }, {
            "performance-now": 2
          }],
          5: [function (require2, module3, exports3) {
            "use strict";

            var _createClass = /* @__PURE__ */function () {
              function defineProperties(target, props) {
                for (var i = 0; i < props.length; i++) {
                  var descriptor = props[i];
                  descriptor.enumerable = descriptor.enumerable || false;
                  descriptor.configurable = true;
                  if ("value" in descriptor) descriptor.writable = true;
                  Object.defineProperty(target, descriptor.key, descriptor);
                }
              }
              return function (Constructor, protoProps, staticProps) {
                if (protoProps) defineProperties(Constructor.prototype, protoProps);
                if (staticProps) defineProperties(Constructor, staticProps);
                return Constructor;
              };
            }();
            function _classCallCheck(instance, Constructor) {
              if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
              }
            }
            var rqAnFr = require2("raf");
            var objectAssign = require2("object-assign");
            var helpers = {
              propertyCache: {},
              vendors: [null, ["-webkit-", "webkit"], ["-moz-", "Moz"], ["-o-", "O"], ["-ms-", "ms"]],
              clamp: function clamp(value, min, max) {
                return min < max ? value < min ? min : value > max ? max : value : value < max ? max : value > min ? min : value;
              },
              data: function data(element, name) {
                return helpers.deserialize(element.getAttribute("data-" + name));
              },
              deserialize: function deserialize(value) {
                if (value === "true") {
                  return true;
                } else if (value === "false") {
                  return false;
                } else if (value === "null") {
                  return null;
                } else if (!isNaN(parseFloat(value)) && isFinite(value)) {
                  return parseFloat(value);
                } else {
                  return value;
                }
              },
              camelCase: function camelCase(value) {
                return value.replace(/-+(.)?/g, function (match, character) {
                  return character ? character.toUpperCase() : "";
                });
              },
              accelerate: function accelerate(element) {
                helpers.css(element, "transform", "translate3d(0,0,0) rotate(0.0001deg)");
                helpers.css(element, "transform-style", "preserve-3d");
                helpers.css(element, "backface-visibility", "hidden");
              },
              transformSupport: function transformSupport(value) {
                var element = document.createElement("div"),
                  propertySupport = false,
                  propertyValue = null,
                  featureSupport = false,
                  cssProperty = null,
                  jsProperty = null;
                for (var i = 0, l = helpers.vendors.length; i < l; i++) {
                  if (helpers.vendors[i] !== null) {
                    cssProperty = helpers.vendors[i][0] + "transform";
                    jsProperty = helpers.vendors[i][1] + "Transform";
                  } else {
                    cssProperty = "transform";
                    jsProperty = "transform";
                  }
                  if (element.style[jsProperty] !== void 0) {
                    propertySupport = true;
                    break;
                  }
                }
                switch (value) {
                  case "2D":
                    featureSupport = propertySupport;
                    break;
                  case "3D":
                    if (propertySupport) {
                      var body2 = document.body || document.createElement("body"),
                        documentElement = document.documentElement,
                        documentOverflow = documentElement.style.overflow,
                        isCreatedBody = false;
                      if (!document.body) {
                        isCreatedBody = true;
                        documentElement.style.overflow = "hidden";
                        documentElement.appendChild(body2);
                        body2.style.overflow = "hidden";
                        body2.style.background = "";
                      }
                      body2.appendChild(element);
                      element.style[jsProperty] = "translate3d(1px,1px,1px)";
                      propertyValue = window.getComputedStyle(element).getPropertyValue(cssProperty);
                      featureSupport = propertyValue !== void 0 && propertyValue.length > 0 && propertyValue !== "none";
                      documentElement.style.overflow = documentOverflow;
                      body2.removeChild(element);
                      if (isCreatedBody) {
                        body2.removeAttribute("style");
                        body2.parentNode.removeChild(body2);
                      }
                    }
                    break;
                }
                return featureSupport;
              },
              css: function css(element, property, value) {
                var jsProperty = helpers.propertyCache[property];
                if (!jsProperty) {
                  for (var i = 0, l = helpers.vendors.length; i < l; i++) {
                    if (helpers.vendors[i] !== null) {
                      jsProperty = helpers.camelCase(helpers.vendors[i][1] + "-" + property);
                    } else {
                      jsProperty = property;
                    }
                    if (element.style[jsProperty] !== void 0) {
                      helpers.propertyCache[property] = jsProperty;
                      break;
                    }
                  }
                }
                element.style[jsProperty] = value;
              }
            };
            var MAGIC_NUMBER = 30,
              DEFAULTS = {
                relativeInput: false,
                clipRelativeInput: false,
                inputElement: null,
                hoverOnly: false,
                calibrationThreshold: 100,
                calibrationDelay: 500,
                supportDelay: 500,
                calibrateX: false,
                calibrateY: true,
                invertX: true,
                invertY: true,
                limitX: false,
                limitY: false,
                scalarX: 10,
                scalarY: 10,
                frictionX: 0.1,
                frictionY: 0.1,
                originX: 0.5,
                originY: 0.5,
                pointerEvents: false,
                precision: 1,
                onReady: null,
                selector: null
              };
            var Parallax2 = function () {
              function Parallax3(element, options) {
                _classCallCheck(this, Parallax3);
                this.element = element;
                var data = {
                  calibrateX: helpers.data(this.element, "calibrate-x"),
                  calibrateY: helpers.data(this.element, "calibrate-y"),
                  invertX: helpers.data(this.element, "invert-x"),
                  invertY: helpers.data(this.element, "invert-y"),
                  limitX: helpers.data(this.element, "limit-x"),
                  limitY: helpers.data(this.element, "limit-y"),
                  scalarX: helpers.data(this.element, "scalar-x"),
                  scalarY: helpers.data(this.element, "scalar-y"),
                  frictionX: helpers.data(this.element, "friction-x"),
                  frictionY: helpers.data(this.element, "friction-y"),
                  originX: helpers.data(this.element, "origin-x"),
                  originY: helpers.data(this.element, "origin-y"),
                  pointerEvents: helpers.data(this.element, "pointer-events"),
                  precision: helpers.data(this.element, "precision"),
                  relativeInput: helpers.data(this.element, "relative-input"),
                  clipRelativeInput: helpers.data(this.element, "clip-relative-input"),
                  hoverOnly: helpers.data(this.element, "hover-only"),
                  inputElement: document.querySelector(helpers.data(this.element, "input-element")),
                  selector: helpers.data(this.element, "selector")
                };
                for (var key in data) {
                  if (data[key] === null) {
                    delete data[key];
                  }
                }
                objectAssign(this, DEFAULTS, data, options);
                if (!this.inputElement) {
                  this.inputElement = this.element;
                }
                this.calibrationTimer = null;
                this.calibrationFlag = true;
                this.enabled = false;
                this.depthsX = [];
                this.depthsY = [];
                this.raf = null;
                this.bounds = null;
                this.elementPositionX = 0;
                this.elementPositionY = 0;
                this.elementWidth = 0;
                this.elementHeight = 0;
                this.elementCenterX = 0;
                this.elementCenterY = 0;
                this.elementRangeX = 0;
                this.elementRangeY = 0;
                this.calibrationX = 0;
                this.calibrationY = 0;
                this.inputX = 0;
                this.inputY = 0;
                this.motionX = 0;
                this.motionY = 0;
                this.velocityX = 0;
                this.velocityY = 0;
                this.onMouseMove = this.onMouseMove.bind(this);
                this.onDeviceOrientation = this.onDeviceOrientation.bind(this);
                this.onDeviceMotion = this.onDeviceMotion.bind(this);
                this.onOrientationTimer = this.onOrientationTimer.bind(this);
                this.onMotionTimer = this.onMotionTimer.bind(this);
                this.onCalibrationTimer = this.onCalibrationTimer.bind(this);
                this.onAnimationFrame = this.onAnimationFrame.bind(this);
                this.onWindowResize = this.onWindowResize.bind(this);
                this.windowWidth = null;
                this.windowHeight = null;
                this.windowCenterX = null;
                this.windowCenterY = null;
                this.windowRadiusX = null;
                this.windowRadiusY = null;
                this.portrait = false;
                this.desktop = !navigator.userAgent.match(/(iPhone|iPod|iPad|Android|BlackBerry|BB10|mobi|tablet|opera mini|nexus 7)/i);
                this.motionSupport = !!window.DeviceMotionEvent && !this.desktop;
                this.orientationSupport = !!window.DeviceOrientationEvent && !this.desktop;
                this.orientationStatus = 0;
                this.motionStatus = 0;
                this.initialise();
              }
              _createClass(Parallax3, [{
                key: "initialise",
                value: function initialise() {
                  if (this.transform2DSupport === void 0) {
                    this.transform2DSupport = helpers.transformSupport("2D");
                    this.transform3DSupport = helpers.transformSupport("3D");
                  }
                  if (this.transform3DSupport) {
                    helpers.accelerate(this.element);
                  }
                  var style = window.getComputedStyle(this.element);
                  if (style.getPropertyValue("position") === "static") {
                    this.element.style.position = "relative";
                  }
                  if (!this.pointerEvents) {
                    this.element.style.pointerEvents = "none";
                  }
                  this.updateLayers();
                  this.updateDimensions();
                  this.enable();
                  this.queueCalibration(this.calibrationDelay);
                }
              }, {
                key: "doReadyCallback",
                value: function doReadyCallback() {
                  if (this.onReady) {
                    this.onReady();
                  }
                }
              }, {
                key: "updateLayers",
                value: function updateLayers() {
                  if (this.selector) {
                    this.layers = this.element.querySelectorAll(this.selector);
                  } else {
                    this.layers = this.element.children;
                  }
                  if (!this.layers.length) {
                    console.warn("ParallaxJS: Your scene does not have any layers.");
                  }
                  this.depthsX = [];
                  this.depthsY = [];
                  for (var index = 0; index < this.layers.length; index++) {
                    var layer = this.layers[index];
                    if (this.transform3DSupport) {
                      helpers.accelerate(layer);
                    }
                    layer.style.position = index ? "absolute" : "relative";
                    layer.style.display = "block";
                    layer.style.left = 0;
                    layer.style.top = 0;
                    var depth = helpers.data(layer, "depth") || 0;
                    this.depthsX.push(helpers.data(layer, "depth-x") || depth);
                    this.depthsY.push(helpers.data(layer, "depth-y") || depth);
                  }
                }
              }, {
                key: "updateDimensions",
                value: function updateDimensions() {
                  this.windowWidth = window.innerWidth;
                  this.windowHeight = window.innerHeight;
                  this.windowCenterX = this.windowWidth * this.originX;
                  this.windowCenterY = this.windowHeight * this.originY;
                  this.windowRadiusX = Math.max(this.windowCenterX, this.windowWidth - this.windowCenterX);
                  this.windowRadiusY = Math.max(this.windowCenterY, this.windowHeight - this.windowCenterY);
                }
              }, {
                key: "updateBounds",
                value: function updateBounds() {
                  this.bounds = this.inputElement.getBoundingClientRect();
                  this.elementPositionX = this.bounds.left;
                  this.elementPositionY = this.bounds.top;
                  this.elementWidth = this.bounds.width;
                  this.elementHeight = this.bounds.height;
                  this.elementCenterX = this.elementWidth * this.originX;
                  this.elementCenterY = this.elementHeight * this.originY;
                  this.elementRangeX = Math.max(this.elementCenterX, this.elementWidth - this.elementCenterX);
                  this.elementRangeY = Math.max(this.elementCenterY, this.elementHeight - this.elementCenterY);
                }
              }, {
                key: "queueCalibration",
                value: function queueCalibration(delay) {
                  clearTimeout(this.calibrationTimer);
                  this.calibrationTimer = setTimeout(this.onCalibrationTimer, delay);
                }
              }, {
                key: "enable",
                value: function enable() {
                  if (this.enabled) {
                    return;
                  }
                  this.enabled = true;
                  if (this.orientationSupport) {
                    this.portrait = false;
                    window.addEventListener("deviceorientation", this.onDeviceOrientation);
                    this.detectionTimer = setTimeout(this.onOrientationTimer, this.supportDelay);
                  } else if (this.motionSupport) {
                    this.portrait = false;
                    window.addEventListener("devicemotion", this.onDeviceMotion);
                    this.detectionTimer = setTimeout(this.onMotionTimer, this.supportDelay);
                  } else {
                    this.calibrationX = 0;
                    this.calibrationY = 0;
                    this.portrait = false;
                    window.addEventListener("mousemove", this.onMouseMove);
                    this.doReadyCallback();
                  }
                  window.addEventListener("resize", this.onWindowResize);
                  this.raf = rqAnFr(this.onAnimationFrame);
                }
              }, {
                key: "disable",
                value: function disable() {
                  if (!this.enabled) {
                    return;
                  }
                  this.enabled = false;
                  if (this.orientationSupport) {
                    window.removeEventListener("deviceorientation", this.onDeviceOrientation);
                  } else if (this.motionSupport) {
                    window.removeEventListener("devicemotion", this.onDeviceMotion);
                  } else {
                    window.removeEventListener("mousemove", this.onMouseMove);
                  }
                  window.removeEventListener("resize", this.onWindowResize);
                  rqAnFr.cancel(this.raf);
                }
              }, {
                key: "calibrate",
                value: function calibrate(x, y) {
                  this.calibrateX = x === void 0 ? this.calibrateX : x;
                  this.calibrateY = y === void 0 ? this.calibrateY : y;
                }
              }, {
                key: "invert",
                value: function invert(x, y) {
                  this.invertX = x === void 0 ? this.invertX : x;
                  this.invertY = y === void 0 ? this.invertY : y;
                }
              }, {
                key: "friction",
                value: function friction(x, y) {
                  this.frictionX = x === void 0 ? this.frictionX : x;
                  this.frictionY = y === void 0 ? this.frictionY : y;
                }
              }, {
                key: "scalar",
                value: function scalar(x, y) {
                  this.scalarX = x === void 0 ? this.scalarX : x;
                  this.scalarY = y === void 0 ? this.scalarY : y;
                }
              }, {
                key: "limit",
                value: function limit(x, y) {
                  this.limitX = x === void 0 ? this.limitX : x;
                  this.limitY = y === void 0 ? this.limitY : y;
                }
              }, {
                key: "origin",
                value: function origin(x, y) {
                  this.originX = x === void 0 ? this.originX : x;
                  this.originY = y === void 0 ? this.originY : y;
                }
              }, {
                key: "setInputElement",
                value: function setInputElement(element) {
                  this.inputElement = element;
                  this.updateDimensions();
                }
              }, {
                key: "setPosition",
                value: function setPosition(element, x, y) {
                  x = x.toFixed(this.precision) + "px";
                  y = y.toFixed(this.precision) + "px";
                  if (this.transform3DSupport) {
                    helpers.css(element, "transform", "translate3d(" + x + "," + y + ",0)");
                  } else if (this.transform2DSupport) {
                    helpers.css(element, "transform", "translate(" + x + "," + y + ")");
                  } else {
                    element.style.left = x;
                    element.style.top = y;
                  }
                }
              }, {
                key: "onOrientationTimer",
                value: function onOrientationTimer() {
                  if (this.orientationSupport && this.orientationStatus === 0) {
                    this.disable();
                    this.orientationSupport = false;
                    this.enable();
                  } else {
                    this.doReadyCallback();
                  }
                }
              }, {
                key: "onMotionTimer",
                value: function onMotionTimer() {
                  if (this.motionSupport && this.motionStatus === 0) {
                    this.disable();
                    this.motionSupport = false;
                    this.enable();
                  } else {
                    this.doReadyCallback();
                  }
                }
              }, {
                key: "onCalibrationTimer",
                value: function onCalibrationTimer() {
                  this.calibrationFlag = true;
                }
              }, {
                key: "onWindowResize",
                value: function onWindowResize() {
                  this.updateDimensions();
                }
              }, {
                key: "onAnimationFrame",
                value: function onAnimationFrame() {
                  this.updateBounds();
                  var calibratedInputX = this.inputX - this.calibrationX,
                    calibratedInputY = this.inputY - this.calibrationY;
                  if (Math.abs(calibratedInputX) > this.calibrationThreshold || Math.abs(calibratedInputY) > this.calibrationThreshold) {
                    this.queueCalibration(0);
                  }
                  if (this.portrait) {
                    this.motionX = this.calibrateX ? calibratedInputY : this.inputY;
                    this.motionY = this.calibrateY ? calibratedInputX : this.inputX;
                  } else {
                    this.motionX = this.calibrateX ? calibratedInputX : this.inputX;
                    this.motionY = this.calibrateY ? calibratedInputY : this.inputY;
                  }
                  this.motionX *= this.elementWidth * (this.scalarX / 100);
                  this.motionY *= this.elementHeight * (this.scalarY / 100);
                  if (!isNaN(parseFloat(this.limitX))) {
                    this.motionX = helpers.clamp(this.motionX, -this.limitX, this.limitX);
                  }
                  if (!isNaN(parseFloat(this.limitY))) {
                    this.motionY = helpers.clamp(this.motionY, -this.limitY, this.limitY);
                  }
                  this.velocityX += (this.motionX - this.velocityX) * this.frictionX;
                  this.velocityY += (this.motionY - this.velocityY) * this.frictionY;
                  for (var index = 0; index < this.layers.length; index++) {
                    var layer = this.layers[index],
                      depthX = this.depthsX[index],
                      depthY = this.depthsY[index],
                      xOffset = this.velocityX * (depthX * (this.invertX ? -1 : 1)),
                      yOffset = this.velocityY * (depthY * (this.invertY ? -1 : 1));
                    this.setPosition(layer, xOffset, yOffset);
                  }
                  this.raf = rqAnFr(this.onAnimationFrame);
                }
              }, {
                key: "rotate",
                value: function rotate(beta, gamma) {
                  var x = (beta || 0) / MAGIC_NUMBER,
                    y = (gamma || 0) / MAGIC_NUMBER;
                  var portrait = this.windowHeight > this.windowWidth;
                  if (this.portrait !== portrait) {
                    this.portrait = portrait;
                    this.calibrationFlag = true;
                  }
                  if (this.calibrationFlag) {
                    this.calibrationFlag = false;
                    this.calibrationX = x;
                    this.calibrationY = y;
                  }
                  this.inputX = x;
                  this.inputY = y;
                }
              }, {
                key: "onDeviceOrientation",
                value: function onDeviceOrientation(event) {
                  var beta = event.beta;
                  var gamma = event.gamma;
                  if (beta !== null && gamma !== null) {
                    this.orientationStatus = 1;
                    this.rotate(beta, gamma);
                  }
                }
              }, {
                key: "onDeviceMotion",
                value: function onDeviceMotion(event) {
                  var beta = event.rotationRate.beta;
                  var gamma = event.rotationRate.gamma;
                  if (beta !== null && gamma !== null) {
                    this.motionStatus = 1;
                    this.rotate(beta, gamma);
                  }
                }
              }, {
                key: "onMouseMove",
                value: function onMouseMove(event) {
                  var clientX = event.clientX,
                    clientY = event.clientY;
                  if (this.hoverOnly && (clientX < this.elementPositionX || clientX > this.elementPositionX + this.elementWidth || clientY < this.elementPositionY || clientY > this.elementPositionY + this.elementHeight)) {
                    this.inputX = 0;
                    this.inputY = 0;
                    return;
                  }
                  if (this.relativeInput) {
                    if (this.clipRelativeInput) {
                      clientX = Math.max(clientX, this.elementPositionX);
                      clientX = Math.min(clientX, this.elementPositionX + this.elementWidth);
                      clientY = Math.max(clientY, this.elementPositionY);
                      clientY = Math.min(clientY, this.elementPositionY + this.elementHeight);
                    }
                    if (this.elementRangeX && this.elementRangeY) {
                      this.inputX = (clientX - this.elementPositionX - this.elementCenterX) / this.elementRangeX;
                      this.inputY = (clientY - this.elementPositionY - this.elementCenterY) / this.elementRangeY;
                    }
                  } else {
                    if (this.windowRadiusX && this.windowRadiusY) {
                      this.inputX = (clientX - this.windowCenterX) / this.windowRadiusX;
                      this.inputY = (clientY - this.windowCenterY) / this.windowRadiusY;
                    }
                  }
                }
              }, {
                key: "destroy",
                value: function destroy() {
                  this.disable();
                  clearTimeout(this.calibrationTimer);
                  clearTimeout(this.detectionTimer);
                  this.element.removeAttribute("style");
                  for (var index = 0; index < this.layers.length; index++) {
                    this.layers[index].removeAttribute("style");
                  }
                  delete this.element;
                  delete this.layers;
                }
              }, {
                key: "version",
                value: function version() {
                  return "3.1.0";
                }
              }]);
              return Parallax3;
            }();
            module3.exports = Parallax2;
          }, {
            "object-assign": 1,
            "raf": 4
          }]
        }, {}, [5])(5);
      });
    }
  });

  // src/main.js
  var import_parallax_js = __toESM(require_parallax());
  if (!window.SLOADED) {
    window.SLOADED = {};
    window.RELOAD = true;
  } else {
    window.RELOAD = false;
  }
  var scene = document.createElement("div");
  document.body.appendChild(scene);
  scene.id = "scene";
  scene.dataset.turboPermanent = "true";
  scene.style.zIndex = -100;
  scene.style.position = "fixed";
  scene.id = "parallax-bg";
  scene.style.inset = "-300px";
  var img = document.createElement("img");
  scene.appendChild(img);
  img.src = "/mediawiki/images/9/93/Qysf-background1.jpg";
  img.dataset.depth = 0.5;
  new import_parallax_js["default"](scene);
})();
/*! Bundled license information:

parallax-js/dist/parallax.js:
  (*
  object-assign
  (c) Sindre Sorhus
  @license MIT
  *)
*/