@dxyl/utils 1.0.1 → 1.1.1

package/types/lodash/_reEscape.d.ts

@@ -0,0 +1,3 @@
+export default reEscape;
+/** Used to match template delimiters. */
+declare var reEscape: RegExp;

package/types/lodash/_reEvaluate.d.ts

@@ -0,0 +1,3 @@
+export default reEvaluate;
+/** Used to match template delimiters. */
+declare var reEvaluate: RegExp;

package/types/lodash/_reInterpolate.d.ts

@@ -0,0 +1,3 @@
+export default reInterpolate;
+/** Used to match template delimiters. */
+declare var reInterpolate: RegExp;

package/types/lodash/_realNames.d.ts

@@ -0,0 +1,3 @@
+export default realNames;
+/** Used to lookup unminified function names. */
+declare var realNames: {};

package/types/lodash/_reorder.d.ts

@@ -0,0 +1,12 @@
+export default reorder;
+/**
+ * Reorder `array` according to the specified indexes where the element at
+ * the first index is assigned as the first element, the element at
+ * the second index is assigned as the second element, and so on.
+ *
+ * @private
+ * @param {Array} array The array to reorder.
+ * @param {Array} indexes The arranged array indexes.
+ * @returns {Array} Returns `array`.
+ */
+declare function reorder(array: any[], indexes: any[]): any[];

package/types/lodash/_replaceHolders.d.ts

@@ -0,0 +1,11 @@
+export default replaceHolders;
+/**
+ * Replaces all `placeholder` elements in `array` with an internal placeholder
+ * and returns an array of their indexes.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {*} placeholder The placeholder to replace.
+ * @returns {Array} Returns the new array of placeholder indexes.
+ */
+declare function replaceHolders(array: any[], placeholder: any): any[];

package/types/lodash/_root.d.ts

@@ -0,0 +1,3 @@
+export default root;
+/** Used as a reference to the global object. */
+declare var root: any;

package/types/lodash/_safeGet.d.ts

@@ -0,0 +1,10 @@
+export default safeGet;
+/**
+ * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+declare function safeGet(object: Object, key: string): any;

package/types/lodash/_setCacheAdd.d.ts

@@ -0,0 +1,12 @@
+export default setCacheAdd;
+/**
+ * Adds `value` to the array cache.
+ *
+ * @private
+ * @name add
+ * @memberOf SetCache
+ * @alias push
+ * @param {*} value The value to cache.
+ * @returns {Object} Returns the cache instance.
+ */
+declare function setCacheAdd(value: any): Object;

package/types/lodash/_setCacheHas.d.ts

@@ -0,0 +1,11 @@
+export default setCacheHas;
+/**
+ * Checks if `value` is in the array cache.
+ *
+ * @private
+ * @name has
+ * @memberOf SetCache
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `true` if `value` is found, else `false`.
+ */
+declare function setCacheHas(value: any): number;

package/types/lodash/_setData.d.ts

@@ -0,0 +1,16 @@
+export default setData;
+/**
+ * Sets metadata for `func`.
+ *
+ * **Note:** If this function becomes hot, i.e. is invoked a lot in a short
+ * period of time, it will trip its breaker and transition to an identity
+ * function to avoid garbage collection pauses in V8. See
+ * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)
+ * for more details.
+ *
+ * @private
+ * @param {Function} func The function to associate metadata with.
+ * @param {*} data The metadata.
+ * @returns {Function} Returns `func`.
+ */
+declare var setData: Function;

package/types/lodash/_setToArray.d.ts

@@ -0,0 +1,9 @@
+export default setToArray;
+/**
+ * Converts `set` to an array of its values.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the values.
+ */
+declare function setToArray(set: Object): any[];

package/types/lodash/_setToPairs.d.ts

@@ -0,0 +1,9 @@
+export default setToPairs;
+/**
+ * Converts `set` to its value-value pairs.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the value-value pairs.
+ */
+declare function setToPairs(set: Object): any[];

package/types/lodash/_setToString.d.ts

@@ -0,0 +1,10 @@
+export default setToString;
+/**
+ * Sets the `toString` method of `func` to return `string`.
+ *
+ * @private
+ * @param {Function} func The function to modify.
+ * @param {Function} string The `toString` result.
+ * @returns {Function} Returns `func`.
+ */
+declare var setToString: Function;

