@prefecthq/graphs 1.0.8 → 2.0.1

package/dist/{viewport.es-ae91b8e8.mjs → viewport.es-73ad6f79.mjs}

@@ -1,32 +1,53 @@
-import { P as c, R as b, T as C, C as P } from "./index-0e0bc71d.mjs";
+import { T as C, C as P, R as b, P as c } from "./index-aba921f4.mjs";
 import "vue";
 class u {
+  /** The viewport to which this plugin is attached. */
+  /**
+   * Flags whether this plugin has been "paused".
+   *
+   * @see Plugin#pause
+   * @see Plugin#resume
+   */
+  /** @param {Viewport} parent */
   constructor(t) {
     this.parent = t, this.paused = !1;
   }
+  /** Called when plugin is removed */
   destroy() {
   }
+  /** Handler for pointerdown PIXI event */
   down(t) {
     return !1;
   }
+  /** Handler for pointermove PIXI event */
   move(t) {
     return !1;
   }
+  /** Handler for pointerup PIXI event */
   up(t) {
     return !1;
   }
+  /** Handler for wheel event on div */
   wheel(t) {
     return !1;
   }
+  /**
+   * Called on each tick
+   * @param {number} elapsed time in millisecond since last update
+   */
   update(t) {
   }
+  /** Called when the viewport is resized */
   resize() {
   }
+  /** Called when the viewport is manually moved */
   reset() {
   }
+  /** Pause the plugin */
   pause() {
     this.paused = !0;
   }
+  /** Un-pause the plugin */
   resume() {
     this.paused = !1;
   }
@@ -166,33 +187,61 @@ const Y = {
   time: 1e3
 };
 class d extends u {
+  /** The starting x-coordinate of the viewport. */
+  /** The starting y-coordinate of the viewport. */
+  /** The change in the x-coordinate of the viewport through the animation.*/
+  /** The change in the y-coordinate of the viewport through the animation. */
+  /** Marks whether the center of the viewport is preserved in the animation. */
+  /** The starting viewport width. */
   __init() {
     this.startWidth = null;
   }
+  /** The starting viewport height. */
   __init2() {
     this.startHeight = null;
   }
+  /** The change in the viewport's width through the animation. */
   __init3() {
     this.deltaWidth = null;
   }
+  /** The change in the viewport's height through the animation. */
   __init4() {
     this.deltaHeight = null;
   }
+  /** The viewport's width post-animation. */
   __init5() {
     this.width = null;
   }
+  /** The viewport's height post-animation. */
   __init6() {
     this.height = null;
   }
+  /** The time since the animation started. */
   __init7() {
     this.time = 0;
   }
+  /**
+   * This is called by {@link Viewport.animate}.
+   *
+   * @param parent
+   * @param options
+   */
   constructor(t, e = {}) {
     super(t), d.prototype.__init.call(this), d.prototype.__init2.call(this), d.prototype.__init3.call(this), d.prototype.__init4.call(this), d.prototype.__init5.call(this), d.prototype.__init6.call(this), d.prototype.__init7.call(this), this.options = Object.assign({}, Y, e), this.options.ease = H(this.options.ease), this.setupPosition(), this.setupZoom(), this.time = 0;
   }
+  /**
+   * Setup `startX`, `startY`, `deltaX`, `deltaY`, `keepCenter`.
+   *
+   * This is called during construction.
+   */
   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 = !1) : this.keepCenter = !0;
   }
+  /**
+   * Setup `startWidth, `startHeight`, `deltaWidth, `deltaHeight, `width`, `height`.
+   *
+   * This is called during construction.
+   */
   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);
   }
