danholibraryjs 1.8.0 → 1.10.0

package/.gitattributes

@@ -1,2 +1,2 @@
-# Auto detect text files and perform LF normalization
-* text=auto
+# Auto detect text files and perform LF normalization
+* text=auto

package/dist/Classes/Events/Event.js

@@ -53,7 +53,7 @@ class Event {
      */
     on(listener, prepend = false) {
         if (this.limit > 0 && this._listeners.length + 1 > this.limit) {
-            throw new Error(`Event limit, ${this.limit}, reached for event ${this.name}!`);
+            throw new Error(`Event limit, ${this.limit}, reached for event ${this.name.toString()}!`);
         }
         if (prepend)
             this._listeners = [listener, ...this._listeners];

package/dist/Classes/Events/EventCollection.js

@@ -99,7 +99,7 @@ class EventCollection {
         }
         const event = this.get(eventName);
         if (!event)
-            throw new Error(`Unknown event, ${eventName}!`);
+            throw new Error(`Unknown event, ${eventName.toString()}!`);
         event.limit = limit;
         this._events.set(eventName, event);
         return this;

package/dist/Classes/Events/EventEmitter.d.ts

@@ -40,21 +40,21 @@ export declare class EventEmitter<Events extends BaseEvent<string, Array<any>>>
      * @param listener Callback function to run, when event occurs
      * @returns this
      */
-    on<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): this;
+    on<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): EventEmitter<Events>;
     /**
      * Adds listener to event collection, and runs listener once when event is emitted
      * @param event Event to handle
      * @param listener Callback function to run, when event occurs
      * @returns this
      */
-    once<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): this;
+    once<Return extends any, Event extends keyof Events>(event: Event, listener: EventHandler<Events, Event, Return>): EventEmitter<Events>;
     /**
      * Removes listener(s) from event
      * @param event Event to get collection of listeners | "all"
      * @param listener If left null, removes all listeners tied to event, else only removes listener from event
      * @returns this
      */
-    off<Return extends any, Event extends keyof Events>(event?: Event | 'all', listener?: EventHandler<Events, Event, Return>): this;
+    off<Return extends any, Event extends keyof Events>(event?: Event | 'all', listener?: EventHandler<Events, Event, Return>): EventEmitter<Events>;
     /**
      * Emits event and runs all listeners tied to event
      * @param event Event to emit
@@ -69,6 +69,6 @@ export declare class EventEmitter<Events extends BaseEvent<string, Array<any>>>
      * @param limit Limit of events to keep. If you want to limit amount of events saved, use 'all'.
      * @returns this with the new limit
      */
-    limit<Event extends keyof Events>(event: 'all' | Event, limit: number): this;
+    limit<Event extends keyof Events>(event: 'all' | Event, limit: number): EventEmitter<Events>;
 }
 export default EventEmitter;

package/dist/Classes/Time/Date.d.ts

@@ -1,16 +1,16 @@
 import { BetterOmit, PartialExcept, LongMonth, LongDay, ShortDay, ShortMonth } from "../../Types";
 import TimeProperties from "./TimeProperties";
 import TimeSpan, { TimeSpanFormat } from "./TimeSpan";
-declare type Data = PartialExcept<BetterOmit<TimeProperties<true>, 'weeks'>, 'years' | 'months'>;
-declare type Double = `${number}${number}`;
-declare type Quadruple = `${Double}${Double}`;
-declare type DateFormat = `${Double}/${Double}/${Quadruple}`;
+type Data = PartialExcept<BetterOmit<TimeProperties<true>, 'weeks'>, 'years' | 'months'>;
+type Double = `${number}${number}`;
+type Quadruple = `${Double}${Double}`;
+type DateFormat = `${Double}/${Double}/${Quadruple}`;
 /**
  * Type used to construct DanhoDate.
  * @Data Partial TimeProperties except years & months
  * @DateFormat string as dd/MM/yyyy
  */
