synthetic-event 1.1.1 → 2.0.0

package/LICENSE.md

@@ -1,19 +1,19 @@
-Copyright © 2017 Raoul van Rüschen
-
-This software is provided 'as-is', without any express or implied warranty. In
-no event will the authors be held liable for any damages arising from the use of
-this software.
-
-Permission is granted to anyone to use this software for any purpose, including
-commercial applications, and to alter it and redistribute it freely, subject to
-the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim
-   that you wrote the original software. If you use this software in a product,
-   an acknowledgment in the product documentation would be appreciated but is
-   not required.
-
-2. Altered source versions must be plainly marked as such, and must not be
-   misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source distribution.
+Copyright © 2017 Raoul van Rüschen
+
+This software is provided 'as-is', without any express or implied warranty. In
+no event will the authors be held liable for any damages arising from the use of
+this software.
+
+Permission is granted to anyone to use this software for any purpose, including
+commercial applications, and to alter it and redistribute it freely, subject to
+the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim
+   that you wrote the original software. If you use this software in a product,
+   an acknowledgment in the product documentation would be appreciated but is
+   not required.
+
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.

package/README.md

@@ -1,89 +1,81 @@
-# Synthetic Event
-
-[![Build status](https://travis-ci.org/vanruesc/synthetic-event.svg?branch=master)](https://travis-ci.org/vanruesc/synthetic-event)
-[![NPM version](https://badge.fury.io/js/synthetic-event.svg)](http://badge.fury.io/js/synthetic-event)
-[![Dependencies](https://david-dm.org/vanruesc/synthetic-event.svg?branch=master)](https://david-dm.org/vanruesc/synthetic-event)
-
-This library provides a simplified implementation of the two interfaces [Event](https://developer.mozilla.org/en-US/docs/Web/API/Event) and [EventTarget](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget). The included base classes can be used to create synthetic events and custom event targets in any environment.
-
-If your focus lies on DOM events, please refer to the native [CustomEvent](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent) class. An alternative way to create custom event targets in a browser environment is to use a [DocumentFragment](https://developer.mozilla.org/en/docs/Web/API/Document/createDocumentFragment) as a dummy target.
-
-*[Documentation](https://vanruesc.github.io/synthetic-event)*
-
-
-## Installation
-
-```sh
-npm install synthetic-event
-``` 
-
-
-## Usage
-
-##### Basics
-
-```js
-import { Event, EventTarget } from "synthetic-event";
-
-const eventTarget = new EventTarget();
-
-eventTarget.addEventListener("test", (event) => {
-
-	console.log("listener function", event.target);
-
-});
-
-eventTarget.addEventListener("test", {
-
-	handleEvent(event) {
-
-		console.log("listener object", event.target);
-
-	}
-
-});
-
-eventTarget.dispatchEvent(new Event("test"));
-```
-
-##### Custom Events
-
-```js
-import { Event } from "synthetic-event";
-
-export class MyEvent extends Event {
-
-	constructor(type) {
-
-		super(type);
-
-		this.myData = null;
-
-	}
-
-}
-```
-
-##### Custom EventTargets
-
-```js
-import { Event, EventTarget } from "synthetic-event";
-
-export class MyEventTarget extends EventTarget {
-
-	constructor() {
-
-		super();
-
-		this.myEvent = new Event("tick");
-		setInterval(() => this.dispatchEvent(this.myEvent), 1000);
-
-	}
-
-}
-```
-
-
-## Contributing
-
-Maintain the existing coding style. Add unit tests for any new or changed functionality. Lint and test your code.
+# Synthetic Event
+
+[![CI](https://github.com/vanruesc/synthetic-event/actions/workflows/ci.yml/badge.svg)](https://github.com/vanruesc/synthetic-event/actions/workflows/ci.yml)
+[![Version](https://badgen.net/npm/v/synthetic-event?color=green)](https://www.npmjs.com/package/synthetic-event)
+
+This library provides a simplified implementation of the [EventTarget](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget) interface. The included classes and interfaces can be used to create [synthetic events](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model/Events#creating_and_dispatching_events) and custom event targets in any environment.
+
+If your focus lies on DOM events, please refer to the native [CustomEvent](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent) class. An alternative way to create custom event targets in a browser environment is to use a [DocumentFragment](https://developer.mozilla.org/en/docs/Web/API/Document/createDocumentFragment) as a dummy target.
+
+*[Documentation](https://vanruesc.github.io/synthetic-event)*
+
+## Installation
+
+```sh
+npm install synthetic-event
+``` 
+
+## Usage
+
+##### Basics
+
+```ts
+import { Event, EventTarget } from "synthetic-event";
+
+export interface MyEventMap {
+
+	test: Event<"test">;
+
+}
+
+const eventTarget = new EventTarget<MyEventMap>();
+
+eventTarget.addEventListener("test", (event) => {
+
+	console.log("listener function", event.target);
+
+});
+
+eventTarget.addEventListener("test", {
+
+	handleEvent(event) {
+
+		console.log("listener object", event.target);
+
+	}
+
+});
+
+eventTarget.dispatchEvent({ type: "test" });
+```
+
+##### Custom EventTarget
+
+```ts
+import { Event, EventTarget } from "synthetic-event";
+
+export interface MyEventMap {
+
+	tick: Event<"tick">;
+
+}
+
+export class MyEventTarget extends EventTarget<MyEventMap> {
+
+	private readonly myEvent: Event<"tick">;
+
+	constructor() {
+
+		super();
+
+		this.myEvent = { type: "tick" };
+		setInterval(() => this.dispatchEvent(this.myEvent), 1000);
+
+	}
+
+}
+```
+
+## Contributing
+
+Maintain the existing coding style. Add unit tests for any new or changed functionality. Lint and test your code.

package/dist/index.js

@@ -0,0 +1,131 @@
+/**
+ * synthetic-event v2.0.0 build Sat Jan 10 2026
+ * https://github.com/vanruesc/synthetic-event
+ * Copyright 2026 Raoul van Rüschen
+ * @license Zlib
+ */
+
+// src/EventTarget.ts
+var EventTarget = class {
+  /**
+   * A collection of event listener functions.
+   */
+  listenerFunctions;
+  /**
+   * A collection of event listener objects.
+   */
+  listenerObjects;
+  /**
+   * Constructs a new event target.
+   */
+  constructor() {
+    this.listenerFunctions = /* @__PURE__ */ new Map();
+    this.listenerObjects = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Registers an event handler of a specific event type on the event target.
+   *
+   * @param type - The event type to listen for.
+   * @param listener - An event listener or callback.
+   */
+  addEventListener(type, listener) {
+    if (typeof listener === "function") {
+      if (this.listenerFunctions.has(type)) {
+        const listeners = this.listenerFunctions.get(type);
+        listeners.add(listener);
+      } else {
+        const listeners = /* @__PURE__ */ new Set([listener]);
+        this.listenerFunctions.set(type, listeners);
+      }
+      return;
+    }
+    if (this.listenerObjects.has(type)) {
+      const listeners = this.listenerObjects.get(type);
+      listeners.add(listener);
+    } else {
+      const listeners = /* @__PURE__ */ new Set([listener]);
+      this.listenerObjects.set(type, listeners);
+    }
+  }
+  /**
+   * Removes an event handler of a specific event type from the event target.
+   *
+   * @param type - The event type to remove.
+   * @param listener - The event listener to remove.
+   */
+  hasEventListener(type, listener) {
+    if (typeof listener === "function") {
+      if (!this.listenerFunctions.has(type)) {
+        return false;
+      }
+      const listeners2 = this.listenerFunctions.get(type);
+      return listeners2.has(listener);
+    }
+    if (!this.listenerObjects.has(type)) {
+      return false;
+    }
+    const listeners = this.listenerObjects.get(type);
+    return listeners.has(listener);
+  }
+  /**
+   * Removes an event handler of a specific event type from the event target.
+   *
+   * @param type - The event type to remove.
+   * @param listener - The event listener to remove.
+   */
+  removeEventListener(type, listener) {
+    if (typeof listener === "function") {
+      if (!this.listenerFunctions.has(type)) {
+        return;
+      }
+      const listeners2 = this.listenerFunctions.get(type);
+      if (listeners2.delete(listener) && listeners2.size === 0) {
+        this.listenerFunctions.delete(type);
+      }
+      return;
+    }
+    if (!this.listenerObjects.has(type)) {
+      return;
+    }
+    const listeners = this.listenerObjects.get(type);
+    if (listeners.delete(listener) && listeners.size === 0) {
+      this.listenerObjects.delete(type);
+    }
+  }
+  /**
+   * Dispatches an event at the specified event target, invoking the affected event listeners in the appropriate order.
+   *
+   * Event listeners can safely be added and removed while an event is being dispatched.
+   *
+   * @see https://262.ecma-international.org/#sec-map.prototype.foreach for more information on the iteration behavior.
+   * @param event - The event to dispatch.
+   * @param target - An event target.
+   */
+  dispatchEvent(event, target = this) {
+    const listenerFunctions = target.listenerFunctions;
+    const listenerObjects = target.listenerObjects;
+    event.target = target;
+    if (listenerFunctions.has(event.type)) {
+      const listeners = listenerFunctions.get(event.type);
+      for (const listener of listeners) {
+        listener.call(target, event);
+      }
+    }
+    if (listenerObjects.has(event.type)) {
+      const listeners = listenerObjects.get(event.type);
+      for (const listener of listeners) {
+        listener.handleEvent(event);
+      }
+    }
+  }
+  /**
+   * Removes all listeners.
+   */
+  clearEventListeners() {
+    this.listenerFunctions.clear();
+    this.listenerObjects.clear();
+  }
+};
+export {
+  EventTarget
+};

package/dist/types/Event.d.ts

@@ -0,0 +1,13 @@
+/**
+ * An event.
+ */
+export interface Event<TEventType extends string = string, TTarget = unknown> {
+    /**
+     * The type of the event.
+     */
+    type: TEventType;
+    /**
+     * A reference to the target to which the event was originally dispatched.
+     */
+    target?: TTarget;
+}

package/dist/types/EventListener.d.ts

@@ -0,0 +1,5 @@
+import { Event } from "./Event.js";
+/**
+ * An event listener.
+ */
+export type EventListener<TEventData, TEventType extends string, TTarget = unknown> = (event: TEventData & Event<TEventType, TTarget>) => void;

package/dist/types/EventListenerObject.d.ts

@@ -0,0 +1,12 @@
+import { Event } from "./Event.js";
+/**
+ * An event listener object.
+ */
+export interface EventListenerObject<TEventData, TEventType extends string, TTarget = unknown> {
+    /**
+     * Handles a given event.
+     *
+     * @param event - The event.
+     */
+    handleEvent(event: TEventData & Event<TEventType, TTarget>): void;
+}

package/dist/types/EventTarget.d.ts

@@ -0,0 +1,55 @@
+import { Event } from "./Event.js";
+import { EventListener } from "./EventListener.js";
+import { EventListenerObject } from "./EventListenerObject.js";
+/**
+ * An event target that can dispatch events to registered listeners.
+ */
+export declare class EventTarget<TEventMap extends object = object> {
+    /**
+     * A collection of event listener functions.
+     */
+    protected readonly listenerFunctions: Map<string, Set<EventListener<TEventMap[keyof TEventMap], string, this>>>;
+    /**
+     * A collection of event listener objects.
+     */
+    protected readonly listenerObjects: Map<string, Set<EventListenerObject<TEventMap[keyof TEventMap], string, this>>>;
+    /**
+     * Constructs a new event target.
+     */
+    constructor();
+    /**
+     * Registers an event handler of a specific event type on the event target.
+     *
+     * @param type - The event type to listen for.
+     * @param listener - An event listener or callback.
+     */
+    addEventListener<T extends Extract<keyof TEventMap, string>>(type: T, listener: EventListener<TEventMap[T], T, this> | EventListenerObject<TEventMap[T], T, this>): void;
+    /**
+     * Removes an event handler of a specific event type from the event target.
+     *
+     * @param type - The event type to remove.
+     * @param listener - The event listener to remove.
+     */
+    hasEventListener<T extends Extract<keyof TEventMap, string>>(type: T, listener: EventListener<TEventMap[T], T, this> | EventListenerObject<TEventMap[T], T, this>): boolean;
+    /**
+     * Removes an event handler of a specific event type from the event target.
+     *
+     * @param type - The event type to remove.
+     * @param listener - The event listener to remove.
+     */
+    removeEventListener<T extends Extract<keyof TEventMap, string>>(type: T, listener: EventListener<TEventMap[T], T, this> | EventListenerObject<TEventMap[T], T, this>): void;
+    /**
+     * Dispatches an event at the specified event target, invoking the affected event listeners in the appropriate order.
+     *
+     * Event listeners can safely be added and removed while an event is being dispatched.
+     *
+     * @see https://262.ecma-international.org/#sec-map.prototype.foreach for more information on the iteration behavior.
+     * @param event - The event to dispatch.
+     * @param target - An event target.
+     */
+    dispatchEvent<T extends Extract<keyof TEventMap, string>>(event: Event<T> & TEventMap[T], target?: EventTarget<TEventMap>): void;
+    /**
+     * Removes all listeners.
+     */
+    clearEventListeners(): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Event.js";
+export * from "./EventListener.js";
+export * from "./EventListenerObject.js";
+export * from "./EventTarget.js";

package/package.json

@@ -1,83 +1,77 @@
-{
-	"name": "synthetic-event",
-	"version": "1.1.1",
-	"description": "A collection of base classes for custom events and event targets.",
-	"homepage": "https://github.com/vanruesc/synthetic-event",
-	"main": "build/synthetic-event.js",
-	"module": "build/synthetic-event.esm.js",
-	"types": "build/types/index.d.ts",
-	"exports": {
-		".": "build/synthetic-event.esm.js"
-	},
-	"type": "module",
-	"sideEffects": false,
-	"license": "Zlib",
-	"keywords": [
-		"event",
-		"target",
-		"emitter",
-		"listener",
-		"dispatcher",
-		"synthetic",
-		"custom"
-	],
-	"author": {
-		"name": "Raoul van Rüschen",
-		"email": "vanruesc@outlook.de"
-	},
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/vanruesc/synthetic-event.git"
-	},
-	"bugs": {
-		"url": "https://github.com/vanruesc/synthetic-event/issues"
-	},
-	"files": [
-		"build"
-	],
-	"scripts": {
-		"ava": "ava",
-		"build": "cross-env NODE_ENV=production rollup -c",
-		"build-debug": "rollup -c",
-		"clean": "rimraf build docs",
-		"doc": "typedoc",
-		"dev": "concurrently -k -n rollup,eslint \"rollup -c -w\" \"esw -w --ext .ts src\"",
-		"lint": "eslint src",
-		"prepack": "npm test && npm run doc",
-		"pretest": "npm run lint && npm run clean && npm run build",
-		"test": "ava"
-	},
-	"ava": {
-		"failFast": true,
-		"files": [
-			"test/**/*.js"
-		]
-	},
-	"eslintConfig": {
-		"root": true,
-		"extends": "aether/typescript",
-		"parserOptions": {
-			"project": [
-				"tsconfig.json"
-			]
-		}
-	},
-	"devDependencies": {
-		"@rollup/plugin-node-resolve": "8.x.x",
-		"@rollup/plugin-typescript": "5.x.x",
-		"@typescript-eslint/eslint-plugin": "3.x.x",
-		"@typescript-eslint/parser": "3.x.x",
-		"ava": "3.x.x",
-		"concurrently": "5.x.x",
-		"cross-env": "7.x.x",
-		"eslint": "7.x.x",
-		"eslint-config-aether": "1.x.x",
-		"eslint-watch": "7.x.x",
-		"rimraf": "3.x.x",
-		"rollup": "2.x.x",
-		"rollup-plugin-terser": "7.x.x",
-		"tslib": "2.x.x",
-		"typedoc": "0.x.x",
-		"typescript": "3.x.x"
-	}
-}
+{
+	"name": "synthetic-event",
+	"version": "2.0.0",
+	"description": "A collection of base classes for custom events and event targets.",
+	"homepage": "https://github.com/vanruesc/synthetic-event",
+	"license": "Zlib",
+	"type": "module",
+	"sideEffects": false,
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/types/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/types/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"keywords": [
+		"event",
+		"target",
+		"emitter",
+		"listener",
+		"dispatcher",
+		"synthetic",
+		"custom"
+	],
+	"author": {
+		"name": "Raoul van Rüschen",
+		"email": "vanruesc@outlook.de"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/vanruesc/synthetic-event.git"
+	},
+	"bugs": {
+		"url": "https://github.com/vanruesc/synthetic-event/issues"
+	},
+	"files": [
+		"dist"
+	],
+	"engines": {
+		"node": ">= 21"
+	},
+	"pnpm": {
+		"onlyBuiltDependencies": [
+			"esbuild"
+		]
+	},
+	"scripts": {
+		"build": "run-p build:js:min build:dts",
+		"build:js": "node esbuild",
+		"build:js:min": "node esbuild -m",
+		"build:dts": "tsc -p tsconfig.d.json",
+		"clean": "del-cli dist public",
+		"doc": "typedoc --plugin typedoc-plugin-mdn-links",
+		"lint": "run-p lint:*",
+		"lint:js": "eslint --fix src test",
+		"lint:tsc": "tsc --noEmit",
+		"prepublishOnly": "npm test",
+		"pretest": "run-s clean lint build",
+		"test": "node --import tsx --test",
+		"posttest": "npm run doc"
+	},
+	"devDependencies": {
+		"@types/node": "25.x.x",
+		"del-cli": "7.x.x",
+		"esbuild": "0.27.x",
+		"eslint": "9.x.x",
+		"eslint-config-aether": "2.x.x",
+		"npm-run-all": "4.x.x",
+		"tslib": "2.x.x",
+		"tsx": "4.x.x",
+		"typedoc": "0.x.x",
+		"typedoc-plugin-mdn-links": "5.x.x",
+		"typescript": "5.9.x"
+	}
+}

package/build/synthetic-event.esm.js

@@ -1,59 +0,0 @@
-/**
- * synthetic-event v1.1.1 build Mon Aug 10 2020
- * https://github.com/vanruesc/synthetic-event
- * Copyright 2020 Raoul van Rüschen
- * @license Zlib
- */
-class Event {
-    constructor(type) {
-        this.type = type;
-        this.target = null;
-    }
-}
-
-class EventTarget {
-    constructor() {
-        this.listenerFunctions = new Map();
-        this.listenerObjects = new Map();
-    }
-    addEventListener(type, listener) {
-        const m = (typeof listener === "function") ?
-            this.listenerFunctions : this.listenerObjects;
-        if (m.has(type)) {
-            m.get(type).add(listener);
-        }
-        else {
-            m.set(type, new Set([listener]));
-        }
-    }
-    removeEventListener(type, listener) {
-        const m = (typeof listener === "function") ?
-            this.listenerFunctions : this.listenerObjects;
-        if (m.has(type)) {
-            const listeners = m.get(type);
-            listeners.delete(listener);
-            if (listeners.size === 0) {
-                m.delete(type);
-            }
-        }
-    }
-    dispatchEvent(event, target = this) {
-        const listenerFunctions = target.listenerFunctions;
-        const listenerObjects = target.listenerObjects;
-        event.target = target;
-        if (listenerFunctions.has(event.type)) {
-            const listeners = listenerFunctions.get(event.type);
-            for (const listener of listeners) {
-                listener.call(target, event);
-            }
-        }
-        if (listenerObjects.has(event.type)) {
-            const listeners = listenerObjects.get(event.type);
-            for (const listener of listeners) {
-                listener.handleEvent(event);
-            }
-        }
-    }
-}
-
-export { Event, EventTarget };

package/build/synthetic-event.js

@@ -1,121 +0,0 @@
-/**
- * synthetic-event v1.1.1 build Mon Aug 10 2020
- * https://github.com/vanruesc/synthetic-event
- * Copyright 2020 Raoul van Rüschen
- * @license Zlib
- */
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SYNTHETICEVENT = {}));
-}(this, (function (exports) { 'use strict';
-
-    var Event = (function () {
-        function Event(type) {
-            this.type = type;
-            this.target = null;
-        }
-        return Event;
-    }());
-
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    function __values(o) {
-        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-        if (m) return m.call(o);
-        if (o && typeof o.length === "number") return {
-            next: function () {
-                if (o && i >= o.length) o = void 0;
-                return { value: o && o[i++], done: !o };
-            }
-        };
-        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-    }
-
-    var EventTarget = (function () {
-        function EventTarget() {
-            this.listenerFunctions = new Map();
-            this.listenerObjects = new Map();
-        }
-        EventTarget.prototype.addEventListener = function (type, listener) {
-            var m = (typeof listener === "function") ?
-                this.listenerFunctions : this.listenerObjects;
-            if (m.has(type)) {
-                m.get(type).add(listener);
-            }
-            else {
-                m.set(type, new Set([listener]));
-            }
-        };
-        EventTarget.prototype.removeEventListener = function (type, listener) {
-            var m = (typeof listener === "function") ?
-                this.listenerFunctions : this.listenerObjects;
-            if (m.has(type)) {
-                var listeners = m.get(type);
-                listeners.delete(listener);
-                if (listeners.size === 0) {
-                    m.delete(type);
-                }
-            }
-        };
-        EventTarget.prototype.dispatchEvent = function (event, target) {
-            var e_1, _a, e_2, _b;
-            if (target === void 0) { target = this; }
-            var listenerFunctions = target.listenerFunctions;
-            var listenerObjects = target.listenerObjects;
-            event.target = target;
-            if (listenerFunctions.has(event.type)) {
-                var listeners = listenerFunctions.get(event.type);
-                try {
-                    for (var listeners_1 = __values(listeners), listeners_1_1 = listeners_1.next(); !listeners_1_1.done; listeners_1_1 = listeners_1.next()) {
-                        var listener = listeners_1_1.value;
-                        listener.call(target, event);
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (listeners_1_1 && !listeners_1_1.done && (_a = listeners_1.return)) _a.call(listeners_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-            }
-            if (listenerObjects.has(event.type)) {
-                var listeners = listenerObjects.get(event.type);
-                try {
-                    for (var listeners_2 = __values(listeners), listeners_2_1 = listeners_2.next(); !listeners_2_1.done; listeners_2_1 = listeners_2.next()) {
-                        var listener = listeners_2_1.value;
-                        listener.handleEvent(event);
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (listeners_2_1 && !listeners_2_1.done && (_b = listeners_2.return)) _b.call(listeners_2);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
-            }
-        };
-        return EventTarget;
-    }());
-
-    exports.Event = Event;
-    exports.EventTarget = EventTarget;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-})));

package/build/synthetic-event.min.js

@@ -1,21 +0,0 @@
-/**
- * synthetic-event v1.1.1 build Mon Aug 10 2020
- * https://github.com/vanruesc/synthetic-event
- * Copyright 2020 Raoul van Rüschen
- * @license Zlib
- */
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).SYNTHETICEVENT={})}(this,(function(e){"use strict";var t=function(e){this.type=e,this.target=null};
-/*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */function n(e){var t="function"==typeof Symbol&&Symbol.iterator,n=t&&e[t],r=0;if(n)return n.call(e);if(e&&"number"==typeof e.length)return{next:function(){return e&&r>=e.length&&(e=void 0),{value:e&&e[r++],done:!e}}};throw new TypeError(t?"Object is not iterable.":"Symbol.iterator is not defined.")}var r=function(){function e(){this.listenerFunctions=new Map,this.listenerObjects=new Map}return e.prototype.addEventListener=function(e,t){var n="function"==typeof t?this.listenerFunctions:this.listenerObjects;n.has(e)?n.get(e).add(t):n.set(e,new Set([t]))},e.prototype.removeEventListener=function(e,t){var n="function"==typeof t?this.listenerFunctions:this.listenerObjects;if(n.has(e)){var r=n.get(e);r.delete(t),0===r.size&&n.delete(e)}},e.prototype.dispatchEvent=function(e,t){var r,i,o,l;void 0===t&&(t=this);var s=t.listenerFunctions,a=t.listenerObjects;if(e.target=t,s.has(e.type)){var f=s.get(e.type);try{for(var c=n(f),u=c.next();!u.done;u=c.next()){u.value.call(t,e)}}catch(e){r={error:e}}finally{try{u&&!u.done&&(i=c.return)&&i.call(c)}finally{if(r)throw r.error}}}if(a.has(e.type)){f=a.get(e.type);try{for(var y=n(f),d=y.next();!d.done;d=y.next()){d.value.handleEvent(e)}}catch(e){o={error:e}}finally{try{d&&!d.done&&(l=y.return)&&l.call(y)}finally{if(o)throw o.error}}}},e}();e.Event=t,e.EventTarget=r,Object.defineProperty(e,"__esModule",{value:!0})}));

package/build/types/Event.d.ts

@@ -1,6 +0,0 @@
-import { EventTarget } from "./EventTarget";
-export declare class Event {
-    type: string;
-    target: EventTarget;
-    constructor(type: string);
-}

package/build/types/EventListener.d.ts

@@ -1,4 +0,0 @@
-import { Event } from "./Event";
-export interface EventListener {
-    (event: Event): void;
-}

package/build/types/EventListenerObject.d.ts

@@ -1,4 +0,0 @@
-import { Event } from "./Event";
-export interface EventListenerObject {
-    handleEvent(event: Event): void;
-}

package/build/types/EventTarget.d.ts

@@ -1,11 +0,0 @@
-import { Event } from "./Event";
-import { EventListener } from "./EventListener";
-import { EventListenerObject } from "./EventListenerObject";
-export declare class EventTarget {
-    protected listenerFunctions: Map<string, Set<EventListener>>;
-    protected listenerObjects: Map<string, Set<EventListenerObject>>;
-    constructor();
-    addEventListener(type: string, listener: EventListener | EventListenerObject): void;
-    removeEventListener(type: string, listener: EventListener | EventListenerObject): void;
-    dispatchEvent(event: Event, target?: EventTarget): void;
-}

package/build/types/index.d.ts

@@ -1,4 +0,0 @@
-export { Event } from "./Event";
-export { EventListener } from "./EventListener";
-export { EventListenerObject } from "./EventListenerObject";
-export { EventTarget } from "./EventTarget";