danholibraryjs 1.11.0 → 2.0.1

package/dist/Extensions/Map.d.ts

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

@@ -0,0 +1,13 @@
+type Separators = {
+    thousand: string;
+    decimal: string;
+};
+declare global {
+    interface Number {
+        toSeparationString(separators: Partial<Separators>): string;
+        toRomanNumeral(): string;
+    }
+}
+export declare function toSeparationString(this: number, separators: Partial<Separators>): string;
+export declare function toRomanNumeral(this: number): string;
+export {};

package/dist/Extensions/Number.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRomanNumeral = exports.toSeparationString = void 0;
+function toSeparationString(separators) {
+    const { thousand = '.', decimal = '.' } = separators;
+    const [integerPart, decimalPart] = this.toString().split('.');
+    const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, thousand);
+    return decimalPart ? `${formattedInteger}${decimal}${decimalPart}` : formattedInteger;
+}
+exports.toSeparationString = toSeparationString;
+Number.prototype.toSeparationString = toSeparationString;
+function toRomanNumeral() {
+    if (this <= 0 || this >= 4000)
+        throw new RangeError('Number must be between 1 and 3999 to convert to Roman numeral');
+    const numeralMap = [
+        [1000, 'M'],
+        [900, 'CM'],
+        [500, 'D'],
+        [400, 'CD'],
+        [100, 'C'],
+        [90, 'XC'],
+        [50, 'L'],
+        [40, 'XL'],
+        [10, 'X'],
+        [9, 'IX'],
+        [5, 'V'],
+        [4, 'IV'],
+        [1, 'I']
+    ];
+    let value = this;
+    return numeralMap.reduce((acc, [numeralValue, numeral]) => {
+        while (value >= numeralValue) {
+            acc += numeral;
+            value -= numeralValue;
+        }
+        return acc;
+    }, '');
+}
+exports.toRomanNumeral = toRomanNumeral;
+Number.prototype.toRomanNumeral = toRomanNumeral;

package/dist/Extensions/Object/arrays.extension.d.ts

@@ -0,0 +1,17 @@
+import { ValueOf } from "../../Types";
+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>]>;
+        /**
+         * Destructures object into array of property keys
+         * @param from Object to destruct
+         */
+        keysOf<From extends {} = {}>(from: From): Array<keyof From>;
+    }
+}
+export declare function array<From extends {} = {}>(this: object, from: From): Array<[keyof From, ValueOf<From>]>;
+export declare function keysOf<From extends {} = {}>(this: object, from: From): Array<keyof From>;

package/dist/Extensions/Object/arrays.extension.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keysOf = exports.array = void 0;
+function array(from) {
+    return Object.entries(from);
+}
+exports.array = array;
+Object.array = array;
+function keysOf(from) {
+    return Object.keys(from);
+}
+exports.keysOf = keysOf;
+Object.keysOf = keysOf;

package/dist/Extensions/Object/booleans.extension.d.ts

@@ -0,0 +1,18 @@
+declare global {
+    interface ObjectConstructor {
+        /**
+         * Returns true if objects are equal by comparing their properties and values recursively. Does not compare functions.
+         * @param a First object
+         * @param b Second object
+         * @returns true if objects are equal, false otherwise
+         */
+        areEqual<T extends object | null>(a?: T, b?: T): boolean;
+        /**
+         * Returns true if object is empty
+         * @param obj Object to check
+         */
+        isNullOrUndefined(obj: any): obj is null | undefined;
+    }
+}
+export declare function areEqual<T extends object | null>(a?: T, b?: T): boolean;
+export declare function isNullOrUndefined(obj: any): obj is null | undefined;