-export declare type DanhoDateConstructor = Data | DateFormat | number | Date;
+export type DanhoDateConstructor = Data | DateFormat | number | Date;
 declare class DanhoDate {
     /**
      * Returns the value of the current irl time

package/dist/Classes/Time/Time.d.ts

@@ -1,8 +1,8 @@
 import { LongMonth } from "../../Types/Date";
 /** '2s' or 2000 */
-export declare type TimeUnit = 'ms' | 's' | 'm' | 'h' | 'd' | 'w' | 'M' | 'y';
-export declare type TimeString = `${number}${TimeUnit}`;
-export declare type TimeDelay = number | TimeString;
+export type TimeUnit = 'ms' | 's' | 'm' | 'h' | 'd' | 'w' | 'M' | 'y';
+export type TimeString = `${number}${TimeUnit}`;
+export type TimeDelay = number | TimeString;
 export declare const ValidTime: RegExp;
 /**
  * Converts input into milliseconds

package/dist/Classes/Time/TimeProperties.d.ts

@@ -1,3 +1,3 @@
-declare type TimeKeys = 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
-export declare type TimeProperties<Plural extends boolean = false> = Record<Plural extends true ? `${TimeKeys}s` : TimeKeys, number>;
+type TimeKeys = 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
+export type TimeProperties<Plural extends boolean = false> = Record<Plural extends true ? `${TimeKeys}s` : TimeKeys, number>;
 export default TimeProperties;

package/dist/Classes/Time/TimeSpan.d.ts

@@ -4,7 +4,7 @@ import TimeProperties from "./TimeProperties";
 /**
  * What properties to include when using TimeSpan.toString(format: TimeSpanFormat): string
  */
-export declare type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number, boolean>>;
+export type TimeSpanFormat = Partial<TransformType<TimeProperties<true>, number, boolean>>;
 /**
  * Timespan between 2 dates.
  * @borrows TimeSpanValue

package/dist/Classes/index.d.ts

@@ -1,2 +1,3 @@
 export * from './Events';
 export * from './Time';
+export * from './store';

package/dist/Classes/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Events"), exports);
 __exportStar(require("./Time"), exports);
+__exportStar(require("./store"), exports);

package/dist/Classes/store.d.ts

@@ -1,6 +1,6 @@
 import { Arrayable } from "../Types";
 import { EventEmitter } from "./Events";
-export declare type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = (state: State, ...args: Types[Action]) => State;
+export type Reducer<State, Types extends Record<string, any[]>, Action extends keyof Types> = (state: State, ...args: Types[Action]) => State;
 /**
  * EventEmitter, but it stores state and handles state change with reducers
  *

package/dist/Classes/store.js

@@ -82,4 +82,3 @@ class Store extends Events_1.EventEmitter {
     }
 }
 exports.Store = Store;
-exports.default = Store;

package/dist/Extensions/Array.d.ts

@@ -1,5 +1,5 @@
 export {};
-declare type UpdateFinder<T> = (item: T, index: number, self: Array<T>) => boolean;
+type UpdateFinder<T> = (item: T, index: number, self: Array<T>) => boolean;
 declare global {
     interface Array<T> {
         /**
@@ -27,5 +27,12 @@ declare global {
          * @param i Index of item
          */
         index(i: number): T;
+        /**
+         * For every x in array, execute callback
+         * @param every i.e every 2nd item in array
+         * @param callback Function to execute
+         * @returns Array of results
+         */
+        nth<U>(every: number, callback: (collection: Array<T>, index: number, self: this) => U): Array<U>;
     }
 }

package/dist/Extensions/Array.js

