danholibraryjs 1.5.0 → 1.8.0

package/dist/Extensions/Array.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Array.prototype.add = function (...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;
+    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) {
+    const index = typeof value === 'number' ? value : this.indexOf(value);
+    if (index > -1)
+        this.splice(index, 1);
+    return this;
+};
+Array.prototype.random = function () {
+    const randomIndex = Math.round(Math.random() * this.length);
+    return this[randomIndex];
+};
+Array.prototype.index = function (i) {
+    return this[i < 0 ? this.length + i : i];
+};

package/dist/Extensions/Map.d.ts

@@ -0,0 +1,38 @@
+export {};
+declare global {
+    interface Map<K, V> {
+        /**
+         * Converts into Array<[Key, Value]>
+         */
+        array(): 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, self: 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, self: this) => 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. Returns undefined if nothing found
+         * @param callback Callbacking function to find KeyValuePair
+         */
+        find(callback: (value: V, key: K, index: number, self: this) => boolean): [K, V] | undefined;
+        /**
+         * 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;
+    }
+}

package/dist/Extensions/Map.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+};

package/dist/Extensions/Object.d.ts

@@ -0,0 +1,16 @@
+import { ValueOf } from "../Types";
+export {};
+declare global {
+    interface ObjectConstructor {
+        /**
+         * Destructures object into array of [property, value]
+         * @param from Object to destruct
+         */
+        array<From = {}>(from: From): Array<[keyof From, ValueOf<From>]>;
+        /**
+         * Destructures object into array of property keys
+         * @param from Object to destruct
+         */
+        keysOf<From = {}>(from: From): Array<keyof From>;
+    }
+}

package/dist/Extensions/Object.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.keysOf = function (from) {
+    return Object.keys(from);
+};
+Object.array = function (from) {
+    return Object.keysOf(from).map(prop => [prop, from[prop]]);
+};

package/dist/Extensions/String.d.ts

@@ -0,0 +1,26 @@
+import IReplacement from "../Interfaces/IReplacement";
+export {};
+declare global {
+    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;
+        /**
+         * String.substring but accepting negative numbers to cut from length
+         * @param start Start of string. 0 indexed, if negative number, subtracts number from length
+         * @param end End of string. 0 indexed, if negative number, substracts number from length
+         */
+        clip(start: number, end?: number): string;
+    }
+}

package/dist/Extensions/String.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) {
+    return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '_');
+};
+String.prototype.toKebabCase = function (replaceOptions) {
+    return spaceReplacer(this, replaceOptions.replacer || ' ', replaceOptions.replacement || '-');
+};
+String.prototype.clip = function (start, end) {
+    return this.substring(start < 0 ? this.length - start : start, end && end < 0 ? this.length + end : end);
+};

package/dist/Extensions/index.d.ts

@@ -0,0 +1,29 @@
+import ElementOptions from "../Interfaces/ElementOptions";
+import { IElement } from "../Types";
+export * from './Array';
+export * from './Map';
+export * from './Object';
+export * from './String';
+declare global {
+    interface BooleanConstructor {
+        /**
+         * Parses string to boolean. Will only return true if value === "true" otherwise false
+         */
+        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[];
+    }
+}