package/dist/Extensions/Object/booleans.extension.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNullOrUndefined = exports.areEqual = void 0;
+function areEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (isNullOrUndefined(a) && isNullOrUndefined(b))
+        return true;
+    const keysA = Object.keys(a ?? {});
+    const keysB = Object.keys(b ?? {});
+    if (keysA.length !== keysB.length)
+        return false;
+    try {
+        const jsonA = JSON.stringify(a);
+        const jsonB = JSON.stringify(b);
+        if (jsonA === jsonB)
+            return true;
+    }
+    catch {
+        for (const key of keysA) {
+            if (!keysB.includes(key))
+                return false;
+            if (!areEqual(a[key], b[key]))
+                return false;
+        }
+    }
+    return true;
+}
+exports.areEqual = areEqual;
+Object.areEqual = areEqual;
+function isNullOrUndefined(obj) {
+    return obj === null || obj === undefined;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+Object.isNullOrUndefined = isNullOrUndefined;

package/dist/Extensions/Object/extracts.extension.d.ts

@@ -0,0 +1,38 @@
+declare global {
+    interface ObjectConstructor {
+        /**
+         * Get a copy of object without specified properties or partial versions.
+         * @param from Object to extract properties from
+         * @param props Properties to extract/Omit
+         */
+        omit<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props>;
+        /**
+         * Get a copy of object with only specified properties or partial versions.
+         * @param from Object to extract properties from
+         * @param props Properties to extract/Pick
+         */
+        pick<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props>;
+        /**
+         * Receive an object with properties that are not in union of source and target objects
+         * @param source Source object
+         * @param target Target object
+         * @param exclude Properties to exclude from difference
+         * @returns Object with properties that are not in union of source and target objects, excluding specified properties
+         */
+        difference<T extends object>(source: T, target: T, ...exclude: Array<keyof T>): Omit<T, keyof T>;
+        /**
+         * Deeply combines objects, with later objects in parameters taking precedence over earlier ones. Does not combine arrays.
+         * @param objects Objects to combine
+         * @returns Combined object
+         */
+        combine<T extends Record<string, any | undefined>>(...objects: Array<Partial<T> | undefined>): T;
+    }
+}
+export declare function omit<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Omit<From, Props>;
+export declare function pick<From extends {}, Props extends keyof From>(from: From, ...props: Array<Props | Partial<From>>): Pick<From, Props>;
+export declare function difference<T extends object>(source: T, target: T, ...exclude: Array<keyof T>): Omit<T, keyof T>;
+type Combinable<T extends Record<string, any>> = {
+    [key in keyof T]?: T[key] extends Record<string, any> ? Combinable<T[key]> : T[key];
+};
+export declare function combine<T extends Record<string, any | undefined>>(...objects: Array<Combinable<T> | undefined>): T;
+export {};

package/dist/Extensions/Object/extracts.extension.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combine = exports.difference = exports.pick = exports.omit = void 0;
+function omit(from, ...props) {
+    return props.reduce((result, prop) => {
+        if (typeof prop === "object") {
+            const keys = Object.keysOf(prop);
+            keys.forEach(key => delete result[key]);
+        }
+        else {
+            delete result[prop];
+        }
+        return result;
+    }, { ...from });
+}
+exports.omit = omit;
+Object.omit = omit;
+function pick(from, ...props) {
+    return props.reduce((result, prop) => {
+        if (typeof prop === "object") {
+            const keys = Object.keysOf(prop);
+            keys.forEach(key => result[key] = from[key]);
+        }
+        else {
+            result[prop] = from[prop];
+        }
+        return result;
+    }, {});
+}
+exports.pick = pick;
+Object.pick = pick;
+function difference(source, target, ...exclude) {
+    const diffKeys = new Set([...Object.keysOf(source), ...Object.keysOf(target)]);
+    exclude?.forEach(key => diffKeys.delete(key));
+    return [...diffKeys.values()].reduce((acc, key, i, arr) => {
+        const sourceValue = JSON.stringify(source[key]);
+        const targetValue = JSON.stringify(target[key]);
+        if (sourceValue !== targetValue)
+            acc[key] = target[key];
+        return acc;
+    }, {});
+}
+exports.difference = difference;
+Object.difference = difference;
+function combine(...objects) {
+    return objects.reduce((acc, obj) => {
+        if (!obj)
+            return acc;
+        for (const key in obj) {
+            if (typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+                try {
+                    acc[key] = combine(acc[key], obj[key]);
+                }
+                catch (err) {
+                    const error = err;
+                    if (error.message.includes('Maximum call stack size exceeded')) {
+                        acc[key] = obj[key];
+                    }
+                    else
+                        throw err;
+                }
+            }
+            else if (obj[key] !== undefined && obj[key] !== null && obj[key] !== '') {
+                // @ts-ignore
+                acc[key] = obj[key];
+            }
+        }
+        return acc;
+    }, {});
+}
+exports.combine = combine;
+Object.combine = combine;

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

@@ -1,49 +1,4 @@
-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 {};
+export * from './arrays.extension';
+export * from './booleans.extension';
+export * from './extracts.extension';
+export * from './properties.extension';

package/dist/Extensions/Object/index.js

@@ -1,38 +1,20 @@
-"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,
-};
+"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("./arrays.extension"), exports);
+__exportStar(require("./booleans.extension"), exports);
+__exportStar(require("./extracts.extension"), exports);
+__exportStar(require("./properties.extension"), exports);

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

@@ -1,28 +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 {};
+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.extension.d.ts

@@ -0,0 +1,33 @@
+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>>;
+};
+declare global {
+    interface ObjectConstructor {
+        properties: Properties;
+    }
+}
+export declare const properties: Properties;
+export {};