danholibraryjs 1.5.0 → 1.8.0

package/tsconfig.json

@@ -1,10 +1,102 @@
 {
   "compilerOptions": {
-    "module": "commonjs",
-    "target": "esnext",
-    "declaration": true,
-    "outDir": "./dist",
-    "resolveJsonModule": true,
-    "watch": true
-  }
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Enable incremental compilation */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./",                          /* Specify the folder for .tsbuildinfo incremental compilation files. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "esnext",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "lib": ["ESNext", "DOM"],                                   /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h' */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.` */
+    // "reactNamespace": "",                             /* Specify the object invoked for `createElement`. This only applies when targeting `react` JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    "rootDir": "./src",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like `./node_modules/@types`. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    "resolveJsonModule": true,                        /* Enable importing .json files */
+    // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
+
+    /* Emit */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have `@internal` in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like `__extends` in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing `const enum` declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied `any` type.. */
+    // "strictNullChecks": true,                         /* When type checking, take into account `null` and `undefined`. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for `bind`, `call`, and `apply` methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when `this` is given the type `any`. */
+    // "useUnknownInCatchVariables": true,               /* Type catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when a local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Include 'undefined' in index signature results */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true,                                /* Skip type checking all .d.ts files. */
+    "watch": true,
+  },
 }

package/dist/Extensions.d.ts

@@ -1,85 +0,0 @@
-import ElementOptions from "./Interfaces/ElementOptions";
-import IReplacement from "./Interfaces/IReplacement";
-declare global {
-    interface Document {
-        /**
-         * Creates an element like Document#createElement, however with construction options to assign values in construction instead of after construction.
-         * @param tagName HTMLElement tag name
-         * @param options Construction options, instead of assigning values after construction
-         */
-        createProperElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementOptions): HTMLElementTagNameMap[K];
-    }
-    interface HTMLCollection {
-        /**
-         * Converts HTMLCollection to Element[]
-         */
-        array(): Element[];
-    }
-    interface Array<T> {
-        /**
-         * Pushes items to array and returns self with new items
-         * @param items Items to add to array
-         */
-        add(...items: Array<T>): this;
-        /**
-         * Removes item from array and returns self without item
-         * @param item Item to remove
-         */
-        remove(item: T): this;
-        /**
-         * Returns a random element from array
-         */
-        random(): T;
-    }
-    interface Map<K, V> {
-        /**
-         * Converts into Array<[Key, Value]>
-         */
-        array(): [K, V][];
-        /**
-         * Maps values into new types of generics
-         * @param callback Callbacking function to map values
-         */
-        map<EK, EV>(callback: (value: V, key?: K, index?: number, map?: this) => [EK, EV]): Map<EK, EV>;
-        /**
-         * Returns array of "accepted" values. Criteria defined in callback param
-         * @param callback Callbacking function to filter away unwanted values
-         */
-        filter(callback: (value: V, key?: K, index?: number, map?: Map<K, V>) => boolean): Map<K, V>;
-        /**
-         * Returns array of keys
-         */
-        keyArr(): Array<K>;
-        /**
-         * Returns array of values
-         */
-        valueArr(): Array<V>;
-        /**
-         * Returns first [key, value] match to callback param
-         * @param callback Callbacking function to find KeyValuePair
-         */
-        find(callback: (value: V, key?: K, index?: number, map?: Map<K, V>) => boolean): [K, V];
-        /**
-         * Whether or not map includes a  value. Returns true if it does, false if not ¯\_(ツ)_/¯
-         * @param value Value that may be includded in map
-         * @param fromIndex Start looking for value from specific index+. Default: 0
-         */
-        includes(value: V, fromIndex?: number): boolean;
-    }
-    interface String {
-        /**
-         * Uppercases first letter of string
-         */
-        toPascalCase(): string;
-        /**
-         * Replaces "replacer" (default: ' ') with "replacement" (default: '_')
-         * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
-         */
-        toSnakeCase(replaceOptions?: IReplacement): string;
-        /**
-         * Replaces "replacer" (default: ' ') with "replacement" (default: '-')
-         * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
-         */
-        toKebabCase(replaceOptions?: IReplacement): string;
-    }
-}