@@ -1,26 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-Array.prototype.add = function (...items) {
+exports.ArrayExtensions = void 0;
+function add(...items) {
     this.push(...items);
     return this;
-};
-Array.prototype.update = function (old, updated) {
-    const item = typeof old === 'number' ? this[old] : typeof old === 'function' ? this.find(old) : old;
+}
+Array.prototype.add = add;
+function update(old, updated) {
+    const item = typeof old === 'number' ? this[old]
+        : typeof old === 'function' ? this.find(old)
+            : old;
     if (!item)
         throw new Error('Old was not found in array!');
     const index = this.indexOf(item);
     return this[index] = updated;
-};
-Array.prototype.remove = function (value) {
+}
+Array.prototype.update = update;
+function remove(value) {
     const index = typeof value === 'number' ? value : this.indexOf(value);
     if (index > -1)
         this.splice(index, 1);
     return this;
-};
-Array.prototype.random = function () {
+}
+Array.prototype.remove = remove;
+function random() {
     const randomIndex = Math.round(Math.random() * this.length);
     return this[randomIndex];
-};
-Array.prototype.index = function (i) {
+}
+Array.prototype.random = random;
+function index(i) {
     return this[i < 0 ? this.length + i : i];
+}
+Array.prototype.index = index;
+function nth(every, callback) {
+    const result = new Array();
+    let collection = new Array();
+    for (let i = 0; i < this.length; i++) {
+        collection.push(this[i]);
+        if (i % every === 0) {
+            result.push(callback(this[i], i, collection, this));
+            collection = new Array();
+        }
+    }
+    return result;
+}
+Array.prototype.nth = nth;
+exports.ArrayExtensions = {
+    add, update, remove,
+    random, index, nth
+};
+Array.prototype.nth = function (every, callback) {
+    const result = new Array();
+    let collection = new Array();
+    for (let i = 0; i < this.length; i++) {
+        collection.push(this[i]);
+        if (i % every === 0) {
+            result.push(callback(collection, i, this));
+            collection = new Array();
+        }
+    }
+    return result;
 };

package/dist/Extensions/Document.d.ts

@@ -0,0 +1,27 @@
+import { IElement } from "../Types";
+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
+         * @param children Child elements
+         */
+        createProperElement<Tag extends keyof HTMLElementTagNameMap>(tagName: Tag, options?: Partial<HTMLElementTagNameMap[Tag]>, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
+        createProperElement<Tag extends keyof HTMLElementTagNameMap>(tagName: Tag, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
+        createElementFromString<K extends keyof HTMLElementTagNameMap>(html: string, parentTag?: K): HTMLElementTagNameMap[K];
+    }
+    interface HTMLCollection {
+        /**
+         * Converts HTMLCollection to Element[]
+         */
+        array(): Element[];
+    }
+}
+declare function createElement<Tag extends keyof HTMLElementTagNameMap>(this: Document, tagName: Tag, options?: Partial<HTMLElementTagNameMap[Tag]> | string, ...children: Array<IElement>): HTMLElementTagNameMap[Tag];
+declare function createElementFromString<Tag extends keyof HTMLElementTagNameMap>(this: Document, html: string, tag?: Tag): HTMLElementTagNameMap[Tag];
+export declare const DocumentExtensions: {
+    createElement: typeof createElement;
+    createElementFromString: typeof createElementFromString;
+};
+export {};

package/dist/Extensions/Document.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentExtensions = void 0;
+function createElement(tagName, options, ...children) {
+    const element = Object.assign(document.createElement(tagName), typeof options === 'string' ? {} : options);
+    children ??= typeof options === 'string' ? [options] : [];
+    typeof options === 'string' && children.unshift(options);
+    if (!children.length)
+        return element;
+    else if (typeof children === 'string')
+        element.innerHTML = children;
+    else if (children instanceof Array)
+        children.forEach(child => (typeof child === 'string' ?
+            element.innerHTML += child :
+            element.appendChild(child)));
+    else
+        element.appendChild(children);
+    return element;
+}
+Document.prototype.createProperElement = createElement;
+function createElementFromString(html, tag) {
+    if (!html.startsWith(`<${tag}`))
+        html = `<${tag}>${html}</${tag}>`;
+    return new DOMParser().parseFromString(html, 'text/html').body.firstElementChild;
+}
+Document.prototype.createElementFromString = createElementFromString;
+HTMLCollection.prototype.array = function () {
+    return Array.from(this);
+};
+exports.DocumentExtensions = {
+    createElement, createElementFromString
+};

package/dist/Extensions/Function.d.ts

@@ -0,0 +1,14 @@
+declare global {
+    interface Function {
+        /**
+         * Checks if obj is a function
+         * @param obj Object to check
+         */
+        is(obj: any): obj is Function;
+    }
+}
+declare function is(obj: any): obj is Function;
+export declare const FunctionExtensions: {
+    is: typeof is;
+};
+export {};

package/dist/Extensions/Function.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionExtensions = void 0;
+function is(obj) {
+    return typeof obj === 'function';
+}
+Function.is = is;
+exports.FunctionExtensions = {
+    is
+};

package/dist/Extensions/Map.d.ts

@@ -1,4 +1,3 @@
-export {};
 declare global {
     interface Map<K, V> {
         /**
@@ -36,3 +35,20 @@ declare global {
         includes(value: V, fromIndex?: number): boolean;
     }
 }
+declare function array<K, V>(this: Map<K, V>): Array<[K, V]>;
+declare function map<K, V, EK, EV>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => [EK, EV]): Map<EK, EV>;
+declare function filter<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean): Map<K, V>;
+declare function keyArr<K, V>(this: Map<K, V>): Array<K>;
+declare function valueArr<K, V>(this: Map<K, V>): Array<V>;
+declare function find<K, V>(this: Map<K, V>, callback: (value: V, key: K, index: number, map: Map<K, V>) => boolean): [K, V] | undefined;
+declare function includes<K, V>(this: Map<K, V>, item: V, fromIndex?: number): boolean;
+export declare const MapExtensions: {
+    array: typeof array;
+    map: typeof map;
+    filter: typeof filter;
+    keyArr: typeof keyArr;
+    valueArr: typeof valueArr;
+    find: typeof find;
+    includes: typeof includes;
+};
+export {};

package/dist/Extensions/Map.js

@@ -1,31 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-Map.prototype.array = function () {
+exports.MapExtensions = void 0;
+function array() {
     let result = new Array();
     for (const kvp of this) {
         result.push(kvp);
     }
     return result;
-};
-Map.prototype.map = function (callback) {
+}
+Map.prototype.array = array;
+function map(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) {
+}
+Map.prototype.map = map;
+function filter(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 () {
+}
+Map.prototype.filter = filter;
+function keyArr() {
     return this.array().map(([k]) => k);
-};
-Map.prototype.valueArr = function () {
+}
+Map.prototype.keyArr = keyArr;
+function valueArr() {
     return this.array().map(([_, v]) => v);
-};
-Map.prototype.find = function (callback) {
+}
+Map.prototype.valueArr = valueArr;
+function find(callback) {
     return this.array().find(([k, v], i) => callback(v, k, i, this));
-};
-Map.prototype.includes = function (item, fromIndex) {
+}
+Map.prototype.find = find;
+function includes(item, fromIndex) {
     return this.valueArr().includes(item, fromIndex);
+}
+Map.prototype.includes = includes;
+exports.MapExtensions = {
+    array, map, filter, keyArr, valueArr, find, includes
 };

package/dist/Extensions/Object/index.d.ts

@@ -0,0 +1,49 @@
+import { ValueOf } from "../../Types";
+import { Properties } from "./properties";
+declare global {
+    interface ObjectConstructor {
+        /**
+         * Destructures object into array of [property, value]
+         * @param from Object to destruct
+         */
+        array<From extends {} = {}>(from: From): Array<[keyof From, ValueOf<From>]>;
+        /**
+         * Omits properties from object, but for some reason the correct term is "extract"
+         * @param from Object to extract properties from
+         * @param props Properties to extract/Omit
+         */
+        extract<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props>;
+        /**
+         * Pick properties from object, but for some reason the correct term is "exclude"
+         * @param from Object to exclude properties from
+         * @param props Properties to exclude/pick
+         */
+        exclude<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props>;
+        /**
+         * Returns true if object is empty
+         * @param obj Object to check
+         */
+        isNullOrUndefined(obj: any): obj is null | undefined;
+        /**
+         * Destructures object into array of property keys
+         * @param from Object to destruct
+         */
+        keysOf<From extends {} = {}>(from: From): Array<keyof From>;
+        omit<From extends {}, Exclude extends keyof From>(from: From, ...exclude: Exclude[]): Omit<From, Exclude>;
+        properties: Properties;
+    }
+}
+declare function array<From extends {} = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]>;
+declare function extract<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props>;
+declare function exclude<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props>;
+declare function isNullOrUndefined(obj: any): obj is null | undefined;
+declare function keysOf<From extends {} = {}>(this: object, from: From): Array<keyof From>;
+export declare const ObjectExtensions: {
+    properties: Properties;
+    array: typeof array;
+    extract: typeof extract;
+    exclude: typeof exclude;
+    isNullOrUndefined: typeof isNullOrUndefined;
+    keysOf: typeof keysOf;
+};
+export {};