package/dist/Extensions/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Array"), exports);
+__exportStar(require("./Map"), exports);
+__exportStar(require("./Object"), exports);
+__exportStar(require("./String"), exports);
+Boolean.parseBoolean = function (value) {
+    return value === "true";
+};
+try {
+    Document.prototype.createProperElement = function (tagName, options, ...children) {
+        let baseElement = document.createElement(tagName);
+        if (!options)
+            return baseElement;
+        const { id, class: className, dataset, ...rest } = options;
+        if (id)
+            baseElement.id = id;
+        if (className) {
+            const classNames = Array.isArray(className) ? className : [className];
+            classNames.forEach(className => baseElement.classList.add(className));
+        }
+        children ?? options.children;
+        if (children) {
+            const childrenElements = Array.isArray(children) ? children : [children];
+            childrenElements.forEach(child => baseElement.append(child));
+        }
+        if (dataset)
+            Object.entries(dataset).forEach(([key, value]) => baseElement.dataset[key] = value);
+        for (const optionKey in rest) {
+            const optionValue = rest[optionKey];
+            if (optionValue === undefined)
+                continue;
+            if (typeof optionValue === 'function') {
+                baseElement.addEventListener(optionKey.substring(2), rest[optionKey]);
+            }
+            else {
+                baseElement.setAttribute(optionKey, optionValue.toString());
+            }
+        }
+        return baseElement;
+    };
+    Document.prototype.createFromHtml = function (html, parentTag) {
+        return new DOMParser().parseFromString(html, 'text/html').body.firstChild;
+    };
+    HTMLCollection.prototype.array = function () {
+        let result = new Array();
+        for (let i = 0; i < this.length; i++) {
+            const item = this.item(i);
+            if (item !== null)
+                result.push(item);
+        }
+        return result;
+    };
+}
+catch {
+    // Used in node.js
+}

package/dist/Functions/GetCSSProperty.d.ts

@@ -0,0 +1,15 @@
+declare type CSSReturnTypes = {
+    string: string;
+    number: number;
+};
+/**
+ * Gets the value of "property" in type "type" from query "query"
+ * Basically, you can get your --color-primary from :root
+ *
+ * @param property Name of the property to get
+ * @param type Type of the property to parse
+ * @param query Query to get the element that has the property
+ * @returns Property value converted to type
+*/
+export declare function GetCSSProperty<Type extends keyof CSSReturnTypes>(property: string, type: Type, query?: string): CSSReturnTypes[Type];
+export {};

package/dist/Functions/GetCSSProperty.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetCSSProperty = void 0;
+/**
+ * Gets the value of "property" in type "type" from query "query"
+ * Basically, you can get your --color-primary from :root
+ *
+ * @param property Name of the property to get
+ * @param type Type of the property to parse
+ * @param query Query to get the element that has the property
+ * @returns Property value converted to type
+*/
+function GetCSSProperty(property, type, query = ":root") {
+    const rootEl = document.querySelector(query);
+    if (!rootEl)
+        throw new Error(`${query} does not exist!`);
+    const rootStyles = getComputedStyle(rootEl);
+    const cssProp = rootStyles.getPropertyValue(property);
+    if (type === 'string')
+        return cssProp;
+    const numberValue = parseInt(cssProp);
+    if (isNaN(numberValue))
+        throw new Error(`${property} is not a number!: ${cssProp}`);
+    return numberValue;
+}
+exports.GetCSSProperty = GetCSSProperty;