package/types/lodash/_setWrapToString.d.ts

@@ -0,0 +1,12 @@
+export default setWrapToString;
+/**
+ * Sets the `toString` method of `wrapper` to mimic the source of `reference`
+ * with wrapper details in a comment at the top of the source body.
+ *
+ * @private
+ * @param {Function} wrapper The function to modify.
+ * @param {Function} reference The reference function.
+ * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
+ * @returns {Function} Returns `wrapper`.
+ */
+declare function setWrapToString(wrapper: Function, reference: Function, bitmask: number): Function;

package/types/lodash/_shortOut.d.ts

@@ -0,0 +1,11 @@
+export default shortOut;
+/**
+ * Creates a function that'll short out and invoke `identity` instead
+ * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
+ * milliseconds.
+ *
+ * @private
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new shortable function.
+ */
+declare function shortOut(func: Function): Function;

package/types/lodash/_shuffleSelf.d.ts

@@ -0,0 +1,10 @@
+export default shuffleSelf;
+/**
+ * A specialized version of `_.shuffle` which mutates and sets the size of `array`.
+ *
+ * @private
+ * @param {Array} array The array to shuffle.
+ * @param {number} [size=array.length] The size of `array`.
+ * @returns {Array} Returns `array`.
+ */
+declare function shuffleSelf(array: any[], size?: number): any[];

package/types/lodash/_stackClear.d.ts

@@ -0,0 +1,14 @@
+import { default as ListCache } from './_ListCache.js';
+export default stackClear;
+/**
+ * Removes all key-value entries from the stack.
+ *
+ * @private
+ * @name clear
+ * @memberOf Stack
+ */
+declare function stackClear(): void;
+declare class stackClear {
+    __data__: ListCache;
+    size: number;
+}

package/types/lodash/_stackDelete.d.ts

@@ -0,0 +1,24 @@
+export default stackDelete;
+/**
+ * Removes `key` and its value from the stack.
+ *
+ * @private
+ * @name delete
+ * @memberOf Stack
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+declare function stackDelete(key: string): boolean;
+declare class stackDelete {
+    /**
+     * Removes `key` and its value from the stack.
+     *
+     * @private
+     * @name delete
+     * @memberOf Stack
+     * @param {string} key The key of the value to remove.
+     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+     */
+    private constructor();
+    size: any;
+}

package/types/lodash/_stackGet.d.ts

@@ -0,0 +1,11 @@
+export default stackGet;
+/**
+ * Gets the stack value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Stack
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+declare function stackGet(key: string): any;

package/types/lodash/_stackHas.d.ts

@@ -0,0 +1,11 @@
+export default stackHas;
+/**
+ * Checks if a stack value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Stack
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+declare function stackHas(key: string): boolean;

package/types/lodash/_stackSet.d.ts

@@ -0,0 +1,28 @@
+import { default as MapCache } from './_MapCache.js';
+export default stackSet;
+/**
+ * Sets the stack `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Stack
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the stack cache instance.
+ */
+declare function stackSet(key: string, value: any): Object;
+declare class stackSet {
+    /**
+     * Sets the stack `key` to `value`.
+     *
+     * @private
+     * @name set
+     * @memberOf Stack
+     * @param {string} key The key of the value to set.
+     * @param {*} value The value to set.
+     * @returns {Object} Returns the stack cache instance.
+     */
+    private constructor();
+    size: any;
+    __data__: MapCache | undefined;
+}

package/types/lodash/_strictIndexOf.d.ts

@@ -0,0 +1,12 @@
+export default strictIndexOf;
+/**
+ * A specialized version of `_.indexOf` which performs strict equality
+ * comparisons of values, i.e. `===`.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} fromIndex The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+declare function strictIndexOf(array: any[], value: any, fromIndex: number): number;

package/types/lodash/_strictLastIndexOf.d.ts

@@ -0,0 +1,12 @@
+export default strictLastIndexOf;
+/**
+ * A specialized version of `_.lastIndexOf` which performs strict equality
+ * comparisons of values, i.e. `===`.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} fromIndex The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+declare function strictLastIndexOf(array: any[], value: any, fromIndex: number): number;

package/types/lodash/_stringSize.d.ts

@@ -0,0 +1,9 @@
+export default stringSize;
+/**
+ * Gets the number of symbols in `string`.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {number} Returns the string size.
+ */
+declare function stringSize(string: string): number;