package/dist/Extensions.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-Document.prototype.createProperElement = function (tagName, options) {
-    let baseElement = document.createElement(tagName);
-    if (!options)
-        return baseElement;
-    if (options.classes) {
-        baseElement.classList.add(...options.classes);
-    }
-    if (options.attributes) {
-        options.attributes.forEach(([attribute, value]) => baseElement.setAttribute(attribute, value));
-    }
-    if (options.children) {
-        baseElement.append(...[].concat(options.children));
-    }
-    if (options.events) {
-        options.events.forEach(({ name, handler }) => (baseElement.addEventListener(name, handler)));
-    }
-    return baseElement;
-};
-HTMLCollection.prototype.array = function () {
-    let result = new Array();
-    for (let i = 0; i < this.length; i++) {
-        result.push(this.item(i));
-    }
-    return result;
-};
-Array.prototype.add = function (...items) {
-    this.push(...items);
-    return this;
-};
-Array.prototype.remove = function (item) {
-    const itemInArray = this.includes(item) ? item : this.find(i => i == item);
-    if (!itemInArray)
-        throw new Error(`item is not in array!`);
-    const itemIndex = this.indexOf(itemInArray);
-    this.splice(itemIndex, 1);
-    return this;
-};
-Array.prototype.random = function () {
-    const randomIndex = Math.round(Math.random() * this.length);
-    return this[randomIndex];
-};
-Map.prototype.array = function () {
-    let result = new Array();
-    for (const kvp of this) {
-        result.push(kvp);
-    }
-    return result;
-};
-Map.prototype.map = function (callback) {
-    return this.array()
-        .map(([k, v], i) => callback(v, k, i, this))
-        .reduce((map, [key, value]) => map.set(key, value), new Map());
-};
-Map.prototype.filter = function (callback) {
-    return this.array()
-        .filter(([k, v], i) => callback(v, k, i, this))
-        .reduce((map, [key, value]) => map.set(key, value), new Map());
-};
-Map.prototype.keyArr = function () {
-    return this.array().map(([k]) => k);
-};
-Map.prototype.valueArr = function () {
-    return this.array().map(([_, v]) => v);
-};
-Map.prototype.find = function (callback) {
-    return this.array().find(([k, v], i) => callback(v, k, i, this));
-};
-Map.prototype.includes = function (item, fromIndex) {
-    return this.valueArr().includes(item, fromIndex);
-};
-String.prototype.toPascalCase = function () {
-    return this.substring(0, 1).toUpperCase() + this.substring(1);
-};
-function spaceReplacer(self, replacer, replacement) {
-    return self.replace(new RegExp(`${typeof replacer == 'string' ? replacer : replacer.source}+`), replacement);
-}
-String.prototype.toSnakeCase = function (replaceOptions = { replacer: ' ', replacement: '_' }) {
-    return spaceReplacer(this, replaceOptions.replacer, replaceOptions.replacement);
-};
-String.prototype.toKebabCase = function (replaceOptions = { replacer: ' ', replacement: '-' }) {
-    return spaceReplacer(this, replaceOptions.replacer, replaceOptions.replacement);
-};

package/dist/Interfaces/BaseEventInterface.d.ts

@@ -1,4 +0,0 @@
-export interface BaseEvent {
-    error: [err: Error];
-}
-export default BaseEvent;

package/dist/Interfaces/IHTMLEvent.d.ts

@@ -1,4 +0,0 @@
-export default interface IHTMLEvent<E extends keyof HTMLElementEventMap> {
-    name: E;
-    handler: (e: HTMLElementEventMap[E]) => any;
-}

package/dist/Types/EventHandler.d.ts

@@ -1,7 +0,0 @@
-import BaseEvent from "../Interfaces/BaseEventInterface";
-/**
- * Eventhandler type for:
- * @see EventCollection
- */
-export declare type EventHandler<Events extends BaseEvent, Event extends keyof Events, ReturnType = any> = (args: Events[Event]) => ReturnType;
-export default EventHandler;

package/dist/Types/IElement.d.ts

@@ -1,9 +0,0 @@
-/**
- * Used for HTMLElement.append in ElementOptions, Document.createProperElement.
- * IElement accepts HTML Elements or HTMl-like strings.
- *
- * @see HTMLElement.append
- * @see Document.createProperElement
- */
-export declare type IElement = HTMLElement | string;
-export default IElement;

package/dist/Types/StringRegex.d.ts

