index.js

(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
module.exports = (function() {

  if(typeof EventTarget === 'undefined') {
    window.EventTarget = Node;
  }

  /**
   * Event listener interceptor
   */

  var EventListenerInterceptor = {
    interceptors: [] // { target: EventTarget, interceptors: [{ add: Function, remove: Function }, ...] }
  };


  /**
   * Returns if exists a previously registered listener from a target and the normalized arguments
   * @param target
   * @param normalizedArguments
   * @return {*}
   */
  EventListenerInterceptor.getRegisteredEventListener = function(target, normalizedArguments) {
    var key = normalizedArguments.type + '-' + (normalizedArguments.options.capture ? '1' : '0');
    if(
      (target.__eventListeners !== void 0) &&
      (target.__eventListeners[key] !== void 0)
    ) {
      var map = target.__eventListeners[key];
      for(var i = 0; i < map.length; i++) {
        if(map[i].listener === normalizedArguments.listener) {
          return map[i];
        }
      }
    }
    return null;
  };

  /**
   * Registers a listener on a target with some options
   * @param target
   * @param normalizedArguments
   */
  EventListenerInterceptor.registerEventListener = function(target, normalizedArguments) {
    var key = normalizedArguments.type + '-' + (normalizedArguments.options.capture ? '1' : '0');

    if(target.__eventListeners === void 0) {
      target.__eventListeners = {};
    }

    if(target.__eventListeners[key] === void 0) {
      target.__eventListeners[key] = [];
    }

    target.__eventListeners[key].push(normalizedArguments);
  };

  /**
   * Unregisters a listener on a target with some options
   * @param target
   * @param normalizedArguments
   */
  EventListenerInterceptor.unregisterEventListener = function(target, normalizedArguments) {
    var key = normalizedArguments.type + '-' + (normalizedArguments.options.capture ? '1' : '0');
    if(
      (target.__eventListeners !==  void 0) &&
      (target.__eventListeners[key] !== void 0)
    ) {
      var map = target.__eventListeners[key];
      for(var i = 0; i < map.length; i++) {
        if(map[i].listener === normalizedArguments.listener) {
          map.splice(i, 1);
        }
      }

      if(map.length === 0) {
        delete target.__eventListeners[key];
      }
    }
  };



  EventListenerInterceptor.normalizeListenerCallback = function(listener) {
    if(typeof listener === 'function') {
      return listener;
    } else if((typeof listener === 'object') && (typeof listener.handleEvent === 'function')) {
      return listener.handleEvent;
    } else {
      // to support Symbol
      return function(event) {
        listener(event);
      };
    }
  };

  EventListenerInterceptor.normalizeListenerOptions = function(options) {
    var type = options === null ? 'null' : typeof options;
    switch(type) {
      case 'boolean':
        options = { capture: options };
        break;
      case 'undefined':
      case 'null':
        options = { capture: false };
        break;
      case 'object':
        break;
      default:
        throw new Error('Unsupported options type for addEventListener');
    }

    options.once      = Boolean(options.once);
    options.passive   = Boolean(options.passive);
    options.capture   = Boolean(options.capture);

    return options;
  };

  EventListenerInterceptor.normalizeListenerArguments = function(type, listener, options) {
    return {
      type: type,
      listener: this.normalizeListenerCallback(listener),
      options: this.normalizeListenerOptions(options)
    };
  };



  EventListenerInterceptor.intercept = function(target, interceptors) {
    // get an interceptor with this target or null
    var interceptor = null;
    for (var i = 0; i < this.interceptors.length; i++) {
      if(this.interceptors[i].target === target) {
        interceptor = this.interceptors[i];
      }
    }

    // if no interceptor already set
    if (interceptor === null) {
      interceptor = { target: target, interceptors: [interceptors] };
      this.interceptors.push(interceptor);

      this.interceptAddEventListener(target, interceptor);
      this.interceptRemoveEventListener(target, interceptor);
    } else { // if an interceptor already set, simply add interceptors to the list
      interceptor.interceptors.push(interceptors);
    }

    // var release = function() {
    //   target.prototype.addEventListener = addEventListener;
    //   target.prototype.removeEventListener = removeEventListener;
    // };
    // this.interceptors.push(release);
    // return release;
  };

  EventListenerInterceptor.interceptAddEventListener = function(target, interceptor) {
    var _this = this;

    var addEventListener = target.prototype.addEventListener;
    target.prototype.addEventListener = function(type, listener, options) {
      var normalizedArguments = _this.normalizeListenerArguments(type, listener, options);
      var registeredEventListener = _this.getRegisteredEventListener(this, normalizedArguments);

      if (!registeredEventListener) {

        normalizedArguments.polyfilled = {
          type: normalizedArguments.type,
          listener: normalizedArguments.listener,
          options: {
            capture: normalizedArguments.options.capture,
            once: normalizedArguments.options.once,
            passive: normalizedArguments.options.passive
          }
        };

        for (var i = 0; i < interceptor.interceptors.length; i++) {
          var interceptors = interceptor.interceptors[i];
          if (typeof interceptors.add === 'function') {
            interceptors.add(normalizedArguments);
          }
        }

        // console.log('normalizedArguments', normalizedArguments.polyfilled);

        _this.registerEventListener(this, normalizedArguments);

        addEventListener.call(
          this,
          normalizedArguments.polyfilled.type,
          normalizedArguments.polyfilled.listener,
          normalizedArguments.polyfilled.options
        );
      }
    };

    return function() {
      target.prototype.addEventListener = addEventListener;
    };
  };

  EventListenerInterceptor.interceptRemoveEventListener = function(target, interceptor) {
    var _this = this;

    var removeEventListener = target.prototype.removeEventListener;
    target.prototype.removeEventListener = function(type, listener, options) {
      var normalizedArguments = _this.normalizeListenerArguments(type, listener, options);
      var registeredEventListener = _this.getRegisteredEventListener(this, normalizedArguments);

      if (registeredEventListener) {
        _this.unregisterEventListener(this, normalizedArguments);
        removeEventListener.call(
          this,
          registeredEventListener.polyfilled.type,
          registeredEventListener.polyfilled.listener,
          registeredEventListener.polyfilled.options
        );
      } else {
        removeEventListener.call(this, type, listener, options);
      }
    };

    return function() {
      target.prototype.removeEventListener = removeEventListener;
    };
  };

  EventListenerInterceptor.interceptAll = function(interceptors) {
    this.intercept(EventTarget, interceptors);
    if(!(window instanceof EventTarget)) {
      this.intercept(Window, interceptors);
    }
  };

  EventListenerInterceptor.releaseAll = function() {
    for(var i = 0, l = this.interceptors.length; i < l; i++) {
      this.interceptors();
    }
  };


  EventListenerInterceptor.error = function(error) {
    // throw error;
    console.error(error);
  };

  return EventListenerInterceptor;
})();
},{}],2:[function(require,module,exports){
(function(EventListenerInterceptor) {
  /**
   * Event listener type support
   */

  EventListenerInterceptor.isSupportedOnEvent = function(target, type) {
    return (('on' + type) in target);
  };

  EventListenerInterceptor.isSupportedTransitionEvent = function(target, type) {
    return EventListenerInterceptor.isSupportedOnEvent(target, type) || (('style' in target) && (target.style['transition'] !== void 0));
  };

  EventListenerInterceptor.isSupportedFullScreenEvent = function(target, type) {
    if(EventListenerInterceptor.isSupportedOnEvent(target, type)) {
      return true;
    } else {
      if(/^ms/.test(type.toLowerCase())) {
        return 'msRequestFullscreen' in document.body;
      } else if(/^moz/.test(type)) {
        return 'mozRequestFullscreen' in document.body;
      } else if(/^webkit/.test(type)) {
        return 'webkitRequestFullscreen' in document.body;
      } else {
        return false;
      }
    }
  };


  EventListenerInterceptor.generateEventTypes = function() {
    var _this = this;

    this.eventTypes = {}; // map of types that resolved to something else
    this.vendorPrefixes = ['', 'webkit', 'moz', 'ms', 'o'];


    this.eventTypes['wheel'] = ['wheel', 'mousewheel', 'DOMMouseScroll'].map(function(type) {
      return { type: type, isSupported: _this.isSupportedOnEvent } ;
    });

    this.eventTypes['fullscreenchange'] = ['fullscreenchange', 'mozfullscreenchange', 'webkitfullscreenchange', 'MSFullscreenChange', 'msfullscreenchange'].map(function(type) {
      return { type: type, isSupported: _this.isSupportedFullScreenEvent } ;
    });

    this.eventTypes['fullscreenerror'] = ['fullscreenerror', 'mozfullscreenerror', 'webkitfullscreenerror', 'MSFullscreenError', 'msfullscreenerror'].map(function(type) {
      return { type: type, isSupported: _this.isSupportedFullScreenEvent } ;
    });

    [
      'pointerlockchange', 'pointerlockerror',
      'animationstart', 'animationiteration', 'animationend',
      'pointercancel', 'pointerdown', 'pointerhover', 'pointermove', 'pointerout', 'pointerover', 'pointerup'
    ].forEach(function(type) {
      _this.eventTypes[type] = _this.vendorPrefixes
        .map(function(prefix) {
          return { type: (prefix + type), isSupported: _this.isSupportedOnEvent } ;
        });
    });

    ['transitionstart', 'transitionrun', 'transitionend'].forEach(function(type) {
      _this.eventTypes[type] = _this.vendorPrefixes
        .map(function(prefix) {
          return { type: (prefix + type), isSupported: _this.isSupportedTransitionEvent } ;
        });
    });
  };

  EventListenerInterceptor.getSupportedEventType = function(target, type) {
    var types = this.eventTypes[type];
    if(types === void 0) {
      return type;
    } else {
      var _type;
      for(var i = 0; i < types.length; i++) {
        _type = types[i];
        if(_type.isSupported(target, _type.type)) {
          // console.log('use : ' + eventTypesPolyfiller[i].type);
          return _type.type;
        }
      }

      // this.error(new Error('Event listener type ' + String(type) + ' on ' + String(target) + ' is not supported by current environment'));
      return type;
    }
  };


  EventListenerInterceptor.polyfillListenerEventTypes = function() {
    this.generateEventTypes();

    var _this = this;

    this.interceptAll({
      add: function(normalizedArguments) {
        normalizedArguments.polyfilled.type = _this.getSupportedEventType(this, normalizedArguments.polyfilled.type);
      }
    });
  };


  EventListenerInterceptor.polyfillListenerEventTypes();

})(require('./EventListenerInterceptor.js'));
},{"./EventListenerInterceptor.js":1}],3:[function(require,module,exports){
(function(EventListenerInterceptor) {
  /**
   * Event listener options support
   */

  EventListenerInterceptor.detectSupportedOptions = function() {
    var _this = this;

    this.supportedOptions = {
      once: false,
      passive: false,
      capture: false,

      all: false,
      some: false
    };

    document.createDocumentFragment().addEventListener('test', function() {}, {
      get once() {
        _this.supportedOptions.once = true;
        return false;
      },
      get passive() {
        _this.supportedOptions.passive = true;
        return false;
      },
      get capture() {
        _this.supportedOptions.capture = true;
        return false;
      }
    });

    // useful shortcuts to detect if options are all/some supported
    this.supportedOptions.all  = this.supportedOptions.once && this.supportedOptions.passive && this.supportedOptions.capture;
    this.supportedOptions.some = this.supportedOptions.once || this.supportedOptions.passive || this.supportedOptions.capture;
  };

  EventListenerInterceptor.polyfillListenerOptions = function() {
    this.detectSupportedOptions();
    if (!this.supportedOptions.all) {
      var _this = this;

      this.interceptAll({
        add: function(normalizedArguments) {
          // console.log('intercepted', normalizedArguments);

          var once = normalizedArguments.options.once && !_this.supportedOptions.once;
          var passive = normalizedArguments.options.passive && !_this.supportedOptions.passive;

          if (once || passive) {
            var listener = normalizedArguments.polyfilled.listener;

            normalizedArguments.polyfilled.listener = function(event) {
              if(once) {
                this.removeEventListener(normalizedArguments.type, normalizedArguments.listener, normalizedArguments.options);
              }

              if(passive) {
                event.preventDefault = function() {
                  throw new Error('Unable to preventDefault inside passive event listener invocation.');
                };
              }

              return listener.call(this, event);
            };
          }

          if (!_this.supportedOptions.some) {
            normalizedArguments.polyfilled.options = normalizedArguments.options.capture;
          }
        }
      });
    }
  };


  EventListenerInterceptor.polyfillListenerOptions();


  // var onclick = function() {
  //   console.log('click');
  // };

  // document.body.addEventListener('click', onclick, false);
  // document.body.addEventListener('click', onclick, { once: true });
  // document.body.addEventListener('click', onclick, { once: true });
  // document.body.addEventListener('click', onclick, false);
  // document.body.addEventListener('click', onclick, false);

})(require('./EventListenerInterceptor.js'));
},{"./EventListenerInterceptor.js":1}],4:[function(require,module,exports){
module.exports = (function() {
  return function ApplyThisPrototype(event, target) {
    if ((typeof target === 'object') && (target !== null)) {
      var proto = Object.getPrototypeOf(target);
      var property;

      for (property in proto) {
        if (!(property in event)) {
          var descriptor = Object.getOwnPropertyDescriptor(proto, property);
          if (descriptor) {
            Object.defineProperty(event, property, descriptor);
          }
        }
      }

      for (property in target) {
        if (!(property in event)) {
          event[property] = target[property];
        }
      }
    }
  }
})();

},{}],5:[function(require,module,exports){
(function(ApplyThisPrototype) {
  /**
   * Polyfill CustomEvent
   */
  try {
    var event = new window.CustomEvent('event', { bubbles: true, cancelable: true });
  } catch (error) {
    var CustomEventOriginal = window.CustomEvent || window.Event;
    var CustomEvent = function(eventName, params) {
      params = params || {};
      var event = document.createEvent('CustomEvent');
      event.initCustomEvent(
        eventName,
        (params.bubbles === void 0) ? false : params.bubbles,
        (params.cancelable === void 0) ? false : params.cancelable,
        (params.detail === void 0) ? {} : params.detail
      );
      ApplyThisPrototype(event, this);
      return event;
    };
    CustomEvent.prototype = CustomEventOriginal.prototype;
    window.CustomEvent = CustomEvent;
  }
})(require('./ApplyThisPrototype.js'));
},{"./ApplyThisPrototype.js":4}],6:[function(require,module,exports){
(function(ApplyThisPrototype) {
  // ✓, ✗

  /**
   * Polyfill Event
   */
  try {
    var event = new window.Event('event', { bubbles: true, cancelable: true });
  } catch(error) {
    var EventOriginal = window.Event;
    var Event = function(eventName, params) {
      params = params || {};
      var event = document.createEvent('Event');
      event.initEvent(
        eventName,
        (params.bubbles === void 0) ? false : params.bubbles,
        (params.cancelable === void 0) ? false : params.cancelable,
        (params.detail === void 0) ? {} : params.detail
      );
      ApplyThisPrototype(event, this);
      return event;
    };
    Event.prototype = EventOriginal.prototype;
    window.Event = Event;
  }
})(require('./ApplyThisPrototype.js'));
},{"./ApplyThisPrototype.js":4}],7:[function(require,module,exports){
(function(ApplyThisPrototype) {
  /**
   * Polyfill FocusEvent : https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent/FocusEvent
   *  - relatedTarget ✓
   */
  try {
    var event = new window.FocusEvent('event', { bubbles: true, cancelable: true });
  } catch (error) {
    var FocusEventOriginal = window.FocusEvent || window.Event;
    var FocusEvent = function(eventName, params) {
      params = params || {};
      var event = document.createEvent('FocusEvent');

      // https://msdn.microsoft.com/en-us/library/ff975954(v=vs.85).aspx
      event.initFocusEvent(
        eventName,
        (params.bubbles === void 0) ? false : params.bubbles,
        (params.cancelable === void 0) ? false : params.cancelable,
        (params.view === void 0) ? window : params.view,
        (params.detail === void 0) ? {} : params.detail,
        (params.relatedTarget === void 0) ? null : params.relatedTarget
      );

      ApplyThisPrototype(event, this);

      return event;
    };
    FocusEvent.prototype = FocusEventOriginal.prototype;
    window.FocusEvent = FocusEvent;
  }
})(require('./ApplyThisPrototype.js'));
},{"./ApplyThisPrototype.js":4}],8:[function(require,module,exports){
(function(ApplyThisPrototype) {
  /**
   * Polyfill KeyboardEvent : https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/KeyboardEvent
   *  - key ✓
   *  - char ✓
   *  - code ✓
   *  - location ✓
   *  - ctrlKey ✓
   *  - shiftKey ✓
   *  - altKey ✓
   *  - metaKey ✓
   *  - repeat ✓
   *  - isComposing ✗
   *  - charCode ✓
   *  - keyCode ✓
   *  - which ✓
   */
  try {
    var event = new window.KeyboardEvent('event', { bubbles: true, cancelable: true });
  } catch (error) {
    var KeyboardEventOriginal = window.KeyboardEvent || window.Event;
    var KeyboardEvent = function(eventName, params) {
      params = params || {};
      var event = document.createEvent('KeyboardEvent');

      // https://msdn.microsoft.com/en-us/library/ff975297(v=vs.85).aspx
      event.initKeyboardEvent(
        eventName,
        (params.bubbles === void 0) ? false : params.bubbles,
        (params.cancelable === void 0) ? false : params.cancelable,
        (params.view === void 0) ? window : params.view,
        (params.key === void 0) ? '' : params.key,
        (params.location === void 0) ? 0 : params.location,
        ((params.ctrlKey === true) ? 'Control ' : '') +
        ((params.altKey === true) ? 'Alt ' : '') +
        ((params.shiftKey === true) ? 'Shift ' : '') +
        ((params.metaKey === true) ? 'Meta ' : ''),
        (params.repeat === void 0) ? false : params.repeat,
        (params.locale === void 0) ? navigator.language : params.locale
      );

      event.keyCode   = (params.keyCode === void 0) ? 0 : params.keyCode;
      event.code      = (params.code === void 0) ? '' : params.code;
      event.charCode  = (params.charCode === void 0) ? 0 : params.charCode;
      event.char      = (params.charCode === void 0) ? '' : params.charCode;
      event.which     = (params.which === void 0) ? 0 : params.which;

      ApplyThisPrototype(event, this);

      return event;
    };
    KeyboardEvent.prototype = KeyboardEventOriginal.prototype;
    window.KeyboardEvent = KeyboardEvent;
  }

})(require('./ApplyThisPrototype.js'));
},{"./ApplyThisPrototype.js":4}],9:[function(require,module,exports){
(function(ApplyThisPrototype) {
  /**
   * Polyfill MouseEvent : https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/MouseEvent
   *  - screenX ✓
   *  - screenY ✓
   *  - clientX ✓
   *  - clientY ✓
   *  - ctrlKey ✓
   *  - shiftKey ✓
   *  - altKey ✓
   *  - metaKey ✓
   *  - button ✓
   *  - buttons ✓
   *  - region ✓
   */
  try {
    var event = new window.MouseEvent('event', { bubbles: true, cancelable: true });
  } catch (error) {
    var MouseEventOriginal = window.MouseEvent || window.Event;
    var MouseEvent = function(eventName, params) {
      params = params || {};
      var event = document.createEvent('MouseEvent');

      // https://msdn.microsoft.com/en-us/library/ff975292(v=vs.85).aspx
      event.initMouseEvent(
        eventName,
        (params.bubbles === void 0) ? false : params.bubbles,
        (params.cancelable === void 0) ? false : params.cancelable,
        (params.view === void 0) ? window : params.view,
        (params.detail === void 0) ? 0 : params.detail,
        (params.screenX === void 0) ? 0 : params.screenX,
        (params.screenY === void 0) ? 0 : params.screenY,
        (params.clientX === void 0) ? 0 : params.clientX,
        (params.clientY === void 0) ? 0 : params.clientY,
        (params.ctrlKey === void 0) ? false : params.ctrlKey,
        (params.altKey === void 0) ? false : params.altKey,
        (params.shiftKey === void 0) ? false : params.shiftKey,
        (params.metaKey === void 0) ? false : params.metaKey,
        (params.button === void 0) ? 0 : params.button,
        (params.relatedTarget === void 0) ? null : params.relatedTarget
      );

      event.buttons = (params.buttons === void 0) ? 0 : params.buttons;
      event.region  = (params.region === void 0) ? null : params.region;

      ApplyThisPrototype(event, this);

      return event;
    };
    MouseEvent.prototype = MouseEventOriginal.prototype;
    window.MouseEvent = MouseEvent;
  }
})(require('./ApplyThisPrototype.js'));
},{"./ApplyThisPrototype.js":4}],10:[function(require,module,exports){
(function(ApplyThisPrototype) {
  /**
   * Polyfill PointerEvent
   *  - pointerId ✓
   *  - width ✓
   *  - height ✓
   *  - pressure ✓
   *  - tangentialPressure ✓
   *  - tiltX ✓
   *  - tiltY ✓
   *  - twist ✓
   *  - pointerType ✓
   *  - isPrimary ✓
   */
  try {
    var event = new window.PointerEvent('event', { bubbles: true, cancelable: true });
  } catch (error) {
    var PointerEventOriginal = window.PointerEvent || window.Event;
    var PointerEvent = function(eventName, params) {
      params = params || {};
      var event = document.createEvent('PointerEvent');

      // https://msdn.microsoft.com/en-us/library/jj192039(v=vs.85).aspx
      event.initPointerEvent(
        eventName,
        (params.bubbles === void 0) ? false : params.bubbles,
        (params.cancelable === void 0) ? false : params.cancelable,
        (params.view === void 0) ? window : params.view,
        (params.detail === void 0) ? 0 : params.detail,
        (params.screenX === void 0) ? 0 : params.screenX,
        (params.screenY === void 0) ? 0 : params.screenY,
        (params.clientX === void 0) ? 0 : params.clientX,
        (params.clientY === void 0) ? 0 : params.clientY,
        (params.ctrlKey === void 0) ? false : params.ctrlKey,
        (params.altKey === void 0) ? false : params.altKey,
        (params.shiftKey === void 0) ? false : params.shiftKey,
        (params.metaKey === void 0) ? false : params.metaKey,
        (params.button === void 0) ? 0 : params.button,
        (params.relatedTarget === void 0) ? null : params.relatedTarget,

        (params.offsetX  === void 0) ? 0 : params.offsetX,
        (params.offsetY  === void 0) ? 0 : params.offsetY,
        (params.width === void 0) ? 1 : params.width,
        (params.height === void 0) ? 1 : params.height,
        (params.pressure === void 0) ? 0 : params.pressure,
        (params.twist === void 0) ? 0 : params.twist,
        (params.tiltX === void 0) ? 0 : params.tiltX,
        (params.tiltY === void 0) ? 0 : params.tiltY,
        (params.pointerId === void 0) ? 0 : params.pointerId,
        (params.pointerType === void 0) ? '' : params.pointerType,
        (params.hwTimestamp === void 0) ? 0 : params.hwTimestamp,
        (params.isPrimary === void 0) ? false : params.isPrimary
      );

      event.tangentialPressure = (params.tangentialPressure === void 0) ? 0 : params.tangentialPressure;

      ApplyThisPrototype(event, this);

      return event;
    };

    PointerEvent.prototype = PointerEventOriginal.prototype;

    var rotationDescriptor = Object.getOwnPropertyDescriptor(PointerEvent.prototype, 'rotation');
    if (rotationDescriptor) {
      Object.defineProperty(PointerEvent.prototype, 'twist', rotationDescriptor);
    }

    window.PointerEvent = PointerEvent;
  }
})(require('./ApplyThisPrototype.js'));
},{"./ApplyThisPrototype.js":4}],11:[function(require,module,exports){
require('./Event.js');
require('./CustomEvent.js');
require('./MouseEvent.js');
require('./KeyboardEvent.js');
require('./FocusEvent.js');
require('./PointerEvent.js');
},{"./CustomEvent.js":5,"./Event.js":6,"./FocusEvent.js":7,"./KeyboardEvent.js":8,"./MouseEvent.js":9,"./PointerEvent.js":10}],12:[function(require,module,exports){
require('./constructors/index.js');
require('./ListenerOptions.js');
require('./ListenerEventTypes.js');

},{"./ListenerEventTypes.js":2,"./ListenerOptions.js":3,"./constructors/index.js":11}]},{},[12]);