@koine/utils 2.0.0-beta.2 → 2.0.0-beta.200

package/types.d.ts

@@ -1,22 +1,62 @@
-import type { Replace } from "type-fest";
+import type { Replace, Simplify, Exact } from "type-fest";
+/**
+ * Chceck that a type is exactly as another type
+ */
+export type ExactlyAs<Type> = ReturnType<(<T extends Exact<Type, T>>(values: T) => T)>;
+/**
+ * Type to test types
+ *
+ * @category type
+ * @example
+ *
+ * ```ts
+ * type _Test = TestType<
+ *   A extends B ? true : false,
+ *   A & { intruder: 1 } extends B ? false : true
+ * >;
+ * // or, if you want to skip the wrong implementation test, simply
+ * type _Test = TestType<A extends B ? true : false>;
+ * ```
+ */
+export type TestType<RightImplementation extends true, WrongImplementation extends true = true> = RightImplementation | WrongImplementation;
 /**
  * Whatever that in javascript returns `false` when checked in an `if` condition
+ *
+ * @category type
  */
 export type AnythingFalsy = null | undefined | 0 | "";
+/**
+ * Flatten an object bringing the first depth-level of properties to the object
+ * root.
+ *
+ * @borrows [SO' answer by jcalz](https://stackoverflow.com/a/78779784/1938970)
+ * @category type
+ */
+export type FlatObjectFirstLevel<T extends object> = {
+    [K in keyof T]: (x: T[K]) => void;
+} extends Record<keyof T, (x: infer I) => void> ? {
+    [K in keyof I]: I[K];
+} : never;
 /**
  * Pick the keys of an object `T` that starts with `S`. It produces a mapped type
  * with a subset of `T` whose keys start with `S`.
+ *
+ * @category type
  */
 export type PickStartsWith<T extends object, S extends string> = {
     [K in keyof T as K extends `${S}${string}` ? K : never]: T[K];
 };
 /**
  * Returns a union of all the keys of an object `T` which starts with `S`.
+ *
+ * @category type
  */
 export type KeysStartsWith<T extends object, S extends string> = keyof PickStartsWith<T, S>;
 /**
  * Pick the keys of an object `T` that starts with `S`. It produces a mapped type
  * with a subset of `T` whose keys start with `S` *and have `S`* removed.
+ *
+ * @category type
  */
 export type PickStartsWithTails<T extends object, S extends string> = {
     [K in keyof T as K extends `${S}${string}` ? Replace<K, S, ""> : never]: T[K];
@@ -24,5 +64,95 @@ export type PickStartsWithTails<T extends object, S extends string> = {
 /**
  * Returns a union of all the keys of an object `T` which starts with `S`.
  * The strings in the produced union *have `S` removed*.
+ *
+ * @category type
  */
 export type KeysTailsStartsWith<T extends object, S extends string> = keyof PickStartsWithTails<T, S>;
+/**
+ * @borrows [Matt Pocock's _Get Keys of an Object Where Values Are of a Given Type_](https://www.totaltypescript.com/get-keys-of-an-object-where-values-are-of-a-given-type)
+ * @category type
+ */
+export type KeysOfValue<T, TCondition> = {
+    [K in keyof T]: T[K] extends TCondition ? K : never;
+}[keyof T];
+/**
+ * @borrows [SO's answer by 钵钵鸡实力代购](https://stackoverflow.com/a/64994122/1938970)
+ */
+export type Reverse<Tuple> = Tuple extends [infer Head, ...infer Rest] ? [...Reverse<Rest>, Head] : [];
+/**
+ * Make _nullable_ all properties of objec T (deeply)
+ * @use `{ key: $ | null }`
+ *
+ * @category type
+ */
+export type NullableObjectDeep<T extends object> = {
+    [K in keyof T]: T[K] extends object ? NullableObjectDeep<T[K]> | null : T[K] | null;
+};
+/**
+ * Make _non nullable_ all properties of objec T (deeply)
+ * @use `{ key: NonNullable<$> }`
+ *
+ * @category type
+ */
+export type NonNullableObjectDeep<T extends object> = {
+    [K in keyof T]: T[K] extends object ? NonNullableObjectDeep<NonNullable<T[K]>> : NonNullable<T[K]>;
+};
+/**
+ * Make _required_ all properties of objec T (deeply)
+ * @use `{ key-?: Exclude<$, undefined> }`
+ *
+ * @category type
+ */
+export type RequiredObjectDeep<T extends object> = Simplify<{
+    [K in keyof T]-?: T[K] extends object ? Exclude<RequiredObjectDeep<T[K]>, undefined> : Exclude<T[K], undefined>;
+}>;
+/**
+ * Make _required_ and _non nullable_ all properties of objec T (deeply)
+ * @use `{ key-?: NonNullable<$> }`
+ *
+ * @category type
+ */
+export type RequiredNonNullableObjectDeep<T extends object> = Simplify<{
+    [K in keyof T]-?: T[K] extends object ? NonNullable<RequiredNonNullableObjectDeep<T[K]>> : NonNullable<T[K]>;
+}>;
+/**
+ * Construct a type with the properties of T except for those whose value is `never`
+ *
+ * @category type
+ *
+@example
+```ts
+type A = OmitNever<"a" | never>; // A = "a"
+type B = OmitNever<{ a: never; b: 1 }> // B = { b: 1; }
+```
+ */
+export type OmitNever<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+export type OverloadsToTuple<T> = OverloadsToTuple5<T>;
+type OverloadsToTuple5<T> = T extends {
+    (...args: infer P1): infer R1;
+    (...args: infer P2): infer R2;
+    (...args: infer P3): infer R3;
+    (...args: infer P4): infer R4;
+    (...args: infer P5): infer R5;
+} ? [(...args: P1) => R1, (...args: P2) => R2, (...args: P3) => R3, (...args: P4) => R4, (...args: P5) => R5] : OverloadsToTuple4<T>;
+type OverloadsToTuple4<T> = T extends {
+    (...args: infer P1): infer R1;
+    (...args: infer P2): infer R2;
+    (...args: infer P3): infer R3;
+    (...args: infer P4): infer R4;
+} ? [(...args: P1) => R1, (...args: P2) => R2, (...args: P3) => R3, (...args: P4) => R4] : OverloadsToTuple3<T>;
+type OverloadsToTuple3<T> = T extends {
+    (...args: infer P1): infer R1;
+    (...args: infer P2): infer R2;
+    (...args: infer P3): infer R3;
+} ? [(...args: P1) => R1, (...args: P2) => R2, (...args: P3) => R3] : OverloadsToTuple2<T>;
+type OverloadsToTuple2<T> = T extends {
+    (...args: infer P1): infer R1;
+    (...args: infer P2): infer R2;
+} ? [(...args: P1) => R1, (...args: P2) => R2] : OverloadsToTuple1<T>;
+type OverloadsToTuple1<T> = T extends {
+    (...args: infer P1): infer R1;
+} ? [(...args: P1) => R1] : never;
+export {};

package/types.esm.js

@@ -0,0 +1 @@
+

package/typings.d.ts

@@ -1,9 +1,37 @@
 /**
  * List here the global variables used by third party scripts supported within
- * the `koine` ecosystem. For instance Google Analytics globally available
- * variables.
+ * the `koine` ecosystem.
  */
 
-// declare type NullableRecord<T> = {
-//   [K in keyof T]: T[K] | null;
-// };
+declare type AssertTrue<T extends true> = T;
+
+// as in type-fest start
+declare type Simplify<T> = { [KeyType in keyof T]: T[KeyType] };
+// as in type-fest end
+
+/**
+ * Tweak a model by making some properties required (not `optional` and not `nullable`)
+ *
+ * This is useful to tweak/correct the types generated from Swagger.
+ */
+declare type Tweak<
+  TModel extends object,
+  TRequiredKeys extends keyof TModel | never,
+  TReplacements extends Partial<Record<keyof TModel, unknown>> | false = false,
+> = TReplacements extends false
+  ? Simplify<
+      Omit<TModel, TRequiredKeys> &
+        Required<{
+          [K in TRequiredKeys]: NonNullable<TModel[K]>;
+        }>
+    >
+  : Simplify<
+      Omit<
+        Omit<TModel, TRequiredKeys> &
+          Required<{
+            [K in TRequiredKeys]: NonNullable<TModel[K]>;
+          }>,
+        keyof TReplacements
+      > &
+        TReplacements
+    >;

package/uid.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./uid.cjs.js').default;

package/uid.cjs.js

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+let e=0;let uid=(t="id")=>(e++,`${t}-${e}`);
+
+exports.default = uid;
+exports.uid = uid;

package/uid.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './uid.cjs.js';
+export { _default as default } from './uid.cjs.default.js';

package/uid.d.ts

@@ -3,5 +3,5 @@
  *
  * @category uid
  */
-export declare const uid: (prefix?: string) => string;
+export declare let uid: (prefix?: string) => string;
 export default uid;

package/uid.esm.js

@@ -0,0 +1,3 @@
+let e=0;let uid=(t="id")=>(e++,`${t}-${e}`);
+
+export { uid as default, uid };

package/updateLinkParams.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./updateLinkParams.cjs.js').default;

package/updateLinkParams.cjs.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var updateUrlQueryParams = require('./updateUrlQueryParams.cjs.js');
+
+let updateLinkParams=(e,a)=>{let t=updateUrlQueryParams.updateUrlQueryParams(e.href,a);return e.href=t,t};
+
+exports.default = updateLinkParams;
+exports.updateLinkParams = updateLinkParams;

package/updateLinkParams.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './updateLinkParams.cjs.js';
+export { _default as default } from './updateLinkParams.cjs.default.js';

package/updateLinkParams.d.ts

@@ -1,4 +1,4 @@
-import { type AnyQueryParams } from "./location";
+import type { AnyQueryParams } from "./location";
 /**
  * Update link `<a href="">` merging the given new query parameters.
  * it returns the newly created `href` URL value
@@ -6,5 +6,5 @@ import { type AnyQueryParams } from "./location";
  * @category location
  * @pure
  */
-export declare function updateLinkParams($anchor: HTMLAnchorElement, newParams: NonNullable<AnyQueryParams>): string;
+export declare let updateLinkParams: ($anchor: HTMLAnchorElement, newParams: NonNullable<AnyQueryParams>) => string;
 export default updateLinkParams;

package/updateLinkParams.esm.js

@@ -0,0 +1,5 @@
+import { updateUrlQueryParams } from './updateUrlQueryParams.esm.js';
+
+let updateLinkParams=(e,a)=>{let t=updateUrlQueryParams(e.href,a);return e.href=t,t};
+
+export { updateLinkParams as default, updateLinkParams };

package/updateUrlQueryParams.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./updateUrlQueryParams.cjs.js').default;

package/updateUrlQueryParams.cjs.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var buildUrlQueryString = require('./buildUrlQueryString.cjs.js');
+var getUrlQueryParams = require('./getUrlQueryParams.cjs.js');
+var mergeUrlQueryParams = require('./mergeUrlQueryParams.cjs.js');
+
+let updateUrlQueryParams=(a,m={})=>{let l=a.split("?"),u=l[1]?mergeUrlQueryParams.mergeUrlQueryParams(getUrlQueryParams.getUrlQueryParams(a),m):m;return l[0]+buildUrlQueryString.buildUrlQueryString(u)};
+
+exports.default = updateUrlQueryParams;
+exports.updateUrlQueryParams = updateUrlQueryParams;

package/updateUrlQueryParams.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './updateUrlQueryParams.cjs.js';
+export { _default as default } from './updateUrlQueryParams.cjs.default.js';

package/updateUrlQueryParams.d.ts

@@ -1,9 +1,8 @@
-import { type AnyQueryParams } from "./location";
+import type { AnyQueryParams } from "./location";
 /**
  * Update a URL string query parameters merging the given new query parameters
  *
  * @category location
- * @pure
  */
-export declare function updateUrlQueryParams(url: string, newParams?: NonNullable<AnyQueryParams>): string;
+export declare let updateUrlQueryParams: (url: string, newParams?: NonNullable<AnyQueryParams>) => string;
 export default updateUrlQueryParams;

package/updateUrlQueryParams.esm.js

@@ -0,0 +1,7 @@
+import { buildUrlQueryString } from './buildUrlQueryString.esm.js';
+import { getUrlQueryParams } from './getUrlQueryParams.esm.js';
+import { mergeUrlQueryParams } from './mergeUrlQueryParams.esm.js';
+
+let updateUrlQueryParams=(a,m={})=>{let l=a.split("?"),u=l[1]?mergeUrlQueryParams(getUrlQueryParams(a),m):m;return l[0]+buildUrlQueryString(u)};
+
+export { updateUrlQueryParams as default, updateUrlQueryParams };

package/uppercase.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./uppercase.cjs.js').default;

package/uppercase.cjs.js

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+let uppercase=e=>(e||"").toUpperCase();
+
+exports.default = uppercase;
+exports.uppercase = uppercase;

package/uppercase.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './uppercase.cjs.js';
+export { _default as default } from './uppercase.cjs.default.js';

package/uppercase.d.ts

@@ -2,6 +2,7 @@
  * Replacement for native `toUpperCase` tyescript ready (type narrowing ready)
  *
  * @category native
+ * @category text
  */
-export declare const uppercase: <T extends string>(str?: T | null | undefined) => Uppercase<T>;
+export declare let uppercase: <T extends string>(str?: null | T) => Uppercase<T>;
 export default uppercase;

package/uppercase.esm.js

@@ -0,0 +1,3 @@
+let uppercase=e=>(e||"").toUpperCase();
+
+export { uppercase as default, uppercase };

package/urlSearchParamsSerializer.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./urlSearchParamsSerializer.cjs.js').default;

package/urlSearchParamsSerializer.cjs.js

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const urlSearchParamsSerializer=(e,r)=>{let t=Object.keys(e).reduce((r,t)=>(r[t]=e[t][1],r),{}),l=e=>r?`${r}_${e}`:e,a=Object.keys(e).reduce((r,t)=>(r[t]=l(e[t][0]),r),{});return {names:Object.values(a),toNames:a,defaults:t,fromUrl:r=>{let t={};for(let a in e){let[u,c,o]=e[a],s=r.get(l(u));t[a]=s?o(s):c;}return t},toUrl:r=>{let a={};for(let u in t){let[t,c,,o]=e[u],s=o(r[u]??c);s&&(a[l(t)]=s);}return a}}};
+
+exports.default = urlSearchParamsSerializer;
+exports.urlSearchParamsSerializer = urlSearchParamsSerializer;

package/urlSearchParamsSerializer.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './urlSearchParamsSerializer.cjs.js';
+export { _default as default } from './urlSearchParamsSerializer.cjs.default.js';

package/urlSearchParamsSerializer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @param {string} searchParamName
+ * @param {any} defaultValue
+ * @param {(valueFromUrl: string) => DefaultValue} serializeFromUrlSearchParamValue
+ * @param {(valueToUrl: DefaultValue) => string}  serializeToUrlSearchParamValue
+ */
+export type UrlSearchParamSerializer<NameInUrl extends string, DefaultValue> = [
+    NameInUrl,
+    DefaultValue,
+    (valueFromUrl: string) => DefaultValue,
+    (valueToUrl: DefaultValue) => string
+];
+export declare const urlSearchParamsSerializer: <Serializers extends Record<string, UrlSearchParamSerializer<any, any>>, Prefix extends string | undefined>(serializers: Serializers, prefix?: Prefix) => {
+    /**
+     * Array of the search params `names` as they appear in the URL
+     */
+    names: { [Key in keyof Serializers]: Prefix extends undefined ? Serializers[Key][0] : `${Prefix}_${Serializers[Key][0]}`; }[keyof Serializers][];
+    /**
+     * Map of the search params `state` name to the `name` as it appears in the URL
+     */
+    toNames: { [Key in keyof Serializers]: Prefix extends undefined ? Serializers[Key][0] : `${Prefix}_${Serializers[Key][0]}`; };
+    /**
+     * Default state of the search params value
+     */
+    defaults: { [Key_1 in keyof Serializers]: Serializers[Key_1][1]; };
+    /**
+     * Deserialize search params state from the URL ones
+     */
+    fromUrl: (searchParams: URLSearchParams) => { [Key_2 in keyof Serializers]: Serializers[Key_2][1]; };
+    /**
+     * Serialize state to URL search params
+     */
+    toUrl: (data: { [Key_2 in keyof Serializers]?: Serializers[Key_2][1]; }) => Record<string, string>;
+};
+export default urlSearchParamsSerializer;

package/urlSearchParamsSerializer.esm.js

@@ -0,0 +1,3 @@
+const urlSearchParamsSerializer=(e,r)=>{let t=Object.keys(e).reduce((r,t)=>(r[t]=e[t][1],r),{}),l=e=>r?`${r}_${e}`:e,a=Object.keys(e).reduce((r,t)=>(r[t]=l(e[t][0]),r),{});return {names:Object.values(a),toNames:a,defaults:t,fromUrl:r=>{let t={};for(let a in e){let[u,c,o]=e[a],s=r.get(l(u));t[a]=s?o(s):c;}return t},toUrl:r=>{let a={};for(let u in t){let[t,c,,o]=e[u],s=o(r[u]??c);s&&(a[l(t)]=s);}return a}}};
+
+export { urlSearchParamsSerializer as default, urlSearchParamsSerializer };

package/uuid.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./uuid.cjs.js').default;

package/uuid.cjs.js

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+let uuid=()=>"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,x=>{let t=16*Math.random()|0;return ("x"==x?t:3&t|8).toString(16)});
+
+exports.default = uuid;
+exports.uuid = uuid;

package/uuid.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './uuid.cjs.js';
+export { _default as default } from './uuid.cjs.default.js';

package/uuid.d.ts

@@ -4,5 +4,5 @@
  * @category uid
  * @see https://stackoverflow.com/a/2117523/1938970
  */
-export declare const uuid: () => string;
+export declare let uuid: () => string;
 export default uuid;

package/uuid.esm.js

@@ -0,0 +1,3 @@
+let uuid=()=>"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,x=>{let t=16*Math.random()|0;return ("x"==x?t:3&t|8).toString(16)});
+
+export { uuid as default, uuid };

package/uuidNumeric.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./uuidNumeric.cjs.js').default;

package/uuidNumeric.cjs.js

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+let uuidNumeric=()=>new Date().valueOf();
+
+exports.default = uuidNumeric;
+exports.uuidNumeric = uuidNumeric;

package/uuidNumeric.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './uuidNumeric.cjs.js';
+export { _default as default } from './uuidNumeric.cjs.default.js';

package/uuidNumeric.d.ts

@@ -2,5 +2,5 @@
  * @category uid
  * @see https://stackoverflow.com/a/18048162/1938970
  */
-export declare const uuidNumeric: () => number;
+export declare let uuidNumeric: () => number;
 export default uuidNumeric;

package/uuidNumeric.esm.js

@@ -0,0 +1,3 @@
+let uuidNumeric=()=>new Date().valueOf();
+
+export { uuidNumeric as default, uuidNumeric };

package/wait.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./wait.cjs.js').default;

package/wait.cjs.js

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+let wait=e=>new Promise(t=>setTimeout(t,e));
+
+exports.default = wait;
+exports.wait = wait;

package/wait.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './wait.cjs.js';
+export { _default as default } from './wait.cjs.default.js';

package/wait.d.ts

@@ -3,5 +3,5 @@
  *
  * @category async
  */
-export declare const wait: (milliseconds: number) => Promise<unknown>;
+export declare let wait: (milliseconds: number) => Promise<unknown>;
 export default wait;

package/wait.esm.js

@@ -0,0 +1,3 @@
+let wait=e=>new Promise(t=>setTimeout(t,e));
+
+export { wait as default, wait };

package/without.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./without.cjs.js').default;

package/without.cjs.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/without.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './without.cjs.js';
+export { _default as default } from './without.cjs.default.js';

package/without.esm.js

@@ -0,0 +1 @@
+

package/Defer.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Defer = void 0;
-/**
- * @category async
- * @see https://stackoverflow.com/a/37673534/1938970
- * @example
- *
- * ```ts
- * const deferred = Defer();
- * deferred.resolve();
- * deferred.then(handleSuccess, handleError);
- * ```
- */
-function Defer() {
-    // @ts-expect-error nevermind
-    var self = this || {};
-    var p = (self.promise = new Promise(function (resolve, reject) {
-        self.resolve = resolve;
-        self.reject = reject;
-    }));
-    self.then = p.then.bind(p);
-    self.catch = p.catch.bind(p);
-    // if (p.finally) {
-    //   self.finally = p.finally.bind(p);
-    // }
-    return self;
-}
-exports.Defer = Defer;
-exports.default = Defer;

package/Defer.mjs

@@ -1,26 +0,0 @@
-/**
- * @category async
- * @see https://stackoverflow.com/a/37673534/1938970
- * @example
- *
- * ```ts
- * const deferred = Defer();
- * deferred.resolve();
- * deferred.then(handleSuccess, handleError);
- * ```
- */
-export function Defer() {
-    // @ts-expect-error nevermind
-    var self = this || {};
-    var p = (self.promise = new Promise(function (resolve, reject) {
-        self.resolve = resolve;
-        self.reject = reject;
-    }));
-    self.then = p.then.bind(p);
-    self.catch = p.catch.bind(p);
-    // if (p.finally) {
-    //   self.finally = p.finally.bind(p);
-    // }
-    return self;
-}
-export default Defer;

package/Emitter.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Emitter = void 0;
-/**
- * Emitter super simple class
- *
- * Events will be prefixed with the given `namespace` plus a `.` so:
- * `{namespace}.myevent`
- *
- * Adapted from https://github.com/developit/mitt
- *
- * Regarding typescript support @see:
- * - https://stackoverflow.com/q/53299743/1938970
- * - https://github.com/Microsoft/TypeScript/pull/26349
- */
-function Emitter(namespace) {
-    var all = new Map();
-    return {
-        /**
-         * Register an event handler for the given type.
-         */
-        on: function (name, handler) {
-            var handlers = all.get("".concat(namespace, ".").concat(String(name)));
-            var added = handlers && handlers.push(handler);
-            if (!added) {
-                all.set("".concat(namespace, ".").concat(String(name)), [handler]);
-            }
-        },
-        /**
-         * Invoke all handlers for the given type.
-         */
-        emit: function (name, data) {
-            (all.get("".concat(namespace, ".").concat(String(name))) || [])
-                .slice()
-                .map(function (handler) {
-                handler(data);
-            });
-        },
-    };
-}
-exports.Emitter = Emitter;
-exports.default = Emitter;