package/dist/Extensions/Object/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectExtensions = void 0;
+const properties_1 = require("./properties");
+function array(from) {
+    return Object.keysOf(from).map(prop => [prop, from[prop]]);
+}
+Object.array = array;
+function extract(from, ...props) {
+    // If props are Array<keyof From>, Array<Partial<From>>, or Array<keyof From | Partial<From>>, ensure _props as Array<keyof From> 
+    const _props = props.map(prop => typeof prop === "object" ? Object.keysOf(prop) : prop).flat();
+    _props.forEach(prop => delete from[prop]);
+    return from;
+}
+Object.extract = extract;
+function exclude(from, ...props) {
+    // If props are Array<keyof From>, Array<Partial<From>>, or Array<keyof From | Partial<From>>, ensure _props as Array<keyof From>
+    const _props = props.map(prop => typeof prop === "object" ? Object.keysOf(prop) : prop).flat();
+    return Object.keysOf(from).reduce((result, prop) => {
+        if (_props.includes(prop))
+            delete result[prop];
+        return result;
+    }, from);
+}
+Object.exclude = exclude;
+function isNullOrUndefined(obj) {
+    return obj === null || obj === undefined;
+}
+Object.isNullOrUndefined = isNullOrUndefined;
+function keysOf(from) {
+    return Object.keys(from);
+}
+Object.keysOf = keysOf;
+Object.properties = properties_1.properties;
+exports.ObjectExtensions = {
+    properties: properties_1.properties,
+    array, extract, exclude, isNullOrUndefined, keysOf,
+};