package/types/lodash/_stringToArray.d.ts

@@ -0,0 +1,9 @@
+export default stringToArray;
+/**
+ * Converts `string` to an array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the converted array.
+ */
+declare function stringToArray(string: string): any[];

package/types/lodash/_stringToPath.d.ts

@@ -0,0 +1,9 @@
+export default stringToPath;
+/**
+ * Converts `string` to a property path array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the property path array.
+ */
+declare var stringToPath: Function;

package/types/lodash/_toKey.d.ts

@@ -0,0 +1,9 @@
+export default toKey;
+/**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+declare function toKey(value: any): string | symbol;

package/types/lodash/_toSource.d.ts

@@ -0,0 +1,9 @@
+export default toSource;
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to convert.
+ * @returns {string} Returns the source code.
+ */
+declare function toSource(func: Function): string;

package/types/lodash/_trimmedEndIndex.d.ts

@@ -0,0 +1,10 @@
+export default trimmedEndIndex;
+/**
+ * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+ * character of `string`.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {number} Returns the index of the last non-whitespace character.
+ */
+declare function trimmedEndIndex(string: string): number;

package/types/lodash/_unescapeHtmlChar.d.ts

@@ -0,0 +1,9 @@
+export default unescapeHtmlChar;
+/**
+ * Used by `_.unescape` to convert HTML entities to characters.
+ *
+ * @private
+ * @param {string} chr The matched character to unescape.
+ * @returns {string} Returns the unescaped character.
+ */
+declare var unescapeHtmlChar: Function;

package/types/lodash/_unicodeSize.d.ts

@@ -0,0 +1,9 @@
+export default unicodeSize;
+/**
+ * Gets the size of a Unicode `string`.
+ *
+ * @private
+ * @param {string} string The string inspect.
+ * @returns {number} Returns the string size.
+ */
+declare function unicodeSize(string: string): number;

package/types/lodash/_unicodeToArray.d.ts

@@ -0,0 +1,9 @@
+export default unicodeToArray;
+/**
+ * Converts a Unicode `string` to an array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the converted array.
+ */
+declare function unicodeToArray(string: string): any[];

package/types/lodash/_unicodeWords.d.ts

@@ -0,0 +1,9 @@
+export default unicodeWords;
+/**
+ * Splits a Unicode `string` into an array of its words.
+ *
+ * @private
+ * @param {string} The string to inspect.
+ * @returns {Array} Returns the words of `string`.
+ */
+declare function unicodeWords(string: any): any[];

package/types/lodash/_updateWrapDetails.d.ts

@@ -0,0 +1,10 @@
+export default updateWrapDetails;
+/**
+ * Updates wrapper `details` based on `bitmask` flags.
+ *
+ * @private
+ * @returns {Array} details The details to modify.
+ * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
+ * @returns {Array} Returns `details`.
+ */
+declare function updateWrapDetails(details: any, bitmask: number): any[];

package/types/lodash/_wrapperClone.d.ts

@@ -0,0 +1,9 @@
+export default wrapperClone;
+/**
+ * Creates a clone of `wrapper`.
+ *
+ * @private
+ * @param {Object} wrapper The wrapper to clone.
+ * @returns {Object} Returns the cloned wrapper.
+ */
+declare function wrapperClone(wrapper: Object): Object;

package/types/lodash/add.d.ts

@@ -0,0 +1,2 @@
+import { add } from 'lodash';
+export default add;

package/types/lodash/after.d.ts

@@ -0,0 +1,2 @@
+import { after } from 'lodash';
+export default after;

package/types/lodash/array.d.ts