@@ -1,2 +0,0 @@
-export declare type StringRegex = string | RegExp;
-export default StringRegex;

package/src/Classes/EventCollection.ts

@@ -1,116 +0,0 @@
-import BaseEvent from "../Interfaces/BaseEventInterface";
-import EventHandler from "../Types/EventHandler";
-import Event from './Event';
-
-/**
- * Collection of Events from @see EventEmitter
- * @borrows EventHandler
- * @borrows Event
- */
- export class EventCollection<Events extends BaseEvent> {
-    constructor(events?: Map<keyof Events, EventHandler<Events, keyof Events>[]>) {
-        this._events = !events ? 
-            new Map<keyof Events, Event<Events>>() : 
-            events.array().reduce((result, [event, handlers]) => 
-                result.set(event, new Event<Events>(event, ...handlers)), 
-            new Map<keyof Events, Event<Events>>());
-    }
-
-    /**Amount of events stored*/
-    public get size() {
-        return this._events.size;
-    }
-    /**@private Internal event collection*/
-    private _events = new Map<keyof Events, Event<Events>>();
-    /**@private limit of events*/
-    private _limit = 0;
-
-    /**
-     * Returns true if event is in collection
-     * @param event Event name
-     * @returns true if event is in collection
-     */
-    public has(event: keyof Events): boolean { 
-        return this._events.has(event); 
-    }
-    /**
-     * Returns event matching event parameter
-     * @param event Event name
-     * @returns Event
-     */
-    public get<T = any>(event: keyof Events): Event<Events> { 
-        return this._events.get(event); 
-    }
-    /**
-     * Adds handler to event collection with name as key
-     * @param name Event name
-     * @param handler Handler for event
-     * @returns this
-     */
-    public add(name: keyof Events, handler: EventHandler<Events, keyof Events>, once = false): this {
-        if (this._limit > 0 && this._limit + 1 > this._events.size) {
-            throw new Error(`Listener limit, ${this._limit}, reached!`);
-        }
-
-        const event = this.has(name) && this.get(name);
-
-        if (once) this._events.set(name, event ? event.once(handler) : new Event<Events>(name).once(handler))
-        else this._events.set(name, event ? event.on(handler) : new Event(name, handler));
-        return this;
-    }
-    /**
-     * @summary clear(): Clears all events
-     * @summary clear("all", myEventHandler): Removes myEventHandler from all events that have it
-     * @summary clear("myEvent"): Clears all handlers tied to "myEvent"
-     * @summary clear("myEvent", myEventHandler): Removes myEventHandler from "myEvent"
-     * 
-     * @param name Event name | "all"
-     * @param handler Specific handler to remove. If left blank, all handlers in name will be removed
-     * @returns this
-     */
-    public clear(name: keyof Events | "all" = 'all', handler?: EventHandler<Events, keyof Events>): this {
-        //clear(): Clears all events
-        if ((name as string).toLowerCase() == 'all' && handler == null) this._events.clear();           
-
-        //clear("all", myEventHandler): Removes the "myEventHandler" handler from all events
-        else if ((name as string).toLowerCase() == 'all' && handler) this._events = (() => {
-            const eventNames = this._events.array().map(([name, event]) => event.includes(handler) && name);
-            this._events.forEach((event, name) => 
-                eventNames.includes(name) && 
-                this._events.set(name, event.off(handler)
-            ));
-
-            return this._events;
-        })();
-
-        //clear("myEvent"): Deletes myEvent from this._events
-        else if ((name as string).toLowerCase() != "all" && handler == null) this._events.delete(name as keyof Events);
-
-         //clear("myEvent", myEventHandler): Removes the "myEventsHandler" handler from "myEvent"
-        else if ((name as string).toLowerCase() != 'all' && handler) this._events.set(name as keyof Events, this.get(name as keyof Events).off(handler));
-        
-        return this;
-    }
-
-    public emit<Event extends keyof Events>(name: Event, args: Events[Event]) {
-        return this.get(name).emit(args);
-    }
-
-    /**
-     * Limits how many events to accept using EventEmitter#on or EventEmitter#once
-     * @param limit Limit of events to keep
-     * @returns this with the new limit
-     * 
-     * @throws Unknown event, if event name isn't recognized
-     */
-     public limit<Event extends keyof Events>(event: 'all' | Event, limit: number) {
-        if (limit <= 0) return;
-
-        if (event == 'all') this._limit = limit;
-        else if (this.has(event)) this.get(event).limit = limit;
-        else throw new Error(`Unknown event, ${event}!`);
-
-        return this;
-    }
-}
-export default EventCollection;