package/dist/Extensions/Object/properties.d.ts

@@ -0,0 +1,28 @@
+import { PropertiesWith, If } from '../../Types';
+type PrimitiveMap = {
+    string: string;
+    number: number;
+    boolean: boolean;
+    undefined: undefined;
+    null: null;
+    object: object;
+    function: Function;
+    any: any;
+    Date: Date;
+    RegExp: RegExp;
+    Promise: Promise<any>;
+    Array: Array<any>;
+    Map: Map<any, any>;
+    Set: Set<any>;
+};
+/**
+ * Object with getPrimitiveTypes<Source, AllowFunctions extends boolean>(
+ *  source: Source,
+ *  allowFunctions: AllowFunctions = false
+ * ): Object with properties from source that matches primitive type
+ */
+export type Properties = {
+    [Key in keyof PrimitiveMap as `get${Capitalize<Key>}s`]: <Source extends {}, AllowFunctions extends boolean = false>(source: Source, withFunctions?: AllowFunctions) => If<AllowFunctions, PropertiesWith<PrimitiveMap[Key] | ((...args: any[]) => PrimitiveMap[Key]), Source>, PropertiesWith<PrimitiveMap[Key], Source>>;
+};
+export declare const properties: Properties;
+export {};

package/dist/Extensions/Object/properties.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.properties = void 0;
+const String_1 = require("../String");
+exports.properties = [
+    'string', 'number', 'boolean', 'undefined', 'null',
+    'object', 'function', 'any',
+    'Date', 'RegExp', 'Promise', 'Array', 'Map', 'Set'
+].reduce((result, primitive) => {
+    result[`get${String_1.StringExtensions.toPascalCase.bind(primitive)()}s`] = function (source, withFunctions = false) {
+        return Object.keysOf(source).reduce((result, key) => {
+            if (source[key].constructor.name === primitive ||
+                (withFunctions && typeof source[key] === 'function' && source[key]).constructor.name === primitive) {
+                result[key] = source[key];
+            }
+            return result;
+        }, {});
+    };
+    return result;
+}, {});