@@ -0,0 +1,66 @@
+import { default as chunk } from './chunk';
+import { default as compact } from './compact';
+import { default as concat } from './concat';
+import { default as difference } from './difference';
+import { default as differenceBy } from './differenceBy';
+import { default as differenceWith } from './differenceWith';
+import { default as drop } from './drop';
+import { default as dropRight } from './dropRight';
+import { default as dropRightWhile } from './dropRightWhile';
+import { default as dropWhile } from './dropWhile';
+import { default as fill } from './fill';
+import { default as findIndex } from './findIndex';
+import { default as findLastIndex } from './findLastIndex';
+import { default as first } from './first';
+import { default as flatten } from './flatten';
+import { default as flattenDeep } from './flattenDeep';
+import { default as flattenDepth } from './flattenDepth';
+import { default as fromPairs } from './fromPairs';
+import { default as head } from './head';
+import { default as indexOf } from './indexOf';
+import { default as initial } from './initial';
+import { default as intersection } from './intersection';
+import { default as intersectionBy } from './intersectionBy';
+import { default as intersectionWith } from './intersectionWith';
+import { default as join } from './join';
+import { default as last } from './last';
+import { default as lastIndexOf } from './lastIndexOf';
+import { default as nth } from './nth';
+import { default as pull } from './pull';
+import { default as pullAll } from './pullAll';
+import { default as pullAllBy } from './pullAllBy';
+import { default as pullAllWith } from './pullAllWith';
+import { default as pullAt } from './pullAt';
+import { default as remove } from './remove';
+import { default as reverse } from './reverse';
+import { default as slice } from './slice';
+import { default as sortedIndex } from './sortedIndex';
+import { default as sortedIndexBy } from './sortedIndexBy';
+import { default as sortedIndexOf } from './sortedIndexOf';
+import { default as sortedLastIndex } from './sortedLastIndex';
+import { default as sortedLastIndexBy } from './sortedLastIndexBy';
+import { default as sortedLastIndexOf } from './sortedLastIndexOf';
+import { default as sortedUniq } from './sortedUniq';
+import { default as sortedUniqBy } from './sortedUniqBy';
+import { default as tail } from './tail';
+import { default as take } from './take';
+import { default as takeRight } from './takeRight';
+import { default as takeRightWhile } from './takeRightWhile';
+import { default as takeWhile } from './takeWhile';
+import { default as union } from './union';
+import { default as unionBy } from './unionBy';
+import { default as unionWith } from './unionWith';
+import { default as uniq } from './uniq';
+import { default as uniqBy } from './uniqBy';
+import { default as uniqWith } from './uniqWith';
+import { default as unzip } from './unzip';
+import { default as unzipWith } from './unzipWith';
+import { default as without } from './without';
+import { default as xor } from './xor';
+import { default as xorBy } from './xorBy';
+import { default as xorWith } from './xorWith';
+import { default as zip } from './zip';
+import { default as zipObject } from './zipObject';
+import { default as zipObjectDeep } from './zipObjectDeep';
+import { default as zipWith } from './zipWith';
+export { default } from './array.default';

package/types/lodash/array.default.d.ts

