text: /**
   * @author Toru Nagashima <https://github.com/mysticatea>
   * @copyright 2015 Toru Nagashima. All rights reserved.
   * See LICENSE file in root directory for full license.
   */
  'use strict';
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  /**
   * @typedef {object} PrivateData
   * @property {EventTarget} eventTarget The event target.
   * @property {{type:string}} event The original event object.
   * @property {number} eventPhase The current event phase.
   * @property {EventTarget|null} currentTarget The current event target.
   * @property {boolean} canceled The flag to prevent default.
   * @property {boolean} stopped The flag to stop propagation.
   * @property {boolean} immediateStopped The flag to stop propagation immediately.
   * @property {Function|null} passiveListener The listener if the current listener is passive. Otherwise this is null.
   * @property {number} timeStamp The unix time.
   * @private
   */
  
  /**
   * Private data for event wrappers.
   * @type {WeakMap<Event, PrivateData>}
   * @private
   */
  const privateData = new WeakMap();
  
  /**
   * Cache for wrapper classes.
   * @type {WeakMap<Object, Function>}
   * @private
   */
  const wrappers = new WeakMap();
  
  /**
   * Get private data.
   * @param {Event} event The event object to get private data.
   * @returns {PrivateData} The private data of the event.
   * @private
   */
  function pd(event) {
      const retv = privateData.get(event);
      console.assert(
          retv != null,
          "'this' is expected an Event object, but got",
          event
      );
      return retv
  }
  
  /**
   * https://dom.spec.whatwg.org/#set-the-canceled-flag
   * @param data {PrivateData} private data.
   */
  function setCancelFlag(data) {
      if (data.passiveListener != null) {
          if (
              typeof console !== "undefined" &&
              typeof console.error === "function"
          ) {
              console.error(
                  "Unable to preventDefault inside passive event listener invocation.",
                  data.passiveListener
              );
          }
          return
      }
      if (!data.event.cancelable) {
          return
      }
  
      data.canceled = true;
      if (typeof data.event.preventDefault === "function") {
          data.event.preventDefault();
      }
  }
  
  /**
   * @see https://dom.spec.whatwg.org/#interface-event
   * @private
   */
  /**
   * The event wrapper.
   * @constructor
   * @param {EventTarget} eventTarget The event target of this dispatching.
   * @param {Event|{type:string}} event The original event to wrap.
   */
  function Event(eventTarget, event) {
      privateData.set(this, {
          eventTarget,
          event,
          eventPhase: 2,
          currentTarget: eventTarget,
          canceled: false,
          stopped: false,
          immediateStopped: false,
          passiveListener: null,
          timeStamp: event.timeStamp || Date.now(),
      });
  
      // https://heycam.github.io/webidl/#Unforgeable
      Object.defineProperty(this, "isTrusted", { value: false, enumerable: true });
  
      // Define accessors
      const keys = Object.keys(event);
      for (let i = 0; i < keys.length; ++i) {
          const key = keys[i];
          if (!(key in this)) {
              Object.defineProperty(this, key, defineRedirectDescriptor(key));
          }
      }
  }
  
  // Should be enumerable, but class methods are not enumerable.
  Event.prototype = {
      /**
       * The type of this event.
       * @type {string}
       */
      get type() {
          return pd(this).event.type
      },
  
      /**
       * The target of this event.
       * @type {EventTarget}
       */
      get target() {
          return pd(this).eventTarget
      },
  
      /**
       * The target of this event.
       * @type {EventTarget}
       */
      get currentTarget() {
          return pd(this).currentTarget
      },
  
      /**
       * @returns {EventTarget[]} The composed path of this event.
       */
      composedPath() {
          const currentTarget = pd(this).currentTarget;
          if (currentTarget == null) {
              return []
          }
          return [currentTarget]
      },
  
      /**
       * Constant of NONE.
       * @type {number}
       */
      get NONE() {
          return 0
      },
  
      /**
       * Constant of CAPTURING_PHASE.
       * @type {number}
       */
      get CAPTURING_PHASE() {
          return 1
      },
  
      /**
       * Constant of AT_TARGET.
       * @type {number}
       */
      get AT_TARGET() {
          return 2
      },
  
      /**
       * Constant of BUBBLING_PHASE.
       * @type {number}
       */
      get BUBBLING_PHASE() {
          return 3
      },
  
      /**
       * The target of this event.
       * @type {number}
       */
      get eventPhase() {
          return pd(this).eventPhase
      },
  
      /**
       * Stop event bubbling.
       * @returns {void}
       */
      stopPropagation() {
          const data = pd(this);
  
          data.stopped = true;
          if (typeof data.event.stopPropagation === "function") {
              data.event.stopPropagation();
          }
      },
  
      /**
       * Stop event bubbling.
       * @returns {void}
       */
      stopImmediatePropagation() {
          const data = pd(this);
  
          data.stopped = true;
          data.immediateStopped = true;
          if (typeof data.event.stopImmediatePropagation === "function") {
              data.event.stopImmediatePropagation();
          }
      },
  
      /**
       * The flag to be bubbling.
       * @type {boolean}
       */
      get bubbles() {
          return Boolean(pd(this).event.bubbles)
      },
  
      /**
       * The flag to be cancelable.
       * @type {boolean}
       */
      get cancelable() {
          return Boolean(pd(this).event.cancelable)
      },
  
      /**
       * Cancel this event.
       * @returns {void}
       */
      preventDefault() {
          setCancelFlag(pd(this));
      },
  
      /**
       * The flag to indicate cancellation state.
       * @type {boolean}
       */
      get defaultPrevented() {
          return pd(this).canceled
      },
  
      /**
       * The flag to be composed.
       * @type {boolean}
       */
      get composed() {
          return Boolean(pd(this).event.composed)
      },
  
      /**
       * The unix time of this event.
       * @type {number}
       */
      get timeStamp() {
          return pd(this).timeStamp
      },
  
      /**
       * The target of this event.
       * @type {EventTarget}
       * @deprecated
       */
      get srcElement() {
          return pd(this).eventTarget
      },
  
      /**
       * The flag to stop event bubbling.
       * @type {boolean}
       * @deprecated
       */
      get cancelBubble() {
          return pd(this).stopped
      },
      set cancelBubble(value) {
          if (!value) {
              return
          }
          const data = pd(this);
  
          data.stopped = true;
          if (typeof data.event.cancelBubble === "boolean") {
              data.event.cancelBubble = true;
          }
      },
  
      /**
       * The flag to indicate cancellation state.
       * @type {boolean}
       * @deprecated
       */
      get returnValue() {
          return !pd(this).canceled
      },
      set returnValue(value) {
          if (!value) {
              setCancelFlag(pd(this));
          }
      },
  
      /**
       * Initialize this event object. But do nothing under event dispatching.
       * @param {string} type The event type.
       * @param {boolean} [bubbles=false] The flag to be possible to bubble up.
       * @param {boolean} [cancelable=false] The flag to be possible to cancel.
       * @deprecated
       */
      initEvent() {
          // Do nothing.
      },
  };
  
  // `constructor` is not enumerable.
  Object.defineProperty(Event.prototype, "constructor", {
      value: Event,
      configurable: true,
      writable: true,
  });
  
  // Ensure `event instanceof window.Event` is `true`.
  if (typeof window !== "undefined" && typeof window.Event !== "undefined") {
      Object.setPrototypeOf(Event.prototype, window.Event.prototype);
  
      // Make association for wrappers.
      wrappers.set(window.Event.prototype, Event);
  }
  
  /**
   * Get the property descriptor to redirect a given property.
   * @param {string} key Property name to define property descriptor.
   * @returns {PropertyDescriptor} The property descriptor to redirect the property.
   * @private
   */
  function defineRedirectDescriptor(key) {
      return {
          get() {
              return pd(this).event[key]
          },
          set(value) {
              pd(this).event[key] = value;
          },
          configurable: true,
          enumerable: true,
      }
  }
  
  /**
   * Get the property descriptor to call a given method property.
   * @param {string} key Property name to define property descriptor.
   * @returns {PropertyDescriptor} The property descriptor to call the method property.
   * @private
   */
  function defineCallDescriptor(key) {
      return {
          value() {
              const event = pd(this).event;
              return event[key].apply(event, arguments)
          },
          configurable: true,
          enumerable: true,
      }
  }
  
  /**
   * Define new wrapper class.
   * @param {Function} BaseEvent The base wrapper class.
   * @param {Object} proto The prototype of the original event.
   * @returns {Function} The defined wrapper class.
   * @private
   */
  function defineWrapper(BaseEvent, proto) {
      const keys = Object.keys(proto);
      if (keys.length === 0) {
          return BaseEvent
      }
  
      /** CustomEvent */
      function CustomEvent(eventTarget, event) {
          BaseEvent.call(this, eventTarget, event);
      }
  
      CustomEvent.prototype = Object.create(BaseEvent.prototype, {
          constructor: { value: CustomEvent, configurable: true, writable: true },
      });
  
      // Define accessors.
      for (let i = 0; i < keys.length; ++i) {
          const key = keys[i];
          if (!(key in BaseEvent.prototype)) {
              const descriptor = Object.getOwnPropertyDescriptor(proto, key);
              const isFunc = typeof descriptor.value === "function";
              Object.defineProperty(
                  CustomEvent.prototype,
                  key,
                  isFunc
                      ? defineCallDescriptor(key)
                      : defineRedirectDescriptor(key)
              );
          }
      }
  
      return CustomEvent
  }
  
  /**
   * Get the wrapper class of a given prototype.
   * @param {Object} proto The prototype of the original event to get its wrapper.
   * @returns {Function} The wrapper class.
   * @private
   */
  function getWrapper(proto) {
      if (proto == null || proto === Object.prototype) {
          return Event
      }
  
      let wrapper = wrappers.get(proto);
      if (wrapper == null) {
          wrapper = defineWrapper(getWrapper(Object.getPrototypeOf(proto)), proto);
          wrappers.set(proto, wrapper);
      }
      return wrapper
  }
  
  /**
   * Wrap a given event to management a dispatching.
   * @param {EventTarget} eventTarget The event target of this dispatching.
   * @param {Object} event The event to wrap.
   * @returns {Event} The wrapper instance.
   * @private
   */
  function wrapEvent(eventTarget, event) {
      const Wrapper = getWrapper(Object.getPrototypeOf(event));
      return new Wrapper(eventTarget, event)
  }
  
  /**
   * Get the immediateStopped flag of a given event.
   * @param {Event} event The event to get.
   * @returns {boolean} The flag to stop propagation immediately.
   * @private
   */
  function isStopped(event) {
      return pd(event).immediateStopped
  }
  
  /**
   * Set the current event phase of a given event.
   * @param {Event} event The event to set current target.
   * @param {number} eventPhase New event phase.
   * @returns {void}
   * @private
   */
  function setEventPhase(event, eventPhase) {
      pd(event).eventPhase = eventPhase;
  }
  
  /**
   * Set the current target of a given event.
   * @param {Event} event The event to set current target.
   * @param {EventTarget|null} currentTarget New current target.
   * @returns {void}
   * @private
   */
  function setCurrentTarget(event, currentTarget) {
      pd(event).currentTarget = currentTarget;
  }
  
  /**
   * Set a passive listener of a given event.
   * @param {Event} event The event to set current target.
   * @param {Function|null} passiveListener New passive listener.
   * @returns {void}
   * @private
   */
  function setPassiveListener(event, passiveListener) {
      pd(event).passiveListener = passiveListener;
  }
  
  /**
   * @typedef {object} ListenerNode
   * @property {Function} listener
   * @property {1|2|3} listenerType
   * @property {boolean} passive
   * @property {boolean} once
   * @property {ListenerNode|null} next
   * @private
   */
  
  /**
   * @type {WeakMap<object, Map<string, ListenerNode>>}
   * @private
   */
  const listenersMap = new WeakMap();
  
  // Listener types
  const CAPTURE = 1;
  const BUBBLE = 2;
  const ATTRIBUTE = 3;
  
  /**
   * Check whether a given value is an object or not.
   * @param {any} x The value to check.
   * @returns {boolean} `true` if the value is an object.
   */
  function isObject(x) {
      return x !== null && typeof x === "object" //eslint-disable-line no-restricted-syntax
  }
  
  /**
   * Get listeners.
   * @param {EventTarget} eventTarget The event target to get.
   * @returns {Map<string, ListenerNode>} The listeners.
   * @private
   */
  function getListeners(eventTarget) {
      const listeners = listenersMap.get(eventTarget);
      if (listeners == null) {
          throw new TypeError(
              "'this' is expected an EventTarget object, but got another value."
          )
      }
      return listeners
  }
  
  /**
   * Get the property descriptor for the event attribute of a given event.
   * @param {string} eventName The event name to get property descriptor.
   * @returns {PropertyDescriptor} The property descriptor.
   * @private
   */
  function defineEventAttributeDescriptor(eventName) {
      return {
          get() {
              const listeners = getListeners(this);
              let node = listeners.get(eventName);
              while (node != null) {
                  if (node.listenerType === ATTRIBUTE) {
                      return node.listener
                  }
                  node = node.next;
              }
              return null
          },
  
          set(listener) {
              if (typeof listener !== "function" && !isObject(listener)) {
                  listener = null; // eslint-disable-line no-param-reassign
              }
              const listeners = getListeners(this);
  
              // Traverse to the tail while removing old value.
              let prev = null;
              let node = listeners.get(eventName);
              while (node != null) {
                  if (node.listenerType === ATTRIBUTE) {
                      // Remove old value.
                      if (prev !== null) {
                          prev.next = node.next;
                      } else if (node.next !== null) {
                          listeners.set(eventName, node.next);
                      } else {
                          listeners.delete(eventName);
                      }
                  } else {
                      prev = node;
                  }
  
                  node = node.next;
              }
  
              // Add new value.
              if (listener !== null) {
                  const newNode = {
                      listener,
                      listenerType: ATTRIBUTE,
                      passive: false,
                      once: false,
                      next: null,
                  };
                  if (prev === null) {
                      listeners.set(eventName, newNode);
                  } else {
                      prev.next = newNode;
                  }
              }
          },
          configurable: true,
          enumerable: true,
      }
  }
  
  /**
   * Define an event attribute (e.g. `eventTarget.onclick`).
   * @param {Object} eventTargetPrototype The event target prototype to define an event attrbite.
   * @param {string} eventName The event name to define.
   * @returns {void}
   */
  function defineEventAttribute(eventTargetPrototype, eventName) {
      Object.defineProperty(
          eventTargetPrototype,
          `on${eventName}`,
          defineEventAttributeDescriptor(eventName)
      );
  }
  
  /**
   * Define a custom EventTarget with event attributes.
   * @param {string[]} eventNames Event names for event attributes.
   * @returns {EventTarget} The custom EventTarget.
   * @private
   */
  function defineCustomEventTarget(eventNames) {
      /** CustomEventTarget */
      function CustomEventTarget() {
          EventTarget.call(this);
      }
  
      CustomEventTarget.prototype = Object.create(EventTarget.prototype, {
          constructor: {
              value: CustomEventTarget,
              configurable: true,
              writable: true,
          },
      });
  
      for (let i = 0; i < eventNames.length; ++i) {
          defineEventAttribute(CustomEventTarget.prototype, eventNames[i]);
      }
  
      return CustomEventTarget
  }
  
  /**
   * EventTarget.
   *
   * - This is constructor if no arguments.
   * - This is a function which returns a CustomEventTarget constructor if there are arguments.
   *
   * For example:
   *
   *     class A extends EventTarget {}
   *     class B extends EventTarget("message") {}
   *     class C extends EventTarget("message", "error") {}
   *     class D extends EventTarget(["message", "error"]) {}
   */
  function EventTarget() {
      /*eslint-disable consistent-return */
      if (this instanceof EventTarget) {
          listenersMap.set(this, new Map());
          return
      }
      if (arguments.length === 1 && Array.isArray(arguments[0])) {
          return defineCustomEventTarget(arguments[0])
      }
      if (arguments.length > 0) {
          const types = new Array(arguments.length);
          for (let i = 0; i < arguments.length; ++i) {
              types[i] = arguments[i];
          }
          return defineCustomEventTarget(types)
      }
      throw new TypeError("Cannot call a class as a function")
      /*eslint-enable consistent-return */
  }
  
  // Should be enumerable, but class methods are not enumerable.
  EventTarget.prototype = {
      /**
       * Add a given listener to this event target.
       * @param {string} eventName The event name to add.
       * @param {Function} listener The listener to add.
       * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
       * @returns {void}
       */
      addEventListener(eventName, listener, options) {
          if (listener == null) {
              return
          }
          if (typeof listener !== "function" && !isObject(listener)) {
              throw new TypeError("'listener' should be a function or an object.")
          }
  
          const listeners = getListeners(this);
          const optionsIsObj = isObject(options);
          const capture = optionsIsObj
              ? Boolean(options.capture)
              : Boolean(options);
          const listenerType = capture ? CAPTURE : BUBBLE;
          const newNode = {
              listener,
              listenerType,
              passive: optionsIsObj && Boolean(options.passive),
              once: optionsIsObj && Boolean(options.once),
              next: null,
          };
  
          // Set it as the first node if the first node is null.
          let node = listeners.get(eventName);
          if (node === undefined) {
              listeners.set(eventName, newNode);
              return
          }
  
          // Traverse to the tail while checking duplication..
          let prev = null;
          while (node != null) {
              if (
                  node.listener === listener &&
                  node.listenerType === listenerType
              ) {
                  // Should ignore duplication.
                  return
              }
              prev = node;
              node = node.next;
          }
  
          // Add it.
          prev.next = newNode;
      },
  
      /**
       * Remove a given listener from this event target.
       * @param {string} eventName The event name to remove.
       * @param {Function} listener The listener to remove.
       * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
       * @returns {void}
       */
      removeEventListener(eventName, listener, options) {
          if (listener == null) {
              return
          }
  
          const listeners = getListeners(this);
          const capture = isObject(options)
              ? Boolean(options.capture)
              : Boolean(options);
          const listenerType = capture ? CAPTURE : BUBBLE;
  
          let prev = null;
          let node = listeners.get(eventName);
          while (node != null) {
              if (
                  node.listener === listener &&
                  node.listenerType === listenerType
              ) {
                  if (prev !== null) {
                      prev.next = node.next;
                  } else if (node.next !== null) {
                      listeners.set(eventName, node.next);
                  } else {
                      listeners.delete(eventName);
                  }
                  return
              }
  
              prev = node;
              node = node.next;
          }
      },
  
      /**
       * Dispatch a given event.
       * @param {Event|{type:string}} event The event to dispatch.
       * @returns {boolean} `false` if canceled.
       */
      dispatchEvent(event) {
          if (event == null || typeof event.type !== "string") {
              throw new TypeError('"event.type" should be a string.')
          }
  
          // If listeners aren't registered, terminate.
          const listeners = getListeners(this);
          const eventName = event.type;
          let node = listeners.get(eventName);
          if (node == null) {
              return true
          }
  
          // Since we cannot rewrite several properties, so wrap object.
          const wrappedEvent = wrapEvent(this, event);
  
          // This doesn't process capturing phase and bubbling phase.
          // This isn't participating in a tree.
          let prev = null;
          while (node != null) {
              // Remove this listener if it's once
              if (node.once) {
                  if (prev !== null) {
                      prev.next = node.next;
                  } else if (node.next !== null) {
                      listeners.set(eventName, node.next);
                  } else {
                      listeners.delete(eventName);
                  }
              } else {
                  prev = node;
              }
  
              // Call this listener
              setPassiveListener(
                  wrappedEvent,
                  node.passive ? node.listener : null
              );
              if (typeof node.listener === "function") {
                  try {
                      node.listener.call(this, wrappedEvent);
                  } catch (err) {
                      if (
                          typeof console !== "undefined" &&
                          typeof console.error === "function"
                      ) {
                          console.error(err);
                      }
                  }
              } else if (
                  node.listenerType !== ATTRIBUTE &&
                  typeof node.listener.handleEvent === "function"
              ) {
                  node.listener.handleEvent(wrappedEvent);
              }
  
              // Break if `event.stopImmediatePropagation` was called.
              if (isStopped(wrappedEvent)) {
                  break
              }
  
              node = node.next;
          }
          setPassiveListener(wrappedEvent, null);
          setEventPhase(wrappedEvent, 0);
          setCurrentTarget(wrappedEvent, null);
  
          return !wrappedEvent.defaultPrevented
      },
  };
  
  // `constructor` is not enumerable.
  Object.defineProperty(EventTarget.prototype, "constructor", {
      value: EventTarget,
      configurable: true,
      writable: true,
  });
  
  // Ensure `eventTarget instanceof window.EventTarget` is `true`.
  if (
      typeof window !== "undefined" &&
      typeof window.EventTarget !== "undefined"
  ) {
      Object.setPrototypeOf(EventTarget.prototype, window.EventTarget.prototype);
  }
  
  exports.defineEventAttribute = defineEventAttribute;
  exports.EventTarget = EventTarget;
  exports.default = EventTarget;
  
  module.exports = EventTarget
  module.exports.EventTarget = module.exports["default"] = EventTarget
  module.exports.defineEventAttribute = defineEventAttribute
  //# sourceMappingURL=event-target-shim.js.map
  