@@ -255,6 +304,19 @@ const X = {
   bounceBox: null
 };
 class z extends u {
+  /** The options passed to initialize this plugin, cannot be modified again. */
+  /** Holds whether to bounce from left side. */
+  /** Holds whether to bounce from top side. */
+  /** Holds whether to bounce from right side. */
+  /** Holds whether to bounce from bottom side. */
+  /** Direction of underflow along x-axis. */
+  /** Direction of underflow along y-axis. */
+  /** Easing */
+  /** Bounce state along x-axis */
+  /** Bounce state along y-axis */
+  /**
+   * This is called by {@link Viewport.bounce}.
+   */
   constructor(t, e = {}) {
     super(t), this.options = Object.assign({}, X, e), this.ease = H(this.options.ease, "easeInOutSine"), this.options.sides ? this.options.sides === "all" ? this.top = this.bottom = this.left = this.right = !0 : this.options.sides === "horizontal" ? (this.right = this.left = !0, this.top = this.bottom = !1) : this.options.sides === "vertical" ? (this.left = this.right = !1, this.top = this.bottom = !0) : (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 = !1;
     const n = this.options.underflow.toLowerCase();
@@ -281,6 +343,7 @@ class z extends u {
       }
     }
   }
+  /** @internal */
   calcUnderflowX() {
     let t;
     switch (this.underflowX) {
@@ -295,6 +358,7 @@ class z extends u {
     }
     return t;
   }
+  /** @internal */
   calcUnderflowY() {
     let t;
     switch (this.underflowY) {
@@ -372,6 +436,11 @@ const A = {
   underflow: "center"
 };
 class T extends u {
+  /** Options used to initialize this plugin, cannot be modified later. */
+  /** Last state of viewport */
+  /**
+   * This is called by {@link Viewport.clamp}.
+   */
   constructor(t, e = {}) {
     super(t), this.options = Object.assign({}, A, e), this.options.direction && (this.options.left = this.options.direction === "x" || this.options.direction === "all" ? !0 : null, this.options.right = this.options.direction === "x" || this.options.direction === "all" ? !0 : null, this.options.top = this.options.direction === "y" || this.options.direction === "all" ? !0 : null, this.options.bottom = this.options.direction === "y" || this.options.direction === "all" ? !0 : null), this.parseUnderflow(), this.last = { x: null, y: null, scaleX: null, scaleY: null }, this.update();
   }
@@ -435,12 +504,16 @@ const E = {
   maxScale: null
 };
 class L extends u {
+  /**
+   * This is called by {@link Viewport.clampZoom}.
+   */
   constructor(t, e = {}) {
     super(t), this.options = Object.assign({}, E, e), this.clamp();
   }
   resize() {
     this.clamp();
   }
+  /** Clamp the viewport scale zoom) */
   clamp() {
     if (!this.paused) {
       if (this.options.minWidth || this.options.minHeight || this.options.maxWidth || this.options.maxHeight) {
@@ -490,6 +563,32 @@ const D = {
   minSpeed: 0.01
 }, f = 16;
 class U extends u {
+  /** Options used to initialize this plugin. */
+  /**
+   * x-component of the velocity of viewport provided by this plugin, at the current time.
+   *
+   * This is measured in px/frame, where a frame is normalized to 16 milliseconds.
+   */
+  /**
+   * y-component of the velocity of the viewport provided by this plugin, at the current time.
+   *
+   * This is measured in px/frame, where a frame is normalized to 16 milliseconds.
+   */
+  /**
+   * The decay factor for the x-component of the viewport.
+   *
+   * The viewport's velocity decreased by this amount each 16 milliseconds.
+   */
+  /**
+   * The decay factor for the y-component of the viewport.
+   *
+   * The viewport's velocity decreased by this amount each 16 milliseconds.
+   */
+  /** Saved list of recent viewport position snapshots, to estimate velocity. */
+  /** The time since the user released panning of the viewport. */
+  /**
+   * This is called by {@link Viewport.decelerate}.
+   */
   constructor(t, e = {}) {
     super(t), this.options = Object.assign({}, D, e), this.saved = [], this.timeSinceRelease = 0, this.reset(), this.parent.on("moved", (n) => this.moved(n));
   }
@@ -505,6 +604,7 @@ class U extends u {
     const t = this.parent.input.count();
     return (t === 1 || t > 1 && !this.parent.plugins.get("pinch", !0)) && (this.saved.push({ x: this.parent.x, y: this.parent.y, time: performance.now() }), this.saved.length > 60 && this.saved.splice(0, 30)), !1;
   }
+  /** Listener to viewport's "moved" event. */
   moved(t) {
     if (this.saved.length) {
       const e = this.saved[this.saved.length - 1];
@@ -523,6 +623,13 @@ class U extends u {
     }
     return !1;
   }
+  /**
+   * Manually activate deceleration, starting from the (x, y) velocity components passed in the options.
+   *
+   * @param {object} options
+   * @param {number} [options.x] - Specify x-component of initial velocity.
+   * @param {number} [options.y] - Specify y-component of initial velocity.
+   */
   activate(t) {
     t = t || {}, typeof t.x < "u" && (this.x = t.x, this.percentChangeX = this.options.friction), typeof t.y < "u" && (this.y = t.y, this.percentChangeY = this.options.friction);
   }
@@ -560,12 +667,32 @@ const B = {
   wheelSwapAxes: !1
 };
 class S extends u {
+  /** Options used to initialize this plugin, cannot be modified later. */
+  /** Flags when viewport is moving. */
+  /** Factor to apply from {@link IDecelerateOptions}'s reverse. */
+  /** Holds whether dragging is enabled along the x-axis. */
+  /** Holds whether dragging is enabled along the y-axis. */
+  /** Flags whether the keys required to drag are pressed currently. */
+  /** Holds whether the left, center, and right buttons are required to pan. */
+  /** Underflow factor along x-axis */
+  /** Underflow factor along y-axis */
+  /** Last pointer position while panning. */
+  /** The ID of the pointer currently panning the viewport. */
+  /** Array of event-handlers for window */
   __init() {
     this.windowEventHandlers = new Array();
   }
+  /**
+   * This is called by {@link Viewport.drag}.
+   */
   constructor(t, e = {}) {
     super(t), S.prototype.__init.call(this), this.options = Object.assign({}, B, e), this.moved = !1, 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 = !1, this.parseUnderflow(), this.mouseButtons(this.options.mouseButtons), this.options.keyToPress && this.handleKeyPresses(this.options.keyToPress);
   }
+  /**
+   * Handles keypress events and set the keyIsPressed boolean accordingly
+   *
+   * @param {array} codes - key codes that can be used to trigger drag event
+   */
   handleKeyPresses(t) {
     const e = (i) => {
       t.includes(i.code) && (this.keyIsPressed = !0);
@@ -582,6 +709,10 @@ class S extends u {
       window.removeEventListener(t, e);
     });
   }
+  /**
+   * initialize mousebuttons array
+   * @param {string} buttons
+   */
   mouseButtons(t) {
     !t || t === "all" ? this.mouse = [!0, !0, !0] : this.mouse = [
       t.indexOf("left") !== -1,
@@ -593,10 +724,18 @@ class S extends u {
     const t = this.options.underflow.toLowerCase();
     t === "center" ? (this.underflowX = 0, this.underflowY = 0) : (t.includes("left") ? this.underflowX = -1 : t.includes("right") ? this.underflowX = 1 : this.underflowX = 0, t.includes("top") ? this.underflowY = -1 : t.includes("bottom") ? this.underflowY = 1 : this.underflowY = 0);
   }
+  /**
+   * @param {PIXI.InteractionEvent} event
+   * @returns {boolean}
+   */
   checkButtons(t) {
     const e = t.data.pointerType === "mouse", n = this.parent.input.count();
     return !!((n === 1 || n > 1 && !this.parent.plugins.get("pinch", !0)) && (!e || this.mouse[t.data.button]));
   }
+  /**
+   * @param {PIXI.InteractionEvent} event
+   * @returns {boolean}
+   */
   checkKeyPress(t) {
     return !this.options.keyToPress || this.keyIsPressed || this.options.ignoreKeyToPressOnTouch && t.data.pointerType === "touch";
   }
@@ -698,6 +837,16 @@ const F = {
   radius: null
 };
 class V extends u {
+  /** The options used to initialize this plugin. */
+  /** The target this plugin will make the viewport follow. */
+  /** The velocity provided the viewport by following, at the current time. */
+  /**
+   * This is called by {@link Viewport.follow}.
+   *
+   * @param parent
+   * @param target - target to follow
+   * @param options
+   */
   constructor(t, e, n = {}) {
     super(t), this.target = e, this.options = Object.assign({}, F, n), this.velocity = { x: 0, y: 0 };
   }
@@ -751,6 +900,16 @@ const Z = {
   allowButtons: !1
 };
 class N extends u {
+  /** Options used to initialize this plugin, cannot be modified later. */
+  /** Factor from reverse option. */
+  /** Radius squared */
+  /** Scroll region size on the left side. */
+  /** Scroll region size on the top size. */
+  /** Scroll region size on the right side. */
+  /** Scroll region size on the bottom side. */
+  /**
+   * This is called by {@link Viewport.mouseEdges}.
+   */
   constructor(t, e = {}) {
     super(t), this.options = Object.assign({}, Z, e), this.reverse = this.options.reverse ? 1 : -1, this.radiusSquared = typeof this.options.radius == "number" ? Math.pow(this.options.radius, 2) : null, this.resize();
   }
@@ -802,15 +961,21 @@ const R = {
   axis: "all"
 };
 class w extends u {
+  /** Options used to initialize this plugin. */
+  /** Flags whether this plugin is active, i.e. a pointer is down on the viewport. */
   __init() {
     this.active = !1;
   }
+  /** Flags whether the viewport is being pinched. */
   __init2() {
     this.pinching = !1;
   }
   __init3() {
     this.moved = !1;
   }
+  /**
+   * This is called by {@link Viewport.pinch}.
+   */
   constructor(t, e = {}) {
     super(t), w.prototype.__init.call(this), w.prototype.__init2.call(this), w.prototype.__init3.call(this), this.options = Object.assign({}, R, e);
   }
@@ -872,6 +1037,9 @@ const j = {
   forceStart: !1
 };
 class q extends u {
+  /**
+   * This is called by {@link Viewport.snap}.
+   */
   constructor(t, e, n, i = {}) {
     super(t), this.options = Object.assign({}, j, i), this.ease = H(i.ease, "easeInOutSine"), this.x = e, this.y = n, this.options.forceStart && this.snapStart();
   }
@@ -926,6 +1094,9 @@ const K = {
   noMove: !1
 };
 class G extends u {
+  /**
+   * This is called by {@link Viewport.snapZoom}.
+   */
   constructor(t, e = {}) {
     super(t), this.options = Object.assign({}, K, e), this.ease = H(this.options.ease), this.xIndependent = !1, this.yIndependent = !1, this.xScale = 0, this.yScale = 0, this.options.width > 0 && (this.xScale = t.screenWidth / this.options.width, this.xIndependent = !0), this.options.height > 0 && (this.yScale = t.screenHeight / this.options.height, this.yIndependent = !0), this.xScale = this.xIndependent ? this.xScale : this.yScale, this.yScale = this.yIndependent ? this.yScale : this.xScale, this.options.time === 0 ? (t.container.scale.x = this.xScale, t.container.scale.y = this.yScale, this.options.removeOnComplete && this.parent.plugins.remove("snap-zoom")) : e.forceStart && this.createSnapping();
   }
@@ -983,9 +1154,18 @@ const Q = {
   wheelZoom: !0
 };
 class $ extends u {
+  /** Flags whether the keys required to zoom are pressed currently. */
+  /**
+   * This is called by {@link Viewport.wheel}.
+   */
   constructor(t, e = {}) {
     super(t), this.options = Object.assign({}, Q, e), this.keyIsPressed = !1, this.options.keyToPress && this.handleKeyPresses(this.options.keyToPress);
   }
+  /**
+   * Handles keypress events and set the keyIsPressed boolean accordingly
+   *
+   * @param {array} codes - key codes that can be used to trigger zoom event
+   */
   handleKeyPresses(t) {
     window.addEventListener("keydown", (e) => {
       t.includes(e.code) && (this.keyIsPressed = !0);
@@ -1074,9 +1254,11 @@ class $ extends u {
   }
 }
 class J {
+  /** List of active touches on viewport */
   constructor(t) {
     this.viewport = t, this.touches = [], this.addListeners();
   }
+  /** Add input listeners */
   addListeners() {
     this.viewport.interactive = !0, this.viewport.forceHitArea || (this.viewport.hitArea = new b(0, 0, this.viewport.worldWidth, this.viewport.worldHeight)), this.viewport.on("pointerdown", this.down, 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.on("pointerout", this.up, this), this.wheelFunction = (t) => this.handleWheel(t), this.viewport.options.divWheel.addEventListener(
       "wheel",
@@ -1084,9 +1266,18 @@ class J {
       { passive: this.viewport.options.passiveWheel }
     ), this.isMouseDown = !1;
   }
+  /**
+   * Removes all event listeners from viewport
+   * (useful for cleanup of wheel when removing viewport)
+   */
   destroy() {
     this.viewport.options.divWheel.removeEventListener("wheel", this.wheelFunction);
   }
+  /**
+   * handle down events for viewport
+   *
+   * @param {PIXI.InteractionEvent} event
+   */
   down(t) {
     if (this.viewport.pause || !this.viewport.worldVisible)
       return;
@@ -1098,12 +1289,18 @@ class J {
       this.clickedAvailable = !1;
     this.viewport.plugins.down(t) && this.viewport.options.stopPropagation && t.stopPropagation();
   }
+  /** Clears all pointer events */
   clear() {
     this.isMouseDown = !1, this.touches = [], this.last = null;
   }
+  /**
+   * @param {number} change
+   * @returns whether change exceeds threshold
+   */
   checkThreshold(t) {
     return Math.abs(t) >= this.viewport.threshold;
   }
+  /** Handle move events for viewport */
   move(t) {
     if (this.viewport.pause || !this.viewport.worldVisible)
       return;
@@ -1114,6 +1311,7 @@ class J {
     }
     e && this.viewport.options.stopPropagation && t.stopPropagation();
   }
+  /** Handle up events for viewport */
   up(t) {
     if (this.viewport.pause || !this.viewport.worldVisible)
       return;
@@ -1126,6 +1324,7 @@ class J {
       viewport: this
     }), this.clickedAvailable = !1), e && this.viewport.options.stopPropagation && t.stopPropagation();
   }
+  /** Gets pointer position if this.interaction is set */
   getPointerPosition(t) {
     const e = new c();
     if (this.viewport.options.interaction)
@@ -1137,6 +1336,7 @@ class J {
       e.x = t.clientX, e.y = t.clientY;
     return e;
   }
+  /** Handle wheel events */
   handleWheel(t) {
     if (this.viewport.pause || !this.viewport.worldVisible || this.viewport.options.interaction && this.viewport.options.interaction.interactionDOMElement !== t.target)
       return;
@@ -1146,12 +1346,14 @@ class J {
   pause() {
     this.touches = [], this.isMouseDown = !1;
   }
+  /** Get touch by id */
   get(t) {
     for (const e of this.touches)
       if (e.id === t)
         return e;
     return null;
   }
+  /** Remove touch by number */
   remove(t) {
     for (let e = 0; e < this.touches.length; e++)
       if (this.touches[e].id === t) {
@@ -1159,6 +1361,9 @@ class J {
         return;
       }
   }
+  /**
+   * @returns {number} count of mouse/touch pointers that are down on the viewport
+   */
   count() {
     return (this.isMouseDown ? 1 : 0) + this.touches.length;
   }
@@ -1188,67 +1393,150 @@ const m = [
   "clamp"
 ];
 class tt {
+  /** Maps mounted plugins by their type */
+  /**
+   * List of plugins mounted
+   *
+   * This list is kept sorted by the internal priority of plugins (hard-coded).
+   */
+  /** The viewport using the plugins managed by `this`. */
+  /** This is called by {@link Viewport} to initialize the {@link Viewport.plugins plugins}. */
   constructor(t) {
     this.viewport = t, this.list = [], this.plugins = {};
   }
+  /**
+   * Inserts a named plugin or a user plugin into the viewport
+   * default plugin order: 'drag', 'pinch', 'wheel', 'follow', 'mouse-edges', 'decelerate', 'bounce',
+   * 'snap-zoom', 'clamp-zoom', 'snap', 'clamp'
+   *
+   * @param {string} name of plugin
+   * @param {Plugin} plugin - instantiated Plugin class
+   * @param {number} index to insert userPlugin (otherwise inserts it at the end)
+   */
   add(t, e, n = m.length) {
     const i = this.plugins[t];
     i && i.destroy(), this.plugins[t] = e;
     const s = m.indexOf(t);
     s !== -1 && m.splice(s, 1), m.splice(n, 0, t), this.sort();
   }
+  /**
+   * Get plugin
+   *
+   * @param {string} name of plugin
+   * @param {boolean} [ignorePaused] return null if plugin is paused
+   */
   get(t, e) {
     return e && W([this, "access", (n) => n.plugins, "access", (n) => n[t], "optionalAccess", (n) => n.paused]) ? null : this.plugins[t];
   }
+  /**
+   * Update all active plugins
+   *
+   * @internal
+   * @ignore
+   * @param {number} elapsed type in milliseconds since last update
+   */
   update(t) {
     for (const e of this.list)
       e.update(t);
   }
+  /**
+   * Resize all active plugins
+   *
+   * @internal
+   * @ignore
+   */
   resize() {
     for (const t of this.list)
       t.resize();
   }
+  /** Clamps and resets bounce and decelerate (as needed) after manually moving viewport */
   reset() {
     for (const t of this.list)
       t.reset();
   }
+  /** removes all installed plugins */
   removeAll() {
     this.list.forEach((t) => {
       t.destroy();
     }), this.plugins = {}, this.sort();
   }
+  /**
+   * Removes installed plugin
+   *
+   * @param {string} name of plugin (e.g., 'drag', 'pinch')
+   */
   remove(t) {
     this.plugins[t] && (W([this, "access", (e) => e.plugins, "access", (e) => e[t], "optionalAccess", (e) => e.destroy, "call", (e) => e()]), delete this.plugins[t], this.viewport.emit(`${t}-remove`), this.sort());
   }
+  /**
+   * Pause plugin
+   *
+   * @param {string} name of plugin (e.g., 'drag', 'pinch')
+   */
   pause(t) {
     W([this, "access", (e) => e.plugins, "access", (e) => e[t], "optionalAccess", (e) => e.pause, "call", (e) => e()]);
   }
+  /**
+   * Resume plugin
+   *
+   * @param {string} name of plugin (e.g., 'drag', 'pinch')
+   */
   resume(t) {
     W([this, "access", (e) => e.plugins, "access", (e) => e[t], "optionalAccess", (e) => e.resume, "call", (e) => e()]);
   }
+  /**
+   * Sort plugins according to PLUGIN_ORDER
+   *
+   * @internal
+   * @ignore
+   */
   sort() {
     this.list = [];
     for (const t of m)
       this.plugins[t] && this.list.push(this.plugins[t]);
   }
+  /**
+   * Handle down for all plugins
+   *
+   * @internal
+   * @ignore
+   */
   down(t) {
     let e = !1;
     for (const n of this.list)
       n.down(t) && (e = !0);
     return e;
   }
+  /**
+   * Handle move for all plugins
+   *
+   * @internal
+   * @ignore
+   */
   move(t) {
     let e = !1;
     for (const n of this.viewport.plugins.list)
       n.move(t) && (e = !0);
     return e;
   }
+  /**
+   * Handle up for all plugins
+   *
+   * @internal
+   * @ignore
+   */
   up(t) {
     let e = !1;
     for (const n of this.list)
       n.up(t) && (e = !0);
     return e;
   }
+  /**
+   * Handle wheel event for all plugins
+   *
+   * @internal
+   * @ignore
+   */
   wheel(t) {
     let e = !1;
     for (const n of this.list)
@@ -1271,9 +1559,35 @@ const et = {
   ticker: C.shared
 };
 class O extends P {
+  /** Flags whether the viewport is being panned */
+  /** Number of pixels to move to trigger an input event (e.g., drag, pinch) or disable a clicked event */
+  /** Use this to add user plugins or access existing plugins (e.g., to pause, resume, or remove them) */
+  /** Flags whether the viewport zoom is being changed. */
+  /** The options passed when creating this viewport, merged with the default values */
   __init() {
     this._disableOnContextMenu = (t) => t.preventDefault();
   }
+  /**
+   * @param {IViewportOptions} ViewportOptions
+   * @param {number} [options.screenWidth=window.innerWidth]
+   * @param {number} [options.screenHeight=window.innerHeight]
+   * @param {number} [options.worldWidth=this.width]
+   * @param {number} [options.worldHeight=this.height]
+   * @param {number} [options.threshold=5] number of pixels to move to trigger an input event (e.g., drag, pinch)
+   * or disable a clicked event
+   * @param {boolean} [options.passiveWheel=true] whether the 'wheel' event is set to passive (note: if false,
+   * e.preventDefault() will be called when wheel is used over the viewport)
+   * @param {boolean} [options.stopPropagation=false] whether to stopPropagation of events that impact the viewport
+   * (except wheel events, see options.passiveWheel)
+   * @param {HitArea} [options.forceHitArea] change the default hitArea from world size to a new value
+   * @param {boolean} [options.noTicker] set this if you want to manually call update() function on each frame
+   * @param {PIXI.Ticker} [options.ticker=PIXI.Ticker.shared] use this PIXI.ticker for updates
+   * @param {PIXI.InteractionManager} [options.interaction=null] InteractionManager, available from instantiated
+   * WebGLRenderer/CanvasRenderer.plugins.interaction - used to calculate pointer position relative to canvas
+   * location on screen
+   * @param {HTMLElement} [options.divWheel=document.body] div to attach the wheel event
+   * @param {boolean} [options.disableOnContextMenu] remove oncontextmenu=() => {} from the divWheel element
+   */
   constructor(t = {}) {
     super(), O.prototype.__init.call(this), this.options = Object.assign(
       {},
@@ -1282,9 +1596,17 @@ class O extends P {
       t
     ), 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.divWheel = this.options.divWheel || document.body, this.options.disableOnContextMenu && this.options.divWheel.addEventListener("contextmenu", this._disableOnContextMenu), this.options.noTicker || (this.tickerFunction = () => this.update(this.options.ticker.elapsedMS), this.options.ticker.add(this.tickerFunction)), this.input = new J(this), this.plugins = new tt(this);
   }
+  /** Overrides PIXI.Container's destroy to also remove the 'wheel' and PIXI.Ticker listeners */
   destroy(t) {
     !this.options.noTicker && this.tickerFunction && this.options.ticker.remove(this.tickerFunction), this.options.disableOnContextMenu && this.options.divWheel.removeEventListener("contextmenu", this._disableOnContextMenu), this.input.destroy(), super.destroy(t);
   }
+  /**
+   * Update viewport on each frame.
+   *
+   * By default, you do not need to call this unless you set `options.noTicker=true`.
+   *
+   * @param {number} elapsed time in milliseconds since last update
+   */
   update(t) {
     this.pause || (this.plugins.update(t), this.lastViewport && (this.lastViewport.x !== this.x || this.lastViewport.y !== this.y ? this.moving = !0 : this.moving && (this.emit("moved-end", this), this.moving = !1), this.lastViewport.scaleX !== this.scale.x || this.lastViewport.scaleY !== this.scale.y ? this.zooming = !0 : this.zooming && (this.emit("zoomed-end", this), this.zooming = !1)), this.forceHitArea || (this._hitAreaDefault = new b(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,
@@ -1293,42 +1615,71 @@ class O extends P {
       scaleY: this.scale.y
     }, this.emit("frame-end", this));
   }
+  /**
+   * Use this to set screen and world sizes, needed for pinch/wheel/clamp/bounce.
+   * @param {number} screenWidth=window.innerWidth
+   * @param {number} screenHeight=window.innerHeight
+   * @param {number} [worldWidth]
+   * @param {number} [worldHeight]
+   */
   resize(t = window.innerWidth, e = window.innerHeight, n, i) {
     this.screenWidth = t, this.screenHeight = e, typeof n < "u" && (this._worldWidth = n), typeof i < "u" && (this._worldHeight = i), this.plugins.resize(), this.dirty = !0;
   }
+  /** World width, in pixels */
   get worldWidth() {
     return this._worldWidth ? this._worldWidth : this.width / this.scale.x;
   }
   set worldWidth(t) {
     this._worldWidth = t, this.plugins.resize();
   }
+  /** World height, in pixels */
   get worldHeight() {
     return this._worldHeight ? this._worldHeight : this.height / this.scale.y;
   }
   set worldHeight(t) {
     this._worldHeight = t, this.plugins.resize();
   }
+  /** Get visible world bounds of viewport */
   getVisibleBounds() {
     return new b(this.left, this.top, this.worldScreenWidth, this.worldScreenHeight);
   }
+  /** Change coordinates from screen to world */
+  /**
+   * Changes coordinate from screen to world
+   * @param {number|PIXI.Point} x
+   * @param {number} y
+   * @returns {PIXI.Point}
+   */
   toWorld(t, e) {
     return arguments.length === 2 ? this.toLocal(new c(t, e)) : this.toLocal(t);
   }
+  /** Change coordinates from world to screen */
+  /**
+   * Changes coordinate from world to screen
+   * @param {number|PIXI.Point} x
+   * @param {number} y
+   * @returns {PIXI.Point}
+   */
   toScreen(t, e) {
     return arguments.length === 2 ? this.toGlobal(new c(t, e)) : this.toGlobal(t);
   }
+  /** Screen width in world coordinates */
   get worldScreenWidth() {
     return this.screenWidth / this.scale.x;
   }
+  /** Screen height in world coordinates */
   get worldScreenHeight() {
     return this.screenHeight / this.scale.y;
   }
+  /** World width in screen coordinates */
   get screenWorldWidth() {
     return this.worldWidth * this.scale.x;
   }
+  /** World height in screen coordinates */
   get screenWorldHeight() {
     return this.worldHeight * this.scale.y;
   }
+  /** Center of screen in world coordinates */
   get center() {
     return new c(
       this.worldScreenWidth / 2 - this.x / this.scale.x,
@@ -1338,87 +1689,205 @@ class O extends P {
   set center(t) {
     this.moveCenter(t);
   }
+  /**
+   * Move center of viewport to (x, y)
+   * @param {number|PIXI.Point} x
+   * @param {number} [y]
+   * @return {Viewport}
+   */
   moveCenter(...t) {
     let e, n;
     typeof t[0] == "number" ? (e = t[0], n = t[1]) : (e = t[0].x, n = t[0].y);
     const i = (this.worldScreenWidth / 2 - e) * this.scale.x, s = (this.worldScreenHeight / 2 - n) * this.scale.y;
     return (this.x !== i || this.y !== s) && (this.position.set(i, s), this.plugins.reset(), this.dirty = !0), this;
   }
+  /** Top-left corner of Viewport */
   get corner() {
     return new c(-this.x / this.scale.x, -this.y / this.scale.y);
   }
   set corner(t) {
     this.moveCorner(t);
   }
+  /** Move Viewport's top-left corner; also clamps and resets decelerate and bounce (as needed) */
+  /**
+   * MoveCorner
+   * @param {number|PIXI.Point} x
+   * @param {number} [y]
+   * @returns {Viewport}
+   */
   moveCorner(...t) {
     let e, n;
     return t.length === 1 ? (e = -t[0].x * this.scale.x, n = -t[0].y * this.scale.y) : (e = -t[0] * this.scale.x, n = -t[1] * this.scale.y), (e !== this.x || n !== this.y) && (this.position.set(e, n), this.plugins.reset(), this.dirty = !0), this;
   }
+  /** Get how many world pixels fit in screen's width */
   get screenWidthInWorldPixels() {
     return this.screenWidth / this.scale.x;
   }
+  /** Get how many world pixels fit on screen's height */
   get screenHeightInWorldPixels() {
     return this.screenHeight / this.scale.y;
   }
+  /**
+   * Find the scale value that fits a world width on the screen
+   * does not change the viewport (use fit... to change)
+   *
+   * @param width - Width in world pixels
+   * @return - scale
+   */
   findFitWidth(t) {
     return this.screenWidth / t;
   }
+  /**
+   * Finds the scale value that fits a world height on the screens
+   * does not change the viewport (use fit... to change)
+   *
+   * @param height - Height in world pixels
+   * @return - scale
+   */
   findFitHeight(t) {
     return this.screenHeight / t;
   }
+  /**
+   * Finds the scale value that fits the smaller of a world width and world height on the screen
+   * does not change the viewport (use fit... to change)
+   *
+   * @param {number} width in world pixels
+   * @param {number} height in world pixels
+   * @returns {number} scale
+   */
   findFit(t, e) {
     const n = this.screenWidth / t, i = this.screenHeight / e;
     return Math.min(n, i);
   }
+  /**
+   * Finds the scale value that fits the larger of a world width and world height on the screen
+   * does not change the viewport (use fit... to change)
+   *
+   * @param {number} width in world pixels
+   * @param {number} height in world pixels
+   * @returns {number} scale
+   */
   findCover(t, e) {
     const n = this.screenWidth / t, i = this.screenHeight / e;
     return Math.max(n, i);
   }
+  /**
+   * Change zoom so the width fits in the viewport
+   *
+   * @param width - width in world coordinates
+   * @param center - maintain the same center
+   * @param scaleY - whether to set scaleY=scaleX
+   * @param noClamp - whether to disable clamp-zoom
+   * @returns {Viewport} this
+   */
   fitWidth(t = this.worldWidth, e, n = !0, i) {
     let s;
     e && (s = this.center), this.scale.x = this.screenWidth / t, n && (this.scale.y = this.scale.x);
     const h = this.plugins.get("clamp-zoom", !0);
     return !i && h && h.clamp(), e && s && this.moveCenter(s), this;
   }
+  /**
+   * Change zoom so the height fits in the viewport
+   *
+   * @param {number} [height=this.worldHeight] in world coordinates
+   * @param {boolean} [center] maintain the same center of the screen after zoom
+   * @param {boolean} [scaleX=true] whether to set scaleX = scaleY
+   * @param {boolean} [noClamp] whether to disable clamp-zoom
+   * @returns {Viewport} this
+   */
   fitHeight(t = this.worldHeight, e, n = !0, i) {
     let s;
     e && (s = this.center), this.scale.y = this.screenHeight / t, n && (this.scale.x = this.scale.y);
     const h = this.plugins.get("clamp-zoom", !0);
     return !i && h && h.clamp(), e && s && this.moveCenter(s), this;
   }
+  /**
+   * Change zoom so it fits the entire world in the viewport
+   *
+   * @param {boolean} center maintain the same center of the screen after zoom
+   * @returns {Viewport} this
+   */
   fitWorld(t) {
     let e;
     t && (e = 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 n = this.plugins.get("clamp-zoom", !0);
     return n && n.clamp(), t && e && this.moveCenter(e), this;
   }
+  /**
+   * Change zoom so it fits the size or the entire world in the viewport
+   *
+   * @param {boolean} [center] maintain the same center of the screen after zoom
+   * @param {number} [width=this.worldWidth] desired width
+   * @param {number} [height=this.worldHeight] desired height
+   * @returns {Viewport} this
+   */
   fit(t, e = this.worldWidth, n = this.worldHeight) {
     let i;
     t && (i = this.center), this.scale.x = this.screenWidth / e, this.scale.y = this.screenHeight / n, this.scale.x < this.scale.y ? this.scale.y = this.scale.x : this.scale.x = this.scale.y;
     const s = this.plugins.get("clamp-zoom", !0);
     return s && s.clamp(), t && i && this.moveCenter(i), this;
   }
+  /**
+   * Zoom viewport to specific value.
+   *
+   * @param {number} scale value (e.g., 1 would be 100%, 0.25 would be 25%)
+   * @param {boolean} [center] maintain the same center of the screen after zoom
+   * @return {Viewport} this
+   */
   setZoom(t, e) {
     let n;
     e && (n = this.center), this.scale.set(t);
     const i = this.plugins.get("clamp-zoom", !0);
     return i && i.clamp(), e && n && this.moveCenter(n), this;
   }
+  /**
+   * Zoom viewport by a certain percent (in both x and y direction).
+   *
+   * @param {number} percent change (e.g., 0.25 would increase a starting scale of 1.0 to 1.25)
+   * @param {boolean} [center] maintain the same center of the screen after zoom
+   * @return {Viewport} this
+   */
   zoomPercent(t, e) {
     return this.setZoom(this.scale.x + this.scale.x * t, e);
   }
+  /**
+   * Zoom viewport by increasing/decreasing width by a certain number of pixels.
+   *
+   * @param {number} change in pixels
+   * @param {boolean} [center] maintain the same center of the screen after zoom
+   * @return {Viewport} this
+   */
   zoom(t, e) {
     return this.fitWidth(t + this.worldScreenWidth, e), this;
   }
+  /** Changes scale of viewport and maintains center of viewport */
   get scaled() {
     return this.scale.x;
   }
   set scaled(t) {
     this.setZoom(t, !0);
   }
+  /**
+   * Returns zoom to the desired scale
+   *
+   * @param {ISnapZoomOptions} options
+   * @param {number} [options.width=0] - the desired width to snap (to maintain aspect ratio, choose width or height)
+   * @param {number} [options.height=0] - the desired height to snap (to maintain aspect ratio, choose width or height)
+   * @param {number} [options.time=1000] - time for snapping in ms
+   * @param {(string|function)} [options.ease=easeInOutSine] ease function or name (see http://easings.net/
+   *   for supported names)
+   * @param {PIXI.Point} [options.center] - place this point at center during zoom instead of center of the viewport
+   * @param {boolean} [options.interrupt=true] - pause snapping with any user input on the viewport
+   * @param {boolean} [options.removeOnComplete] - removes this plugin after snapping is complete
+   * @param {boolean} [options.removeOnInterrupt] - removes this plugin if interrupted by any user input
+   * @param {boolean} [options.forceStart] - starts the snap immediately regardless of whether the viewport is at the
+   *   desired zoom
+   * @param {boolean} [options.noMove] - zoom but do not move
+   */
   snapZoom(t) {
     return this.plugins.add("snap-zoom", new G(this, t)), this;
   }
+  /** Is container out of world bounds */
   OOB() {
     return {
       left: this.left < 0,
@@ -1431,81 +1900,316 @@ class O extends P {
       )
     };
   }
+  /** World coordinates of the right edge of the screen */
   get right() {
     return -this.x / this.scale.x + this.worldScreenWidth;
   }
   set right(t) {
     this.x = -t * this.scale.x + this.screenWidth, this.plugins.reset();
   }
+  /** World coordinates of the left edge of the screen */
   get left() {
     return -this.x / this.scale.x;
   }
   set left(t) {
     this.x = -t * this.scale.x, this.plugins.reset();
   }
+  /** World coordinates of the top edge of the screen */
   get top() {
     return -this.y / this.scale.y;
   }
   set top(t) {
     this.y = -t * this.scale.y, this.plugins.reset();
   }
+  /** World coordinates of the bottom edge of the screen */
   get bottom() {
     return -this.y / this.scale.y + this.worldScreenHeight;
   }
   set bottom(t) {
     this.y = -t * this.scale.y + this.screenHeight, this.plugins.reset();
   }
+  /**
+   * Determines whether the viewport is dirty (i.e., needs to be rendered to the screen because of a change)
+   */
   get dirty() {
     return !!this._dirty;
   }
   set dirty(t) {
     this._dirty = t;
   }
+  /**
+   * Permanently changes the Viewport's hitArea
+   *
+   * NOTE: if not set then hitArea = PIXI.Rectangle(Viewport.left, Viewport.top, Viewport.worldScreenWidth,
+   * Viewport.worldScreenHeight)
+   */
   get forceHitArea() {
     return this._forceHitArea;
   }
   set forceHitArea(t) {
     t ? (this._forceHitArea = t, this.hitArea = t) : (this._forceHitArea = null, this.hitArea = new b(0, 0, this.worldWidth, this.worldHeight));
   }
+  /**
+   * Enable one-finger touch to drag
+   *
+   * NOTE: if you expect users to use right-click dragging, you should enable `viewport.options.disableOnContextMenu`
+   * to avoid the context menu popping up on each right-click drag.
+   *
+   * @param {IDragOptions} [options]
+   * @param {string} [options.direction=all] direction to drag
+   * @param {boolean} [options.pressDrag=true] whether click to drag is active
+   * @param {boolean} [options.wheel=true] use wheel to scroll in direction (unless wheel plugin is active)
+   * @param {number} [options.wheelScroll=1] number of pixels to scroll with each wheel spin
+   * @param {boolean} [options.reverse] reverse the direction of the wheel scroll
+   * @param {(boolean|string)} [options.clampWheel=false] clamp wheel(to avoid weird bounce with mouse wheel)
+   * @param {string} [options.underflow=center] where to place world if too small for screen
+   * @param {number} [options.factor=1] factor to multiply drag to increase the speed of movement
+   * @param {string} [options.mouseButtons=all] changes which mouse buttons trigger drag, use: 'all', 'left',
+   *  'right' 'middle', or some combination, like, 'middle-right'; you may want to set
+   *   viewport.options.disableOnContextMenu if you want to use right-click dragging
+   * @param {string[]} [options.keyToPress=null] - array containing
+   *  {@link key|https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code} codes of keys that can be
+   *  pressed for the drag to be triggered, e.g.: ['ShiftLeft', 'ShiftRight'}.
+   * @param {boolean} [options.ignoreKeyToPressOnTouch=false] - ignore keyToPress for touch events
+   * @param {number} [options.lineHeight=20] - scaling factor for non-DOM_DELTA_PIXEL scrolling events
+   * @returns {Viewport} this
+   */
   drag(t) {
     return this.plugins.add("drag", new S(this, t)), this;
   }
+  /**
+   * Clamp to world boundaries or other provided boundaries
+   * There are three ways to clamp:
+   * 1. direction: 'all' = the world is clamped to its world boundaries, ie, you cannot drag any part of offscreen
+   *    direction: 'x' | 'y' = only the x or y direction is clamped to its world boundary
+   * 2. left, right, top, bottom = true | number = the world is clamped to the world's pixel location for each side;
+   *    if any of these are set to true, then the location is set to the boundary
+   *    [0, viewport.worldWidth/viewport.worldHeight], eg: to allow the world to be completely dragged offscreen,
+   *    set [-viewport.worldWidth, -viewport.worldHeight, viewport.worldWidth * 2, viewport.worldHeight * 2]
+   *
+   * Underflow determines what happens when the world is smaller than the viewport
+   * 1. none = the world is clamped but there is no special behavior
+   * 2. center = the world is centered on the viewport
+   * 3. combination of top/bottom/center and left/right/center (case insensitive) = the world is stuck to the
+   *     appropriate boundaries
+   *
+   * NOTES:
+   *   clamp is disabled if called with no options; use { direction: 'all' } for all edge clamping
+   *   screenWidth, screenHeight, worldWidth, and worldHeight needs to be set for this to work properly
+   *
+   * @param {object} [options]
+   * @param {(number|boolean)} [options.left=false] - clamp left; true = 0
+   * @param {(number|boolean)} [options.right=false] - clamp right; true = viewport.worldWidth
+   * @param {(number|boolean)} [options.top=false] - clamp top; true = 0
+   * @param {(number|boolean)} [options.bottom=false] - clamp bottom; true = viewport.worldHeight
+   * @param {string} [direction] - (all, x, or y) using clamps of [0, viewport.worldWidth/viewport.worldHeight];
+   *  replaces left/right/top/bottom if set
+   * @param {string} [underflow=center] - where to place world if too small for screen (e.g., top-right, center,
+   *  none, bottomLeft)     * @returns {Viewport} this
+   */
   clamp(t) {
     return this.plugins.add("clamp", new T(this, t)), this;
   }
+  /**
+   * Decelerate after a move
+   *
+   * NOTE: this fires 'moved' event during deceleration
+   *
+   * @param {IDecelerateOptions} [options]
+   * @param {number} [options.friction=0.95] - percent to decelerate after movement
+   * @param {number} [options.bounce=0.8] - percent to decelerate when past boundaries (only applicable when
+   *   viewport.bounce() is active)
+   * @param {number} [options.minSpeed=0.01] - minimum velocity before stopping/reversing acceleration
+   * @return {Viewport} this
+   */
   decelerate(t) {
     return this.plugins.add("decelerate", new U(this, t)), this;
   }
+  /**
+   * Bounce on borders
+   * NOTES:
+   *    screenWidth, screenHeight, worldWidth, and worldHeight needs to be set for this to work properly
+   *    fires 'moved', 'bounce-x-start', 'bounce-y-start', 'bounce-x-end', and 'bounce-y-end' events
+   * @param {object} [options]
+   * @param {string} [options.sides=all] - all, horizontal, vertical, or combination of top, bottom, right, left
+   *  (e.g., 'top-bottom-right')
+   * @param {number} [options.friction=0.5] - friction to apply to decelerate if active
+   * @param {number} [options.time=150] - time in ms to finish bounce
+   * @param {object} [options.bounceBox] - use this bounceBox instead of (0, 0, viewport.worldWidth, viewport.worldHeight)
+   * @param {number} [options.bounceBox.x=0]
+   * @param {number} [options.bounceBox.y=0]
+   * @param {number} [options.bounceBox.width=viewport.worldWidth]
+   * @param {number} [options.bounceBox.height=viewport.worldHeight]
+   * @param {string|function} [options.ease=easeInOutSine] - ease function or name
+   *  (see http://easings.net/ for supported names)
+   * @param {string} [options.underflow=center] - (top/bottom/center and left/right/center, or center)
+   *  where to place world if too small for screen
+   * @return {Viewport} this
+   */
   bounce(t) {
     return this.plugins.add("bounce", new z(this, t)), this;
   }
+  /**
+   * Enable pinch to zoom and two-finger touch to drag
+   *
+   * @param {PinchOptions} [options]
+   * @param {boolean} [options.noDrag] - disable two-finger dragging
+   * @param {number} [options.percent=1] - percent to modify pinch speed
+   * @param {number} [options.factor=1] - factor to multiply two-finger drag to increase the speed of movement
+   * @param {PIXI.Point} [options.center] - place this point at center during zoom instead of center of two fingers
+   * @param {('all'|'x'|'y')} [options.axis=all] - axis to zoom
+   * @return {Viewport} this
+   */
   pinch(t) {
     return this.plugins.add("pinch", new w(this, t)), this;
   }
+  /**
+   * Snap to a point
+   *
+   * @param {number} x
+   * @param {number} y
+   * @param {ISnapOptions} [options]
+   * @param {boolean} [options.topLeft] - snap to the top-left of viewport instead of center
+   * @param {number} [options.friction=0.8] - friction/frame to apply if decelerate is active
+   * @param {number} [options.time=1000] - time in ms to snap
+   * @param {string|function} [options.ease=easeInOutSine] - ease function or name (see http://easings.net/
+   *   for supported names)
+   * @param {boolean} [options.interrupt=true] - pause snapping with any user input on the viewport
+   * @param {boolean} [options.removeOnComplete] - removes this plugin after snapping is complete
+   * @param {boolean} [options.removeOnInterrupt] - removes this plugin if interrupted by any user input
+   * @param {boolean} [options.forceStart] - starts the snap immediately regardless of whether the viewport is at
+   *   the desired location
+   * @return {Viewport} this
+   */
   snap(t, e, n) {
     return this.plugins.add("snap", new q(this, t, e, n)), this;
   }
+  /**
+   * Follow a target
+   *
+   * NOTES:
+   *    uses the (x, y) as the center to follow; for PIXI.Sprite to work properly, use sprite.anchor.set(0.5)
+   *    options.acceleration is not perfect as it doesn't know the velocity of the target. It adds acceleration
+   *    to the start of movement and deceleration to the end of movement when the target is stopped.
+   *    To cancel the follow, use: `viewport.plugins.remove('follow')`
+   *
+   * @fires 'moved' event
+   *
+   * @param {PIXI.DisplayObject} target to follow
+   * @param {IFollowOptions} [options]
+   * @param {number} [options.speed=0] - to follow in pixels/frame (0=teleport to location)
+   * @param {number} [options.acceleration] - set acceleration to accelerate and decelerate at this rate; speed
+   *   cannot be 0 to use acceleration
+   * @param {number} [options.radius] - radius (in world coordinates) of center circle where movement is allowed
+   *   without moving the viewport     * @returns {Viewport} this
+   * @returns {Viewport} this
+   */
   follow(t, e) {
     return this.plugins.add("follow", new V(this, t, e)), this;
   }
+  /**
+   * Zoom using mouse wheel
+   *
+   * NOTE: the default event listener for 'wheel' event is document.body. Use `Viewport.options.divWheel` to
+   * change this default
+   *
+   * @param {IWheelOptions} [options]
+   * @param {number} [options.percent=0.1] - percent to scroll with each spin
+   * @param {number} [options.smooth] - smooth the zooming by providing the number of frames to zoom between wheel spins
+   * @param {boolean} [options.interrupt=true] - stop smoothing with any user input on the viewport
+   * @param {boolean} [options.reverse] - reverse the direction of the scroll
+   * @param {PIXI.Point} [options.center] - place this point at center during zoom instead of current mouse position
+   * @param {number} [options.lineHeight=20] - scaling factor for non-DOM_DELTA_PIXEL scrolling events
+   * @param {('all'|'x'|'y')} [options.axis=all] - axis to zoom
+   * @return {Viewport} this
+   */
   wheel(t) {
     return this.plugins.add("wheel", new $(this, t)), this;
   }
+  /**
+   * Animate the position and/or scale of the viewport
+   * To set the zoom level, use: (1) scale, (2) scaleX and scaleY, or (3) width and/or height
+   * @param {object} options
+   * @param {number} [options.time=1000] - time to animate
+   * @param {PIXI.Point} [options.position=viewport.center] - position to move viewport
+   * @param {number} [options.width] - desired viewport width in world pixels (use instead of scale;
+   *  aspect ratio is maintained if height is not provided)
+   * @param {number} [options.height] - desired viewport height in world pixels (use instead of scale;
+   *  aspect ratio is maintained if width is not provided)
+   * @param {number} [options.scale] - scale to change zoom (scale.x = scale.y)
+   * @param {number} [options.scaleX] - independently change zoom in x-direction
+   * @param {number} [options.scaleY] - independently change zoom in y-direction
+   * @param {(function|string)} [options.ease=linear] - easing function to use
+   * @param {function} [options.callbackOnComplete]
+   * @param {boolean} [options.removeOnInterrupt] removes this plugin if interrupted by any user input
+   * @returns {Viewport} this
+   */
   animate(t) {
     return this.plugins.add("animate", new d(this, t)), this;
   }
+  /**
+   * Enable clamping of zoom to constraints
+   *
+   * The minWidth/Height settings are how small the world can get (as it would appear on the screen)
+   * before clamping. The maxWidth/maxHeight is how larger the world can scale (as it would appear on
+   * the screen) before clamping.
+   *
+   * For example, if you have a world size of 1000 x 1000 and a screen size of 100 x 100, if you set
+   * minWidth/Height = 100 then the world will not be able to zoom smaller than the screen size (ie,
+   * zooming out so it appears smaller than the screen). Similarly, if you set maxWidth/Height = 100
+   * the world will not be able to zoom larger than the screen size (ie, zooming in so it appears
+   * larger than the screen).
+   *
+   * @param {object} [options]
+   * @param {number} [options.minWidth] - minimum width
+   * @param {number} [options.minHeight] - minimum height
+   * @param {number} [options.maxWidth] - maximum width
+   * @param {number} [options.maxHeight] - maximum height
+   * @param {number} [options.minScale] - minimum scale
+   * @param {number} [options.maxScale] - minimum scale
+   * @return {Viewport} this
+   */
   clampZoom(t) {
     return this.plugins.add("clamp-zoom", new L(this, t)), this;
   }
+  /**
+   * Scroll viewport when mouse hovers near one of the edges or radius-distance from center of screen.
+   *
+   * NOTES: fires 'moved' event; there's a known bug where the mouseEdges does not work properly with "windowed" viewports
+   *
+   * @param {IMouseEdgesOptions} [options]
+   * @param {number} [options.radius] - distance from center of screen in screen pixels
+   * @param {number} [options.distance] - distance from all sides in screen pixels
+   * @param {number} [options.top] - alternatively, set top distance (leave unset for no top scroll)
+   * @param {number} [options.bottom] - alternatively, set bottom distance (leave unset for no top scroll)
+   * @param {number} [options.left] - alternatively, set left distance (leave unset for no top scroll)
+   * @param {number} [options.right] - alternatively, set right distance (leave unset for no top scroll)
+   * @param {number} [options.speed=8] - speed in pixels/frame to scroll viewport
+   * @param {boolean} [options.reverse] - reverse direction of scroll
+   * @param {boolean} [options.noDecelerate] - don't use decelerate plugin even if it's installed
+   * @param {boolean} [options.linear] - if using radius, use linear movement (+/- 1, +/- 1) instead of angled
+   *   movement (Math.cos(angle from center), Math.sin(angle from center))
+   * @param {boolean} [options.allowButtons] allows plugin to continue working even when there's a mousedown event
+   */
   mouseEdges(t) {
     return this.plugins.add("mouse-edges", new N(this, t)), this;
   }
+  /** Pause viewport (including animation updates such as decelerate) */
   get pause() {
     return !!this._pause;
   }
   set pause(t) {
     this._pause = t, this.lastViewport = null, this.moving = !1, this.zooming = !1, t && this.input.pause();
   }
+  /**
+   * Move the viewport so the bounding box is visible
+   *
+   * @param x - left
+   * @param y - top
+   * @param width
+   * @param height
+   * @param resizeToFit - Resize the viewport so the box fits within the viewport
+   */
   ensureVisible(t, e, n, i, s) {
     s && (n > this.worldScreenWidth || i > this.worldScreenHeight) && (this.fit(!0, n, i), this.emit("zoomed", { viewport: this, type: "ensureVisible" }));
     let h = !1;
@@ -1530,4 +2234,4 @@ export {
   O as Viewport,
   $ as Wheel
 };
-//# sourceMappingURL=viewport.es-ae91b8e8.mjs.map
+//# sourceMappingURL=viewport.es-73ad6f79.mjs.map