@eva/plugin-worker 2.0.0-beta.16

package/dist/EVA.plugin.worker.js

@@ -0,0 +1,1326 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+window.EVA = window.EVA || {};
+window.EVA.plugin = window.EVA.plugin || {};
+var _EVA_IIFE_worker = function (exports, pixi_js) {
+  'use strict';
+
+  function createCommonjsModule(fn) {
+    var module = {
+      exports: {}
+    };
+    return fn(module, module.exports), module.exports;
+  }
+  var eventemitter3 = createCommonjsModule(function (module) {
+    var has = Object.prototype.hasOwnProperty,
+      prefix = '~';
+    function Events() {}
+    if (Object.create) {
+      Events.prototype = Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== 'function') {
+        throw new TypeError('The listener must be a function');
+      }
+      var listener = new EE(fn, context || emitter, once),
+        evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);else emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();else delete emitter._events[evt];
+    }
+    function EventEmitter() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter.prototype.eventNames = function eventNames() {
+      var names = [],
+        events,
+        name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event,
+        handlers = this._events[evt];
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event,
+        listeners = this._events[evt];
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    };
+    EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt],
+        len = arguments.length,
+        args,
+        i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length,
+          j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;else clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+    EventEmitter.prefixed = prefix;
+    EventEmitter.EventEmitter = EventEmitter;
+    {
+      module.exports = EventEmitter;
+    }
+  });
+  var EventEmitter = eventemitter3;
+  class EventsTickerClass {
+    constructor() {
+      this.interactionFrequency = 10;
+      this._deltaTime = 0;
+      this._didMove = false;
+      this._tickerAdded = false;
+      this._pauseUpdate = true;
+    }
+    init(events) {
+      this.removeTickerListener();
+      this.events = events;
+      this.interactionFrequency = 10;
+      this._deltaTime = 0;
+      this._didMove = false;
+      this._tickerAdded = false;
+      this._pauseUpdate = true;
+    }
+    get pauseUpdate() {
+      return this._pauseUpdate;
+    }
+    set pauseUpdate(paused) {
+      this._pauseUpdate = paused;
+    }
+    addTickerListener() {
+      if (this._tickerAdded || !this.domElement) {
+        return;
+      }
+      pixi_js.Ticker.system.add(this._tickerUpdate, this, pixi_js.UPDATE_PRIORITY.INTERACTION);
+      this._tickerAdded = true;
+    }
+    removeTickerListener() {
+      if (!this._tickerAdded) {
+        return;
+      }
+      pixi_js.Ticker.system.remove(this._tickerUpdate, this);
+      this._tickerAdded = false;
+    }
+    pointerMoved() {
+      this._didMove = true;
+    }
+    _update() {
+      if (!this.domElement || this._pauseUpdate) {
+        return;
+      }
+      if (this._didMove) {
+        this._didMove = false;
+        return;
+      }
+      const rootPointerEvent = this.events['_rootPointerEvent'];
+      if (this.events.supportsTouchEvents && rootPointerEvent.pointerType === 'touch') {
+        return;
+      }
+      globalThis.document.dispatchEvent(new PointerEvent('pointermove', {
+        clientX: rootPointerEvent.clientX,
+        clientY: rootPointerEvent.clientY,
+        pointerType: rootPointerEvent.pointerType,
+        pointerId: rootPointerEvent.pointerId
+      }));
+    }
+    _tickerUpdate(ticker) {
+      this._deltaTime += ticker.deltaTime;
+      if (this._deltaTime < this.interactionFrequency) {
+        return;
+      }
+      this._deltaTime = 0;
+      this._update();
+    }
+  }
+  const EventsTicker = new EventsTickerClass();
+  class FederatedEvent {
+    constructor(manager) {
+      this.bubbles = true;
+      this.cancelBubble = true;
+      this.cancelable = false;
+      this.composed = false;
+      this.defaultPrevented = false;
+      this.eventPhase = FederatedEvent.prototype.NONE;
+      this.propagationStopped = false;
+      this.propagationImmediatelyStopped = false;
+      this.layer = new pixi_js.Point();
+      this.page = new pixi_js.Point();
+      this.NONE = 0;
+      this.CAPTURING_PHASE = 1;
+      this.AT_TARGET = 2;
+      this.BUBBLING_PHASE = 3;
+      this.manager = manager;
+    }
+    get layerX() {
+      return this.layer.x;
+    }
+    get layerY() {
+      return this.layer.y;
+    }
+    get pageX() {
+      return this.page.x;
+    }
+    get pageY() {
+      return this.page.y;
+    }
+    get data() {
+      return this;
+    }
+    composedPath() {
+      if (this.manager && (!this.path || this.path[this.path.length - 1] !== this.target)) {
+        this.path = this.target ? this.manager.propagationPath(this.target) : [];
+      }
+      return this.path;
+    }
+    initEvent(_type, _bubbles, _cancelable) {
+      throw new Error('initEvent() is a legacy DOM API. It is not implemented in the Federated Events API.');
+    }
+    initUIEvent(_typeArg, _bubblesArg, _cancelableArg, _viewArg, _detailArg) {
+      throw new Error('initUIEvent() is a legacy DOM API. It is not implemented in the Federated Events API.');
+    }
+    preventDefault() {
+      if (this.nativeEvent instanceof Event && this.nativeEvent.cancelable) {
+        this.nativeEvent.preventDefault();
+      }
+      this.defaultPrevented = true;
+    }
+    stopImmediatePropagation() {
+      this.propagationImmediatelyStopped = true;
+    }
+    stopPropagation() {
+      this.propagationStopped = true;
+    }
+  }
+  class FederatedMouseEvent extends FederatedEvent {
+    constructor() {
+      super(...arguments);
+      this.client = new pixi_js.Point();
+      this.movement = new pixi_js.Point();
+      this.offset = new pixi_js.Point();
+      this.global = new pixi_js.Point();
+      this.screen = new pixi_js.Point();
+    }
+    get clientX() {
+      return this.client.x;
+    }
+    get clientY() {
+      return this.client.y;
+    }
+    get x() {
+      return this.clientX;
+    }
+    get y() {
+      return this.clientY;
+    }
+    get movementX() {
+      return this.movement.x;
+    }
+    get movementY() {
+      return this.movement.y;
+    }
+    get offsetX() {
+      return this.offset.x;
+    }
+    get offsetY() {
+      return this.offset.y;
+    }
+    get globalX() {
+      return this.global.x;
+    }
+    get globalY() {
+      return this.global.y;
+    }
+    get screenX() {
+      return this.screen.x;
+    }
+    get screenY() {
+      return this.screen.y;
+    }
+    getLocalPosition(container, point, globalPos) {
+      return container.worldTransform.applyInverse(globalPos || this.global, point);
+    }
+    getModifierState(key) {
+      return 'getModifierState' in this.nativeEvent && this.nativeEvent.getModifierState(key);
+    }
+    initMouseEvent(_typeArg, _canBubbleArg, _cancelableArg, _viewArg, _detailArg, _screenXArg, _screenYArg, _clientXArg, _clientYArg, _ctrlKeyArg, _altKeyArg, _shiftKeyArg, _metaKeyArg, _buttonArg, _relatedTargetArg) {
+      throw new Error('Method not implemented.');
+    }
+  }
+  class FederatedPointerEvent extends FederatedMouseEvent {
+    constructor() {
+      super(...arguments);
+      this.width = 0;
+      this.height = 0;
+      this.isPrimary = false;
+    }
+    getCoalescedEvents() {
+      if (this.type === 'pointermove' || this.type === 'mousemove' || this.type === 'touchmove') {
+        return [this];
+      }
+      return [];
+    }
+    getPredictedEvents() {
+      throw new Error('getPredictedEvents is not supported!');
+    }
+  }
+  class FederatedWheelEvent extends FederatedMouseEvent {
+    constructor() {
+      super(...arguments);
+      this.DOM_DELTA_PIXEL = 0;
+      this.DOM_DELTA_LINE = 1;
+      this.DOM_DELTA_PAGE = 2;
+    }
+  }
+  FederatedWheelEvent.DOM_DELTA_PIXEL = 0;
+  FederatedWheelEvent.DOM_DELTA_LINE = 1;
+  FederatedWheelEvent.DOM_DELTA_PAGE = 2;
+  const PROPAGATION_LIMIT = 2048;
+  const tempHitLocation = new pixi_js.Point();
+  const tempLocalMapping = new pixi_js.Point();
+  class EventBoundary {
+    constructor(rootTarget) {
+      this.dispatch = new EventEmitter();
+      this.moveOnAll = false;
+      this.enableGlobalMoveEvents = true;
+      this.mappingState = {
+        trackingData: {}
+      };
+      this.eventPool = new Map();
+      this._allInteractiveElements = [];
+      this._hitElements = [];
+      this._isPointerMoveEvent = false;
+      this.rootTarget = rootTarget;
+      this.hitPruneFn = this.hitPruneFn.bind(this);
+      this.hitTestFn = this.hitTestFn.bind(this);
+      this.mapPointerDown = this.mapPointerDown.bind(this);
+      this.mapPointerMove = this.mapPointerMove.bind(this);
+      this.mapPointerOut = this.mapPointerOut.bind(this);
+      this.mapPointerOver = this.mapPointerOver.bind(this);
+      this.mapPointerUp = this.mapPointerUp.bind(this);
+      this.mapPointerUpOutside = this.mapPointerUpOutside.bind(this);
+      this.mapWheel = this.mapWheel.bind(this);
+      this.mappingTable = {};
+      this.addEventMapping('pointerdown', this.mapPointerDown);
+      this.addEventMapping('pointermove', this.mapPointerMove);
+      this.addEventMapping('pointerout', this.mapPointerOut);
+      this.addEventMapping('pointerleave', this.mapPointerOut);
+      this.addEventMapping('pointerover', this.mapPointerOver);
+      this.addEventMapping('pointerup', this.mapPointerUp);
+      this.addEventMapping('pointerupoutside', this.mapPointerUpOutside);
+      this.addEventMapping('wheel', this.mapWheel);
+    }
+    addEventMapping(type, fn) {
+      if (!this.mappingTable[type]) {
+        this.mappingTable[type] = [];
+      }
+      this.mappingTable[type].push({
+        fn,
+        priority: 0
+      });
+      this.mappingTable[type].sort((a, b) => a.priority - b.priority);
+    }
+    dispatchEvent(e, type) {
+      e.propagationStopped = false;
+      e.propagationImmediatelyStopped = false;
+      this.propagate(e, type);
+      this.dispatch.emit(type || e.type, e);
+    }
+    mapEvent(e) {
+      if (!this.rootTarget) {
+        return;
+      }
+      const mappers = this.mappingTable[e.type];
+      if (mappers) {
+        for (let i = 0, j = mappers.length; i < j; i++) {
+          mappers[i].fn(e);
+        }
+      } else {
+        pixi_js.warn(`[EventBoundary]: Event mapping not defined for ${e.type}`);
+      }
+    }
+    hitTest(x, y) {
+      EventsTicker.pauseUpdate = true;
+      const useMove = this._isPointerMoveEvent && this.enableGlobalMoveEvents;
+      const fn = useMove ? 'hitTestMoveRecursive' : 'hitTestRecursive';
+      const invertedPath = this[fn](this.rootTarget, this.rootTarget.eventMode, tempHitLocation.set(x, y), this.hitTestFn, this.hitPruneFn);
+      return invertedPath && invertedPath[0];
+    }
+    propagate(e, type) {
+      if (!e.target) {
+        return;
+      }
+      const composedPath = e.composedPath();
+      e.eventPhase = e.CAPTURING_PHASE;
+      for (let i = 0, j = composedPath.length - 1; i < j; i++) {
+        e.currentTarget = composedPath[i];
+        this.notifyTarget(e, type);
+        if (e.propagationStopped || e.propagationImmediatelyStopped) return;
+      }
+      e.eventPhase = e.AT_TARGET;
+      e.currentTarget = e.target;
+      this.notifyTarget(e, type);
+      if (e.propagationStopped || e.propagationImmediatelyStopped) return;
+      e.eventPhase = e.BUBBLING_PHASE;
+      for (let i = composedPath.length - 2; i >= 0; i--) {
+        e.currentTarget = composedPath[i];
+        this.notifyTarget(e, type);
+        if (e.propagationStopped || e.propagationImmediatelyStopped) return;
+      }
+    }
+    all(e, type, targets = this._allInteractiveElements) {
+      if (targets.length === 0) return;
+      e.eventPhase = e.BUBBLING_PHASE;
+      const events = Array.isArray(type) ? type : [type];
+      for (let i = targets.length - 1; i >= 0; i--) {
+        events.forEach(event => {
+          e.currentTarget = targets[i];
+          this.notifyTarget(e, event);
+        });
+      }
+    }
+    propagationPath(target) {
+      const propagationPath = [target];
+      for (let i = 0; i < PROPAGATION_LIMIT && target !== this.rootTarget && target.parent; i++) {
+        if (!target.parent) {
+          throw new Error('Cannot find propagation path to disconnected target');
+        }
+        propagationPath.push(target.parent);
+        target = target.parent;
+      }
+      propagationPath.reverse();
+      return propagationPath;
+    }
+    hitTestMoveRecursive(currentTarget, eventMode, location, testFn, pruneFn, ignore = false) {
+      let shouldReturn = false;
+      if (this._interactivePrune(currentTarget)) return null;
+      if (currentTarget.eventMode === 'dynamic' || eventMode === 'dynamic') {
+        EventsTicker.pauseUpdate = false;
+      }
+      if (currentTarget.interactiveChildren && currentTarget.children) {
+        const children = currentTarget.children;
+        for (let i = children.length - 1; i >= 0; i--) {
+          const child = children[i];
+          const nestedHit = this.hitTestMoveRecursive(child, this._isInteractive(eventMode) ? eventMode : child.eventMode, location, testFn, pruneFn, ignore || pruneFn(currentTarget, location));
+          if (nestedHit) {
+            if (nestedHit.length > 0 && !nestedHit[nestedHit.length - 1].parent) {
+              continue;
+            }
+            const isInteractive = currentTarget.isInteractive();
+            if (nestedHit.length > 0 || isInteractive) {
+              if (isInteractive) this._allInteractiveElements.push(currentTarget);
+              nestedHit.push(currentTarget);
+            }
+            if (this._hitElements.length === 0) this._hitElements = nestedHit;
+            shouldReturn = true;
+          }
+        }
+      }
+      const isInteractiveMode = this._isInteractive(eventMode);
+      const isInteractiveTarget = currentTarget.isInteractive();
+      if (isInteractiveTarget && isInteractiveTarget) this._allInteractiveElements.push(currentTarget);
+      if (ignore || this._hitElements.length > 0) return null;
+      if (shouldReturn) return this._hitElements;
+      if (isInteractiveMode && !pruneFn(currentTarget, location) && testFn(currentTarget, location)) {
+        return isInteractiveTarget ? [currentTarget] : [];
+      }
+      return null;
+    }
+    hitTestRecursive(currentTarget, eventMode, location, testFn, pruneFn) {
+      if (this._interactivePrune(currentTarget) || pruneFn(currentTarget, location)) {
+        return null;
+      }
+      if (currentTarget.eventMode === 'dynamic' || eventMode === 'dynamic') {
+        EventsTicker.pauseUpdate = false;
+      }
+      if (currentTarget.interactiveChildren && currentTarget.children) {
+        const children = currentTarget.children;
+        const relativeLocation = location;
+        for (let i = children.length - 1; i >= 0; i--) {
+          const child = children[i];
+          const nestedHit = this.hitTestRecursive(child, this._isInteractive(eventMode) ? eventMode : child.eventMode, relativeLocation, testFn, pruneFn);
+          if (nestedHit) {
+            if (nestedHit.length > 0 && !nestedHit[nestedHit.length - 1].parent) {
+              continue;
+            }
+            const isInteractive = currentTarget.isInteractive();
+            if (nestedHit.length > 0 || isInteractive) nestedHit.push(currentTarget);
+            return nestedHit;
+          }
+        }
+      }
+      const isInteractiveMode = this._isInteractive(eventMode);
+      const isInteractiveTarget = currentTarget.isInteractive();
+      if (isInteractiveMode && testFn(currentTarget, location)) {
+        return isInteractiveTarget ? [currentTarget] : [];
+      }
+      return null;
+    }
+    _isInteractive(int) {
+      return int === 'static' || int === 'dynamic';
+    }
+    _interactivePrune(container) {
+      if (!container || !container.visible || !container.renderable || !container.measurable) {
+        return true;
+      }
+      if (container.eventMode === 'none') {
+        return true;
+      }
+      if (container.eventMode === 'passive' && !container.interactiveChildren) {
+        return true;
+      }
+      return false;
+    }
+    hitPruneFn(container, location) {
+      if (container.hitArea) {
+        container.worldTransform.applyInverse(location, tempLocalMapping);
+        if (!container.hitArea.contains(tempLocalMapping.x, tempLocalMapping.y)) {
+          return true;
+        }
+      }
+      if (container.effects && container.effects.length) {
+        for (let i = 0; i < container.effects.length; i++) {
+          const effect = container.effects[i];
+          if (effect.containsPoint) {
+            const effectContainsPoint = effect.containsPoint(location, this.hitTestFn);
+            if (!effectContainsPoint) {
+              return true;
+            }
+          }
+        }
+      }
+      return false;
+    }
+    hitTestFn(container, location) {
+      var _a;
+      if (container.hitArea) {
+        return true;
+      }
+      if ((_a = container) === null || _a === void 0 ? void 0 : _a.containsPoint) {
+        container.worldTransform.applyInverse(location, tempLocalMapping);
+        return container.containsPoint(tempLocalMapping);
+      }
+      return false;
+    }
+    notifyTarget(e, type) {
+      var _a;
+      if (!e.currentTarget.isInteractive()) {
+        return;
+      }
+      type = type !== null && type !== void 0 ? type : e.type;
+      const handlerKey = `on${type}`;
+      (_a = e.currentTarget[handlerKey]) === null || _a === void 0 ? void 0 : _a(e);
+      const key = e.eventPhase === e.CAPTURING_PHASE || e.eventPhase === e.AT_TARGET ? `${type}capture` : type;
+      this._notifyListeners(e, key);
+      if (e.eventPhase === e.AT_TARGET) {
+        this._notifyListeners(e, type);
+      }
+    }
+    mapPointerDown(from) {
+      if (!(from instanceof FederatedPointerEvent)) {
+        pixi_js.warn('EventBoundary cannot map a non-pointer event as a pointer event');
+        return;
+      }
+      const e = this.createPointerEvent(from);
+      this.dispatchEvent(e, 'pointerdown');
+      if (e.pointerType === 'touch') {
+        this.dispatchEvent(e, 'touchstart');
+      } else if (e.pointerType === 'mouse' || e.pointerType === 'pen') {
+        const isRightButton = e.button === 2;
+        this.dispatchEvent(e, isRightButton ? 'rightdown' : 'mousedown');
+      }
+      const trackingData = this.trackingData(from.pointerId);
+      trackingData.pressTargetsByButton[from.button] = e.composedPath();
+      this.freeEvent(e);
+    }
+    mapPointerMove(from) {
+      var _a, _b, _c;
+      if (!(from instanceof FederatedPointerEvent)) {
+        pixi_js.warn('EventBoundary cannot map a non-pointer event as a pointer event');
+        return;
+      }
+      this._allInteractiveElements.length = 0;
+      this._hitElements.length = 0;
+      this._isPointerMoveEvent = true;
+      const e = this.createPointerEvent(from);
+      this._isPointerMoveEvent = false;
+      const isMouse = e.pointerType === 'mouse' || e.pointerType === 'pen';
+      const trackingData = this.trackingData(from.pointerId);
+      const outTarget = this.findMountedTarget(trackingData.overTargets);
+      if (((_a = trackingData.overTargets) === null || _a === void 0 ? void 0 : _a.length) > 0 && outTarget !== e.target) {
+        const outType = from.type === 'mousemove' ? 'mouseout' : 'pointerout';
+        const outEvent = this.createPointerEvent(from, outType, outTarget);
+        this.dispatchEvent(outEvent, 'pointerout');
+        if (isMouse) this.dispatchEvent(outEvent, 'mouseout');
+        if (!e.composedPath().includes(outTarget)) {
+          const leaveEvent = this.createPointerEvent(from, 'pointerleave', outTarget);
+          leaveEvent.eventPhase = leaveEvent.AT_TARGET;
+          while (leaveEvent.target && !e.composedPath().includes(leaveEvent.target)) {
+            leaveEvent.currentTarget = leaveEvent.target;
+            this.notifyTarget(leaveEvent);
+            if (isMouse) this.notifyTarget(leaveEvent, 'mouseleave');
+            leaveEvent.target = leaveEvent.target.parent;
+          }
+          this.freeEvent(leaveEvent);
+        }
+        this.freeEvent(outEvent);
+      }
+      if (outTarget !== e.target) {
+        const overType = from.type === 'mousemove' ? 'mouseover' : 'pointerover';
+        const overEvent = this.clonePointerEvent(e, overType);
+        this.dispatchEvent(overEvent, 'pointerover');
+        if (isMouse) this.dispatchEvent(overEvent, 'mouseover');
+        let overTargetAncestor = outTarget === null || outTarget === void 0 ? void 0 : outTarget.parent;
+        while (overTargetAncestor && overTargetAncestor !== this.rootTarget.parent) {
+          if (overTargetAncestor === e.target) break;
+          overTargetAncestor = overTargetAncestor.parent;
+        }
+        const didPointerEnter = !overTargetAncestor || overTargetAncestor === this.rootTarget.parent;
+        if (didPointerEnter) {
+          const enterEvent = this.clonePointerEvent(e, 'pointerenter');
+          enterEvent.eventPhase = enterEvent.AT_TARGET;
+          while (enterEvent.target && enterEvent.target !== outTarget && enterEvent.target !== this.rootTarget.parent) {
+            enterEvent.currentTarget = enterEvent.target;
+            this.notifyTarget(enterEvent);
+            if (isMouse) this.notifyTarget(enterEvent, 'mouseenter');
+            enterEvent.target = enterEvent.target.parent;
+          }
+          this.freeEvent(enterEvent);
+        }
+        this.freeEvent(overEvent);
+      }
+      const allMethods = [];
+      const allowGlobalPointerEvents = (_b = this.enableGlobalMoveEvents) !== null && _b !== void 0 ? _b : true;
+      this.moveOnAll ? allMethods.push('pointermove') : this.dispatchEvent(e, 'pointermove');
+      allowGlobalPointerEvents && allMethods.push('globalpointermove');
+      if (e.pointerType === 'touch') {
+        this.moveOnAll ? allMethods.splice(1, 0, 'touchmove') : this.dispatchEvent(e, 'touchmove');
+        allowGlobalPointerEvents && allMethods.push('globaltouchmove');
+      }
+      if (isMouse) {
+        this.moveOnAll ? allMethods.splice(1, 0, 'mousemove') : this.dispatchEvent(e, 'mousemove');
+        allowGlobalPointerEvents && allMethods.push('globalmousemove');
+        this.cursor = (_c = e.target) === null || _c === void 0 ? void 0 : _c.cursor;
+      }
+      if (allMethods.length > 0) {
+        this.all(e, allMethods);
+      }
+      this._allInteractiveElements.length = 0;
+      this._hitElements.length = 0;
+      trackingData.overTargets = e.composedPath();
+      this.freeEvent(e);
+    }
+    mapPointerOver(from) {
+      var _a;
+      if (!(from instanceof FederatedPointerEvent)) {
+        pixi_js.warn('EventBoundary cannot map a non-pointer event as a pointer event');
+        return;
+      }
+      const trackingData = this.trackingData(from.pointerId);
+      const e = this.createPointerEvent(from);
+      const isMouse = e.pointerType === 'mouse' || e.pointerType === 'pen';
+      this.dispatchEvent(e, 'pointerover');
+      if (isMouse) this.dispatchEvent(e, 'mouseover');
+      if (e.pointerType === 'mouse') this.cursor = (_a = e.target) === null || _a === void 0 ? void 0 : _a.cursor;
+      const enterEvent = this.clonePointerEvent(e, 'pointerenter');
+      enterEvent.eventPhase = enterEvent.AT_TARGET;
+      while (enterEvent.target && enterEvent.target !== this.rootTarget.parent) {
+        enterEvent.currentTarget = enterEvent.target;
+        this.notifyTarget(enterEvent);
+        if (isMouse) this.notifyTarget(enterEvent, 'mouseenter');
+        enterEvent.target = enterEvent.target.parent;
+      }
+      trackingData.overTargets = e.composedPath();
+      this.freeEvent(e);
+      this.freeEvent(enterEvent);
+    }
+    mapPointerOut(from) {
+      if (!(from instanceof FederatedPointerEvent)) {
+        pixi_js.warn('EventBoundary cannot map a non-pointer event as a pointer event');
+        return;
+      }
+      const trackingData = this.trackingData(from.pointerId);
+      if (trackingData.overTargets) {
+        const isMouse = from.pointerType === 'mouse' || from.pointerType === 'pen';
+        const outTarget = this.findMountedTarget(trackingData.overTargets);
+        const outEvent = this.createPointerEvent(from, 'pointerout', outTarget);
+        this.dispatchEvent(outEvent);
+        if (isMouse) this.dispatchEvent(outEvent, 'mouseout');
+        const leaveEvent = this.createPointerEvent(from, 'pointerleave', outTarget);
+        leaveEvent.eventPhase = leaveEvent.AT_TARGET;
+        while (leaveEvent.target && leaveEvent.target !== this.rootTarget.parent) {
+          leaveEvent.currentTarget = leaveEvent.target;
+          this.notifyTarget(leaveEvent);
+          if (isMouse) this.notifyTarget(leaveEvent, 'mouseleave');
+          leaveEvent.target = leaveEvent.target.parent;
+        }
+        trackingData.overTargets = null;
+        this.freeEvent(outEvent);
+        this.freeEvent(leaveEvent);
+      }
+      this.cursor = null;
+    }
+    mapPointerUp(from) {
+      if (!(from instanceof FederatedPointerEvent)) {
+        pixi_js.warn('EventBoundary cannot map a non-pointer event as a pointer event');
+        return;
+      }
+      const now = performance.now();
+      const e = this.createPointerEvent(from);
+      this.dispatchEvent(e, 'pointerup');
+      if (e.pointerType === 'touch') {
+        this.dispatchEvent(e, 'touchend');
+      } else if (e.pointerType === 'mouse' || e.pointerType === 'pen') {
+        const isRightButton = e.button === 2;
+        this.dispatchEvent(e, isRightButton ? 'rightup' : 'mouseup');
+      }
+      const trackingData = this.trackingData(from.pointerId);
+      const pressTarget = this.findMountedTarget(trackingData.pressTargetsByButton[from.button]);
+      let clickTarget = pressTarget;
+      if (pressTarget && !e.composedPath().includes(pressTarget)) {
+        let currentTarget = pressTarget;
+        while (currentTarget && !e.composedPath().includes(currentTarget)) {
+          e.currentTarget = currentTarget;
+          this.notifyTarget(e, 'pointerupoutside');
+          if (e.pointerType === 'touch') {
+            this.notifyTarget(e, 'touchendoutside');
+          } else if (e.pointerType === 'mouse' || e.pointerType === 'pen') {
+            const isRightButton = e.button === 2;
+            this.notifyTarget(e, isRightButton ? 'rightupoutside' : 'mouseupoutside');
+          }
+          currentTarget = currentTarget.parent;
+        }
+        delete trackingData.pressTargetsByButton[from.button];
+        clickTarget = currentTarget;
+      }
+      if (clickTarget) {
+        const clickEvent = this.clonePointerEvent(e, 'click');
+        clickEvent.target = clickTarget;
+        clickEvent.path = null;
+        if (!trackingData.clicksByButton[from.button]) {
+          trackingData.clicksByButton[from.button] = {
+            clickCount: 0,
+            target: clickEvent.target,
+            timeStamp: now
+          };
+        }
+        const clickHistory = trackingData.clicksByButton[from.button];
+        if (clickHistory.target === clickEvent.target && now - clickHistory.timeStamp < 200) {
+          ++clickHistory.clickCount;
+        } else {
+          clickHistory.clickCount = 1;
+        }
+        clickHistory.target = clickEvent.target;
+        clickHistory.timeStamp = now;
+        clickEvent.detail = clickHistory.clickCount;
+        if (clickEvent.pointerType === 'mouse') {
+          const isRightButton = clickEvent.button === 2;
+          this.dispatchEvent(clickEvent, isRightButton ? 'rightclick' : 'click');
+        } else if (clickEvent.pointerType === 'touch') {
+          this.dispatchEvent(clickEvent, 'tap');
+        }
+        this.dispatchEvent(clickEvent, 'pointertap');
+        this.freeEvent(clickEvent);
+      }
+      this.freeEvent(e);
+    }
+    mapPointerUpOutside(from) {
+      if (!(from instanceof FederatedPointerEvent)) {
+        pixi_js.warn('EventBoundary cannot map a non-pointer event as a pointer event');
+        return;
+      }
+      const trackingData = this.trackingData(from.pointerId);
+      const pressTarget = this.findMountedTarget(trackingData.pressTargetsByButton[from.button]);
+      const e = this.createPointerEvent(from);
+      if (pressTarget) {
+        let currentTarget = pressTarget;
+        while (currentTarget) {
+          e.currentTarget = currentTarget;
+          this.notifyTarget(e, 'pointerupoutside');
+          if (e.pointerType === 'touch') {
+            this.notifyTarget(e, 'touchendoutside');
+          } else if (e.pointerType === 'mouse' || e.pointerType === 'pen') {
+            this.notifyTarget(e, e.button === 2 ? 'rightupoutside' : 'mouseupoutside');
+          }
+          currentTarget = currentTarget.parent;
+        }
+        delete trackingData.pressTargetsByButton[from.button];
+      }
+      this.freeEvent(e);
+    }
+    mapWheel(from) {
+      if (!(from instanceof FederatedWheelEvent)) {
+        pixi_js.warn('EventBoundary cannot map a non-wheel event as a wheel event');
+        return;
+      }
+      const wheelEvent = this.createWheelEvent(from);
+      this.dispatchEvent(wheelEvent);
+      this.freeEvent(wheelEvent);
+    }
+    findMountedTarget(propagationPath) {
+      if (!propagationPath) {
+        return null;
+      }
+      let currentTarget = propagationPath[0];
+      for (let i = 1; i < propagationPath.length; i++) {
+        if (propagationPath[i].parent === currentTarget) {
+          currentTarget = propagationPath[i];
+        } else {
+          break;
+        }
+      }
+      return currentTarget;
+    }
+    createPointerEvent(from, type, target) {
+      var _a;
+      const event = this.allocateEvent(FederatedPointerEvent);
+      this.copyPointerData(from, event);
+      this.copyMouseData(from, event);
+      this.copyData(from, event);
+      event.nativeEvent = from.nativeEvent;
+      event.originalEvent = from;
+      event.target = (_a = target !== null && target !== void 0 ? target : this.hitTest(event.global.x, event.global.y)) !== null && _a !== void 0 ? _a : this._hitElements[0];
+      if (typeof type === 'string') {
+        event.type = type;
+      }
+      return event;
+    }
+    createWheelEvent(from) {
+      const event = this.allocateEvent(FederatedWheelEvent);
+      this.copyWheelData(from, event);
+      this.copyMouseData(from, event);
+      this.copyData(from, event);
+      event.nativeEvent = from.nativeEvent;
+      event.originalEvent = from;
+      event.target = this.hitTest(event.global.x, event.global.y);
+      return event;
+    }
+    clonePointerEvent(from, type) {
+      const event = this.allocateEvent(FederatedPointerEvent);
+      event.nativeEvent = from.nativeEvent;
+      event.originalEvent = from.originalEvent;
+      this.copyPointerData(from, event);
+      this.copyMouseData(from, event);
+      this.copyData(from, event);
+      event.target = from.target;
+      event.path = from.composedPath().slice();
+      event.type = type !== null && type !== void 0 ? type : event.type;
+      return event;
+    }
+    copyWheelData(from, to) {
+      to.deltaMode = from.deltaMode;
+      to.deltaX = from.deltaX;
+      to.deltaY = from.deltaY;
+      to.deltaZ = from.deltaZ;
+    }
+    copyPointerData(from, to) {
+      if (!(from instanceof FederatedPointerEvent && to instanceof FederatedPointerEvent)) return;
+      to.pointerId = from.pointerId;
+      to.width = from.width;
+      to.height = from.height;
+      to.isPrimary = from.isPrimary;
+      to.pointerType = from.pointerType;
+      to.pressure = from.pressure;
+      to.tangentialPressure = from.tangentialPressure;
+      to.tiltX = from.tiltX;
+      to.tiltY = from.tiltY;
+      to.twist = from.twist;
+    }
+    copyMouseData(from, to) {
+      if (!(from instanceof FederatedMouseEvent && to instanceof FederatedMouseEvent)) return;
+      to.altKey = from.altKey;
+      to.button = from.button;
+      to.buttons = from.buttons;
+      to.client.copyFrom(from.client);
+      to.ctrlKey = from.ctrlKey;
+      to.metaKey = from.metaKey;
+      to.movement.copyFrom(from.movement);
+      to.screen.copyFrom(from.screen);
+      to.shiftKey = from.shiftKey;
+      to.global.copyFrom(from.global);
+    }
+    copyData(from, to) {
+      to.isTrusted = from.isTrusted;
+      to.srcElement = from.srcElement;
+      to.timeStamp = performance.now();
+      to.type = from.type;
+      to.detail = from.detail;
+      to.view = from.view;
+      to.which = from.which;
+      to.layer.copyFrom(from.layer);
+      to.page.copyFrom(from.page);
+    }
+    trackingData(id) {
+      if (!this.mappingState.trackingData[id]) {
+        this.mappingState.trackingData[id] = {
+          pressTargetsByButton: {},
+          clicksByButton: {},
+          overTarget: null
+        };
+      }
+      return this.mappingState.trackingData[id];
+    }
+    allocateEvent(constructor) {
+      if (!this.eventPool.has(constructor)) {
+        this.eventPool.set(constructor, []);
+      }
+      const event = this.eventPool.get(constructor).pop() || new constructor(this);
+      event.eventPhase = event.NONE;
+      event.currentTarget = null;
+      event.defaultPrevented = false;
+      event.path = null;
+      event.target = null;
+      return event;
+    }
+    freeEvent(event) {
+      if (event.manager !== this) throw new Error('It is illegal to free an event not managed by this EventBoundary!');
+      const constructor = event.constructor;
+      if (!this.eventPool.has(constructor)) {
+        this.eventPool.set(constructor, []);
+      }
+      this.eventPool.get(constructor).push(event);
+    }
+    _notifyListeners(e, type) {
+      const listeners = e.currentTarget._events[type];
+      if (!listeners) return;
+      if ('fn' in listeners) {
+        if (listeners.once) e.currentTarget.removeListener(type, listeners.fn, undefined, true);
+        listeners.fn.call(listeners.context, e);
+      } else {
+        for (let i = 0, j = listeners.length; i < j && !e.propagationImmediatelyStopped; i++) {
+          if (listeners[i].once) e.currentTarget.removeListener(type, listeners[i].fn, undefined, true);
+          listeners[i].fn.call(listeners[i].context, e);
+        }
+      }
+    }
+  }
+  const TOUCH_TO_POINTER = {
+    touchstart: 'pointerdown',
+    touchend: 'pointerup',
+    touchendoutside: 'pointerupoutside',
+    touchmove: 'pointermove',
+    touchcancel: 'pointercancel'
+  };
+  class EventSystem {
+    constructor(renderer) {
+      this.supportsTouchEvents = 'ontouchstart' in globalThis;
+      this.supportsPointerEvents = !!globalThis.PointerEvent;
+      this.domElement = null;
+      this.resolution = 1;
+      this.renderer = renderer;
+      this.rootBoundary = new EventBoundary(null);
+      EventsTicker.init(this);
+      this.autoPreventDefault = true;
+      this._eventsAdded = false;
+      this._rootPointerEvent = new FederatedPointerEvent(null);
+      this._rootWheelEvent = new FederatedWheelEvent(null);
+      this.cursorStyles = {
+        default: 'inherit',
+        pointer: 'pointer'
+      };
+      this.features = new Proxy(_extends({}, EventSystem.defaultEventFeatures), {
+        set: (target, key, value) => {
+          if (key === 'globalMove') {
+            this.rootBoundary.enableGlobalMoveEvents = value;
+          }
+          target[key] = value;
+          return true;
+        }
+      });
+      this._onPointerDown = this._onPointerDown.bind(this);
+      this._onPointerMove = this._onPointerMove.bind(this);
+      this._onPointerUp = this._onPointerUp.bind(this);
+      this._onPointerOverOut = this._onPointerOverOut.bind(this);
+      this.onWheel = this.onWheel.bind(this);
+    }
+    static get defaultEventMode() {
+      return this._defaultEventMode;
+    }
+    init(options) {
+      var _a, _b;
+      const {
+        canvas,
+        resolution
+      } = this.renderer;
+      this.setTargetElement(canvas);
+      this.resolution = resolution;
+      EventSystem._defaultEventMode = (_a = options.eventMode) !== null && _a !== void 0 ? _a : 'passive';
+      _extends(this.features, (_b = options.eventFeatures) !== null && _b !== void 0 ? _b : {});
+      this.rootBoundary.enableGlobalMoveEvents = this.features.globalMove;
+    }
+    resolutionChange(resolution) {
+      this.resolution = resolution;
+    }
+    destroy() {
+      this.setTargetElement(null);
+      this.renderer = null;
+      this._currentCursor = null;
+    }
+    setCursor(mode) {
+      if (!mode) {
+        mode = 'default';
+      }
+      let applyStyles = true;
+      if (globalThis.OffscreenCanvas && this.domElement instanceof OffscreenCanvas) {
+        applyStyles = false;
+      }
+      if (this._currentCursor === mode) {
+        return;
+      }
+      this._currentCursor = mode;
+      const style = this.cursorStyles[mode];
+      if (style) {
+        switch (typeof style) {
+          case 'string':
+            if (applyStyles) {
+              this.domElement.style.cursor = style;
+            }
+            break;
+          case 'function':
+            style(mode);
+            break;
+          case 'object':
+            if (applyStyles) {
+              _extends(this.domElement.style, style);
+            }
+            break;
+        }
+      } else if (applyStyles && typeof mode === 'string' && !Object.prototype.hasOwnProperty.call(this.cursorStyles, mode)) {
+        this.domElement.style.cursor = mode;
+      }
+    }
+    get pointer() {
+      return this._rootPointerEvent;
+    }
+    _onPointerDown(nativeEvent) {
+      if (!this.features.click) return;
+      this.rootBoundary.rootTarget = this.renderer.lastObjectRendered;
+      const events = this._normalizeToPointerData(nativeEvent);
+      if (this.autoPreventDefault && events[0].isNormalized) {
+        const cancelable = nativeEvent.cancelable || !('cancelable' in nativeEvent);
+        if (cancelable) {
+          nativeEvent.preventDefault();
+        }
+      }
+      for (let i = 0, j = events.length; i < j; i++) {
+        const nativeEvent = events[i];
+        const federatedEvent = this._bootstrapEvent(this._rootPointerEvent, nativeEvent);
+        this.rootBoundary.mapEvent(federatedEvent);
+      }
+      this.setCursor(this.rootBoundary.cursor);
+    }
+    _onPointerMove(nativeEvent) {
+      if (!this.features.move) return;
+      this.rootBoundary.rootTarget = this.renderer.lastObjectRendered;
+      EventsTicker.pointerMoved();
+      const normalizedEvents = this._normalizeToPointerData(nativeEvent);
+      for (let i = 0, j = normalizedEvents.length; i < j; i++) {
+        const event = this._bootstrapEvent(this._rootPointerEvent, normalizedEvents[i]);
+        this.rootBoundary.mapEvent(event);
+      }
+      this.setCursor(this.rootBoundary.cursor);
+    }
+    _onPointerUp(nativeEvent) {
+      if (!this.features.click) return;
+      this.rootBoundary.rootTarget = this.renderer.lastObjectRendered;
+      const outside = '';
+      const normalizedEvents = this._normalizeToPointerData(nativeEvent);
+      for (let i = 0, j = normalizedEvents.length; i < j; i++) {
+        const event = this._bootstrapEvent(this._rootPointerEvent, normalizedEvents[i]);
+        event.type += outside;
+        this.rootBoundary.mapEvent(event);
+      }
+      this.setCursor(this.rootBoundary.cursor);
+    }
+    _onPointerOverOut(nativeEvent) {
+      if (!this.features.click) return;
+      this.rootBoundary.rootTarget = this.renderer.lastObjectRendered;
+      const normalizedEvents = this._normalizeToPointerData(nativeEvent);
+      for (let i = 0, j = normalizedEvents.length; i < j; i++) {
+        const event = this._bootstrapEvent(this._rootPointerEvent, normalizedEvents[i]);
+        this.rootBoundary.mapEvent(event);
+      }
+      this.setCursor(this.rootBoundary.cursor);
+    }
+    onWheel(nativeEvent) {
+      if (!this.features.wheel) return;
+      const wheelEvent = this.normalizeWheelEvent(nativeEvent);
+      this.rootBoundary.rootTarget = this.renderer.lastObjectRendered;
+      this.rootBoundary.mapEvent(wheelEvent);
+    }
+    setTargetElement(element) {
+      this._removeEvents();
+      this.domElement = element;
+      EventsTicker.domElement = element;
+      this._addEvents();
+    }
+    _addEvents() {
+      if (this._eventsAdded || !this.domElement) {
+        return;
+      }
+      EventsTicker.addTickerListener();
+      const style = this.domElement.style;
+      if (style) {
+        if (globalThis.navigator.msPointerEnabled) {
+          style.msContentZooming = 'none';
+          style.msTouchAction = 'none';
+        } else if (this.supportsPointerEvents) {
+          style.touchAction = 'none';
+        }
+      }
+      EventSystem.eventsHandler = {
+        pointermove: this._onPointerMove.bind(this),
+        pointerdown: this._onPointerDown.bind(this),
+        pointerleave: this._onPointerOverOut.bind(this),
+        pointerover: this._onPointerOverOut.bind(this),
+        pointerup: this._onPointerUp.bind(this),
+        mousemove: this._onPointerMove.bind(this),
+        mousedown: this._onPointerDown.bind(this),
+        mouseout: this._onPointerOverOut.bind(this),
+        mouseover: this._onPointerOverOut.bind(this),
+        mouseup: this._onPointerUp.bind(this),
+        touchstart: this._onPointerDown.bind(this),
+        touchend: this._onPointerUp.bind(this),
+        touchmove: this._onPointerMove.bind(this)
+      };
+      EventSystem.eventsHandler['wheel'] = this.onWheel.bind(this);
+      this._eventsAdded = true;
+    }
+    _removeEvents() {
+      if (!this._eventsAdded || !this.domElement) {
+        return;
+      }
+      EventsTicker.removeTickerListener();
+      const style = this.domElement.style;
+      if (style) {
+        if (globalThis.navigator.msPointerEnabled) {
+          style.msContentZooming = '';
+          style.msTouchAction = '';
+        } else if (this.supportsPointerEvents) {
+          style.touchAction = '';
+        }
+      }
+      EventSystem.eventsHandler = [];
+      this.domElement = null;
+      this._eventsAdded = false;
+    }
+    mapPositionToPoint(point, x, y) {
+      const rect = this.domElement.isConnected ? this.domElement.getBoundingClientRect() : {
+        x: 0,
+        y: 0,
+        width: this.domElement.width,
+        height: this.domElement.height,
+        left: 0,
+        top: 0
+      };
+      const resolutionMultiplier = 1.0 / this.resolution;
+      point.x = (x - rect.left) * (this.domElement.width / rect.width) * resolutionMultiplier;
+      point.y = (y - rect.top) * (this.domElement.height / rect.height) * resolutionMultiplier;
+    }
+    _normalizeToPointerData(event) {
+      return event.normalizedEvents;
+    }
+    normalizeWheelEvent(nativeEvent) {
+      const event = this._rootWheelEvent;
+      this._transferMouseData(event, nativeEvent);
+      event.deltaX = nativeEvent.deltaX;
+      event.deltaY = nativeEvent.deltaY;
+      event.deltaZ = nativeEvent.deltaZ;
+      event.deltaMode = nativeEvent.deltaMode;
+      this.mapPositionToPoint(event.screen, nativeEvent.clientX, nativeEvent.clientY);
+      event.global.copyFrom(event.screen);
+      event.offset.copyFrom(event.screen);
+      event.nativeEvent = nativeEvent;
+      event.type = nativeEvent.type;
+      return event;
+    }
+    _bootstrapEvent(event, nativeEvent) {
+      event.originalEvent = null;
+      event.nativeEvent = nativeEvent;
+      event.pointerId = nativeEvent.pointerId;
+      event.width = nativeEvent.width;
+      event.height = nativeEvent.height;
+      event.isPrimary = nativeEvent.isPrimary;
+      event.pointerType = nativeEvent.pointerType;
+      event.pressure = nativeEvent.pressure;
+      event.tangentialPressure = nativeEvent.tangentialPressure;
+      event.tiltX = nativeEvent.tiltX;
+      event.tiltY = nativeEvent.tiltY;
+      event.twist = nativeEvent.twist;
+      this._transferMouseData(event, nativeEvent);
+      this.mapPositionToPoint(event.screen, nativeEvent.clientX, nativeEvent.clientY);
+      event.global.copyFrom(event.screen);
+      event.offset.copyFrom(event.screen);
+      event.isTrusted = nativeEvent.isTrusted;
+      if (event.type === 'pointerleave') {
+        event.type = 'pointerout';
+      }
+      if (event.type.startsWith('mouse')) {
+        event.type = event.type.replace('mouse', 'pointer');
+      }
+      if (event.type.startsWith('touch')) {
+        event.type = TOUCH_TO_POINTER[event.type] || event.type;
+      }
+      return event;
+    }
+    _transferMouseData(event, nativeEvent) {
+      event.isTrusted = nativeEvent.isTrusted;
+      event.srcElement = nativeEvent.srcElement;
+      event.timeStamp = performance.now();
+      event.type = nativeEvent.type;
+      event.altKey = nativeEvent.altKey;
+      event.button = nativeEvent.button;
+      event.buttons = nativeEvent.buttons;
+      event.client.x = nativeEvent.clientX;
+      event.client.y = nativeEvent.clientY;
+      event.ctrlKey = nativeEvent.ctrlKey;
+      event.metaKey = nativeEvent.metaKey;
+      event.movement.x = nativeEvent.movementX;
+      event.movement.y = nativeEvent.movementY;
+      event.page.x = nativeEvent.pageX;
+      event.page.y = nativeEvent.pageY;
+      event.relatedTarget = null;
+      event.shiftKey = nativeEvent.shiftKey;
+    }
+  }
+  EventSystem.extension = {
+    name: 'events',
+    type: [pixi_js.ExtensionType.WebGLSystem, pixi_js.ExtensionType.CanvasSystem, pixi_js.ExtensionType.WebGPUSystem],
+    priority: -1
+  };
+  EventSystem.eventsHandler = {};
+  EventSystem.defaultEventFeatures = {
+    move: true,
+    globalMove: true,
+    click: true,
+    wheel: true
+  };
+  const eventHandler = data => {
+    const {
+      type,
+      eventName,
+      event,
+      normalizedEvents
+    } = data;
+    if (type === 'eva-event') {
+      const fn = EventSystem.eventsHandler[eventName];
+      fn && fn(_extends(_extends({}, event), {
+        preventDefault() {},
+        normalizedEvents
+      }));
+    }
+  };
+  exports.eventHandler = eventHandler;
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+  return exports;
+}({}, PIXI);
+window.EVA.plugin.worker = window.EVA.plugin.worker || _EVA_IIFE_worker;