pixi-watchface-engine 0.1.0 → 0.1.1

package/dist/index.js

@@ -33036,12 +33036,15 @@ class Text extends AbstractText {
   }
 }
 // node_modules/pixi.js/lib/index.mjs
+init_Point();
+init_Rectangle();
 init_Texture();
 init_textureFrom();
 init_Container();
 init_Graphics();
 init_Sprite();
 init_TextStyle();
+init_Ticker();
 init_eventemitter3();
 extensions.add(browserExt, webworkerExt);
 
@@ -34984,9 +34987,1575 @@ class KeyboardShortcutsPlugin {
     }
   }
 }
+// node_modules/pixi-viewport/dist/pixi_viewport.js
+var S2 = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function M2(l2) {
+  return l2 && l2.__esModule && Object.prototype.hasOwnProperty.call(l2, "default") ? l2.default : l2;
+}
+var W = { exports: {} };
+(function(l2, t2) {
+  (function() {
+    var e2, n2;
+    n2 = function(i2) {
+      return l2.exports = i2;
+    }, e2 = {
+      linear: function(i2, s2, h2, o2) {
+        return h2 * i2 / o2 + s2;
+      },
+      easeInQuad: function(i2, s2, h2, o2) {
+        return h2 * (i2 /= o2) * i2 + s2;
+      },
+      easeOutQuad: function(i2, s2, h2, o2) {
+        return -h2 * (i2 /= o2) * (i2 - 2) + s2;
+      },
+      easeInOutQuad: function(i2, s2, h2, o2) {
+        return (i2 /= o2 / 2) < 1 ? h2 / 2 * i2 * i2 + s2 : -h2 / 2 * (--i2 * (i2 - 2) - 1) + s2;
+      },
+      easeInCubic: function(i2, s2, h2, o2) {
+        return h2 * (i2 /= o2) * i2 * i2 + s2;
+      },
+      easeOutCubic: function(i2, s2, h2, o2) {
+        return h2 * ((i2 = i2 / o2 - 1) * i2 * i2 + 1) + s2;
+      },
+      easeInOutCubic: function(i2, s2, h2, o2) {
+        return (i2 /= o2 / 2) < 1 ? h2 / 2 * i2 * i2 * i2 + s2 : h2 / 2 * ((i2 -= 2) * i2 * i2 + 2) + s2;
+      },
+      easeInQuart: function(i2, s2, h2, o2) {
+        return h2 * (i2 /= o2) * i2 * i2 * i2 + s2;
+      },
+      easeOutQuart: function(i2, s2, h2, o2) {
+        return -h2 * ((i2 = i2 / o2 - 1) * i2 * i2 * i2 - 1) + s2;
+      },
+      easeInOutQuart: function(i2, s2, h2, o2) {
+        return (i2 /= o2 / 2) < 1 ? h2 / 2 * i2 * i2 * i2 * i2 + s2 : -h2 / 2 * ((i2 -= 2) * i2 * i2 * i2 - 2) + s2;
+      },
+      easeInQuint: function(i2, s2, h2, o2) {
+        return h2 * (i2 /= o2) * i2 * i2 * i2 * i2 + s2;
+      },
+      easeOutQuint: function(i2, s2, h2, o2) {
+        return h2 * ((i2 = i2 / o2 - 1) * i2 * i2 * i2 * i2 + 1) + s2;
+      },
+      easeInOutQuint: function(i2, s2, h2, o2) {
+        return (i2 /= o2 / 2) < 1 ? h2 / 2 * i2 * i2 * i2 * i2 * i2 + s2 : h2 / 2 * ((i2 -= 2) * i2 * i2 * i2 * i2 + 2) + s2;
+      },
+      easeInSine: function(i2, s2, h2, o2) {
+        return -h2 * Math.cos(i2 / o2 * (Math.PI / 2)) + h2 + s2;
+      },
+      easeOutSine: function(i2, s2, h2, o2) {
+        return h2 * Math.sin(i2 / o2 * (Math.PI / 2)) + s2;
+      },
+      easeInOutSine: function(i2, s2, h2, o2) {
+        return -h2 / 2 * (Math.cos(Math.PI * i2 / o2) - 1) + s2;
+      },
+      easeInExpo: function(i2, s2, h2, o2) {
+        return i2 === 0 ? s2 : h2 * Math.pow(2, 10 * (i2 / o2 - 1)) + s2;
+      },
+      easeOutExpo: function(i2, s2, h2, o2) {
+        return i2 === o2 ? s2 + h2 : h2 * (-Math.pow(2, -10 * i2 / o2) + 1) + s2;
+      },
+      easeInOutExpo: function(i2, s2, h2, o2) {
+        return (i2 /= o2 / 2) < 1 ? h2 / 2 * Math.pow(2, 10 * (i2 - 1)) + s2 : h2 / 2 * (-Math.pow(2, -10 * --i2) + 2) + s2;
+      },
+      easeInCirc: function(i2, s2, h2, o2) {
+        return -h2 * (Math.sqrt(1 - (i2 /= o2) * i2) - 1) + s2;
+      },
+      easeOutCirc: function(i2, s2, h2, o2) {
+        return h2 * Math.sqrt(1 - (i2 = i2 / o2 - 1) * i2) + s2;
+      },
+      easeInOutCirc: function(i2, s2, h2, o2) {
+        return (i2 /= o2 / 2) < 1 ? -h2 / 2 * (Math.sqrt(1 - i2 * i2) - 1) + s2 : h2 / 2 * (Math.sqrt(1 - (i2 -= 2) * i2) + 1) + s2;
+      },
+      easeInElastic: function(i2, s2, h2, o2) {
+        var r2, a2, p2;
+        return p2 = 1.70158, a2 = 0, r2 = h2, i2 === 0 || (i2 /= o2), a2 || (a2 = o2 * 0.3), r2 < Math.abs(h2) ? (r2 = h2, p2 = a2 / 4) : p2 = a2 / (2 * Math.PI) * Math.asin(h2 / r2), -(r2 * Math.pow(2, 10 * (i2 -= 1)) * Math.sin((i2 * o2 - p2) * (2 * Math.PI) / a2)) + s2;
+      },
+      easeOutElastic: function(i2, s2, h2, o2) {
+        var r2, a2, p2;
+        return p2 = 1.70158, a2 = 0, r2 = h2, i2 === 0 || (i2 /= o2), a2 || (a2 = o2 * 0.3), r2 < Math.abs(h2) ? (r2 = h2, p2 = a2 / 4) : p2 = a2 / (2 * Math.PI) * Math.asin(h2 / r2), r2 * Math.pow(2, -10 * i2) * Math.sin((i2 * o2 - p2) * (2 * Math.PI) / a2) + h2 + s2;
+      },
+      easeInOutElastic: function(i2, s2, h2, o2) {
+        var r2, a2, p2;
+        return p2 = 1.70158, a2 = 0, r2 = h2, i2 === 0 || (i2 /= o2 / 2), a2 || (a2 = o2 * (0.3 * 1.5)), r2 < Math.abs(h2) ? (r2 = h2, p2 = a2 / 4) : p2 = a2 / (2 * Math.PI) * Math.asin(h2 / r2), i2 < 1 ? -0.5 * (r2 * Math.pow(2, 10 * (i2 -= 1)) * Math.sin((i2 * o2 - p2) * (2 * Math.PI) / a2)) + s2 : r2 * Math.pow(2, -10 * (i2 -= 1)) * Math.sin((i2 * o2 - p2) * (2 * Math.PI) / a2) * 0.5 + h2 + s2;
+      },
+      easeInBack: function(i2, s2, h2, o2, r2) {
+        return r2 === undefined && (r2 = 1.70158), h2 * (i2 /= o2) * i2 * ((r2 + 1) * i2 - r2) + s2;
+      },
+      easeOutBack: function(i2, s2, h2, o2, r2) {
+        return r2 === undefined && (r2 = 1.70158), h2 * ((i2 = i2 / o2 - 1) * i2 * ((r2 + 1) * i2 + r2) + 1) + s2;
+      },
+      easeInOutBack: function(i2, s2, h2, o2, r2) {
+        return r2 === undefined && (r2 = 1.70158), (i2 /= o2 / 2) < 1 ? h2 / 2 * (i2 * i2 * (((r2 *= 1.525) + 1) * i2 - r2)) + s2 : h2 / 2 * ((i2 -= 2) * i2 * (((r2 *= 1.525) + 1) * i2 + r2) + 2) + s2;
+      },
+      easeInBounce: function(i2, s2, h2, o2) {
+        var r2;
+        return r2 = e2.easeOutBounce(o2 - i2, 0, h2, o2), h2 - r2 + s2;
+      },
+      easeOutBounce: function(i2, s2, h2, o2) {
+        return (i2 /= o2) < 1 / 2.75 ? h2 * (7.5625 * i2 * i2) + s2 : i2 < 2 / 2.75 ? h2 * (7.5625 * (i2 -= 1.5 / 2.75) * i2 + 0.75) + s2 : i2 < 2.5 / 2.75 ? h2 * (7.5625 * (i2 -= 2.25 / 2.75) * i2 + 0.9375) + s2 : h2 * (7.5625 * (i2 -= 2.625 / 2.75) * i2 + 0.984375) + s2;
+      },
+      easeInOutBounce: function(i2, s2, h2, o2) {
+        var r2;
+        return i2 < o2 / 2 ? (r2 = e2.easeInBounce(i2 * 2, 0, h2, o2), r2 * 0.5 + s2) : (r2 = e2.easeOutBounce(i2 * 2 - o2, 0, h2, o2), r2 * 0.5 + h2 * 0.5 + s2);
+      }
+    }, n2(e2);
+  }).call(S2);
+})(W);
+var O = W.exports;
+var v2 = /* @__PURE__ */ M2(O);
+function x2(l2, t2) {
+  if (l2) {
+    if (typeof l2 == "function")
+      return l2;
+    if (typeof l2 == "string")
+      return v2[l2];
+  } else
+    return v2[t2];
+}
+
+class P {
+  constructor(t2) {
+    this.viewport = t2, this.touches = [], this.addListeners();
+  }
+  addListeners() {
+    this.viewport.eventMode = "static", this.viewport.forceHitArea || (this.viewport.hitArea = new Rectangle(0, 0, this.viewport.worldWidth, this.viewport.worldHeight)), this.viewport.on("pointerdown", this.down, this), this.viewport.options.allowPreserveDragOutside ? this.viewport.on("globalpointermove", this.move, this) : this.viewport.on("pointermove", this.move, this), this.viewport.on("pointerup", this.up, this), this.viewport.on("pointerupoutside", this.up, this), this.viewport.on("pointercancel", this.up, this), this.viewport.options.allowPreserveDragOutside || this.viewport.on("pointerleave", this.up, this), this.wheelFunction = (t2) => this.handleWheel(t2), this.viewport.options.events.domElement.addEventListener("wheel", this.wheelFunction, { passive: this.viewport.options.passiveWheel }), this.isMouseDown = false;
+  }
+  destroy() {
+    var t2;
+    (t2 = this.viewport.options.events.domElement) == null || t2.removeEventListener("wheel", this.wheelFunction);
+  }
+  down(t2) {
+    if (this.viewport.pause || !this.viewport.visible)
+      return;
+    if (t2.pointerType === "mouse" ? this.isMouseDown = true : this.get(t2.pointerId) || this.touches.push({ id: t2.pointerId, last: null }), this.count() === 1) {
+      this.last = t2.global.clone();
+      const n2 = this.viewport.plugins.get("decelerate", true), i2 = this.viewport.plugins.get("bounce", true);
+      (!n2 || !n2.isActive()) && (!i2 || !i2.isActive()) ? this.clickedAvailable = true : this.clickedAvailable = false;
+    } else
+      this.clickedAvailable = false;
+    this.viewport.plugins.down(t2) && this.viewport.options.stopPropagation && t2.stopPropagation();
+  }
+  clear() {
+    this.isMouseDown = false, this.touches = [], this.last = null;
+  }
+  checkThreshold(t2) {
+    return Math.abs(t2) >= this.viewport.threshold;
+  }
+  move(t2) {
+    if (this.viewport.pause || !this.viewport.visible)
+      return;
+    const e2 = this.viewport.plugins.move(t2);
+    if (this.clickedAvailable && this.last) {
+      const n2 = t2.global.x - this.last.x, i2 = t2.global.y - this.last.y;
+      (this.checkThreshold(n2) || this.checkThreshold(i2)) && (this.clickedAvailable = false);
+    }
+    e2 && this.viewport.options.stopPropagation && t2.stopPropagation();
+  }
+  up(t2) {
+    if (this.viewport.pause || !this.viewport.visible)
+      return;
+    t2.pointerType === "mouse" && (this.isMouseDown = false), t2.pointerType !== "mouse" && this.remove(t2.pointerId);
+    const e2 = this.viewport.plugins.up(t2);
+    this.clickedAvailable && this.count() === 0 && this.last && (this.viewport.emit("clicked", {
+      event: t2,
+      screen: this.last,
+      world: this.viewport.toWorld(this.last),
+      viewport: this.viewport
+    }), this.clickedAvailable = false), e2 && this.viewport.options.stopPropagation && t2.stopPropagation();
+  }
+  getPointerPosition(t2) {
+    const e2 = new Point;
+    return this.viewport.options.events.mapPositionToPoint(e2, t2.clientX, t2.clientY), e2;
+  }
+  handleWheel(t2) {
+    if (this.viewport.pause || !this.viewport.visible)
+      return;
+    const e2 = this.viewport.toLocal(this.getPointerPosition(t2));
+    this.viewport.left <= e2.x && e2.x <= this.viewport.right && this.viewport.top <= e2.y && e2.y <= this.viewport.bottom && this.viewport.plugins.wheel(t2) && !this.viewport.options.passiveWheel && t2.preventDefault();
+  }
+  pause() {
+    this.touches = [], this.isMouseDown = false;
+  }
+  get(t2) {
+    for (const e2 of this.touches)
+      if (e2.id === t2)
+        return e2;
+    return null;
+  }
+  remove(t2) {
+    for (let e2 = 0;e2 < this.touches.length; e2++)
+      if (this.touches[e2].id === t2) {
+        this.touches.splice(e2, 1);
+        return;
+      }
+  }
+  count() {
+    return (this.isMouseDown ? 1 : 0) + this.touches.length;
+  }
+}
+var m2 = [
+  "drag",
+  "pinch",
+  "wheel",
+  "follow",
+  "mouse-edges",
+  "decelerate",
+  "animate",
+  "bounce",
+  "snap-zoom",
+  "clamp-zoom",
+  "snap",
+  "clamp"
+];
+
+class C {
+  constructor(t2) {
+    this.viewport = t2, this.list = [], this.plugins = {};
+  }
+  add(t2, e2, n2 = m2.length) {
+    const i2 = this.plugins[t2];
+    i2 && i2.destroy(), this.plugins[t2] = e2;
+    const s2 = m2.indexOf(t2);
+    s2 !== -1 && m2.splice(s2, 1), m2.splice(n2, 0, t2), this.sort();
+  }
+  get(t2, e2) {
+    var n2;
+    return e2 && (n2 = this.plugins[t2]) != null && n2.paused ? null : this.plugins[t2];
+  }
+  update(t2) {
+    for (const e2 of this.list)
+      e2.update(t2);
+  }
+  resize() {
+    for (const t2 of this.list)
+      t2.resize();
+  }
+  reset() {
+    for (const t2 of this.list)
+      t2.reset();
+  }
+  removeAll() {
+    this.list.forEach((t2) => {
+      t2.destroy();
+    }), this.plugins = {}, this.sort();
+  }
+  remove(t2) {
+    var e2;
+    this.plugins[t2] && ((e2 = this.plugins[t2]) == null || e2.destroy(), delete this.plugins[t2], this.viewport.emit("plugin-remove", t2), this.sort());
+  }
+  pause(t2) {
+    var e2;
+    (e2 = this.plugins[t2]) == null || e2.pause();
+  }
+  resume(t2) {
+    var e2;
+    (e2 = this.plugins[t2]) == null || e2.resume();
+  }
+  sort() {
+    this.list = [];
+    for (const t2 of m2)
+      this.plugins[t2] && this.list.push(this.plugins[t2]);
+  }
+  down(t2) {
+    let e2 = false;
+    for (const n2 of this.list)
+      n2.down(t2) && (e2 = true);
+    return e2;
+  }
+  move(t2) {
+    let e2 = false;
+    for (const n2 of this.viewport.plugins.list)
+      n2.move(t2) && (e2 = true);
+    return e2;
+  }
+  up(t2) {
+    let e2 = false;
+    for (const n2 of this.list)
+      n2.up(t2) && (e2 = true);
+    return e2;
+  }
+  wheel(t2) {
+    let e2 = false;
+    for (const n2 of this.list)
+      n2.wheel(t2) && (e2 = true);
+    return e2;
+  }
+}
+
+class u2 {
+  constructor(t2) {
+    this.parent = t2, this.paused = false;
+  }
+  destroy() {}
+  down(t2) {
+    return false;
+  }
+  move(t2) {
+    return false;
+  }
+  up(t2) {
+    return false;
+  }
+  wheel(t2) {
+    return false;
+  }
+  update(t2) {}
+  resize() {}
+  reset() {}
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+  }
+}
+var I = {
+  removeOnInterrupt: false,
+  ease: "linear",
+  time: 1000
+};
+
+class k2 extends u2 {
+  constructor(t2, e2 = {}) {
+    super(t2), this.startWidth = null, this.startHeight = null, this.deltaWidth = null, this.deltaHeight = null, this.width = null, this.height = null, this.time = 0, this.options = Object.assign({}, I, e2), this.options.ease = x2(this.options.ease), this.setupPosition(), this.setupZoom(), this.time = 0;
+  }
+  setupPosition() {
+    typeof this.options.position < "u" ? (this.startX = this.parent.center.x, this.startY = this.parent.center.y, this.deltaX = this.options.position.x - this.parent.center.x, this.deltaY = this.options.position.y - this.parent.center.y, this.keepCenter = false) : this.keepCenter = true;
+  }
+  setupZoom() {
+    this.width = null, this.height = null, typeof this.options.scale < "u" ? this.width = this.parent.screenWidth / this.options.scale : typeof this.options.scaleX < "u" || typeof this.options.scaleY < "u" ? (typeof this.options.scaleX < "u" && (this.width = this.parent.screenWidth / this.options.scaleX), typeof this.options.scaleY < "u" && (this.height = this.parent.screenHeight / this.options.scaleY)) : (typeof this.options.width < "u" && (this.width = this.options.width), typeof this.options.height < "u" && (this.height = this.options.height)), this.width !== null && (this.startWidth = this.parent.screenWidthInWorldPixels, this.deltaWidth = this.width - this.startWidth), this.height !== null && (this.startHeight = this.parent.screenHeightInWorldPixels, this.deltaHeight = this.height - this.startHeight);
+  }
+  down() {
+    return this.options.removeOnInterrupt && this.parent.plugins.remove("animate"), false;
+  }
+  complete() {
+    this.parent.plugins.remove("animate"), this.width !== null && this.parent.fitWidth(this.width, this.keepCenter, this.height === null), this.height !== null && this.parent.fitHeight(this.height, this.keepCenter, this.width === null), !this.keepCenter && this.options.position && this.parent.moveCenter(this.options.position), this.parent.emit("animate-end", this.parent), this.options.callbackOnComplete && this.options.callbackOnComplete(this.parent);
+  }
+  update(t2) {
+    if (this.paused)
+      return;
+    this.time += t2;
+    const e2 = new Point(this.parent.scale.x, this.parent.scale.y);
+    if (this.time >= this.options.time) {
+      const n2 = this.parent.width, i2 = this.parent.height;
+      this.complete(), (n2 !== this.parent.width || i2 !== this.parent.height) && this.parent.emit("zoomed", { viewport: this.parent, original: e2, type: "animate" });
+    } else {
+      const n2 = this.options.ease(this.time, 0, 1, this.options.time);
+      if (this.width !== null) {
+        const i2 = this.startWidth, s2 = this.deltaWidth;
+        this.parent.fitWidth(i2 + s2 * n2, this.keepCenter, this.height === null);
+      }
+      if (this.height !== null) {
+        const i2 = this.startHeight, s2 = this.deltaHeight;
+        this.parent.fitHeight(i2 + s2 * n2, this.keepCenter, this.width === null);
+      }
+      if (this.width === null ? this.parent.scale.x = this.parent.scale.y : this.height === null && (this.parent.scale.y = this.parent.scale.x), !this.keepCenter) {
+        const i2 = this.startX, s2 = this.startY, h2 = this.deltaX, o2 = this.deltaY, r2 = new Point(this.parent.x, this.parent.y);
+        this.parent.moveCenter(i2 + h2 * n2, s2 + o2 * n2), this.parent.emit("moved", { viewport: this.parent, original: r2, type: "animate" });
+      }
+      (this.width || this.height) && this.parent.emit("zoomed", { viewport: this.parent, original: e2, type: "animate" });
+    }
+  }
+}
+var Y = {
+  sides: "all",
+  friction: 0.5,
+  time: 150,
+  ease: "easeInOutSine",
+  underflow: "center",
+  bounceBox: null
+};
+
+class X extends u2 {
+  constructor(t2, e2 = {}) {
+    super(t2), this.options = Object.assign({}, Y, e2), this.ease = x2(this.options.ease, "easeInOutSine"), this.options.sides ? this.options.sides === "all" ? this.top = this.bottom = this.left = this.right = true : this.options.sides === "horizontal" ? (this.right = this.left = true, this.top = this.bottom = false) : this.options.sides === "vertical" ? (this.left = this.right = false, this.top = this.bottom = true) : (this.top = this.options.sides.indexOf("top") !== -1, this.bottom = this.options.sides.indexOf("bottom") !== -1, this.left = this.options.sides.indexOf("left") !== -1, this.right = this.options.sides.indexOf("right") !== -1) : this.left = this.top = this.right = this.bottom = false;
+    const n2 = this.options.underflow.toLowerCase();
+    n2 === "center" ? (this.underflowX = 0, this.underflowY = 0) : (this.underflowX = n2.indexOf("left") !== -1 ? -1 : n2.indexOf("right") !== -1 ? 1 : 0, this.underflowY = n2.indexOf("top") !== -1 ? -1 : n2.indexOf("bottom") !== -1 ? 1 : 0), this.reset();
+  }
+  isActive() {
+    return this.toX !== null || this.toY !== null;
+  }
+  down() {
+    return this.toX = this.toY = null, false;
+  }
+  up() {
+    return this.bounce(), false;
+  }
+  update(t2) {
+    if (!this.paused) {
+      if (this.bounce(), this.toX) {
+        const e2 = this.toX;
+        e2.time += t2, this.parent.emit("moved", { viewport: this.parent, type: "bounce-x" }), e2.time >= this.options.time ? (this.parent.x = e2.end, this.toX = null, this.parent.emit("bounce-x-end", this.parent)) : this.parent.x = this.ease(e2.time, e2.start, e2.delta, this.options.time);
+      }
+      if (this.toY) {
+        const e2 = this.toY;
+        e2.time += t2, this.parent.emit("moved", { viewport: this.parent, type: "bounce-y" }), e2.time >= this.options.time ? (this.parent.y = e2.end, this.toY = null, this.parent.emit("bounce-y-end", this.parent)) : this.parent.y = this.ease(e2.time, e2.start, e2.delta, this.options.time);
+      }
+    }
+  }
+  calcUnderflowX() {
+    let t2;
+    switch (this.underflowX) {
+      case -1:
+        t2 = 0;
+        break;
+      case 1:
+        t2 = this.parent.screenWidth - this.parent.screenWorldWidth;
+        break;
+      default:
+        t2 = (this.parent.screenWidth - this.parent.screenWorldWidth) / 2;
+    }
+    return t2;
+  }
+  calcUnderflowY() {
+    let t2;
+    switch (this.underflowY) {
+      case -1:
+        t2 = 0;
+        break;
+      case 1:
+        t2 = this.parent.screenHeight - this.parent.screenWorldHeight;
+        break;
+      default:
+        t2 = (this.parent.screenHeight - this.parent.screenWorldHeight) / 2;
+    }
+    return t2;
+  }
+  oob() {
+    const t2 = this.options.bounceBox;
+    if (t2) {
+      const e2 = typeof t2.x > "u" ? 0 : t2.x, n2 = typeof t2.y > "u" ? 0 : t2.y, i2 = typeof t2.width > "u" ? this.parent.worldWidth : t2.width, s2 = typeof t2.height > "u" ? this.parent.worldHeight : t2.height;
+      return {
+        left: this.parent.left < e2,
+        right: this.parent.right > i2,
+        top: this.parent.top < n2,
+        bottom: this.parent.bottom > s2,
+        topLeft: new Point(e2 * this.parent.scale.x, n2 * this.parent.scale.y),
+        bottomRight: new Point(i2 * this.parent.scale.x - this.parent.screenWidth, s2 * this.parent.scale.y - this.parent.screenHeight)
+      };
+    }
+    return {
+      left: this.parent.left < 0,
+      right: this.parent.right > this.parent.worldWidth,
+      top: this.parent.top < 0,
+      bottom: this.parent.bottom > this.parent.worldHeight,
+      topLeft: new Point(0, 0),
+      bottomRight: new Point(this.parent.worldWidth * this.parent.scale.x - this.parent.screenWidth, this.parent.worldHeight * this.parent.scale.y - this.parent.screenHeight)
+    };
+  }
+  bounce() {
+    var s2, h2;
+    if (this.paused)
+      return;
+    let t2, e2 = this.parent.plugins.get("decelerate", true);
+    e2 && (e2.x || e2.y) && (e2.x && e2.percentChangeX === ((s2 = e2.options) == null ? undefined : s2.friction) || e2.y && e2.percentChangeY === ((h2 = e2.options) == null ? undefined : h2.friction)) && (t2 = this.oob(), (t2.left && this.left || t2.right && this.right) && (e2.percentChangeX = this.options.friction), (t2.top && this.top || t2.bottom && this.bottom) && (e2.percentChangeY = this.options.friction));
+    const n2 = this.parent.plugins.get("drag", true) || {}, i2 = this.parent.plugins.get("pinch", true) || {};
+    if (e2 = e2 || {}, !(n2 != null && n2.active) && !(i2 != null && i2.active) && (!this.toX || !this.toY) && (!e2.x || !e2.y)) {
+      t2 = t2 || this.oob();
+      const { topLeft: o2, bottomRight: r2 } = t2;
+      if (!this.toX && !e2.x) {
+        let a2 = null;
+        t2.left && this.left ? a2 = this.parent.screenWorldWidth < this.parent.screenWidth ? this.calcUnderflowX() : -o2.x : t2.right && this.right && (a2 = this.parent.screenWorldWidth < this.parent.screenWidth ? this.calcUnderflowX() : -r2.x), a2 !== null && this.parent.x !== a2 && (this.toX = { time: 0, start: this.parent.x, delta: a2 - this.parent.x, end: a2 }, this.parent.emit("bounce-x-start", this.parent));
+      }
+      if (!this.toY && !e2.y) {
+        let a2 = null;
+        t2.top && this.top ? a2 = this.parent.screenWorldHeight < this.parent.screenHeight ? this.calcUnderflowY() : -o2.y : t2.bottom && this.bottom && (a2 = this.parent.screenWorldHeight < this.parent.screenHeight ? this.calcUnderflowY() : -r2.y), a2 !== null && this.parent.y !== a2 && (this.toY = { time: 0, start: this.parent.y, delta: a2 - this.parent.y, end: a2 }, this.parent.emit("bounce-y-start", this.parent));
+      }
+    }
+  }
+  reset() {
+    this.toX = this.toY = null, this.bounce();
+  }
+}
+var z = {
+  left: false,
+  right: false,
+  top: false,
+  bottom: false,
+  direction: null,
+  underflow: "center"
+};
+
+class A extends u2 {
+  constructor(t2, e2 = {}) {
+    super(t2), this.options = Object.assign({}, z, e2), this.options.direction && (this.options.left = this.options.direction === "x" || this.options.direction === "all" ? true : null, this.options.right = this.options.direction === "x" || this.options.direction === "all" ? true : null, this.options.top = this.options.direction === "y" || this.options.direction === "all" ? true : null, this.options.bottom = this.options.direction === "y" || this.options.direction === "all" ? true : null), this.parseUnderflow(), this.last = { x: null, y: null, scaleX: null, scaleY: null }, this.update();
+  }
+  parseUnderflow() {
+    const t2 = this.options.underflow.toLowerCase();
+    t2 === "none" ? this.noUnderflow = true : t2 === "center" ? (this.underflowX = this.underflowY = 0, this.noUnderflow = false) : (this.underflowX = t2.indexOf("left") !== -1 ? -1 : t2.indexOf("right") !== -1 ? 1 : 0, this.underflowY = t2.indexOf("top") !== -1 ? -1 : t2.indexOf("bottom") !== -1 ? 1 : 0, this.noUnderflow = false);
+  }
+  move() {
+    return this.update(), false;
+  }
+  update() {
+    if (this.paused || this.parent.x === this.last.x && this.parent.y === this.last.y && this.parent.scale.x === this.last.scaleX && this.parent.scale.y === this.last.scaleY)
+      return;
+    const t2 = new Point(this.parent.x, this.parent.y), e2 = this.parent.plugins.decelerate || {};
+    if (this.options.left !== null || this.options.right !== null) {
+      let n2 = false;
+      if (!this.noUnderflow && this.parent.screenWorldWidth < this.parent.screenWidth)
+        switch (this.underflowX) {
+          case -1:
+            this.parent.x !== 0 && (this.parent.x = 0, n2 = true);
+            break;
+          case 1:
+            this.parent.x !== this.parent.screenWidth - this.parent.screenWorldWidth && (this.parent.x = this.parent.screenWidth - this.parent.screenWorldWidth, n2 = true);
+            break;
+          default:
+            this.parent.x !== (this.parent.screenWidth - this.parent.screenWorldWidth) / 2 && (this.parent.x = (this.parent.screenWidth - this.parent.screenWorldWidth) / 2, n2 = true);
+        }
+      else
+        this.options.left !== null && this.parent.left < (this.options.left === true ? 0 : this.options.left) && (this.parent.x = -(this.options.left === true ? 0 : this.options.left) * this.parent.scale.x, e2.x = 0, n2 = true), this.options.right !== null && this.parent.right > (this.options.right === true ? this.parent.worldWidth : this.options.right) && (this.parent.x = -(this.options.right === true ? this.parent.worldWidth : this.options.right) * this.parent.scale.x + this.parent.screenWidth, e2.x = 0, n2 = true);
+      n2 && this.parent.emit("moved", {
+        viewport: this.parent,
+        original: t2,
+        type: "clamp-x"
+      });
+    }
+    if (this.options.top !== null || this.options.bottom !== null) {
+      let n2 = false;
+      if (!this.noUnderflow && this.parent.screenWorldHeight < this.parent.screenHeight)
+        switch (this.underflowY) {
+          case -1:
+            this.parent.y !== 0 && (this.parent.y = 0, n2 = true);
+            break;
+          case 1:
+            this.parent.y !== this.parent.screenHeight - this.parent.screenWorldHeight && (this.parent.y = this.parent.screenHeight - this.parent.screenWorldHeight, n2 = true);
+            break;
+          default:
+            this.parent.y !== (this.parent.screenHeight - this.parent.screenWorldHeight) / 2 && (this.parent.y = (this.parent.screenHeight - this.parent.screenWorldHeight) / 2, n2 = true);
+        }
+      else
+        this.options.top !== null && this.parent.top < (this.options.top === true ? 0 : this.options.top) && (this.parent.y = -(this.options.top === true ? 0 : this.options.top) * this.parent.scale.y, e2.y = 0, n2 = true), this.options.bottom !== null && this.parent.bottom > (this.options.bottom === true ? this.parent.worldHeight : this.options.bottom) && (this.parent.y = -(this.options.bottom === true ? this.parent.worldHeight : this.options.bottom) * this.parent.scale.y + this.parent.screenHeight, e2.y = 0, n2 = true);
+      n2 && this.parent.emit("moved", {
+        viewport: this.parent,
+        original: t2,
+        type: "clamp-y"
+      });
+    }
+    this.last.x = this.parent.x, this.last.y = this.parent.y, this.last.scaleX = this.parent.scale.x, this.last.scaleY = this.parent.scale.y;
+  }
+  reset() {
+    this.update();
+  }
+}
+var T = {
+  minWidth: null,
+  minHeight: null,
+  maxWidth: null,
+  maxHeight: null,
+  minScale: null,
+  maxScale: null
+};
+
+class _ extends u2 {
+  constructor(t2, e2 = {}) {
+    super(t2), this.options = Object.assign({}, T, e2), this.clamp();
+  }
+  resize() {
+    this.clamp();
+  }
+  clamp() {
+    if (!this.paused) {
+      if (this.options.minWidth || this.options.minHeight || this.options.maxWidth || this.options.maxHeight) {
+        let t2 = this.parent.worldScreenWidth, e2 = this.parent.worldScreenHeight;
+        if (this.options.minWidth !== null && t2 < this.options.minWidth) {
+          const n2 = this.parent.scale.x;
+          this.parent.fitWidth(this.options.minWidth, false, false, true), this.parent.scale.y *= this.parent.scale.x / n2, t2 = this.parent.worldScreenWidth, e2 = this.parent.worldScreenHeight, this.parent.emit("zoomed", { viewport: this.parent, type: "clamp-zoom" });
+        }
+        if (this.options.maxWidth !== null && t2 > this.options.maxWidth) {
+          const n2 = this.parent.scale.x;
+          this.parent.fitWidth(this.options.maxWidth, false, false, true), this.parent.scale.y *= this.parent.scale.x / n2, t2 = this.parent.worldScreenWidth, e2 = this.parent.worldScreenHeight, this.parent.emit("zoomed", { viewport: this.parent, type: "clamp-zoom" });
+        }
+        if (this.options.minHeight !== null && e2 < this.options.minHeight) {
+          const n2 = this.parent.scale.y;
+          this.parent.fitHeight(this.options.minHeight, false, false, true), this.parent.scale.x *= this.parent.scale.y / n2, t2 = this.parent.worldScreenWidth, e2 = this.parent.worldScreenHeight, this.parent.emit("zoomed", { viewport: this.parent, type: "clamp-zoom" });
+        }
+        if (this.options.maxHeight !== null && e2 > this.options.maxHeight) {
+          const n2 = this.parent.scale.y;
+          this.parent.fitHeight(this.options.maxHeight, false, false, true), this.parent.scale.x *= this.parent.scale.y / n2, this.parent.emit("zoomed", { viewport: this.parent, type: "clamp-zoom" });
+        }
+      } else if (this.options.minScale || this.options.maxScale) {
+        const t2 = { x: null, y: null }, e2 = { x: null, y: null };
+        if (typeof this.options.minScale == "number")
+          t2.x = this.options.minScale, t2.y = this.options.minScale;
+        else if (this.options.minScale !== null) {
+          const s2 = this.options.minScale;
+          t2.x = typeof s2.x > "u" ? null : s2.x, t2.y = typeof s2.y > "u" ? null : s2.y;
+        }
+        if (typeof this.options.maxScale == "number")
+          e2.x = this.options.maxScale, e2.y = this.options.maxScale;
+        else if (this.options.maxScale !== null) {
+          const s2 = this.options.maxScale;
+          e2.x = typeof s2.x > "u" ? null : s2.x, e2.y = typeof s2.y > "u" ? null : s2.y;
+        }
+        let n2 = this.parent.scale.x, i2 = this.parent.scale.y;
+        t2.x !== null && n2 < t2.x && (n2 = t2.x), e2.x !== null && n2 > e2.x && (n2 = e2.x), t2.y !== null && i2 < t2.y && (i2 = t2.y), e2.y !== null && i2 > e2.y && (i2 = e2.y), (n2 !== this.parent.scale.x || i2 !== this.parent.scale.y) && (this.parent.scale.set(n2, i2), this.parent.emit("zoomed", { viewport: this.parent, type: "clamp-zoom" }));
+      }
+    }
+  }
+  reset() {
+    this.clamp();
+  }
+}
+var L = {
+  friction: 0.98,
+  bounce: 0.8,
+  minSpeed: 0.01
+};
+var d2 = 16;
+
+class E extends u2 {
+  constructor(t2, e2 = {}) {
+    super(t2), this.options = Object.assign({}, L, e2), this.saved = [], this.timeSinceRelease = 0, this.reset(), this.parent.on("moved", (n2) => this.handleMoved(n2));
+  }
+  down() {
+    return this.saved = [], this.x = this.y = null, false;
+  }
+  isActive() {
+    return !!(this.x || this.y);
+  }
+  move() {
+    if (this.paused)
+      return false;
+    const t2 = this.parent.input.count();
+    return (t2 === 1 || t2 > 1 && !this.parent.plugins.get("pinch", true)) && (this.saved.push({ x: this.parent.x, y: this.parent.y, time: performance.now() }), this.saved.length > 60 && this.saved.splice(0, 30)), false;
+  }
+  handleMoved(t2) {
+    if (this.saved.length) {
+      const e2 = this.saved[this.saved.length - 1];
+      t2.type === "clamp-x" && t2.original ? e2.x === t2.original.x && (e2.x = this.parent.x) : t2.type === "clamp-y" && t2.original && e2.y === t2.original.y && (e2.y = this.parent.y);
+    }
+  }
+  up() {
+    if (this.parent.input.count() === 0 && this.saved.length) {
+      const t2 = performance.now();
+      for (const e2 of this.saved)
+        if (e2.time >= t2 - 100) {
+          const n2 = t2 - e2.time;
+          this.x = (this.parent.x - e2.x) / n2, this.y = (this.parent.y - e2.y) / n2, this.percentChangeX = this.percentChangeY = this.options.friction, this.timeSinceRelease = 0;
+          break;
+        }
+    }
+    return false;
+  }
+  activate(t2) {
+    t2 = t2 || {}, typeof t2.x < "u" && (this.x = t2.x, this.percentChangeX = this.options.friction), typeof t2.y < "u" && (this.y = t2.y, this.percentChangeY = this.options.friction);
+  }
+  update(t2) {
+    if (this.paused)
+      return;
+    const e2 = this.x || this.y, n2 = this.timeSinceRelease, i2 = this.timeSinceRelease + t2;
+    if (this.x) {
+      const s2 = this.percentChangeX, h2 = Math.log(s2);
+      this.parent.x += this.x * d2 / h2 * (Math.pow(s2, i2 / d2) - Math.pow(s2, n2 / d2)), this.x *= Math.pow(this.percentChangeX, t2 / d2);
+    }
+    if (this.y) {
+      const s2 = this.percentChangeY, h2 = Math.log(s2);
+      this.parent.y += this.y * d2 / h2 * (Math.pow(s2, i2 / d2) - Math.pow(s2, n2 / d2)), this.y *= Math.pow(this.percentChangeY, t2 / d2);
+    }
+    this.timeSinceRelease += t2, this.x && this.y ? Math.abs(this.x) < this.options.minSpeed && Math.abs(this.y) < this.options.minSpeed && (this.x = 0, this.y = 0) : (Math.abs(this.x || 0) < this.options.minSpeed && (this.x = 0), Math.abs(this.y || 0) < this.options.minSpeed && (this.y = 0)), e2 && this.parent.emit("moved", { viewport: this.parent, type: "decelerate" });
+  }
+  reset() {
+    this.x = this.y = null;
+  }
+}
+var D = {
+  direction: "all",
+  pressDrag: true,
+  wheel: true,
+  wheelScroll: 1,
+  reverse: false,
+  clampWheel: false,
+  underflow: "center",
+  factor: 1,
+  mouseButtons: "all",
+  keyToPress: null,
+  ignoreKeyToPressOnTouch: false,
+  lineHeight: 20,
+  wheelSwapAxes: false
+};
+
+class U extends u2 {
+  constructor(t2, e2 = {}) {
+    super(t2), this.windowEventHandlers = [], this.options = Object.assign({}, D, e2), this.moved = false, this.reverse = this.options.reverse ? 1 : -1, this.xDirection = !this.options.direction || this.options.direction === "all" || this.options.direction === "x", this.yDirection = !this.options.direction || this.options.direction === "all" || this.options.direction === "y", this.keyIsPressed = false, this.parseUnderflow(), this.mouseButtons(this.options.mouseButtons), this.options.keyToPress && this.handleKeyPresses(this.options.keyToPress);
+  }
+  handleKeyPresses(t2) {
+    const e2 = (i2) => {
+      t2.includes(i2.code) && (this.keyIsPressed = true);
+    }, n2 = (i2) => {
+      t2.includes(i2.code) && (this.keyIsPressed = false);
+    };
+    this.addWindowEventHandler("keyup", n2), this.addWindowEventHandler("keydown", e2);
+  }
+  addWindowEventHandler(t2, e2) {
+    typeof window > "u" || (window.addEventListener(t2, e2), this.windowEventHandlers.push({ event: t2, handler: e2 }));
+  }
+  destroy() {
+    typeof window > "u" || this.windowEventHandlers.forEach(({ event: t2, handler: e2 }) => {
+      window.removeEventListener(t2, e2);
+    });
+  }
+  mouseButtons(t2) {
+    !t2 || t2 === "all" ? this.mouse = [true, true, true] : this.mouse = [
+      t2.indexOf("left") !== -1,
+      t2.indexOf("middle") !== -1,
+      t2.indexOf("right") !== -1
+    ];
+  }
+  parseUnderflow() {
+    const t2 = this.options.underflow.toLowerCase();
+    t2 === "center" ? (this.underflowX = 0, this.underflowY = 0) : (t2.includes("left") ? this.underflowX = -1 : t2.includes("right") ? this.underflowX = 1 : this.underflowX = 0, t2.includes("top") ? this.underflowY = -1 : t2.includes("bottom") ? this.underflowY = 1 : this.underflowY = 0);
+  }
+  checkButtons(t2) {
+    const e2 = t2.pointerType === "mouse", n2 = this.parent.input.count();
+    return !!((n2 === 1 || n2 > 1 && !this.parent.plugins.get("pinch", true)) && (!e2 || this.mouse[t2.button]));
+  }
+  checkKeyPress(t2) {
+    return !this.options.keyToPress || this.keyIsPressed || this.options.ignoreKeyToPressOnTouch && t2.data.pointerType === "touch";
+  }
+  down(t2) {
+    return this.paused || !this.options.pressDrag ? false : this.checkButtons(t2) && this.checkKeyPress(t2) ? (this.last = { x: t2.global.x, y: t2.global.y }, (this.parent.parent || this.parent).toLocal(this.last, undefined, this.last), this.current = t2.pointerId, true) : (this.last = null, false);
+  }
+  get active() {
+    return this.moved;
+  }
+  move(t2) {
+    if (this.paused || !this.options.pressDrag)
+      return false;
+    if (this.last && this.current === t2.data.pointerId) {
+      const e2 = t2.global.x, n2 = t2.global.y, i2 = this.parent.input.count();
+      if (i2 === 1 || i2 > 1 && !this.parent.plugins.get("pinch", true)) {
+        const s2 = { x: e2, y: n2 };
+        (this.parent.parent || this.parent).toLocal(s2, undefined, s2);
+        const h2 = s2.x - this.last.x, o2 = s2.y - this.last.y;
+        if (this.moved || this.xDirection && this.parent.input.checkThreshold(h2) || this.yDirection && this.parent.input.checkThreshold(o2))
+          return this.xDirection && (this.parent.x += (s2.x - this.last.x) * this.options.factor), this.yDirection && (this.parent.y += (s2.y - this.last.y) * this.options.factor), this.last = s2, this.moved || this.parent.emit("drag-start", {
+            event: t2,
+            screen: new Point(this.last.x, this.last.y),
+            world: this.parent.toWorld(new Point(this.last.x, this.last.y)),
+            viewport: this.parent
+          }), this.moved = true, this.parent.emit("moved", { viewport: this.parent, type: "drag" }), true;
+      } else
+        this.moved = false;
+    }
+    return false;
+  }
+  up(t2) {
+    if (this.paused)
+      return false;
+    const e2 = this.parent.input.touches;
+    if (e2.length === 1) {
+      const n2 = e2[0];
+      return n2.last && (this.last = { x: n2.last.x, y: n2.last.y }, this.current = n2.id), this.moved = false, true;
+    } else if (this.last && this.moved) {
+      const n2 = new Point(this.last.x, this.last.y);
+      return (this.parent.parent || this.parent).toGlobal(n2, n2, true), this.parent.emit("drag-end", {
+        event: t2,
+        screen: n2,
+        world: this.parent.toWorld(n2),
+        viewport: this.parent
+      }), this.last = null, this.moved = false, true;
+    }
+    return false;
+  }
+  wheel(t2) {
+    if (this.paused)
+      return false;
+    if (this.options.wheel) {
+      const e2 = this.parent.plugins.get("wheel", true);
+      if (!e2 || !e2.options.wheelZoom && !t2.ctrlKey) {
+        const n2 = t2.deltaMode ? this.options.lineHeight : 1, i2 = [t2.deltaX, t2.deltaY], [s2, h2] = this.options.wheelSwapAxes ? i2.reverse() : i2;
+        return this.xDirection && (this.parent.x += s2 * n2 * this.options.wheelScroll * this.reverse), this.yDirection && (this.parent.y += h2 * n2 * this.options.wheelScroll * this.reverse), this.options.clampWheel && this.clamp(), this.parent.emit("wheel-scroll", this.parent), this.parent.emit("moved", { viewport: this.parent, type: "wheel" }), this.parent.options.passiveWheel || t2.preventDefault(), this.parent.options.stopPropagation && t2.stopPropagation(), true;
+      }
+    }
+    return false;
+  }
+  resume() {
+    this.last = null, this.paused = false;
+  }
+  clamp() {
+    const t2 = this.parent.plugins.get("decelerate", true) || {};
+    if (this.options.clampWheel !== "y")
+      if (this.parent.screenWorldWidth < this.parent.screenWidth)
+        switch (this.underflowX) {
+          case -1:
+            this.parent.x = 0;
+            break;
+          case 1:
+            this.parent.x = this.parent.screenWidth - this.parent.screenWorldWidth;
+            break;
+          default:
+            this.parent.x = (this.parent.screenWidth - this.parent.screenWorldWidth) / 2;
+        }
+      else
+        this.parent.left < 0 ? (this.parent.x = 0, t2.x = 0) : this.parent.right > this.parent.worldWidth && (this.parent.x = -this.parent.worldWidth * this.parent.scale.x + this.parent.screenWidth, t2.x = 0);
+    if (this.options.clampWheel !== "x")
+      if (this.parent.screenWorldHeight < this.parent.screenHeight)
+        switch (this.underflowY) {
+          case -1:
+            this.parent.y = 0;
+            break;
+          case 1:
+            this.parent.y = this.parent.screenHeight - this.parent.screenWorldHeight;
+            break;
+          default:
+            this.parent.y = (this.parent.screenHeight - this.parent.screenWorldHeight) / 2;
+        }
+      else
+        this.parent.top < 0 && (this.parent.y = 0, t2.y = 0), this.parent.bottom > this.parent.worldHeight && (this.parent.y = -this.parent.worldHeight * this.parent.scale.y + this.parent.screenHeight, t2.y = 0);
+  }
+}
+var F = {
+  speed: 0,
+  acceleration: null,
+  radius: null
+};
+
+class B extends u2 {
+  constructor(t2, e2, n2 = {}) {
+    super(t2), this.target = e2, this.options = Object.assign({}, F, n2), this.velocity = { x: 0, y: 0 };
+  }
+  update(t2) {
+    if (this.paused)
+      return;
+    const e2 = this.parent.center;
+    let n2 = this.target.x, i2 = this.target.y;
+    if (this.options.radius)
+      if (Math.sqrt(Math.pow(this.target.y - e2.y, 2) + Math.pow(this.target.x - e2.x, 2)) > this.options.radius) {
+        const r2 = Math.atan2(this.target.y - e2.y, this.target.x - e2.x);
+        n2 = this.target.x - Math.cos(r2) * this.options.radius, i2 = this.target.y - Math.sin(r2) * this.options.radius;
+      } else
+        return;
+    const s2 = n2 - e2.x, h2 = i2 - e2.y;
+    if (s2 || h2)
+      if (this.options.speed)
+        if (this.options.acceleration) {
+          const o2 = Math.atan2(i2 - e2.y, n2 - e2.x), r2 = Math.sqrt(Math.pow(s2, 2) + Math.pow(h2, 2));
+          if (r2) {
+            const a2 = (Math.pow(this.velocity.x, 2) + Math.pow(this.velocity.y, 2)) / (2 * this.options.acceleration);
+            r2 > a2 ? this.velocity = {
+              x: Math.min(this.velocity.x + (this.options.acceleration * t2, this.options.speed)),
+              y: Math.min(this.velocity.y + (this.options.acceleration * t2, this.options.speed))
+            } : this.velocity = {
+              x: Math.max(this.velocity.x - this.options.acceleration * this.options.speed, 0),
+              y: Math.max(this.velocity.y - this.options.acceleration * this.options.speed, 0)
+            };
+            const p2 = Math.cos(o2) * this.velocity.x, f2 = Math.sin(o2) * this.velocity.y, g2 = Math.abs(p2) > Math.abs(s2) ? n2 : e2.x + p2, w2 = Math.abs(f2) > Math.abs(h2) ? i2 : e2.y + f2;
+            this.parent.moveCenter(g2, w2), this.parent.emit("moved", { viewport: this.parent, type: "follow" });
+          }
+        } else {
+          const o2 = Math.atan2(i2 - e2.y, n2 - e2.x), r2 = Math.cos(o2) * this.options.speed, a2 = Math.sin(o2) * this.options.speed, p2 = Math.abs(r2) > Math.abs(s2) ? n2 : e2.x + r2, f2 = Math.abs(a2) > Math.abs(h2) ? i2 : e2.y + a2;
+          this.parent.moveCenter(p2, f2), this.parent.emit("moved", { viewport: this.parent, type: "follow" });
+        }
+      else
+        this.parent.moveCenter(n2, i2), this.parent.emit("moved", { viewport: this.parent, type: "follow" });
+  }
+}
+var N2 = {
+  radius: null,
+  distance: null,
+  top: null,
+  bottom: null,
+  left: null,
+  right: null,
+  speed: 8,
+  reverse: false,
+  noDecelerate: false,
+  linear: false,
+  allowButtons: false
+};
+
+class V extends u2 {
+  constructor(t2, e2 = {}) {
+    super(t2), this.options = Object.assign({}, N2, e2), this.reverse = this.options.reverse ? 1 : -1, this.radiusSquared = typeof this.options.radius == "number" ? Math.pow(this.options.radius, 2) : null, this.resize();
+  }
+  resize() {
+    const t2 = this.options.distance;
+    t2 !== null ? (this.left = t2, this.top = t2, this.right = this.parent.screenWidth - t2, this.bottom = this.parent.screenHeight - t2) : this.options.radius || (this.left = this.options.left, this.top = this.options.top, this.right = this.options.right === null ? null : this.parent.screenWidth - this.options.right, this.bottom = this.options.bottom === null ? null : this.parent.screenHeight - this.options.bottom);
+  }
+  down() {
+    return this.paused || this.options.allowButtons || (this.horizontal = this.vertical = null), false;
+  }
+  move(t2) {
+    if (this.paused || t2.pointerType !== "mouse" && t2.pointerId !== 1 || !this.options.allowButtons && t2.buttons !== 0)
+      return false;
+    const e2 = t2.global.x, n2 = t2.global.y;
+    if (this.radiusSquared) {
+      const i2 = this.parent.toScreen(this.parent.center);
+      if (Math.pow(i2.x - e2, 2) + Math.pow(i2.y - n2, 2) >= this.radiusSquared) {
+        const h2 = Math.atan2(i2.y - n2, i2.x - e2);
+        this.options.linear ? (this.horizontal = Math.round(Math.cos(h2)) * this.options.speed * this.reverse * (60 / 1000), this.vertical = Math.round(Math.sin(h2)) * this.options.speed * this.reverse * (60 / 1000)) : (this.horizontal = Math.cos(h2) * this.options.speed * this.reverse * (60 / 1000), this.vertical = Math.sin(h2) * this.options.speed * this.reverse * (60 / 1000));
+      } else
+        this.horizontal && this.decelerateHorizontal(), this.vertical && this.decelerateVertical(), this.horizontal = this.vertical = 0;
+    } else
+      this.left !== null && e2 < this.left ? this.horizontal = Number(this.reverse) * this.options.speed * (60 / 1000) : this.right !== null && e2 > this.right ? this.horizontal = -1 * this.reverse * this.options.speed * (60 / 1000) : (this.decelerateHorizontal(), this.horizontal = 0), this.top !== null && n2 < this.top ? this.vertical = Number(this.reverse) * this.options.speed * (60 / 1000) : this.bottom !== null && n2 > this.bottom ? this.vertical = -1 * this.reverse * this.options.speed * (60 / 1000) : (this.decelerateVertical(), this.vertical = 0);
+    return false;
+  }
+  decelerateHorizontal() {
+    const t2 = this.parent.plugins.get("decelerate", true);
+    this.horizontal && t2 && !this.options.noDecelerate && t2.activate({ x: this.horizontal * this.options.speed * this.reverse / (1000 / 60) });
+  }
+  decelerateVertical() {
+    const t2 = this.parent.plugins.get("decelerate", true);
+    this.vertical && t2 && !this.options.noDecelerate && t2.activate({ y: this.vertical * this.options.speed * this.reverse / (1000 / 60) });
+  }
+  up() {
+    return this.paused || (this.horizontal && this.decelerateHorizontal(), this.vertical && this.decelerateVertical(), this.horizontal = this.vertical = null), false;
+  }
+  update() {
+    if (!this.paused && (this.horizontal || this.vertical)) {
+      const t2 = this.parent.center;
+      this.horizontal && (t2.x += this.horizontal * this.options.speed), this.vertical && (t2.y += this.vertical * this.options.speed), this.parent.moveCenter(t2), this.parent.emit("moved", { viewport: this.parent, type: "mouse-edges" });
+    }
+  }
+}
+var Z = {
+  noDrag: false,
+  percent: 1,
+  center: null,
+  factor: 1,
+  axis: "all"
+};
+var R = new Point;
+
+class j2 extends u2 {
+  constructor(t2, e2 = {}) {
+    super(t2), this.active = false, this.pinching = false, this.moved = false, this.options = Object.assign({}, Z, e2);
+  }
+  down() {
+    return this.parent.input.count() >= 2 ? (this.active = true, true) : false;
+  }
+  isAxisX() {
+    return ["all", "x"].includes(this.options.axis);
+  }
+  isAxisY() {
+    return ["all", "y"].includes(this.options.axis);
+  }
+  move(t2) {
+    if (this.paused || !this.active)
+      return false;
+    const { x: e2, y: n2 } = (this.parent.parent || this.parent).toLocal(t2.global, undefined, R), i2 = this.parent.input.touches;
+    if (i2.length >= 2) {
+      const s2 = i2[0], h2 = i2[1], o2 = s2.last && h2.last ? Math.sqrt(Math.pow(h2.last.x - s2.last.x, 2) + Math.pow(h2.last.y - s2.last.y, 2)) : null;
+      if (s2.id === t2.pointerId ? s2.last = { x: e2, y: n2, data: t2 } : h2.id === t2.pointerId && (h2.last = { x: e2, y: n2, data: t2 }), o2) {
+        let r2;
+        const a2 = new Point(s2.last.x + (h2.last.x - s2.last.x) / 2, s2.last.y + (h2.last.y - s2.last.y) / 2);
+        this.options.center || (r2 = this.parent.toLocal(a2, this.parent.parent || this.parent));
+        let p2 = Math.sqrt(Math.pow(h2.last.x - s2.last.x, 2) + Math.pow(h2.last.y - s2.last.y, 2));
+        p2 = p2 === 0 ? p2 = 0.0000000001 : p2;
+        const f2 = (1 - o2 / p2) * this.options.percent * (this.isAxisX() ? this.parent.scale.x : this.parent.scale.y);
+        this.isAxisX() && (this.parent.scale.x += f2), this.isAxisY() && (this.parent.scale.y += f2), this.parent.emit("zoomed", {
+          viewport: this.parent,
+          type: "pinch",
+          center: a2
+        });
+        const g2 = this.parent.plugins.get("clamp-zoom", true);
+        if (g2 && g2.clamp(), this.options.center)
+          this.parent.moveCenter(this.options.center);
+        else {
+          const w2 = (this.parent.parent || this.parent).toLocal(r2, this.parent);
+          this.parent.x += (a2.x - w2.x) * this.options.factor, this.parent.y += (a2.y - w2.y) * this.options.factor, this.parent.emit("moved", { viewport: this.parent, type: "pinch" });
+        }
+        !this.options.noDrag && this.lastCenter && (this.parent.x += (a2.x - this.lastCenter.x) * this.options.factor, this.parent.y += (a2.y - this.lastCenter.y) * this.options.factor, this.parent.emit("moved", { viewport: this.parent, type: "pinch" })), this.lastCenter = a2, this.moved = true;
+      } else
+        this.pinching || (this.parent.emit("pinch-start", this.parent), this.pinching = true);
+      return true;
+    }
+    return false;
+  }
+  up() {
+    return this.pinching && this.parent.input.touches.length <= 1 ? (this.active = false, this.lastCenter = null, this.pinching = false, this.moved = false, this.parent.emit("pinch-end", this.parent), true) : false;
+  }
+}
+var K = {
+  topLeft: false,
+  friction: 0.8,
+  time: 1000,
+  ease: "easeInOutSine",
+  interrupt: true,
+  removeOnComplete: false,
+  removeOnInterrupt: false,
+  forceStart: false
+};
+
+class q extends u2 {
+  constructor(t2, e2, n2, i2 = {}) {
+    super(t2), this.options = Object.assign({}, K, i2), this.ease = x2(i2.ease, "easeInOutSine"), this.x = e2, this.y = n2, this.options.forceStart && this.snapStart();
+  }
+  snapStart() {
+    this.percent = 0, this.snapping = { time: 0 };
+    const t2 = this.options.topLeft ? this.parent.corner : this.parent.center;
+    this.deltaX = this.x - t2.x, this.deltaY = this.y - t2.y, this.startX = t2.x, this.startY = t2.y, this.parent.emit("snap-start", this.parent);
+  }
+  wheel() {
+    return this.options.removeOnInterrupt && this.parent.plugins.remove("snap"), false;
+  }
+  down() {
+    return this.options.removeOnInterrupt ? this.parent.plugins.remove("snap") : this.options.interrupt && (this.snapping = null), false;
+  }
+  up() {
+    if (this.parent.input.count() === 0) {
+      const t2 = this.parent.plugins.get("decelerate", true);
+      t2 && (t2.x || t2.y) && (t2.percentChangeX = t2.percentChangeY = this.options.friction);
+    }
+    return false;
+  }
+  update(t2) {
+    if (!this.paused && !(this.options.interrupt && this.parent.input.count() !== 0))
+      if (this.snapping) {
+        const e2 = this.snapping;
+        e2.time += t2;
+        let n2, i2, s2;
+        const h2 = this.startX, o2 = this.startY, r2 = this.deltaX, a2 = this.deltaY;
+        if (e2.time > this.options.time)
+          n2 = true, i2 = h2 + r2, s2 = o2 + a2;
+        else {
+          const p2 = this.ease(e2.time, 0, 1, this.options.time);
+          i2 = h2 + r2 * p2, s2 = o2 + a2 * p2;
+        }
+        this.options.topLeft ? this.parent.moveCorner(i2, s2) : this.parent.moveCenter(i2, s2), this.parent.emit("moved", { viewport: this.parent, type: "snap" }), n2 && (this.options.removeOnComplete && this.parent.plugins.remove("snap"), this.parent.emit("snap-end", this.parent), this.snapping = null);
+      } else {
+        const e2 = this.options.topLeft ? this.parent.corner : this.parent.center;
+        (e2.x !== this.x || e2.y !== this.y) && this.snapStart();
+      }
+  }
+}
+var Q = {
+  width: 0,
+  height: 0,
+  time: 1000,
+  ease: "easeInOutSine",
+  center: null,
+  interrupt: true,
+  removeOnComplete: false,
+  removeOnInterrupt: false,
+  forceStart: false,
+  noMove: false
+};
+
+class G extends u2 {
+  constructor(t2, e2 = {}) {
+    super(t2), this.options = Object.assign({}, Q, e2), this.ease = x2(this.options.ease), this.xIndependent = false, this.yIndependent = false, this.xScale = 0, this.yScale = 0, this.options.width > 0 && (this.xScale = t2.screenWidth / this.options.width, this.xIndependent = true), this.options.height > 0 && (this.yScale = t2.screenHeight / this.options.height, this.yIndependent = true), this.xScale = this.xIndependent ? this.xScale : this.yScale, this.yScale = this.yIndependent ? this.yScale : this.xScale, this.options.time === 0 ? (t2.container.scale.x = this.xScale, t2.container.scale.y = this.yScale, this.options.removeOnComplete && this.parent.plugins.remove("snap-zoom")) : e2.forceStart && this.createSnapping();
+  }
+  createSnapping() {
+    const t2 = this.parent.worldScreenWidth, e2 = this.parent.worldScreenHeight, n2 = this.parent.screenWidth / this.xScale, i2 = this.parent.screenHeight / this.yScale;
+    this.snapping = {
+      time: 0,
+      startX: t2,
+      startY: e2,
+      deltaX: n2 - t2,
+      deltaY: i2 - e2
+    }, this.parent.emit("snap-zoom-start", this.parent);
+  }
+  resize() {
+    this.snapping = null, this.options.width > 0 && (this.xScale = this.parent.screenWidth / this.options.width), this.options.height > 0 && (this.yScale = this.parent.screenHeight / this.options.height), this.xScale = this.xIndependent ? this.xScale : this.yScale, this.yScale = this.yIndependent ? this.yScale : this.xScale;
+  }
+  wheel() {
+    return this.options.removeOnInterrupt && this.parent.plugins.remove("snap-zoom"), false;
+  }
+  down() {
+    return this.options.removeOnInterrupt ? this.parent.plugins.remove("snap-zoom") : this.options.interrupt && (this.snapping = null), false;
+  }
+  update(t2) {
+    if (this.paused || this.options.interrupt && this.parent.input.count() !== 0)
+      return;
+    let e2;
+    if (!this.options.center && !this.options.noMove && (e2 = this.parent.center), !this.snapping)
+      (this.parent.scale.x !== this.xScale || this.parent.scale.y !== this.yScale) && this.createSnapping();
+    else if (this.snapping) {
+      const n2 = this.snapping;
+      if (n2.time += t2, n2.time >= this.options.time)
+        this.parent.scale.set(this.xScale, this.yScale), this.options.removeOnComplete && this.parent.plugins.remove("snap-zoom"), this.parent.emit("snap-zoom-end", this.parent), this.snapping = null;
+      else {
+        const s2 = this.snapping, h2 = this.ease(s2.time, s2.startX, s2.deltaX, this.options.time), o2 = this.ease(s2.time, s2.startY, s2.deltaY, this.options.time);
+        this.parent.scale.x = this.parent.screenWidth / h2, this.parent.scale.y = this.parent.screenHeight / o2;
+      }
+      const i2 = this.parent.plugins.get("clamp-zoom", true);
+      i2 && i2.clamp(), this.options.noMove || (this.options.center ? this.parent.moveCenter(this.options.center) : this.parent.moveCenter(e2));
+    }
+  }
+  resume() {
+    this.snapping = null, super.resume();
+  }
+}
+var J = {
+  percent: 0.1,
+  smooth: false,
+  interrupt: true,
+  reverse: false,
+  center: null,
+  lineHeight: 20,
+  axis: "all",
+  keyToPress: null,
+  trackpadPinch: false,
+  wheelZoom: true
+};
+
+class $2 extends u2 {
+  constructor(t2, e2 = {}) {
+    super(t2), this.options = Object.assign({}, J, e2), this.keyIsPressed = false, this.options.keyToPress && this.handleKeyPresses(this.options.keyToPress);
+  }
+  handleKeyPresses(t2) {
+    typeof window > "u" || (window.addEventListener("keydown", (e2) => {
+      t2.includes(e2.code) && (this.keyIsPressed = true);
+    }), window.addEventListener("keyup", (e2) => {
+      t2.includes(e2.code) && (this.keyIsPressed = false);
+    }));
+  }
+  checkKeyPress() {
+    return !this.options.keyToPress || this.keyIsPressed;
+  }
+  down() {
+    return this.options.interrupt && (this.smoothing = null), false;
+  }
+  isAxisX() {
+    return ["all", "x"].includes(this.options.axis);
+  }
+  isAxisY() {
+    return ["all", "y"].includes(this.options.axis);
+  }
+  update() {
+    if (this.smoothing) {
+      const t2 = this.smoothingCenter, e2 = this.smoothing;
+      let n2;
+      this.options.center || (n2 = this.parent.toLocal(t2)), this.isAxisX() && (this.parent.scale.x += e2.x), this.isAxisY() && (this.parent.scale.y += e2.y), this.parent.emit("zoomed", { viewport: this.parent, type: "wheel" });
+      const i2 = this.parent.plugins.get("clamp-zoom", true);
+      if (i2 && i2.clamp(), this.options.center)
+        this.parent.moveCenter(this.options.center);
+      else {
+        const s2 = this.parent.parent || this.parent;
+        s2.toLocal(n2, this.parent, n2);
+        const h2 = s2.toLocal(t2);
+        this.parent.x += h2.x - n2.x, this.parent.y += h2.y - n2.y;
+      }
+      this.parent.emit("moved", { viewport: this.parent, type: "wheel" }), this.smoothingCount++, typeof this.options.smooth == "number" && this.smoothingCount >= this.options.smooth && (this.smoothing = null);
+    }
+  }
+  pinch(t2) {
+    if (this.paused)
+      return;
+    const e2 = this.parent.input.getPointerPosition(t2), n2 = -t2.deltaY * (t2.deltaMode ? this.options.lineHeight : 1) / 200, i2 = Math.pow(2, (1 + this.options.percent) * n2);
+    let s2;
+    this.options.center || (s2 = this.parent.toLocal(e2)), this.isAxisX() && (this.parent.scale.x *= i2), this.isAxisY() && (this.parent.scale.y *= i2), this.parent.emit("zoomed", { viewport: this.parent, type: "wheel" });
+    const h2 = this.parent.plugins.get("clamp-zoom", true);
+    if (h2 && h2.clamp(), this.options.center)
+      this.parent.moveCenter(this.options.center);
+    else {
+      const o2 = this.parent.parent || this.parent;
+      o2.toLocal(s2, this.parent, s2);
+      const r2 = o2.toLocal(e2);
+      this.parent.x += r2.x - s2.x, this.parent.y += r2.y - s2.y;
+    }
+    this.parent.emit("moved", { viewport: this.parent, type: "wheel" }), this.parent.emit("wheel-start", { event: t2, viewport: this.parent });
+  }
+  wheel(t2) {
+    if (this.paused || !this.checkKeyPress())
+      return false;
+    if (t2.ctrlKey && this.options.trackpadPinch)
+      this.pinch(t2);
+    else if (this.options.wheelZoom) {
+      const e2 = this.parent.input.getPointerPosition(t2), i2 = (this.options.reverse ? -1 : 1) * -t2.deltaY * (t2.deltaMode ? this.options.lineHeight : 1) / 500, s2 = Math.pow(2, (1 + this.options.percent) * i2);
+      if (this.options.smooth) {
+        const h2 = {
+          x: this.smoothing ? this.smoothing.x * (this.options.smooth - this.smoothingCount) : 0,
+          y: this.smoothing ? this.smoothing.y * (this.options.smooth - this.smoothingCount) : 0
+        };
+        this.smoothing = {
+          x: ((this.parent.scale.x + h2.x) * s2 - this.parent.scale.x) / this.options.smooth,
+          y: ((this.parent.scale.y + h2.y) * s2 - this.parent.scale.y) / this.options.smooth
+        }, this.smoothingCount = 0, this.smoothingCenter = e2;
+      } else {
+        let h2;
+        this.options.center || (h2 = this.parent.toLocal(e2)), this.isAxisX() && (this.parent.scale.x *= s2), this.isAxisY() && (this.parent.scale.y *= s2), this.parent.emit("zoomed", { viewport: this.parent, type: "wheel" });
+        const o2 = this.parent.plugins.get("clamp-zoom", true);
+        if (o2 && o2.clamp(), this.options.center)
+          this.parent.moveCenter(this.options.center);
+        else {
+          const r2 = this.parent.parent || this.parent;
+          r2.toLocal(h2, this.parent, h2);
+          const a2 = r2.toLocal(e2);
+          this.parent.x += a2.x - h2.x, this.parent.y += a2.y - h2.y;
+        }
+      }
+      this.parent.emit("moved", { viewport: this.parent, type: "wheel" }), this.parent.emit("wheel-start", { event: t2, viewport: this.parent });
+    }
+    return !this.parent.options.passiveWheel;
+  }
+}
+var tt = {
+  screenWidth: typeof window > "u" ? 0 : window.innerWidth,
+  screenHeight: typeof window > "u" ? 0 : window.innerHeight,
+  worldWidth: null,
+  worldHeight: null,
+  threshold: 5,
+  passiveWheel: true,
+  stopPropagation: false,
+  forceHitArea: null,
+  noTicker: false,
+  disableOnContextMenu: false,
+  ticker: Ticker.shared,
+  allowPreserveDragOutside: false
+};
+
+class it extends Container {
+  constructor(t2) {
+    super(), this._disableOnContextMenu = (e2) => e2.preventDefault(), this.options = {
+      ...tt,
+      ...t2
+    }, this.screenWidth = this.options.screenWidth, this.screenHeight = this.options.screenHeight, this._worldWidth = this.options.worldWidth, this._worldHeight = this.options.worldHeight, this.forceHitArea = this.options.forceHitArea, this.threshold = this.options.threshold, this.options.disableOnContextMenu && this.options.events.domElement.addEventListener("contextmenu", this._disableOnContextMenu), this.options.noTicker || (this.tickerFunction = () => this.update(this.options.ticker.elapsedMS), this.options.ticker.add(this.tickerFunction)), this.input = new P(this), this.plugins = new C(this);
+  }
+  destroy(t2) {
+    var e2;
+    !this.options.noTicker && this.tickerFunction && this.options.ticker.remove(this.tickerFunction), this.options.disableOnContextMenu && ((e2 = this.options.events.domElement) == null || e2.removeEventListener("contextmenu", this._disableOnContextMenu)), this.input.destroy(), super.destroy(t2);
+  }
+  update(t2) {
+    this.pause || (this.plugins.update(t2), this.lastViewport && (this.lastViewport.x !== this.x || this.lastViewport.y !== this.y ? this.moving = true : this.moving && (this.emit("moved-end", this), this.moving = false), this.lastViewport.scaleX !== this.scale.x || this.lastViewport.scaleY !== this.scale.y ? this.zooming = true : this.zooming && (this.emit("zoomed-end", this), this.zooming = false)), this.forceHitArea || (this._hitAreaDefault = new Rectangle(this.left, this.top, this.worldScreenWidth, this.worldScreenHeight), this.hitArea = this._hitAreaDefault), this._dirty = this._dirty || !this.lastViewport || this.lastViewport.x !== this.x || this.lastViewport.y !== this.y || this.lastViewport.scaleX !== this.scale.x || this.lastViewport.scaleY !== this.scale.y, this.lastViewport = {
+      x: this.x,
+      y: this.y,
+      scaleX: this.scale.x,
+      scaleY: this.scale.y
+    }, this.emit("frame-end", this));
+  }
+  resize(t2 = typeof window > "u" ? 0 : window.innerWidth, e2 = typeof window > "u" ? 0 : window.innerHeight, n2, i2) {
+    this.screenWidth = t2, this.screenHeight = e2, typeof n2 < "u" && (this._worldWidth = n2), typeof i2 < "u" && (this._worldHeight = i2), this.plugins.resize(), this.dirty = true;
+  }
+  get worldWidth() {
+    return this._worldWidth ? this._worldWidth : this.width / this.scale.x;
+  }
+  set worldWidth(t2) {
+    this._worldWidth = t2, this.plugins.resize();
+  }
+  get worldHeight() {
+    return this._worldHeight ? this._worldHeight : this.height / this.scale.y;
+  }
+  set worldHeight(t2) {
+    this._worldHeight = t2, this.plugins.resize();
+  }
+  getVisibleBounds() {
+    return new Rectangle(this.left, this.top, this.worldScreenWidth, this.worldScreenHeight);
+  }
+  toWorld(t2, e2) {
+    return arguments.length === 2 ? this.toLocal(new Point(t2, e2)) : this.toLocal(t2);
+  }
+  toScreen(t2, e2) {
+    return arguments.length === 2 ? this.toGlobal(new Point(t2, e2)) : this.toGlobal(t2);
+  }
+  get worldScreenWidth() {
+    return this.screenWidth / this.scale.x;
+  }
+  get worldScreenHeight() {
+    return this.screenHeight / this.scale.y;
+  }
+  get screenWorldWidth() {
+    return this.worldWidth * this.scale.x;
+  }
+  get screenWorldHeight() {
+    return this.worldHeight * this.scale.y;
+  }
+  get center() {
+    return new Point(this.worldScreenWidth / 2 - this.x / this.scale.x, this.worldScreenHeight / 2 - this.y / this.scale.y);
+  }
+  set center(t2) {
+    this.moveCenter(t2);
+  }
+  moveCenter(...t2) {
+    let e2, n2;
+    typeof t2[0] == "number" ? (e2 = t2[0], n2 = t2[1]) : (e2 = t2[0].x, n2 = t2[0].y);
+    const i2 = (this.worldScreenWidth / 2 - e2) * this.scale.x, s2 = (this.worldScreenHeight / 2 - n2) * this.scale.y;
+    return (this.x !== i2 || this.y !== s2) && (this.position.set(i2, s2), this.plugins.reset(), this.dirty = true), this;
+  }
+  get corner() {
+    return new Point(-this.x / this.scale.x, -this.y / this.scale.y);
+  }
+  set corner(t2) {
+    this.moveCorner(t2);
+  }
+  moveCorner(...t2) {
+    let e2, n2;
+    return t2.length === 1 ? (e2 = -t2[0].x * this.scale.x, n2 = -t2[0].y * this.scale.y) : (e2 = -t2[0] * this.scale.x, n2 = -t2[1] * this.scale.y), (e2 !== this.x || n2 !== this.y) && (this.position.set(e2, n2), this.plugins.reset(), this.dirty = true), this;
+  }
+  get screenWidthInWorldPixels() {
+    return this.screenWidth / this.scale.x;
+  }
+  get screenHeightInWorldPixels() {
+    return this.screenHeight / this.scale.y;
+  }
+  findFitWidth(t2) {
+    return this.screenWidth / t2;
+  }
+  findFitHeight(t2) {
+    return this.screenHeight / t2;
+  }
+  findFit(t2, e2) {
+    const n2 = this.screenWidth / t2, i2 = this.screenHeight / e2;
+    return Math.min(n2, i2);
+  }
+  findCover(t2, e2) {
+    const n2 = this.screenWidth / t2, i2 = this.screenHeight / e2;
+    return Math.max(n2, i2);
+  }
+  fitWidth(t2 = this.worldWidth, e2, n2 = true, i2) {
+    let s2;
+    e2 && (s2 = this.center), this.scale.x = this.screenWidth / t2, n2 && (this.scale.y = this.scale.x);
+    const h2 = this.plugins.get("clamp-zoom", true);
+    return !i2 && h2 && h2.clamp(), e2 && s2 && this.moveCenter(s2), this;
+  }
+  fitHeight(t2 = this.worldHeight, e2, n2 = true, i2) {
+    let s2;
+    e2 && (s2 = this.center), this.scale.y = this.screenHeight / t2, n2 && (this.scale.x = this.scale.y);
+    const h2 = this.plugins.get("clamp-zoom", true);
+    return !i2 && h2 && h2.clamp(), e2 && s2 && this.moveCenter(s2), this;
+  }
+  fitWorld(t2) {
+    let e2;
+    t2 && (e2 = this.center), this.scale.x = this.screenWidth / this.worldWidth, this.scale.y = this.screenHeight / this.worldHeight, this.scale.x < this.scale.y ? this.scale.y = this.scale.x : this.scale.x = this.scale.y;
+    const n2 = this.plugins.get("clamp-zoom", true);
+    return n2 && n2.clamp(), t2 && e2 && this.moveCenter(e2), this;
+  }
+  fit(t2, e2 = this.worldWidth, n2 = this.worldHeight) {
+    let i2;
+    t2 && (i2 = this.center), this.scale.x = this.screenWidth / e2, this.scale.y = this.screenHeight / n2, this.scale.x < this.scale.y ? this.scale.y = this.scale.x : this.scale.x = this.scale.y;
+    const s2 = this.plugins.get("clamp-zoom", true);
+    return s2 && s2.clamp(), t2 && i2 && this.moveCenter(i2), this;
+  }
+  setZoom(t2, e2) {
+    let n2;
+    e2 && (n2 = this.center), this.scale.set(t2);
+    const i2 = this.plugins.get("clamp-zoom", true);
+    return i2 && i2.clamp(), e2 && n2 && this.moveCenter(n2), this;
+  }
+  zoomPercent(t2, e2) {
+    return this.setZoom(this.scale.x + this.scale.x * t2, e2);
+  }
+  zoom(t2, e2) {
+    return this.fitWidth(t2 + this.worldScreenWidth, e2), this;
+  }
+  get scaled() {
+    return this.scale.x;
+  }
+  set scaled(t2) {
+    this.setZoom(t2, true);
+  }
+  snapZoom(t2) {
+    return this.plugins.add("snap-zoom", new G(this, t2)), this;
+  }
+  OOB() {
+    return {
+      left: this.left < 0,
+      right: this.right > this.worldWidth,
+      top: this.top < 0,
+      bottom: this.bottom > this.worldHeight,
+      cornerPoint: new Point(this.worldWidth * this.scale.x - this.screenWidth, this.worldHeight * this.scale.y - this.screenHeight)
+    };
+  }
+  get right() {
+    return -this.x / this.scale.x + this.worldScreenWidth;
+  }
+  set right(t2) {
+    this.x = -t2 * this.scale.x + this.screenWidth, this.plugins.reset();
+  }
+  get left() {
+    return -this.x / this.scale.x;
+  }
+  set left(t2) {
+    this.x = -t2 * this.scale.x, this.plugins.reset();
+  }
+  get top() {
+    return -this.y / this.scale.y;
+  }
+  set top(t2) {
+    this.y = -t2 * this.scale.y, this.plugins.reset();
+  }
+  get bottom() {
+    return -this.y / this.scale.y + this.worldScreenHeight;
+  }
+  set bottom(t2) {
+    this.y = -t2 * this.scale.y + this.screenHeight, this.plugins.reset();
+  }
+  get dirty() {
+    return !!this._dirty;
+  }
+  set dirty(t2) {
+    this._dirty = t2;
+  }
+  get forceHitArea() {
+    return this._forceHitArea;
+  }
+  set forceHitArea(t2) {
+    t2 ? (this._forceHitArea = t2, this.hitArea = t2) : (this._forceHitArea = null, this.hitArea = new Rectangle(0, 0, this.worldWidth, this.worldHeight));
+  }
+  drag(t2) {
+    return this.plugins.add("drag", new U(this, t2)), this;
+  }
+  clamp(t2) {
+    return this.plugins.add("clamp", new A(this, t2)), this;
+  }
+  decelerate(t2) {
+    return this.plugins.add("decelerate", new E(this, t2)), this;
+  }
+  bounce(t2) {
+    return this.plugins.add("bounce", new X(this, t2)), this;
+  }
+  pinch(t2) {
+    return this.plugins.add("pinch", new j2(this, t2)), this;
+  }
+  snap(t2, e2, n2) {
+    return this.plugins.add("snap", new q(this, t2, e2, n2)), this;
+  }
+  follow(t2, e2) {
+    return this.plugins.add("follow", new B(this, t2, e2)), this;
+  }
+  wheel(t2) {
+    return this.plugins.add("wheel", new $2(this, t2)), this;
+  }
+  animate(t2) {
+    return this.plugins.add("animate", new k2(this, t2)), this;
+  }
+  clampZoom(t2) {
+    return this.plugins.add("clamp-zoom", new _(this, t2)), this;
+  }
+  mouseEdges(t2) {
+    return this.plugins.add("mouse-edges", new V(this, t2)), this;
+  }
+  get pause() {
+    return !!this._pause;
+  }
+  set pause(t2) {
+    this._pause = t2, this.lastViewport = null, this.moving = false, this.zooming = false, t2 && this.input.pause();
+  }
+  ensureVisible(t2, e2, n2, i2, s2) {
+    s2 && (n2 > this.worldScreenWidth || i2 > this.worldScreenHeight) && (this.fit(true, n2, i2), this.emit("zoomed", { viewport: this, type: "ensureVisible" }));
+    let h2 = false;
+    t2 < this.left ? (this.left = t2, h2 = true) : t2 + n2 > this.right && (this.right = t2 + n2, h2 = true), e2 < this.top ? (this.top = e2, h2 = true) : e2 + i2 > this.bottom && (this.bottom = e2 + i2, h2 = true), h2 && this.emit("moved", { viewport: this, type: "ensureVisible" });
+  }
+}
+
+// src/plugins/ViewportPlugin.ts
+var DEFAULTS2 = {
+  worldWidth: 0,
+  worldHeight: 0,
+  minScale: 0.1,
+  maxScale: 10,
+  drag: true,
+  pinch: true,
+  wheel: true,
+  decelerate: true
+};
+
+class ViewportPlugin {
+  name = "viewport";
+  options;
+  engine;
+  _viewport;
+  constructor(options) {
+    this.options = { ...DEFAULTS2, ...options };
+  }
+  get viewport() {
+    return this._viewport;
+  }
+  get zoom() {
+    return this._viewport?.scale.x ?? 1;
+  }
+  set zoom(value) {
+    if (!this._viewport)
+      return;
+    const clamped = Math.max(this.options.minScale, Math.min(this.options.maxScale, value));
+    this._viewport.setZoom(clamped, true);
+    this.engine.eventBus.emit("viewport:zoomed", { zoom: clamped });
+  }
+  get drag() {
+    return this.options.drag;
+  }
+  set drag(value) {
+    this.options.drag = value;
+    if (!this._viewport)
+      return;
+    if (value) {
+      this._viewport.drag({ mouseButtons: "middle-right" });
+    } else {
+      this._viewport.plugins.remove("drag");
+    }
+  }
+  get wheel() {
+    return this.options.wheel;
+  }
+  set wheel(value) {
+    this.options.wheel = value;
+    if (!this._viewport)
+      return;
+    if (value) {
+      this._viewport.wheel({ smooth: 3 });
+    } else {
+      this._viewport.plugins.remove("wheel");
+    }
+  }
+  init(engine) {
+    this.engine = engine;
+    const { app } = engine;
+    const { width, height } = engine.options;
+    const worldWidth = this.options.worldWidth || width;
+    const worldHeight = this.options.worldHeight || height;
+    this._viewport = new it({
+      screenWidth: width,
+      screenHeight: height,
+      worldWidth,
+      worldHeight,
+      events: app.renderer.events
+    });
+    this._viewport.clampZoom({
+      minScale: this.options.minScale,
+      maxScale: this.options.maxScale
+    });
+    if (this.options.drag)
+      this._viewport.drag({ mouseButtons: "middle-right" });
+    if (this.options.pinch)
+      this._viewport.pinch();
+    if (this.options.wheel)
+      this._viewport.wheel({ smooth: 3 });
+    if (this.options.decelerate)
+      this._viewport.decelerate();
+    const layers = [
+      engine.getBackgroundLayer(),
+      engine.getElementsLayer(),
+      engine.getSelectionLayer(),
+      engine.getOverlayLayer()
+    ];
+    for (const layer of layers) {
+      layer.parent?.removeChild(layer);
+      this._viewport.addChild(layer);
+    }
+    app.stage.addChildAt(this._viewport, 0);
+    this._viewport.on("zoomed", () => {
+      this.engine.eventBus.emit("viewport:zoomed", { zoom: this._viewport.scale.x });
+    });
+    this._viewport.on("moved", () => {
+      this.engine.eventBus.emit("viewport:moved", {
+        x: this._viewport.x,
+        y: this._viewport.y
+      });
+    });
+  }
+  destroy() {
+    if (!this._viewport)
+      return;
+    const { app } = this.engine;
+    const layers = [
+      this.engine.getBackgroundLayer(),
+      this.engine.getElementsLayer(),
+      this.engine.getSelectionLayer(),
+      this.engine.getOverlayLayer()
+    ];
+    for (const layer of layers) {
+      this._viewport.removeChild(layer);
+      app.stage.addChild(layer);
+    }
+    this._viewport.destroy();
+  }
+}
 export {
   ZOrderManager,
   WatchfaceEngine,
+  ViewportPlugin,
   UndoRedoPlugin,
   TextElement,
   ShapeElement,