@unicom-cloud/utils 0.1.23 → 0.1.24

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 @@
+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;
+}
+import MapCache from './_MapCache.js';

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,17 @@
+export default add;
+/**
+ * Adds two numbers.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.4.0
+ * @category Math
+ * @param {number} augend The first number in an addition.
+ * @param {number} addend The second number in an addition.
+ * @returns {number} Returns the total.
+ * @example
+ *
+ * _.add(6, 4);
+ * // => 10
+ */
+declare var add: Function;

package/types/lodash/after.d.ts

@@ -0,0 +1,26 @@
+export default after;
+/**
+ * The opposite of `_.before`; this method creates a function that invokes
+ * `func` once it's called `n` or more times.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {number} n The number of calls before `func` is invoked.
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * var saves = ['profile', 'settings'];
+ *
+ * var done = _.after(saves.length, function() {
+ *   console.log('done saving!');
+ * });
+ *
+ * _.forEach(saves, function(type) {
+ *   asyncSave({ 'type': type, 'complete': done });
+ * });
+ * // => Logs 'done saving!' after the two async saves have completed.
+ */
+declare function after(n: number, func: Function): Function;

package/types/lodash/array.d.ts

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

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

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

package/types/lodash/ary.d.ts

@@ -0,0 +1,19 @@
+export default ary;
+/**
+ * Creates a function that invokes `func`, with up to `n` arguments,
+ * ignoring any additional arguments.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Function
+ * @param {Function} func The function to cap arguments for.
+ * @param {number} [n=func.length] The arity cap.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Function} Returns the new capped function.
+ * @example
+ *
+ * _.map(['6', '8', '10'], _.ary(parseInt, 1));
+ * // => [6, 8, 10]
+ */
+declare function ary(func: Function, n?: number, guard: any): Function;

package/types/lodash/assign.d.ts

@@ -0,0 +1,34 @@
+export default assign;
+/**
+ * Assigns own enumerable string keyed properties of source objects to the
+ * destination object. Source objects are applied from left to right.
+ * Subsequent sources overwrite property assignments of previous sources.
+ *
+ * **Note:** This method mutates `object` and is loosely based on
+ * [`Object.assign`](https://mdn.io/Object/assign).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.10.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @see _.assignIn
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ * }
+ *
+ * function Bar() {
+ *   this.c = 3;
+ * }
+ *
+ * Foo.prototype.b = 2;
+ * Bar.prototype.d = 4;
+ *
+ * _.assign({ 'a': 0 }, new Foo, new Bar);
+ * // => { 'a': 1, 'c': 3 }
+ */
+declare var assign: Function;

package/types/lodash/assignIn.d.ts

@@ -0,0 +1,33 @@
+export default assignIn;
+/**
+ * This method is like `_.assign` except that it iterates over own and
+ * inherited source properties.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @alias extend
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @see _.assign
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ * }
+ *
+ * function Bar() {
+ *   this.c = 3;
+ * }
+ *
+ * Foo.prototype.b = 2;
+ * Bar.prototype.d = 4;
+ *
+ * _.assignIn({ 'a': 0 }, new Foo, new Bar);
+ * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
+ */
+declare var assignIn: Function;

package/types/lodash/assignInWith.d.ts

@@ -0,0 +1,31 @@
+export default assignInWith;
+/**
+ * This method is like `_.assignIn` except that it accepts `customizer`
+ * which is invoked to produce the assigned values. If `customizer` returns
+ * `undefined`, assignment is handled by the method instead. The `customizer`
+ * is invoked with five arguments: (objValue, srcValue, key, object, source).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @alias extendWith
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} sources The source objects.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @returns {Object} Returns `object`.
+ * @see _.assignWith
+ * @example
+ *
+ * function customizer(objValue, srcValue) {
+ *   return _.isUndefined(objValue) ? srcValue : objValue;
+ * }
+ *
+ * var defaults = _.partialRight(_.assignInWith, customizer);
+ *
+ * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
+ * // => { 'a': 1, 'b': 2 }
+ */
+declare var assignInWith: Function;

package/types/lodash/assignWith.d.ts

@@ -0,0 +1,30 @@
+export default assignWith;
+/**
+ * This method is like `_.assign` except that it accepts `customizer`
+ * which is invoked to produce the assigned values. If `customizer` returns
+ * `undefined`, assignment is handled by the method instead. The `customizer`
+ * is invoked with five arguments: (objValue, srcValue, key, object, source).
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} sources The source objects.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @returns {Object} Returns `object`.
+ * @see _.assignInWith
+ * @example
+ *
+ * function customizer(objValue, srcValue) {
+ *   return _.isUndefined(objValue) ? srcValue : objValue;
+ * }
+ *
+ * var defaults = _.partialRight(_.assignWith, customizer);
+ *
+ * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
+ * // => { 'a': 1, 'b': 2 }
+ */
+declare var assignWith: Function;

package/types/lodash/at.d.ts

@@ -0,0 +1,19 @@
+export default at;
+/**
+ * Creates an array of values corresponding to `paths` of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.0.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {...(string|string[])} [paths] The property paths to pick.
+ * @returns {Array} Returns the picked values.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
+ *
+ * _.at(object, ['a[0].b.c', 'a[1]']);
+ * // => [3, 4]
+ */
+declare var at: Function;

package/types/lodash/attempt.d.ts

@@ -0,0 +1,24 @@
+export default attempt;
+/**
+ * Attempts to invoke `func`, returning either the result or the caught error
+ * object. Any additional arguments are provided to `func` when it's invoked.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Util
+ * @param {Function} func The function to attempt.
+ * @param {...*} [args] The arguments to invoke `func` with.
+ * @returns {*} Returns the `func` result or error object.
+ * @example
+ *
+ * // Avoid throwing errors for invalid selectors.
+ * var elements = _.attempt(function(selector) {
+ *   return document.querySelectorAll(selector);
+ * }, '>_>');
+ *
+ * if (_.isError(elements)) {
+ *   elements = [];
+ * }
+ */
+declare var attempt: Function;