text: /**
   *
   * @see (https://npmjs.com/package/event-target-shim-es5)
   * @see https://github.com/mysticatea/event-target-shim/blob/HEAD/dist/event-target-shim.mjs
   * @license (MIT)
   */
  
  /**
   * @author Toru Nagashima <https://github.com/mysticatea>
   * @copyright 2015 Toru Nagashima. All rights reserved.
   * See LICENSE file in root directory for full license.
   */
  /**
   * @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);
  }
  
  export default EventTarget;
  export { defineEventAttribute, EventTarget };
  // >>>># sourceMappingURL=event-target-shim.mjs.map
  