package/src/Extensions.ts

@@ -1,185 +0,0 @@
-import ElementOptions from "./Interfaces/ElementOptions";
-import IReplacement from "./Interfaces/IReplacement";
-
-declare global {
-    interface Document {
-        /**
-         * Creates an element like Document#createElement, however with construction options to assign values in construction instead of after construction.
-         * @param tagName HTMLElement tag name
-         * @param options Construction options, instead of assigning values after construction
-         */
-        createProperElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementOptions): HTMLElementTagNameMap[K]
-    }
-    interface HTMLCollection {
-        /**
-         * Converts HTMLCollection to Element[]
-         */
-        array(): Element[]
-    }
-    interface Array<T> {
-        /**
-         * Pushes items to array and returns self with new items
-         * @param items Items to add to array
-         */
-        add(...items: Array<T>): this
-        /**
-         * Removes item from array and returns self without item
-         * @param item Item to remove
-         */
-        remove(item: T): this
-        /**
-         * Returns a random element from array
-         */
-        random(): T
-    }
-    interface Map<K, V> {
-        /**
-         * Converts into Array<[Key, Value]>
-         */
-        array(): [K, V][]
-        /**
-         * Maps values into new types of generics
-         * @param callback Callbacking function to map values
-         */
-        map<EK, EV>(callback: (value: V, key?: K, index?: number, map?: this) => [EK, EV]): Map<EK, EV>
-        /**
-         * Returns array of "accepted" values. Criteria defined in callback param
-         * @param callback Callbacking function to filter away unwanted values
-         */
-        filter(callback: (value: V, key?: K, index?: number, map?: Map<K, V>) => boolean): Map<K, V>
-        /**
-         * Returns array of keys
-         */
-        keyArr(): Array<K>
-        /**
-         * Returns array of values
-         */
-        valueArr(): Array<V>
-        /**
-         * Returns first [key, value] match to callback param
-         * @param callback Callbacking function to find KeyValuePair
-         */
-        find(callback: (value: V, key?: K, index?: number, map?: Map<K, V>) => boolean): [K, V]
-        /**
-         * Whether or not map includes a  value. Returns true if it does, false if not ¯\_(ツ)_/¯ 
-         * @param value Value that may be includded in map
-         * @param fromIndex Start looking for value from specific index+. Default: 0
-         */
-        includes(value: V, fromIndex?: number): boolean
-    }
-    interface String {
-        /**
-         * Uppercases first letter of string
-         */
-        toPascalCase(): string
-        /**
-         * Replaces "replacer" (default: ' ') with "replacement" (default: '_')
-         * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
-         */
-        toSnakeCase(replaceOptions?: IReplacement): string
-        /**
-         * Replaces "replacer" (default: ' ') with "replacement" (default: '-')
-         * @param replaceOptions This is practically your stereotypical String.replace, if you really want it to be
-         */
-        toKebabCase(replaceOptions?: IReplacement): string
-    }
-}
-
-Document.prototype.createProperElement = function<K extends keyof HTMLElementTagNameMap>(this: Document, tagName: K, options?: ElementOptions) {
-    let baseElement = document.createElement(tagName);
-    if (!options) return baseElement;
-
-    if (options.classes) {
-        baseElement.classList.add(...options.classes);
-    }
-    
-    if (options.attributes) {
-        options.attributes.forEach(([attribute, value]) => baseElement.setAttribute(attribute, value));
-    }
-
-    if (options.children) {
-        baseElement.append(...[].concat(options.children));
-    }
-
-    if (options.events) {
-        options.events.forEach(({ name, handler }) => (
-            baseElement.addEventListener(name, handler)
-        ))
-    }
-
-    return baseElement;
-}
-
-HTMLCollection.prototype.array = function(this: HTMLCollection) {
-    let result = new Array<Element>();
-
-    for (let i = 0; i < this.length; i++) {
-        result.push(this.item(i));
-    }
-    return result;
-}
-
-Array.prototype.add = function<T>(this: Array<T>, ...items: Array<T>) {
-    this.push(...items);
-    return this;
-}
-Array.prototype.remove = function<T>(this: Array<T>, item: T): Array<T> {
-    const itemInArray = this.includes(item) ? item : this.find(i => i == item);
-    if (!itemInArray) throw new Error(`item is not in array!`);
-    
-    const itemIndex = this.indexOf(itemInArray);
-    this.splice(itemIndex, 1);
-    return this;
-}
-Array.prototype.random = function<T>(this: Array<T>): T {
-    const randomIndex = Math.round(Math.random() * this.length);
-    return this[randomIndex];
-}
-
-Map.prototype.array = function<K, V>(this: Map<K, V>): [K, V][] {
-    let result = new Array<[K, V]>();
-    for (const kvp of this) {
-        result.push(kvp);
-    }
-    return result;
-}
-Map.prototype.map = function<K, V, EK, EV>(this: Map<K, V>, callback: (value: V, key?: K, index?: number, map?: Map<K, V>) => [EK, EV]): Map<EK, EV> {
-    return this.array()
-        .map(([k, v], i) => callback(v, k, i, this))
-        .reduce((map, [key, value]) => 
-            map.set(key, value), 
-        new Map<EK, EV>())
-}
-Map.prototype.filter = function<K, V>(this: Map<K, V>, callback: (value: V, key?: K, index?: number, map?: Map<K, V>) => boolean): Map<K, V> {
-    return this.array()
-        .filter(([k, v], i) => callback(v, k, i, this))
-        .reduce((map, [key, value]) => 
-            map.set(key, value), 
-        new Map<K, V>())
-}
-Map.prototype.keyArr = function<K, V>(this: Map<K, V>): K[] {
-    return this.array().map(([k]) => k);
-}
-Map.prototype.valueArr = function<K, V>(this: Map<K, V>): V[] {
-    return this.array().map(([_, v]) => v);
-}
-Map.prototype.find = function<K, V>(this: Map<K, V>, callback: (value: V, key?: K, index?: number, map?: Map<K, V>) => boolean) {
-    return this.array().find(([k, v], i) => callback(v, k, i, this));
-}
-Map.prototype.includes = function<K, V>(this: Map<K, V>, item: V, fromIndex?: number) {
-    return this.valueArr().includes(item, fromIndex);
-}
-
-String.prototype.toPascalCase = function(this: string) {
-    return this.substring(0, 1).toUpperCase() + this.substring(1);
-}
-
-function spaceReplacer(self: string, replacer: string | RegExp, replacement: string) {
-    return self.replace(new RegExp(`${typeof replacer == 'string' ? replacer : replacer.source}+`), replacement);
-}
-String.prototype.toSnakeCase = function(this: string, replaceOptions: IReplacement = { replacer: ' ', replacement: '_' }) {
-    return spaceReplacer(this, replaceOptions.replacer, replaceOptions.replacement)
-}
-String.prototype.toKebabCase = function(this: string, replaceOptions: IReplacement = { replacer: ' ', replacement: '-' }) {
-    return spaceReplacer(this, replaceOptions.replacer, replaceOptions.replacement);
-}

package/src/Interfaces/BaseEventInterface.ts

@@ -1,4 +0,0 @@
-export interface BaseEvent {
-    error: [err: Error]
-}
-export default BaseEvent;

package/src/Types/EventHandler.ts

@@ -1,12 +0,0 @@
-import BaseEvent from "../Interfaces/BaseEventInterface";
-
-/**
- * Eventhandler type for:
- * @see EventCollection
- */
-export type EventHandler<
-    Events extends BaseEvent, 
-    Event extends keyof Events,
-    ReturnType = any
-> = (args: Events[Event]) => ReturnType;
-export default EventHandler;

package/src/Types/IElement.ts

@@ -1,9 +0,0 @@
-/**
- * Used for HTMLElement.append in ElementOptions, Document.createProperElement.
- * IElement accepts HTML Elements or HTMl-like strings.
- * 
- * @see HTMLElement.append
- * @see Document.createProperElement
- */
-export type IElement = HTMLElement | string;
-export default IElement

package/src/Types/StringRegex.ts

@@ -1,2 +0,0 @@
-export type StringRegex = string | RegExp;
-export default StringRegex;