package/dist/Extensions/String.d.ts

@@ -1,5 +1,4 @@
 import IReplacement from "../Interfaces/IReplacement";
-export {};
 declare global {
     interface String {
         /**
@@ -24,3 +23,14 @@ declare global {
         clip(start: number, end?: number): string;
     }
 }
+declare function toPascalCase(this: string): string;
+declare function toSnakeCase(this: string, replaceOptions: IReplacement): string;
+declare function toKebabCase(this: string, replaceOptions: IReplacement): string;
+declare function clip(this: string, start: number, end?: number): string;
+export declare const StringExtensions: {
+    toPascalCase: typeof toPascalCase;
+    toSnakeCase: typeof toSnakeCase;
+    toKebabCase: typeof toKebabCase;
+    clip: typeof clip;
+};
+export {};

package/dist/Extensions/String.js

@@ -1,17 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-String.prototype.toPascalCase = function () {
+exports.StringExtensions = void 0;
+function toPascalCase() {
     return this.substring(0, 1).toUpperCase() + this.substring(1);
-};
+}
+String.prototype.toPascalCase = toPascalCase;
 function spaceReplacer(self, replacer, replacement) {
     return self.replace(new RegExp(`${typeof replacer == 'string' ? replacer : replacer.source}+`), replacement);
 }
-String.prototype.toSnakeCase = function (replaceOptions) {
+function toSnakeCase(replaceOptions) {
     return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '_');
-};
-String.prototype.toKebabCase = function (replaceOptions) {
+}
+String.prototype.toSnakeCase = toSnakeCase;
+function toKebabCase(replaceOptions) {
     return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '-');
-};
-String.prototype.clip = function (start, end) {
+}
+String.prototype.toKebabCase = toKebabCase;
+function clip(start, end) {
     return this.substring(start < 0 ? this.length - start : start, end && end < 0 ? this.length + end : end);
+}
+String.prototype.clip = clip;
+exports.StringExtensions = {
+    toPascalCase, toSnakeCase, toKebabCase, clip
 };

package/dist/Extensions/index.d.ts

@@ -1,6 +1,5 @@
-import ElementOptions from "../Interfaces/ElementOptions";
-import { IElement } from "../Types";
 export * from './Array';
+export * from './Document';
 export * from './Map';
 export * from './Object';
 export * from './String';
@@ -11,19 +10,8 @@ declare global {
          */
         parseBoolean(value: string): boolean;
     }
-    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, ...children: Array<IElement>): HTMLElementTagNameMap[K];
-        createFromHtml<K extends keyof HTMLElementTagNameMap>(html: string, parentTag?: K): HTMLElementTagNameMap[K];
-    }
-    interface HTMLCollection {
-        /**
-         * Converts HTMLCollection to Element[]
-         */
-        array(): Element[];
-    }
 }
+declare function parseBoolean(value: string): boolean;
+export declare const BooleanExtensions: {
+    parseBoolean: typeof parseBoolean;
+};