package/dist/Functions/HTMLEvent.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Create HTMLEvent object from function
+ * @param name Name of the event
+ * @param handler Handler for the event
+ * @returns Parameters as object
+ */
 export declare function HTMLEvent<Event extends keyof HTMLElementEventMap, ReturnType extends any>(name: Event, handler: (event: HTMLElementEventMap[Event]) => ReturnType): {
     name: Event;
     handler: (event: HTMLElementEventMap[Event]) => ReturnType;

package/dist/Functions/HTMLEvent.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HTMLEvent = void 0;
+/**
+ * Create HTMLEvent object from function
+ * @param name Name of the event
+ * @param handler Handler for the event
+ * @returns Parameters as object
+ */
 function HTMLEvent(name, handler) {
     return { name, handler };
 }

package/dist/Functions/SetNavigationSelected.js

@@ -10,6 +10,8 @@ exports.SetNavigationSelected = void 0;
  */
 function SetNavigationSelected(query, ...currentPageClasses) {
     const header = document.querySelector(query);
+    if (!header)
+        throw { message: `Couldn't find header from query, ${query}` };
     const children = header.children.array().filter(c => c.tagName === 'a');
     const currentPage = document.location.href;
     children.forEach(gc => {

package/dist/Functions/index.d.ts

@@ -1,3 +1,4 @@
 export * from './CopyToClipboard';
+export * from './GetCSSProperty';
 export * from './SetNavigationSelected';
 export * from './HTMLEvent';

package/dist/Functions/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -11,5 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./CopyToClipboard"), exports);
+__exportStar(require("./GetCSSProperty"), exports);
 __exportStar(require("./SetNavigationSelected"), exports);
 __exportStar(require("./HTMLEvent"), exports);

package/dist/Interfaces/ElementOptions.d.ts

@@ -1,18 +1,15 @@
-import IElement from "../Types/IElement";
+import { Arrayable, IElement } from "../Types";
+declare type Events = Record<`on${Capitalize<keyof HTMLElementEventMap>}`, (event: Event) => void>;
 /**
  * Construction options when creating an HTML element using:
- * @see Document.createProperElement */
-export interface ElementOptions {
-    /**css classes to give the element*/
-    classes?: string[];
-    /**attributes to give the element*/
-    attributes?: [string, string][];
-    /**Children of the element*/
-    children?: IElement | IElement[];
-    /**Events for the element to listen to*/
-    events?: Array<{
-        name: string;
-        handler: (e: Event) => any;
-    }>;
-}
+ * @see Document.createProperElement
+ * @borwwos IElement
+ * @borrows Arrayable
+ */
+export declare type ElementOptions = Partial<Events & Record<string, any> & {
+    id: string;
+    class: Arrayable<string>;
+    children: Arrayable<IElement>;
+    dataset: Record<string, string>;
+}>;
 export default ElementOptions;

package/dist/Interfaces/IReplacement.d.ts

@@ -1,4 +1,4 @@
-import StringRegex from "../Types/StringRegex";
+import { StringRegex } from "../Types";
 /**
  * Replacement tool for
  * @see String.toSnakeCase

package/dist/Interfaces/index.d.ts

@@ -1,3 +1,2 @@
 export * from './ElementOptions';
 export * from './IReplacement';
-export * from './BaseEventInterface';

package/dist/Interfaces/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -12,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ElementOptions"), exports);
 __exportStar(require("./IReplacement"), exports);
-__exportStar(require("./BaseEventInterface"), exports);

package/dist/Types/BetterTypes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Construct a type with the properties of Type except for those in type Properties.
+ */
+export declare type BetterOmit<Type, Properties extends keyof Type> = Omit<Type, Properties>;
+/**
+ * Extract from From those types that are assignable to Properties
+ */
+export declare type BetterExtract<From, Properties extends From> = Extract<From, Properties>;
+export declare type PartialExcept<From, Properties extends keyof From> = Partial<From> & Required<Pick<From, Properties>>;

package/dist/Types/Date.d.ts

@@ -0,0 +1,6 @@
+export declare type LongMonth = 'Janurary' | 'February' | 'March' | 'April' | 'May' | 'June' | 'July' | 'August' | 'September' | 'October' | 'November' | 'December';
+export declare type ShortMonth = 'Jan' | 'Feb' | 'Mar' | 'Apr' | 'May' | 'Jun' | 'Jul' | 'Aug' | 'Sep' | 'Oct' | 'Nov' | 'Dec';
+export declare type Month = LongMonth | ShortMonth;
+export declare type ShortDay = 'Mon' | 'Tue' | 'Wed' | 'Thu' | 'Fri' | 'Sat' | 'Sun';
+export declare type LongDay = `${'Mon' | 'Tues' | 'Wednes' | 'Thurs' | 'Fri' | 'Satur' | 'Sun'}day`;
+export declare type Day = ShortDay | LongDay;

package/dist/Types/Events.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Default eventhandler mapper. Object with properties that are arrays
+ */
+export declare type BaseEvent<Keys extends string, Types extends Array<any>> = Record<Keys, Types>;
+/**
+ * Eventhandler type for:
+ * @see EventCollection
+ * @borrows BaseEvent
+ */
+export declare type EventHandler<Events extends BaseEvent<string, Array<any>> = BaseEvent<string, Array<any>>, Event extends keyof Events = keyof Events, ReturnType = any> = (...args: Events[Event]) => ReturnType;

package/dist/Types/PropertiesWith.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Filters all properties from From that has the return type of Type
+ */
+export declare type PropertiesWith<Type, From> = {
+    [Key in keyof From as From[Key] extends Type ? Key : never]: From[Key];
+};
+export default PropertiesWith;
+/**
+ * Fitlers all properties from From that don't have the return type of Type
+ */
+export declare type PropertiesWithout<Type, From> = {
+    [Key in keyof From as From[Key] extends Type ? never : Key]: From[Key];
+};

package/dist/Types/TransformTypes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts Start types to Switch types in From type
+ */
+export declare type TransformType<From, Start, Switch> = {
+    [Key in keyof From]: From[Key] extends Start ? Switch : From[Key];
+};
+/**
+ * Returns object with properties matching BaseType with types of NewType
+ */
+export declare type TransformTypes<From, BaseType, NewType> = Record<keyof {
+    [Key in keyof From as From[Key] extends BaseType ? Key : never]: Key;
+}, NewType>;
+export default TransformTypes;

package/dist/Types/TransformTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Types/index.d.ts

@@ -1,3 +1,31 @@
-export * from './EventHandler';
-export * from './IElement';
-export * from './StringRegex';
+export * from './BetterTypes';
+export * from './Date';
+export * from './Events';
+export * from './TransformTypes';
+export * from './PropertiesWith';
+/**
+ * Item is single or multiple
+ */
+export declare type Arrayable<T> = T | Array<T>;
+/**
+ * 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;
+/**
+ * Return types of T
+ */
+export declare type ValueOf<T> = T[keyof T];
+/**
+ * Type's properties are ReturnType
+ */
+export declare type AllPropsAre<ReturnType> = {
+    [key: string]: ReturnType;
+};
+/**
+ * string or RegExp.. pretty self-explanatory
+ */
+export declare type StringRegex = string | RegExp;

package/dist/Types/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -10,6 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./EventHandler"), exports);
-__exportStar(require("./IElement"), exports);
-__exportStar(require("./StringRegex"), exports);
+__exportStar(require("./BetterTypes"), exports);
+__exportStar(require("./Date"), exports);
+__exportStar(require("./Events"), exports);
+__exportStar(require("./TransformTypes"), exports);
+__exportStar(require("./PropertiesWith"), exports);

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { EventCollection, EventEmitter, Event } from './Classes';
-export { CopyToClipboard, SetNavigationSelected, HTMLEvent } from './Functions';
-export { ElementOptions, IReplacement } from './Interfaces';
-export { EventHandler, IElement, StringRegex } from './Types';
-export * as Extensions from './Extensions';
+export * from './Classes';
+export * from './Extensions';
+export * from './Functions';
+export * from './Interfaces';
+export * from './Types';

package/dist/index.js

@@ -1,12 +1,21 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Extensions = exports.HTMLEvent = exports.SetNavigationSelected = exports.CopyToClipboard = exports.Event = exports.EventEmitter = exports.EventCollection = void 0;
-var Classes_1 = require("./Classes");
-Object.defineProperty(exports, "EventCollection", { enumerable: true, get: function () { return Classes_1.EventCollection; } });
-Object.defineProperty(exports, "EventEmitter", { enumerable: true, get: function () { return Classes_1.EventEmitter; } });
-Object.defineProperty(exports, "Event", { enumerable: true, get: function () { return Classes_1.Event; } });
-var Functions_1 = require("./Functions");
-Object.defineProperty(exports, "CopyToClipboard", { enumerable: true, get: function () { return Functions_1.CopyToClipboard; } });
-Object.defineProperty(exports, "SetNavigationSelected", { enumerable: true, get: function () { return Functions_1.SetNavigationSelected; } });
-Object.defineProperty(exports, "HTMLEvent", { enumerable: true, get: function () { return Functions_1.HTMLEvent; } });
-exports.Extensions = require("./Extensions");
+__exportStar(require("./Classes"), exports);
+__exportStar(require("./Extensions"), exports);
+__exportStar(require("./Functions"), exports);
+__exportStar(require("./Interfaces"), exports);
+__exportStar(require("./Types"), exports);