@@ -0,0 +1,133 @@
+import { default as chunk } from './chunk';
+import { default as compact } from './compact';
+import { default as concat } from './concat';
+import { default as difference } from './difference';
+import { default as differenceBy } from './differenceBy';
+import { default as differenceWith } from './differenceWith';
+import { default as drop } from './drop';
+import { default as dropRight } from './dropRight';
+import { default as dropRightWhile } from './dropRightWhile';
+import { default as dropWhile } from './dropWhile';
+import { default as fill } from './fill';
+import { default as findIndex } from './findIndex';
+import { default as findLastIndex } from './findLastIndex';
+import { default as first } from './first';
+import { default as flatten } from './flatten';
+import { default as flattenDeep } from './flattenDeep';
+import { default as flattenDepth } from './flattenDepth';
+import { default as fromPairs } from './fromPairs';
+import { default as head } from './head';
+import { default as indexOf } from './indexOf';
+import { default as initial } from './initial';
+import { default as intersection } from './intersection';
+import { default as intersectionBy } from './intersectionBy';
+import { default as intersectionWith } from './intersectionWith';
+import { default as join } from './join';
+import { default as last } from './last';
+import { default as lastIndexOf } from './lastIndexOf';
+import { default as nth } from './nth';
+import { default as pull } from './pull';
+import { default as pullAll } from './pullAll';
+import { default as pullAllBy } from './pullAllBy';
+import { default as pullAllWith } from './pullAllWith';
+import { default as pullAt } from './pullAt';
+import { default as remove } from './remove';
+import { default as reverse } from './reverse';
+import { default as slice } from './slice';
+import { default as sortedIndex } from './sortedIndex';
+import { default as sortedIndexBy } from './sortedIndexBy';
+import { default as sortedIndexOf } from './sortedIndexOf';
+import { default as sortedLastIndex } from './sortedLastIndex';
+import { default as sortedLastIndexBy } from './sortedLastIndexBy';
+import { default as sortedLastIndexOf } from './sortedLastIndexOf';
+import { default as sortedUniq } from './sortedUniq';
+import { default as sortedUniqBy } from './sortedUniqBy';
+import { default as tail } from './tail';
+import { default as take } from './take';
+import { default as takeRight } from './takeRight';
+import { default as takeRightWhile } from './takeRightWhile';
+import { default as takeWhile } from './takeWhile';
+import { default as union } from './union';
+import { default as unionBy } from './unionBy';
+import { default as unionWith } from './unionWith';
+import { default as uniq } from './uniq';
+import { default as uniqBy } from './uniqBy';
+import { default as uniqWith } from './uniqWith';
+import { default as unzip } from './unzip';
+import { default as unzipWith } from './unzipWith';
+import { default as without } from './without';
+import { default as xor } from './xor';
+import { default as xorBy } from './xorBy';
+import { default as xorWith } from './xorWith';
+import { default as zip } from './zip';
+import { default as zipObject } from './zipObject';
+import { default as zipObjectDeep } from './zipObjectDeep';
+import { default as zipWith } from './zipWith';
+declare const defaultExport: {
+    chunk: typeof chunk;
+    compact: typeof compact;
+    concat: typeof concat;
+    difference: typeof difference;
+    differenceBy: typeof differenceBy;
+    differenceWith: typeof differenceWith;
+    drop: typeof drop;
+    dropRight: typeof dropRight;
+    dropRightWhile: typeof dropRightWhile;
+    dropWhile: typeof dropWhile;
+    fill: typeof fill;
+    findIndex: typeof findIndex;
+    findLastIndex: typeof findLastIndex;
+    first: typeof first;
+    flatten: typeof flatten;
+    flattenDeep: typeof flattenDeep;
+    flattenDepth: typeof flattenDepth;
+    fromPairs: typeof fromPairs;
+    head: typeof head;
+    indexOf: typeof indexOf;
+    initial: typeof initial;
+    intersection: typeof intersection;
+    intersectionBy: typeof intersectionBy;
+    intersectionWith: typeof intersectionWith;
+    join: typeof join;
+    last: typeof last;
+    lastIndexOf: typeof lastIndexOf;
+    nth: typeof nth;
+    pull: typeof pull;
+    pullAll: typeof pullAll;
+    pullAllBy: typeof pullAllBy;
+    pullAllWith: typeof pullAllWith;
+    pullAt: typeof pullAt;
+    remove: typeof remove;
+    reverse: typeof reverse;
+    slice: typeof slice;
+    sortedIndex: typeof sortedIndex;
+    sortedIndexBy: typeof sortedIndexBy;
+    sortedIndexOf: typeof sortedIndexOf;
+    sortedLastIndex: typeof sortedLastIndex;
+    sortedLastIndexBy: typeof sortedLastIndexBy;
+    sortedLastIndexOf: typeof sortedLastIndexOf;
+    sortedUniq: typeof sortedUniq;
+    sortedUniqBy: typeof sortedUniqBy;
+    tail: typeof tail;
+    take: typeof take;
+    takeRight: typeof takeRight;
+    takeRightWhile: typeof takeRightWhile;
+    takeWhile: typeof takeWhile;
+    union: typeof union;
+    unionBy: typeof unionBy;
+    unionWith: typeof unionWith;
+    uniq: typeof uniq;
+    uniqBy: typeof uniqBy;
+    uniqWith: typeof uniqWith;
+    unzip: typeof unzip;
+    unzipWith: typeof unzipWith;
+    without: typeof without;
+    xor: typeof xor;
+    xorBy: typeof xorBy;
+    xorWith: typeof xorWith;
+    zip: typeof zip;
+    zipObject: typeof zipObject;
+    zipObjectDeep: typeof zipObjectDeep;
+    zipWith: typeof zipWith;
+};
+export default defaultExport;

package/types/lodash/ary.d.ts

@@ -0,0 +1,2 @@
+import { ary } from 'lodash';
+export default ary;

package/types/lodash/assign.d.ts

@@ -0,0 +1,2 @@
+import { assign } from 'lodash';
+export default assign;

package/types/lodash/assignIn.d.ts

@@ -0,0 +1,2 @@
+import { assignIn } from 'lodash';
+export default assignIn;