@gooddata/util 11.68.0-alpha.0 → 11.68.0-alpha.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +1 -1
- package/NOTICE +179 -0
- package/esm/_/_assignValue.d.ts +12 -0
- package/esm/_/_assignValue.d.ts.map +1 -0
- package/esm/_/_assignValue.js +49 -0
- package/esm/_/_baseAssignValue.d.ts +41 -0
- package/esm/_/_baseAssignValue.d.ts.map +1 -0
- package/esm/_/_baseAssignValue.js +48 -0
- package/esm/_/_baseClone.d.ts +28 -0
- package/esm/_/_baseClone.d.ts.map +1 -0
- package/esm/_/_baseClone.js +229 -0
- package/esm/_/_baseDifference.d.ts +18 -0
- package/esm/_/_baseDifference.d.ts.map +1 -0
- package/esm/_/_baseDifference.js +79 -0
- package/esm/_/_baseEach.d.ts +11 -0
- package/esm/_/_baseEach.d.ts.map +1 -0
- package/esm/_/_baseEach.js +62 -0
- package/esm/_/_baseExtremum.d.ts +15 -0
- package/esm/_/_baseExtremum.d.ts.map +1 -0
- package/esm/_/_baseExtremum.js +64 -0
- package/esm/_/_baseGet.d.ts +10 -0
- package/esm/_/_baseGet.d.ts.map +1 -0
- package/esm/_/_baseGet.js +50 -0
- package/esm/_/_baseGetTag.d.ts +9 -0
- package/esm/_/_baseGetTag.d.ts.map +1 -0
- package/esm/_/_baseGetTag.js +48 -0
- package/esm/_/_baseIntersection.d.ts +19 -0
- package/esm/_/_baseIntersection.d.ts.map +1 -0
- package/esm/_/_baseIntersection.js +91 -0
- package/esm/_/_baseIsEqual.d.ts +34 -0
- package/esm/_/_baseIsEqual.d.ts.map +1 -0
- package/esm/_/_baseIsEqual.js +278 -0
- package/esm/_/_baseIsMatch.d.ts +13 -0
- package/esm/_/_baseIsMatch.d.ts.map +1 -0
- package/esm/_/_baseIsMatch.js +67 -0
- package/esm/_/_baseIteratee.d.ts +15 -0
- package/esm/_/_baseIteratee.d.ts.map +1 -0
- package/esm/_/_baseIteratee.js +65 -0
- package/esm/_/_baseKeys.d.ts +12 -0
- package/esm/_/_baseKeys.d.ts.map +1 -0
- package/esm/_/_baseKeys.js +46 -0
- package/esm/_/_baseMatches.d.ts +10 -0
- package/esm/_/_baseMatches.d.ts.map +1 -0
- package/esm/_/_baseMatches.js +50 -0
- package/esm/_/_baseMatchesProperty.d.ts +11 -0
- package/esm/_/_baseMatchesProperty.d.ts.map +1 -0
- package/esm/_/_baseMatchesProperty.js +59 -0
- package/esm/_/_baseMerge.d.ts +19 -0
- package/esm/_/_baseMerge.d.ts.map +1 -0
- package/esm/_/_baseMerge.js +146 -0
- package/esm/_/_baseOrderBy.d.ts +11 -0
- package/esm/_/_baseOrderBy.d.ts.map +1 -0
- package/esm/_/_baseOrderBy.js +70 -0
- package/esm/_/_basePickBy.d.ts +14 -0
- package/esm/_/_basePickBy.d.ts.map +1 -0
- package/esm/_/_basePickBy.js +57 -0
- package/esm/_/_baseSet.d.ts +13 -0
- package/esm/_/_baseSet.d.ts.map +1 -0
- package/esm/_/_baseSet.js +74 -0
- package/esm/_/_baseSlice.d.ts +45 -0
- package/esm/_/_baseSlice.d.ts.map +1 -0
- package/esm/_/_baseSlice.js +30 -0
- package/esm/_/_baseSum.d.ts +42 -0
- package/esm/_/_baseSum.d.ts.map +1 -0
- package/esm/_/_baseSum.js +21 -0
- package/esm/_/_baseUniq.d.ts +43 -0
- package/esm/_/_baseUniq.d.ts.map +1 -0
- package/esm/_/_baseUniq.js +57 -0
- package/esm/_/_baseUnset.d.ts +13 -0
- package/esm/_/_baseUnset.d.ts.map +1 -0
- package/esm/_/_baseUnset.js +62 -0
- package/esm/_/_castPath.d.ts +10 -0
- package/esm/_/_castPath.d.ts.map +1 -0
- package/esm/_/_castPath.js +48 -0
- package/esm/_/_cloneArrayBuffer.d.ts +39 -0
- package/esm/_/_cloneArrayBuffer.d.ts.map +1 -0
- package/esm/_/_cloneArrayBuffer.js +45 -0
- package/esm/_/_cloneTypedArray.d.ts +10 -0
- package/esm/_/_cloneTypedArray.d.ts.map +1 -0
- package/esm/_/_cloneTypedArray.js +50 -0
- package/esm/_/_compareAscending.d.ts +12 -0
- package/esm/_/_compareAscending.d.ts.map +1 -0
- package/esm/_/_compareAscending.js +78 -0
- package/esm/_/_createCompounder.d.ts +11 -0
- package/esm/_/_createCompounder.d.ts.map +1 -0
- package/esm/_/_createCompounder.js +47 -0
- package/esm/_/_flattenArrayLikeObjects.d.ts +11 -0
- package/esm/_/_flattenArrayLikeObjects.d.ts.map +1 -0
- package/esm/_/_flattenArrayLikeObjects.js +55 -0
- package/esm/_/_getAllKeys.d.ts +9 -0
- package/esm/_/_getAllKeys.d.ts.map +1 -0
- package/esm/_/_getAllKeys.js +43 -0
- package/esm/_/_getAllKeysIn.d.ts +12 -0
- package/esm/_/_getAllKeysIn.d.ts.map +1 -0
- package/esm/_/_getAllKeysIn.js +59 -0
- package/esm/_/_getMatchData.d.ts +16 -0
- package/esm/_/_getMatchData.d.ts.map +1 -0
- package/esm/_/_getMatchData.js +46 -0
- package/esm/_/_getRawTag.d.ts +43 -0
- package/esm/_/_getRawTag.d.ts.map +1 -0
- package/esm/_/_getRawTag.js +65 -0
- package/esm/_/_hasPath.d.ts +13 -0
- package/esm/_/_hasPath.d.ts.map +1 -0
- package/esm/_/_hasPath.js +70 -0
- package/esm/_/_initCloneObject.d.ts +10 -0
- package/esm/_/_initCloneObject.d.ts.map +1 -0
- package/esm/_/_initCloneObject.js +48 -0
- package/esm/_/_isIndex.d.ts +11 -0
- package/esm/_/_isIndex.d.ts.map +1 -0
- package/esm/_/_isIndex.js +51 -0
- package/esm/_/_isIterateeCall.d.ts +13 -0
- package/esm/_/_isIterateeCall.d.ts.map +1 -0
- package/esm/_/_isIterateeCall.js +55 -0
- package/esm/_/_isKey.d.ts +12 -0
- package/esm/_/_isKey.d.ts.map +1 -0
- package/esm/_/_isKey.js +58 -0
- package/esm/_/_isPrototype.d.ts +39 -0
- package/esm/_/_isPrototype.d.ts.map +1 -0
- package/esm/_/_isPrototype.js +43 -0
- package/esm/_/_isStrictComparable.d.ts +9 -0
- package/esm/_/_isStrictComparable.d.ts.map +1 -0
- package/esm/_/_isStrictComparable.js +42 -0
- package/esm/_/_matchesStrictComparable.d.ts +41 -0
- package/esm/_/_matchesStrictComparable.d.ts.map +1 -0
- package/esm/_/_matchesStrictComparable.js +50 -0
- package/esm/_/_stringToPath.d.ts +10 -0
- package/esm/_/_stringToPath.d.ts.map +1 -0
- package/esm/_/_stringToPath.js +64 -0
- package/esm/_/_toKey.d.ts +9 -0
- package/esm/_/_toKey.d.ts.map +1 -0
- package/esm/_/_toKey.js +46 -0
- package/esm/_/_unicode.d.ts +27 -0
- package/esm/_/_unicode.d.ts.map +1 -0
- package/esm/_/_unicode.js +120 -0
- package/esm/_/assignIn.d.ts +35 -0
- package/esm/_/assignIn.d.ts.map +1 -0
- package/esm/_/assignIn.js +50 -0
- package/esm/_/bindAll.d.ts +16 -0
- package/esm/_/bindAll.d.ts.map +1 -0
- package/esm/_/bindAll.js +88 -0
- package/esm/_/camelCase.d.ts +10 -0
- package/esm/_/camelCase.d.ts.map +1 -0
- package/esm/_/camelCase.js +45 -0
- package/esm/_/capitalize.d.ts +9 -0
- package/esm/_/capitalize.d.ts.map +1 -0
- package/esm/_/capitalize.js +43 -0
- package/esm/_/chunk.d.ts +15 -0
- package/esm/_/chunk.d.ts.map +1 -0
- package/esm/_/chunk.js +61 -0
- package/esm/_/clamp.d.ts +17 -0
- package/esm/_/clamp.d.ts.map +1 -0
- package/esm/_/clamp.js +56 -0
- package/esm/_/clone.d.ts +12 -0
- package/esm/_/clone.d.ts.map +1 -0
- package/esm/_/clone.js +45 -0
- package/esm/_/cloneDeep.d.ts +14 -0
- package/esm/_/cloneDeep.d.ts.map +1 -0
- package/esm/_/cloneDeep.js +47 -0
- package/esm/_/cloneDeepWith.d.ts +18 -0
- package/esm/_/cloneDeepWith.d.ts.map +1 -0
- package/esm/_/cloneDeepWith.js +36 -0
- package/esm/_/compact.d.ts +46 -0
- package/esm/_/compact.d.ts.map +1 -0
- package/esm/_/compact.js +23 -0
- package/esm/_/constant.d.ts +39 -0
- package/esm/_/constant.d.ts.map +1 -0
- package/esm/_/constant.js +43 -0
- package/esm/_/debounce.d.ts +70 -0
- package/esm/_/debounce.d.ts.map +1 -0
- package/esm/_/debounce.js +136 -0
- package/esm/_/deburr.d.ts +10 -0
- package/esm/_/deburr.d.ts.map +1 -0
- package/esm/_/deburr.js +243 -0
- package/esm/_/defaults.d.ts +36 -0
- package/esm/_/defaults.d.ts.map +1 -0
- package/esm/_/defaults.js +51 -0
- package/esm/_/difference.d.ts +14 -0
- package/esm/_/difference.d.ts.map +1 -0
- package/esm/_/difference.js +46 -0
- package/esm/_/differenceBy.d.ts +39 -0
- package/esm/_/differenceBy.d.ts.map +1 -0
- package/esm/_/differenceBy.js +40 -0
- package/esm/_/differenceWith.d.ts +27 -0
- package/esm/_/differenceWith.d.ts.map +1 -0
- package/esm/_/differenceWith.js +39 -0
- package/esm/_/dropRightWhile.d.ts +13 -0
- package/esm/_/dropRightWhile.d.ts.map +1 -0
- package/esm/_/dropRightWhile.js +54 -0
- package/esm/_/eq.d.ts +41 -0
- package/esm/_/eq.d.ts.map +1 -0
- package/esm/_/eq.js +43 -0
- package/esm/_/escape.d.ts +13 -0
- package/esm/_/escape.d.ts.map +1 -0
- package/esm/_/escape.js +56 -0
- package/esm/_/escapeRegExp.d.ts +12 -0
- package/esm/_/escapeRegExp.d.ts.map +1 -0
- package/esm/_/escapeRegExp.js +47 -0
- package/esm/_/findKey.d.ts +14 -0
- package/esm/_/findKey.d.ts.map +1 -0
- package/esm/_/findKey.js +58 -0
- package/esm/_/findLastIndex.d.ts +16 -0
- package/esm/_/findLastIndex.d.ts.map +1 -0
- package/esm/_/findLastIndex.js +67 -0
- package/esm/_/get.d.ts +78 -0
- package/esm/_/get.d.ts.map +1 -0
- package/esm/_/get.js +36 -0
- package/esm/_/groupBy.d.ts +19 -0
- package/esm/_/groupBy.d.ts.map +1 -0
- package/esm/_/groupBy.js +49 -0
- package/esm/_/has.d.ts +23 -0
- package/esm/_/has.d.ts.map +1 -0
- package/esm/_/has.js +35 -0
- package/esm/_/inRange.d.ts +14 -0
- package/esm/_/inRange.d.ts.map +1 -0
- package/esm/_/inRange.js +51 -0
- package/esm/_/initial.d.ts +11 -0
- package/esm/_/initial.d.ts.map +1 -0
- package/esm/_/initial.js +44 -0
- package/esm/_/intersection.d.ts +13 -0
- package/esm/_/intersection.d.ts.map +1 -0
- package/esm/_/intersection.js +45 -0
- package/esm/_/intersectionBy.d.ts +32 -0
- package/esm/_/intersectionBy.d.ts.map +1 -0
- package/esm/_/intersectionBy.js +41 -0
- package/esm/_/intersectionWith.d.ts +28 -0
- package/esm/_/intersectionWith.d.ts.map +1 -0
- package/esm/_/intersectionWith.js +38 -0
- package/esm/_/invert.d.ts +14 -0
- package/esm/_/invert.d.ts.map +1 -0
- package/esm/_/invert.js +55 -0
- package/esm/_/isArguments.d.ts +9 -0
- package/esm/_/isArguments.d.ts.map +1 -0
- package/esm/_/isArguments.js +45 -0
- package/esm/_/isArray.d.ts +61 -0
- package/esm/_/isArray.d.ts.map +1 -0
- package/esm/_/isArray.js +62 -0
- package/esm/_/isArrayLike.d.ts +25 -0
- package/esm/_/isArrayLike.d.ts.map +1 -0
- package/esm/_/isArrayLike.js +35 -0
- package/esm/_/isEmpty.d.ts +49 -0
- package/esm/_/isEmpty.d.ts.map +1 -0
- package/esm/_/isEmpty.js +57 -0
- package/esm/_/isEqual.d.ts +15 -0
- package/esm/_/isEqual.d.ts.map +1 -0
- package/esm/_/isEqual.js +48 -0
- package/esm/_/isError.d.ts +11 -0
- package/esm/_/isError.d.ts.map +1 -0
- package/esm/_/isError.js +57 -0
- package/esm/_/isLength.d.ts +41 -0
- package/esm/_/isLength.d.ts.map +1 -0
- package/esm/_/isLength.js +43 -0
- package/esm/_/isObject.d.ts +40 -0
- package/esm/_/isObject.d.ts.map +1 -0
- package/esm/_/isObject.js +42 -0
- package/esm/_/isObjectLike.d.ts +40 -0
- package/esm/_/isObjectLike.d.ts.map +1 -0
- package/esm/_/isObjectLike.js +42 -0
- package/esm/_/isPlainObject.d.ts +10 -0
- package/esm/_/isPlainObject.d.ts.map +1 -0
- package/esm/_/isPlainObject.js +58 -0
- package/esm/_/isSymbol.d.ts +9 -0
- package/esm/_/isSymbol.d.ts.map +1 -0
- package/esm/_/isSymbol.js +45 -0
- package/esm/_/isTypedArray.d.ts +43 -0
- package/esm/_/isTypedArray.d.ts.map +1 -0
- package/esm/_/isTypedArray.js +45 -0
- package/esm/_/kebabCase.d.ts +9 -0
- package/esm/_/kebabCase.d.ts.map +1 -0
- package/esm/_/kebabCase.js +40 -0
- package/esm/_/keyBy.d.ts +17 -0
- package/esm/_/keyBy.d.ts.map +1 -0
- package/esm/_/keyBy.js +43 -0
- package/esm/_/keys.d.ts +11 -0
- package/esm/_/keys.d.ts.map +1 -0
- package/esm/_/keys.js +60 -0
- package/esm/_/keysIn.d.ts +10 -0
- package/esm/_/keysIn.d.ts.map +1 -0
- package/esm/_/keysIn.js +54 -0
- package/esm/_/mapValues.d.ts +63 -0
- package/esm/_/mapValues.d.ts.map +1 -0
- package/esm/_/mapValues.js +47 -0
- package/esm/_/max.d.ts +16 -0
- package/esm/_/max.d.ts.map +1 -0
- package/esm/_/max.js +37 -0
- package/esm/_/memoize.d.ts +89 -0
- package/esm/_/memoize.d.ts.map +1 -0
- package/esm/_/memoize.js +36 -0
- package/esm/_/merge.d.ts +32 -0
- package/esm/_/merge.d.ts.map +1 -0
- package/esm/_/merge.js +45 -0
- package/esm/_/mergeWith.d.ts +34 -0
- package/esm/_/mergeWith.d.ts.map +1 -0
- package/esm/_/mergeWith.js +50 -0
- package/esm/_/min.d.ts +16 -0
- package/esm/_/min.d.ts.map +1 -0
- package/esm/_/min.js +37 -0
- package/esm/_/negate.d.ts +41 -0
- package/esm/_/negate.d.ts.map +1 -0
- package/esm/_/negate.js +48 -0
- package/esm/_/omit.d.ts +27 -0
- package/esm/_/omit.d.ts.map +1 -0
- package/esm/_/omit.js +76 -0
- package/esm/_/omitBy.d.ts +21 -0
- package/esm/_/omitBy.d.ts.map +1 -0
- package/esm/_/omitBy.js +37 -0
- package/esm/_/partial.d.ts +87 -0
- package/esm/_/partial.d.ts.map +1 -0
- package/esm/_/partial.js +30 -0
- package/esm/_/partition.d.ts +23 -0
- package/esm/_/partition.d.ts.map +1 -0
- package/esm/_/partition.js +42 -0
- package/esm/_/pick.d.ts +18 -0
- package/esm/_/pick.d.ts.map +1 -0
- package/esm/_/pick.js +48 -0
- package/esm/_/pickBy.d.ts +21 -0
- package/esm/_/pickBy.d.ts.map +1 -0
- package/esm/_/pickBy.js +36 -0
- package/esm/_/range.d.ts +24 -0
- package/esm/_/range.d.ts.map +1 -0
- package/esm/_/range.js +56 -0
- package/esm/_/reduce.d.ts +37 -0
- package/esm/_/reduce.d.ts.map +1 -0
- package/esm/_/reduce.js +48 -0
- package/esm/_/set.d.ts +25 -0
- package/esm/_/set.d.ts.map +1 -0
- package/esm/_/set.js +35 -0
- package/esm/_/sortBy.d.ts +17 -0
- package/esm/_/sortBy.d.ts.map +1 -0
- package/esm/_/sortBy.js +46 -0
- package/esm/_/sumBy.d.ts +14 -0
- package/esm/_/sumBy.d.ts.map +1 -0
- package/esm/_/sumBy.js +47 -0
- package/esm/_/tail.d.ts +15 -0
- package/esm/_/tail.d.ts.map +1 -0
- package/esm/_/tail.js +36 -0
- package/esm/_/throttle.d.ts +76 -0
- package/esm/_/throttle.d.ts.map +1 -0
- package/esm/_/throttle.js +45 -0
- package/esm/_/times.d.ts +17 -0
- package/esm/_/times.d.ts.map +1 -0
- package/esm/_/times.js +57 -0
- package/esm/_/toFinite.d.ts +10 -0
- package/esm/_/toFinite.d.ts.map +1 -0
- package/esm/_/toFinite.js +50 -0
- package/esm/_/toInteger.d.ts +11 -0
- package/esm/_/toInteger.d.ts.map +1 -0
- package/esm/_/toInteger.js +46 -0
- package/esm/_/toNumber.d.ts +11 -0
- package/esm/_/toNumber.d.ts.map +1 -0
- package/esm/_/toNumber.js +69 -0
- package/esm/_/toString.d.ts +11 -0
- package/esm/_/toString.d.ts.map +1 -0
- package/esm/_/toString.js +57 -0
- package/esm/_/types.d.ts +181 -0
- package/esm/_/types.d.ts.map +1 -0
- package/esm/_/types.js +2 -0
- package/esm/_/unescape.d.ts +13 -0
- package/esm/_/unescape.d.ts.map +1 -0
- package/esm/_/unescape.js +56 -0
- package/esm/_/union.d.ts +11 -0
- package/esm/_/union.d.ts.map +1 -0
- package/esm/_/union.js +44 -0
- package/esm/_/unionBy.d.ts +34 -0
- package/esm/_/unionBy.d.ts.map +1 -0
- package/esm/_/unionBy.js +42 -0
- package/esm/_/uniq.d.ts +12 -0
- package/esm/_/uniq.d.ts.map +1 -0
- package/esm/_/uniq.js +47 -0
- package/esm/_/uniqBy.d.ts +13 -0
- package/esm/_/uniqBy.d.ts.map +1 -0
- package/esm/_/uniqBy.js +49 -0
- package/esm/_/uniqWith.d.ts +14 -0
- package/esm/_/uniqWith.d.ts.map +1 -0
- package/esm/_/uniqWith.js +59 -0
- package/esm/_/update.d.ts +17 -0
- package/esm/_/update.d.ts.map +1 -0
- package/esm/_/update.js +55 -0
- package/esm/_/updateWith.d.ts +23 -0
- package/esm/_/updateWith.d.ts.map +1 -0
- package/esm/_/updateWith.js +41 -0
- package/esm/_/upperFirst.d.ts +10 -0
- package/esm/_/upperFirst.d.ts.map +1 -0
- package/esm/_/upperFirst.js +46 -0
- package/esm/_/without.d.ts +15 -0
- package/esm/_/without.d.ts.map +1 -0
- package/esm/_/without.js +47 -0
- package/esm/_/words.d.ts +9 -0
- package/esm/_/words.d.ts.map +1 -0
- package/esm/_/words.js +50 -0
- package/esm/_/zip.d.ts +28 -0
- package/esm/_/zip.d.ts.map +1 -0
- package/esm/_/zip.js +38 -0
- package/esm/index.d.ts +69 -0
- package/esm/index.d.ts.map +1 -1
- package/esm/index.js +69 -0
- package/esm/util.d.ts +1870 -67
- package/package.json +5 -4
package/esm/util.d.ts
CHANGED
|
@@ -7,148 +7,1628 @@
|
|
|
7
7
|
* @packageDocumentation
|
|
8
8
|
*/
|
|
9
9
|
|
|
10
|
+
/**
|
|
11
|
+
* @internal
|
|
12
|
+
*/
|
|
13
|
+
export declare type _ArrayIterator<T, TResult> = (value: T, index: number, collection: T[]) => TResult;
|
|
14
|
+
|
|
15
|
+
/**
|
|
16
|
+
* This method is like `_assign` except that it iterates over own and inherited source properties: it
|
|
17
|
+
* assigns the own and inherited enumerable string keyed properties of the source objects to the destination
|
|
18
|
+
* object, left to right, so later sources overwrite earlier ones. Falsy sources are skipped, array-like
|
|
19
|
+
* sources are copied by index, and a nullish destination becomes a new object while a primitive one is boxed.
|
|
20
|
+
*
|
|
21
|
+
* **Note:** This method mutates `object`.
|
|
22
|
+
*
|
|
23
|
+
* @param object - The destination object.
|
|
24
|
+
* @param sources - The source objects.
|
|
25
|
+
* @returns Returns `object`.
|
|
26
|
+
* @internal
|
|
27
|
+
*/
|
|
28
|
+
export declare function _assignIn<TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
|
|
29
|
+
|
|
30
|
+
/**
|
|
31
|
+
* @internal
|
|
32
|
+
*/
|
|
33
|
+
export declare function _assignIn<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
|
|
34
|
+
|
|
35
|
+
/**
|
|
36
|
+
* @internal
|
|
37
|
+
*/
|
|
38
|
+
export declare function _assignIn<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3;
|
|
39
|
+
|
|
40
|
+
/**
|
|
41
|
+
* @internal
|
|
42
|
+
*/
|
|
43
|
+
export declare function _assignIn<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4;
|
|
44
|
+
|
|
45
|
+
/**
|
|
46
|
+
* @internal
|
|
47
|
+
*/
|
|
48
|
+
export declare function _assignIn<TObject>(object: TObject): TObject;
|
|
49
|
+
|
|
50
|
+
/**
|
|
51
|
+
* @internal
|
|
52
|
+
*/
|
|
53
|
+
export declare function _assignIn<TResult>(object: any, ...otherArgs: any[]): TResult;
|
|
54
|
+
|
|
55
|
+
/**
|
|
56
|
+
* Binds methods of an object to the object itself, overwriting the existing method. Method names may be
|
|
57
|
+
* specified as individual arguments or as arrays of method names, which are flattened one level; names are
|
|
58
|
+
* coerced to property keys the way lodash does it, so symbols and `-0` are kept.
|
|
59
|
+
*
|
|
60
|
+
* **Note:** This method doesn't set the "length" property of bound functions, and it mutates `object`.
|
|
61
|
+
*
|
|
62
|
+
* @param object - The object to bind and assign the bound methods to.
|
|
63
|
+
* @param methodNames - The object method names to bind.
|
|
64
|
+
* @returns Returns `object`.
|
|
65
|
+
* @throws TypeError when a named property is not a function.
|
|
66
|
+
* @internal
|
|
67
|
+
*/
|
|
68
|
+
export declare function _bindAll<T>(object: T, ...methodNames: _Many<string>[]): T;
|
|
69
|
+
|
|
70
|
+
/**
|
|
71
|
+
* Converts `string` to camel case: the words of the string, lower-cased, with every word but the first
|
|
72
|
+
* capitalised, joined together.
|
|
73
|
+
*
|
|
74
|
+
* @param string - The string to convert.
|
|
75
|
+
* @returns Returns the camel cased string.
|
|
76
|
+
* @internal
|
|
77
|
+
*/
|
|
78
|
+
export declare const _camelCase: (string?: string) => string;
|
|
79
|
+
|
|
80
|
+
/**
|
|
81
|
+
* Converts the first character of `string` to upper case and the remaining to lower case.
|
|
82
|
+
*
|
|
83
|
+
* @param string - The string to capitalize.
|
|
84
|
+
* @returns Returns the capitalized string.
|
|
85
|
+
* @internal
|
|
86
|
+
*/
|
|
87
|
+
export declare function _capitalize(string?: string): string;
|
|
88
|
+
|
|
89
|
+
/**
|
|
90
|
+
* Creates an array of elements split into groups the length of `size`. If `array` can't be split evenly, the
|
|
91
|
+
* final chunk will be the remaining elements. The size is coerced to an integer the way lodash does it, and
|
|
92
|
+
* a size below 1 yields an empty array.
|
|
93
|
+
*
|
|
94
|
+
* @param array - The array to process.
|
|
95
|
+
* @param size - The length of each chunk. Defaults to 1.
|
|
96
|
+
* @param guard - Enables use as an iteratee for methods like `map`: when it is the collection holding
|
|
97
|
+
* `array` at index `size`, the size is ignored.
|
|
98
|
+
* @returns Returns the new array of chunks.
|
|
99
|
+
* @internal
|
|
100
|
+
*/
|
|
101
|
+
export declare function _chunk<T>(array: _List<T> | null | undefined, size?: number, guard?: unknown): T[][];
|
|
102
|
+
|
|
103
|
+
/**
|
|
104
|
+
* Clamps `number` within the inclusive `lower` and `upper` bounds. With two arguments the second one is the
|
|
105
|
+
* upper bound. The upper bound is applied first, bounds that convert to `NaN` count as `0`, an `undefined`
|
|
106
|
+
* bound is skipped, and a `NaN` number is returned as is.
|
|
107
|
+
*
|
|
108
|
+
* @param number - The number to clamp.
|
|
109
|
+
* @param lower - The lower bound.
|
|
110
|
+
* @param upper - The upper bound.
|
|
111
|
+
* @returns Returns the clamped number.
|
|
112
|
+
* @internal
|
|
113
|
+
*/
|
|
114
|
+
export declare function _clamp(number: number, lower: number, upper: number): number;
|
|
115
|
+
|
|
116
|
+
/**
|
|
117
|
+
* @internal
|
|
118
|
+
*/
|
|
119
|
+
export declare function _clamp(number: number, upper: number): number;
|
|
120
|
+
|
|
121
|
+
/**
|
|
122
|
+
* Creates a shallow clone of `value`: arrays, plain objects, arguments objects, dates, regexps, maps, sets,
|
|
123
|
+
* typed arrays, array buffers, data views and boxed primitives are copied one level, with nested values
|
|
124
|
+
* kept by reference. An empty object is returned for uncloneable values such as functions, errors and
|
|
125
|
+
* weak collections.
|
|
126
|
+
*
|
|
127
|
+
* @param value - The value to clone.
|
|
128
|
+
* @returns Returns the cloned value.
|
|
129
|
+
* @internal
|
|
130
|
+
*/
|
|
131
|
+
export declare function _clone<T>(value: T): T;
|
|
132
|
+
|
|
133
|
+
/**
|
|
134
|
+
* Recursively clones `value`.
|
|
135
|
+
*
|
|
136
|
+
* Supports cloning arrays, array buffers, booleans, date objects, maps, numbers, `Object` objects, regexes,
|
|
137
|
+
* sets, strings, symbols, and typed arrays. The own enumerable properties of arguments objects are cloned
|
|
138
|
+
* as plain objects. An empty object is returned for uncloneable values such as error objects, functions,
|
|
139
|
+
* DOM nodes, and WeakMaps; nested uncloneable values are kept by reference.
|
|
140
|
+
*
|
|
141
|
+
* @param value - The value to recursively clone.
|
|
142
|
+
* @returns Returns the deep cloned value.
|
|
143
|
+
* @internal
|
|
144
|
+
*/
|
|
145
|
+
export declare function _cloneDeep<T>(value: T): T;
|
|
146
|
+
|
|
147
|
+
/**
|
|
148
|
+
* This method is like `_cloneDeep` except that it accepts `customizer` which is invoked to produce the
|
|
149
|
+
* cloned value. If `customizer` returns `undefined`, cloning is handled by the method instead. The
|
|
150
|
+
* `customizer` is invoked with up to four arguments: (value [, index|key, object, stack]). Anything but
|
|
151
|
+
* a function is ignored as a customizer.
|
|
152
|
+
*
|
|
153
|
+
* @param value - The value to recursively clone.
|
|
154
|
+
* @param customizer - The function to customize cloning.
|
|
155
|
+
* @returns Returns the deep cloned value.
|
|
156
|
+
* @internal
|
|
157
|
+
*/
|
|
158
|
+
export declare function _cloneDeepWith<T>(value: T, customizer: _CloneDeepWithCustomizer<T>): any;
|
|
159
|
+
|
|
160
|
+
/**
|
|
161
|
+
* @internal
|
|
162
|
+
*/
|
|
163
|
+
export declare function _cloneDeepWith<T>(value: T): T;
|
|
164
|
+
|
|
165
|
+
/**
|
|
166
|
+
* The customizer of `_cloneDeepWith`: invoked with the value alone at the top level and with the value,
|
|
167
|
+
* its key, the containing object and the stack of objects being cloned below. A result other than
|
|
168
|
+
* `undefined` is used as the cloned value.
|
|
169
|
+
*
|
|
170
|
+
* @internal
|
|
171
|
+
*/
|
|
172
|
+
export declare type _CloneDeepWithCustomizer<TObject> = (value: any, key: number | string | undefined, object: TObject | undefined, stack: any) => any;
|
|
173
|
+
|
|
10
174
|
/**
|
|
11
175
|
* Returns combine guard from input guards as a result type is union type of guarded types
|
|
12
176
|
* Its good for array filtering base on multiple guards and its return correct result union type
|
|
13
177
|
*
|
|
14
178
|
* @internal
|
|
15
179
|
*/
|
|
16
|
-
export declare function combineGuards<T extends ((x: unknown) => x is unknown)[]>(...guards: T): (x: unknown) => x is GuardType<T[number]>;
|
|
180
|
+
export declare function combineGuards<T extends ((x: unknown) => x is unknown)[]>(...guards: T): (x: unknown) => x is GuardType<T[number]>;
|
|
181
|
+
|
|
182
|
+
/**
|
|
183
|
+
* Creates an array with all falsey values removed. The values `false`, `null`, `0`, `-0`, `0n`, `""`,
|
|
184
|
+
* `undefined`, and `NaN` are falsey. Holes in sparse arrays are skipped as well.
|
|
185
|
+
*
|
|
186
|
+
* @param array - The array or array-like to _compact.
|
|
187
|
+
* @returns Returns the new array of filtered values.
|
|
188
|
+
* @internal
|
|
189
|
+
*/
|
|
190
|
+
export declare function _compact<T>(array: _List<T | _Falsey> | null | undefined): T[];
|
|
191
|
+
|
|
192
|
+
/**
|
|
193
|
+
* @internal
|
|
194
|
+
*/
|
|
195
|
+
export declare type _Comparator<T> = (a: T, b: T) => boolean;
|
|
196
|
+
|
|
197
|
+
/**
|
|
198
|
+
* @internal
|
|
199
|
+
*/
|
|
200
|
+
export declare type _Comparator2<T1, T2> = (a: T1, b: T2) => boolean;
|
|
201
|
+
|
|
202
|
+
/**
|
|
203
|
+
* A console function, like log, warn or error
|
|
204
|
+
*
|
|
205
|
+
* @internal
|
|
206
|
+
*/
|
|
207
|
+
export declare type ConsoleFunction = (...data: any[]) => void;
|
|
208
|
+
|
|
209
|
+
/**
|
|
210
|
+
* A type of console to suppress
|
|
211
|
+
*
|
|
212
|
+
* @internal
|
|
213
|
+
*/
|
|
214
|
+
export declare type ConsoleType = "error" | "warn" | "log" | "debug" | "info";
|
|
215
|
+
|
|
216
|
+
/**
|
|
217
|
+
* Creates a function that returns `value`, by reference, on every call, ignoring its arguments and `this`.
|
|
218
|
+
*
|
|
219
|
+
* @param value - The value to return from the new function.
|
|
220
|
+
* @returns Returns the new constant function.
|
|
221
|
+
* @internal
|
|
222
|
+
*/
|
|
223
|
+
export declare function _constant<T>(value: T): () => T;
|
|
224
|
+
|
|
225
|
+
/**
|
|
226
|
+
* Wraps a testing-library waitFor so it polls every millisecond instead of the default 50ms.
|
|
227
|
+
*
|
|
228
|
+
* @remarks
|
|
229
|
+
* Use in tests where the awaited work settles on the next microtask or a resolved promise -
|
|
230
|
+
* there, every pending assertion would otherwise cost a full default poll interval.
|
|
231
|
+
*
|
|
232
|
+
* @param waitFor - the consumer's waitFor (e.g. from `@testing-library/react`)
|
|
233
|
+
* @param interval - the polling interval in milliseconds, 1 by default
|
|
234
|
+
* @internal
|
|
235
|
+
*/
|
|
236
|
+
export declare function createTightWaitFor(waitFor: WaitForFn, interval?: number): <T>(callback: () => T | Promise<T>) => Promise<T>;
|
|
237
|
+
|
|
238
|
+
/**
|
|
239
|
+
* Creates a debounced function that delays invoking `func` until after `wait` milliseconds have elapsed
|
|
240
|
+
* since the last time the debounced function was invoked. The debounced function comes with a `cancel`
|
|
241
|
+
* method to cancel delayed `func` invocations and a `flush` method to immediately invoke them. Provide
|
|
242
|
+
* `options` to indicate whether `func` should be invoked on the leading and/or trailing edge of the
|
|
243
|
+
* `wait` timeout. The `func` is invoked with the last arguments provided to the debounced function.
|
|
244
|
+
* Subsequent calls to the debounced function return the result of the last `func` invocation.
|
|
245
|
+
*
|
|
246
|
+
* **Note:** If `leading` and `trailing` options are `true`, `func` is invoked on the trailing edge of
|
|
247
|
+
* the timeout only if the debounced function is invoked more than once during the `wait` timeout.
|
|
248
|
+
*
|
|
249
|
+
* If `wait` is `0` and `leading` is `false`, `func` invocation is deferred until the next tick, similar
|
|
250
|
+
* to `setTimeout` with a timeout of `0`.
|
|
251
|
+
*
|
|
252
|
+
* @param func - The function to debounce.
|
|
253
|
+
* @param wait - The number of milliseconds to delay.
|
|
254
|
+
* @param options - The options object.
|
|
255
|
+
* @returns Returns the new debounced function.
|
|
256
|
+
* @internal
|
|
257
|
+
*/
|
|
258
|
+
export declare function _debounce<T extends (...args: any) => any>(func: T, wait: number | undefined, options: _DebounceSettingsLeading): _DebouncedFuncLeading<T>;
|
|
259
|
+
|
|
260
|
+
/**
|
|
261
|
+
* @see _debounce
|
|
262
|
+
* @internal
|
|
263
|
+
*/
|
|
264
|
+
export declare function _debounce<T extends (...args: any) => any>(func: T, wait?: number, options?: _DebounceSettings): _DebouncedFunc<T>;
|
|
265
|
+
|
|
266
|
+
/**
|
|
267
|
+
* A debounced function: calling it applies the debounce rules and returns the result of the last
|
|
268
|
+
* invocation, or `undefined` before the first one.
|
|
269
|
+
*
|
|
270
|
+
* @internal
|
|
271
|
+
*/
|
|
272
|
+
export declare type _DebouncedFunc<T extends (...args: any[]) => any> = {
|
|
273
|
+
(...args: Parameters<T>): ReturnType<T> | undefined;
|
|
274
|
+
/** Throws away any pending invocation. */
|
|
275
|
+
cancel(): void;
|
|
276
|
+
/** Invokes a pending invocation immediately and returns its result, else returns the last result. */
|
|
277
|
+
flush(): ReturnType<T> | undefined;
|
|
278
|
+
};
|
|
279
|
+
|
|
280
|
+
/**
|
|
281
|
+
* A debounced function created with `leading: true`, so a call always has a result.
|
|
282
|
+
*
|
|
283
|
+
* @internal
|
|
284
|
+
*/
|
|
285
|
+
export declare type _DebouncedFuncLeading<T extends (...args: any[]) => any> = {
|
|
286
|
+
(...args: Parameters<T>): ReturnType<T>;
|
|
287
|
+
flush(): ReturnType<T>;
|
|
288
|
+
} & _DebouncedFunc<T>;
|
|
289
|
+
|
|
290
|
+
/**
|
|
291
|
+
* Options for `_debounce`.
|
|
292
|
+
*
|
|
293
|
+
* @internal
|
|
294
|
+
*/
|
|
295
|
+
export declare type _DebounceSettings = {
|
|
296
|
+
/** Invoke on the leading edge of the timeout. */
|
|
297
|
+
leading?: boolean | undefined;
|
|
298
|
+
/** The maximum time the function is allowed to be delayed before it is invoked. */
|
|
299
|
+
maxWait?: number | undefined;
|
|
300
|
+
/** Invoke on the trailing edge of the timeout. Defaults to `true`. */
|
|
301
|
+
trailing?: boolean | undefined;
|
|
302
|
+
};
|
|
303
|
+
|
|
304
|
+
/**
|
|
305
|
+
* {@link _DebounceSettings} with `leading` switched on, which guarantees a result on every call.
|
|
306
|
+
*
|
|
307
|
+
* @internal
|
|
308
|
+
*/
|
|
309
|
+
export declare type _DebounceSettingsLeading = _DebounceSettings & {
|
|
310
|
+
leading: true;
|
|
311
|
+
};
|
|
312
|
+
|
|
313
|
+
/**
|
|
314
|
+
* Deburrs `string` by converting Latin-1 Supplement and Latin Extended-A letters to basic Latin letters and
|
|
315
|
+
* removing combining diacritical marks.
|
|
316
|
+
*
|
|
317
|
+
* @param string - The string to deburr.
|
|
318
|
+
* @returns Returns the deburred string.
|
|
319
|
+
* @internal
|
|
320
|
+
*/
|
|
321
|
+
export declare function _deburr(string?: string): string;
|
|
322
|
+
|
|
323
|
+
/**
|
|
324
|
+
* Assigns own and inherited enumerable string keyed properties of source objects to the destination object
|
|
325
|
+
* for all destination properties that resolve to `undefined`. Source objects are applied from left to
|
|
326
|
+
* right, so once a property is set, additional values of the same property are ignored. A value inherited
|
|
327
|
+
* from `Object.prototype`, such as `toString`, counts as missing too. Sources are copied by plain
|
|
328
|
+
* assignment, a nullish destination becomes a new object and a primitive one is boxed.
|
|
329
|
+
*
|
|
330
|
+
* **Note:** This method mutates `object`.
|
|
331
|
+
*
|
|
332
|
+
* @param object - The destination object.
|
|
333
|
+
* @param sources - The source objects.
|
|
334
|
+
* @returns Returns `object`.
|
|
335
|
+
* @internal
|
|
336
|
+
*/
|
|
337
|
+
export declare function _defaults<TObject, TSource>(object: TObject, source: TSource): NonNullable<TSource & TObject>;
|
|
338
|
+
|
|
339
|
+
/**
|
|
340
|
+
* @internal
|
|
341
|
+
*/
|
|
342
|
+
export declare function _defaults<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): NonNullable<TSource2 & TSource1 & TObject>;
|
|
343
|
+
|
|
344
|
+
/**
|
|
345
|
+
* @internal
|
|
346
|
+
*/
|
|
347
|
+
export declare function _defaults<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): NonNullable<TSource3 & TSource2 & TSource1 & TObject>;
|
|
348
|
+
|
|
349
|
+
/**
|
|
350
|
+
* @internal
|
|
351
|
+
*/
|
|
352
|
+
export declare function _defaults<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): NonNullable<TSource4 & TSource3 & TSource2 & TSource1 & TObject>;
|
|
353
|
+
|
|
354
|
+
/**
|
|
355
|
+
* @internal
|
|
356
|
+
*/
|
|
357
|
+
export declare function _defaults<TObject>(object: TObject): NonNullable<TObject>;
|
|
358
|
+
|
|
359
|
+
/**
|
|
360
|
+
* @internal
|
|
361
|
+
*/
|
|
362
|
+
export declare function _defaults(object: any, ...sources: any[]): any;
|
|
363
|
+
|
|
364
|
+
/**
|
|
365
|
+
* Returns a promise which will resolve after the provided number of milliseconds.
|
|
366
|
+
*
|
|
367
|
+
* @param timeout - resolve timeout in milliseconds
|
|
368
|
+
* @internal
|
|
369
|
+
*/
|
|
370
|
+
export declare function delay(timeout?: number): Promise<void>;
|
|
371
|
+
|
|
372
|
+
/**
|
|
373
|
+
* @internal
|
|
374
|
+
*/
|
|
375
|
+
export declare type _Dictionary<T> = {
|
|
376
|
+
[index: string]: T;
|
|
377
|
+
};
|
|
378
|
+
|
|
379
|
+
/**
|
|
380
|
+
* Creates an array of `array` values not included in the other given arrays using SameValueZero for equality
|
|
381
|
+
* comparisons. The order and references of result values are determined by the first array. Only array-like
|
|
382
|
+
* objects are inspected: any other first argument yields an empty array and any other exclusion argument is
|
|
383
|
+
* skipped.
|
|
384
|
+
*
|
|
385
|
+
* @param array - The array to inspect.
|
|
386
|
+
* @param values - The arrays of values to exclude.
|
|
387
|
+
* @returns Returns the new array of filtered values.
|
|
388
|
+
* @internal
|
|
389
|
+
*/
|
|
390
|
+
export declare function _difference<T>(array: _List<T> | null | undefined, ...values: _List<T>[]): T[];
|
|
391
|
+
|
|
392
|
+
/**
|
|
393
|
+
* This method is like `_difference` except that it accepts `iteratee` which is invoked for each element of
|
|
394
|
+
* `array` and `values` to generate the criterion by which they're compared. The order and references of
|
|
395
|
+
* result values are determined by the first array. The iteratee is invoked with one argument: (value).
|
|
396
|
+
* The iteratee is the last argument unless that argument is array-like, in which case it is one more list of
|
|
397
|
+
* values and the elements are compared as they are.
|
|
398
|
+
*
|
|
399
|
+
* @param array - The array to inspect.
|
|
400
|
+
* @param values - The values to exclude, followed by the iteratee.
|
|
401
|
+
* @returns Returns the new array of filtered values.
|
|
402
|
+
* @internal
|
|
403
|
+
*/
|
|
404
|
+
export declare function _differenceBy<T1, T2>(array: _List<T1> | null | undefined, values: _List<T2>, iteratee: _ValueIteratee<T1 | T2>): T1[];
|
|
405
|
+
|
|
406
|
+
/**
|
|
407
|
+
* @internal
|
|
408
|
+
*/
|
|
409
|
+
export declare function _differenceBy<T1, T2, T3>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, iteratee: _ValueIteratee<T1 | T2 | T3>): T1[];
|
|
410
|
+
|
|
411
|
+
/**
|
|
412
|
+
* @internal
|
|
413
|
+
*/
|
|
414
|
+
export declare function _differenceBy<T1, T2, T3, T4>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, values3: _List<T4>, iteratee: _ValueIteratee<T1 | T2 | T3 | T4>): T1[];
|
|
415
|
+
|
|
416
|
+
/**
|
|
417
|
+
* @internal
|
|
418
|
+
*/
|
|
419
|
+
export declare function _differenceBy<T1, T2, T3, T4, T5>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, values3: _List<T4>, values4: _List<T5>, iteratee: _ValueIteratee<T1 | T2 | T3 | T4 | T5>): T1[];
|
|
420
|
+
|
|
421
|
+
/**
|
|
422
|
+
* @internal
|
|
423
|
+
*/
|
|
424
|
+
export declare function _differenceBy<T1, T2, T3, T4, T5, T6>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, values3: _List<T4>, values4: _List<T5>, values5: _List<T6>, iteratee: _ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6>): T1[];
|
|
425
|
+
|
|
426
|
+
/**
|
|
427
|
+
* @internal
|
|
428
|
+
*/
|
|
429
|
+
export declare function _differenceBy<T1, T2, T3, T4, T5, T6, T7>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, values3: _List<T4>, values4: _List<T5>, values5: _List<T6>, ...values: (_List<T7> | _ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6 | T7>)[]): T1[];
|
|
430
|
+
|
|
431
|
+
/**
|
|
432
|
+
* @internal
|
|
433
|
+
*/
|
|
434
|
+
export declare function _differenceBy<T>(array: _List<T> | null | undefined, ...values: _List<T>[]): T[];
|
|
435
|
+
|
|
436
|
+
/**
|
|
437
|
+
* This method is like `_difference` except that it accepts `comparator` which is invoked to compare elements
|
|
438
|
+
* of `array` to `values`. The order and references of result values are determined by the first array. The
|
|
439
|
+
* comparator is invoked with two arguments: (arrVal, othVal). As in lodash, the last argument is taken as
|
|
440
|
+
* the comparator unless it is an array-like object, and `-0` is not normalised when a comparator is used.
|
|
441
|
+
*
|
|
442
|
+
* @param array - The array to inspect.
|
|
443
|
+
* @param values - The values to exclude.
|
|
444
|
+
* @param comparator - The comparator invoked per element.
|
|
445
|
+
* @returns Returns the new array of filtered values.
|
|
446
|
+
* @internal
|
|
447
|
+
*/
|
|
448
|
+
export declare function _differenceWith<T1, T2>(array: _List<T1> | null | undefined, values: _List<T2>, comparator: _Comparator2<T1, T2>): T1[];
|
|
449
|
+
|
|
450
|
+
/**
|
|
451
|
+
* @internal
|
|
452
|
+
*/
|
|
453
|
+
export declare function _differenceWith<T1, T2, T3>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, comparator: _Comparator2<T1, T2 | T3>): T1[];
|
|
454
|
+
|
|
455
|
+
/**
|
|
456
|
+
* @internal
|
|
457
|
+
*/
|
|
458
|
+
export declare function _differenceWith<T1, T2, T3, T4>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, ...values: (_List<T4> | _Comparator2<T1, T2 | T3 | T4>)[]): T1[];
|
|
459
|
+
|
|
460
|
+
/**
|
|
461
|
+
* @internal
|
|
462
|
+
*/
|
|
463
|
+
export declare function _differenceWith<T>(array: _List<T> | null | undefined, ...values: _List<T>[]): T[];
|
|
464
|
+
|
|
465
|
+
/**
|
|
466
|
+
* Creates a slice of `array` excluding elements dropped from the end. Elements are dropped until
|
|
467
|
+
* `predicate` returns falsey. The predicate is invoked with three arguments: (value, index, array), and may
|
|
468
|
+
* be an iteratee shorthand; it defaults to the identity. The result is a new dense array.
|
|
469
|
+
*
|
|
470
|
+
* @param array - The array to query.
|
|
471
|
+
* @param predicate - The function invoked per iteration.
|
|
472
|
+
* @returns Returns the slice of `array`.
|
|
473
|
+
* @internal
|
|
474
|
+
*/
|
|
475
|
+
export declare function _dropRightWhile<T>(array: _List<T> | null | undefined, predicate?: _ListIteratee<T>): T[];
|
|
476
|
+
|
|
477
|
+
/**
|
|
478
|
+
* @internal
|
|
479
|
+
*/
|
|
480
|
+
export declare type EmptyObject = Record<never, never>;
|
|
481
|
+
|
|
482
|
+
/** Common interface between Arrays and jQuery objects */
|
|
483
|
+
/**
|
|
484
|
+
* @internal
|
|
485
|
+
*/
|
|
486
|
+
export declare type _EmptyObject<T> = {
|
|
487
|
+
[K in keyof T]?: never;
|
|
488
|
+
};
|
|
489
|
+
|
|
490
|
+
/**
|
|
491
|
+
* @internal
|
|
492
|
+
*/
|
|
493
|
+
export declare type _EmptyObjectOf<T> = _EmptyObject<T> extends T ? _EmptyObject<T> : never;
|
|
494
|
+
|
|
495
|
+
/**
|
|
496
|
+
* Converts the characters `&`, `<`, `>`, `"` and `'` in `string` to their corresponding HTML entities.
|
|
497
|
+
*
|
|
498
|
+
* **Note:** No other characters are escaped. Though `>` is escaped for symmetry, characters like `>` and `/`
|
|
499
|
+
* don't need escaping in HTML and have no special meaning unless they're part of a tag or unquoted attribute
|
|
500
|
+
* value. When working with HTML you should always quote attribute values to reduce XSS vectors.
|
|
501
|
+
*
|
|
502
|
+
* @param string - The string to escape.
|
|
503
|
+
* @returns Returns the escaped string.
|
|
504
|
+
* @internal
|
|
505
|
+
*/
|
|
506
|
+
export declare function _escape(string?: string): string;
|
|
507
|
+
|
|
508
|
+
/**
|
|
509
|
+
* Escapes special characters used in regular expressions.
|
|
510
|
+
* @param value - string to be escaped
|
|
511
|
+
* @returns escaped regular expression
|
|
512
|
+
*
|
|
513
|
+
* @internal
|
|
514
|
+
*/
|
|
515
|
+
export declare function escapeRegExp(value: string): string;
|
|
516
|
+
|
|
517
|
+
/**
|
|
518
|
+
* Escapes the `RegExp` special characters `^`, `$`, `\`, `.`, `*`, `+`, `?`, `(`, `)`, `[`, `]`, `{`, `}`
|
|
519
|
+
* and `|` in `string`, so the result matches the input literally when used in a pattern.
|
|
520
|
+
*
|
|
521
|
+
* **Note:** Unlike the `escapeRegExp` in `stringUtils`, `/` is not escaped, matching lodash.
|
|
522
|
+
*
|
|
523
|
+
* @param string - The string to escape.
|
|
524
|
+
* @returns Returns the escaped string.
|
|
525
|
+
* @internal
|
|
526
|
+
*/
|
|
527
|
+
export declare function _escapeRegExp(string?: string): string;
|
|
528
|
+
|
|
529
|
+
/** Common interface between Arrays and jQuery objects */
|
|
530
|
+
/**
|
|
531
|
+
* @internal
|
|
532
|
+
*/
|
|
533
|
+
export declare type _Falsey = null | undefined | false | "" | 0 | 0n;
|
|
534
|
+
|
|
535
|
+
/**
|
|
536
|
+
* This method is like `_find` except that it returns the key of the first element `predicate` returns
|
|
537
|
+
* truthy for instead of the element itself. Own enumerable string keys are inspected in order, array-likes
|
|
538
|
+
* and strings by index; the predicate is invoked with three arguments: (value, key, object), may be an
|
|
539
|
+
* iteratee shorthand and defaults to the identity.
|
|
540
|
+
*
|
|
541
|
+
* @param object - The object to inspect.
|
|
542
|
+
* @param predicate - The function invoked per iteration.
|
|
543
|
+
* @returns Returns the key of the matched element, else `undefined`.
|
|
544
|
+
* @internal
|
|
545
|
+
*/
|
|
546
|
+
export declare function _findKey<T>(object: T | null | undefined, predicate?: _ObjectIteratee<T>): string | undefined;
|
|
547
|
+
|
|
548
|
+
/**
|
|
549
|
+
* This method is like `_findIndex` except that it iterates over elements of `array` from right to left,
|
|
550
|
+
* returning the index of the first element `predicate` returns truthy for, else `-1`. The predicate is
|
|
551
|
+
* invoked with three arguments: (value, index, array), may be an iteratee shorthand and defaults to the
|
|
552
|
+
* identity. The search starts at `fromIndex`, which is coerced to an integer the way lodash does it, counted
|
|
553
|
+
* from the end when negative and clamped into the array.
|
|
554
|
+
*
|
|
555
|
+
* @param array - The array to inspect.
|
|
556
|
+
* @param predicate - The function invoked per iteration.
|
|
557
|
+
* @param fromIndex - The index to search from. Defaults to the last index.
|
|
558
|
+
* @returns Returns the index of the found element, else `-1`.
|
|
559
|
+
* @internal
|
|
560
|
+
*/
|
|
561
|
+
export declare function _findLastIndex<T>(array: _List<T> | null | undefined, predicate?: _ListIterateeCustom<T, boolean>, fromIndex?: number): number;
|
|
562
|
+
|
|
563
|
+
/**
|
|
564
|
+
* @internal
|
|
565
|
+
*/
|
|
566
|
+
export declare type _Function0<R> = () => R;
|
|
567
|
+
|
|
568
|
+
/**
|
|
569
|
+
* @internal
|
|
570
|
+
*/
|
|
571
|
+
export declare type _Function1<T1, R> = (t1: T1) => R;
|
|
572
|
+
|
|
573
|
+
/**
|
|
574
|
+
* @internal
|
|
575
|
+
*/
|
|
576
|
+
export declare type _Function2<T1, T2, R> = (t1: T1, t2: T2) => R;
|
|
577
|
+
|
|
578
|
+
/**
|
|
579
|
+
* @internal
|
|
580
|
+
*/
|
|
581
|
+
export declare type _Function3<T1, T2, T3, R> = (t1: T1, t2: T2, t3: T3) => R;
|
|
582
|
+
|
|
583
|
+
/**
|
|
584
|
+
* @internal
|
|
585
|
+
*/
|
|
586
|
+
export declare type _Function4<T1, T2, T3, T4, R> = (t1: T1, t2: T2, t3: T3, t4: T4) => R;
|
|
587
|
+
|
|
588
|
+
/**
|
|
589
|
+
* Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned
|
|
590
|
+
* in its place; `null` and other values are returned as they are. Paths may be dotted or bracketed strings,
|
|
591
|
+
* arrays of keys, symbols or numbers, and a key that exists on `object` is read directly instead of being
|
|
592
|
+
* parsed as a path, as in lodash.
|
|
593
|
+
*
|
|
594
|
+
* Unlike the lodash typings, string paths are not typed by their segments; they resolve to `any`.
|
|
595
|
+
*
|
|
596
|
+
* @param object - The object to query.
|
|
597
|
+
* @param path - The path of the property to get.
|
|
598
|
+
* @param defaultValue - The value returned for `undefined` resolved values.
|
|
599
|
+
* @returns Returns the resolved value.
|
|
600
|
+
* @internal
|
|
601
|
+
*/
|
|
602
|
+
export declare function _get<TObject extends object, TKey extends keyof TObject>(object: TObject, path: TKey | [TKey]): TObject[TKey];
|
|
603
|
+
|
|
604
|
+
/**
|
|
605
|
+
* @internal
|
|
606
|
+
*/
|
|
607
|
+
export declare function _get<TObject extends object, TKey extends keyof TObject>(object: TObject | null | undefined, path: TKey | [TKey]): TObject[TKey] | undefined;
|
|
608
|
+
|
|
609
|
+
/**
|
|
610
|
+
* @internal
|
|
611
|
+
*/
|
|
612
|
+
export declare function _get<TObject extends object, TKey extends keyof TObject, TDefault>(object: TObject | null | undefined, path: TKey | [TKey], defaultValue: TDefault): Exclude<TObject[TKey], undefined> | TDefault;
|
|
613
|
+
|
|
614
|
+
/**
|
|
615
|
+
* @internal
|
|
616
|
+
*/
|
|
617
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(object: TObject, path: [TKey1, TKey2]): TObject[TKey1][TKey2];
|
|
618
|
+
|
|
619
|
+
/**
|
|
620
|
+
* @internal
|
|
621
|
+
*/
|
|
622
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>>(object: TObject | null | undefined, path: [TKey1, TKey2]): NonNullable<TObject[TKey1]>[TKey2] | undefined;
|
|
623
|
+
|
|
624
|
+
/**
|
|
625
|
+
* @internal
|
|
626
|
+
*/
|
|
627
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2], defaultValue: TDefault): Exclude<NonNullable<TObject[TKey1]>[TKey2], undefined> | TDefault;
|
|
628
|
+
|
|
629
|
+
/**
|
|
630
|
+
* @internal
|
|
631
|
+
*/
|
|
632
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(object: TObject, path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3];
|
|
633
|
+
|
|
634
|
+
/**
|
|
635
|
+
* @internal
|
|
636
|
+
*/
|
|
637
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3]): NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3] | undefined;
|
|
638
|
+
|
|
639
|
+
/**
|
|
640
|
+
* @internal
|
|
641
|
+
*/
|
|
642
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof NonNullable<TObject[TKey1]>, TKey3 extends keyof NonNullable<NonNullable<TObject[TKey1]>[TKey2]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3], defaultValue: TDefault): Exclude<NonNullable<NonNullable<TObject[TKey1]>[TKey2]>[TKey3], undefined> | TDefault;
|
|
643
|
+
|
|
644
|
+
/**
|
|
645
|
+
* @internal
|
|
646
|
+
*/
|
|
647
|
+
export declare function _get<TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(object: TObject, path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4];
|
|
648
|
+
|
|
649
|
+
/**
|
|
650
|
+
* @internal
|
|
651
|
+
*/
|
|
652
|
+
export declare function _get<T>(object: _NumericDictionary<T>, path: number): T;
|
|
653
|
+
|
|
654
|
+
/**
|
|
655
|
+
* @internal
|
|
656
|
+
*/
|
|
657
|
+
export declare function _get<T>(object: _NumericDictionary<T> | null | undefined, path: number): T | undefined;
|
|
658
|
+
|
|
659
|
+
/**
|
|
660
|
+
* @internal
|
|
661
|
+
*/
|
|
662
|
+
export declare function _get<T, TDefault>(object: _NumericDictionary<T> | null | undefined, path: number, defaultValue: TDefault): T | TDefault;
|
|
663
|
+
|
|
664
|
+
/**
|
|
665
|
+
* @internal
|
|
666
|
+
*/
|
|
667
|
+
export declare function _get<TDefault>(object: null | undefined, path: _PropertyPath, defaultValue: TDefault): TDefault;
|
|
668
|
+
|
|
669
|
+
/**
|
|
670
|
+
* @internal
|
|
671
|
+
*/
|
|
672
|
+
export declare function _get(object: null | undefined, path: _PropertyPath): undefined;
|
|
673
|
+
|
|
674
|
+
/**
|
|
675
|
+
* @internal
|
|
676
|
+
*/
|
|
677
|
+
export declare function _get(object: any, path: _PropertyPath, defaultValue?: any): any;
|
|
678
|
+
|
|
679
|
+
/**
|
|
680
|
+
* Creates an object composed of keys generated from the results of running each element of
|
|
681
|
+
* `collection` thru `iteratee`. The order of grouped values is determined by the order they occur in
|
|
682
|
+
* `collection`. The corresponding value of each key is an array of elements responsible for generating
|
|
683
|
+
* the key. The iteratee is invoked with one argument: (value).
|
|
684
|
+
*
|
|
685
|
+
* @param collection - The collection to iterate over.
|
|
686
|
+
* @param iteratee - The iteratee to transform keys.
|
|
687
|
+
* @returns Returns the composed aggregate object.
|
|
688
|
+
* @internal
|
|
689
|
+
*/
|
|
690
|
+
export declare function _groupBy<T>(collection: _List<T> | null | undefined, iteratee?: _ValueIteratee<T>): _Dictionary<T[]>;
|
|
691
|
+
|
|
692
|
+
/**
|
|
693
|
+
* @see _groupBy
|
|
694
|
+
* @internal
|
|
695
|
+
*/
|
|
696
|
+
export declare function _groupBy<T extends object>(collection: T | null | undefined, iteratee?: _ValueIteratee<T[keyof T]>): _Dictionary<Array<T[keyof T]>>;
|
|
697
|
+
|
|
698
|
+
/**
|
|
699
|
+
* @internal
|
|
700
|
+
*/
|
|
701
|
+
export declare type GuardType<T> = T extends ((o: unknown) => o is infer U) ? U : never;
|
|
702
|
+
|
|
703
|
+
/**
|
|
704
|
+
* Checks if `path` is a direct property of `object`: every segment of the path must be an own property of
|
|
705
|
+
* the value before it, or a valid index of an array or arguments object.
|
|
706
|
+
*
|
|
707
|
+
* @param object - The object to query.
|
|
708
|
+
* @param path - The path to check.
|
|
709
|
+
* @returns Returns `true` if `path` exists, else `false`.
|
|
710
|
+
* @internal
|
|
711
|
+
*/
|
|
712
|
+
export declare function _has<T, K extends _PropertyName>(object: T, path: K): object is T & {
|
|
713
|
+
[P in K]: P extends keyof T ? T[P] : Record<string, unknown> extends T ? T[keyof T] : unknown;
|
|
714
|
+
} & {
|
|
715
|
+
[uniqueSymbol]: unknown;
|
|
716
|
+
};
|
|
717
|
+
|
|
718
|
+
/**
|
|
719
|
+
* @internal
|
|
720
|
+
*/
|
|
721
|
+
export declare function _has<T>(object: T, path: _PropertyPath): boolean;
|
|
722
|
+
|
|
723
|
+
/**
|
|
724
|
+
* Returns a hash code for a string.
|
|
725
|
+
*
|
|
726
|
+
* The hash code for a string object is computed as
|
|
727
|
+
* s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
|
|
728
|
+
* using number arithmetic, where s[i] is the i th character
|
|
729
|
+
* of the given string, n is the length of the string,
|
|
730
|
+
* and ^ indicates exponentiation.
|
|
731
|
+
* (The hash value of the empty string is zero.)
|
|
732
|
+
*
|
|
733
|
+
* @param value - s a string
|
|
734
|
+
* @returns a hash code value for the given string.
|
|
735
|
+
*
|
|
736
|
+
* @internal
|
|
737
|
+
*/
|
|
738
|
+
export declare function hashCodeString(value: string): number;
|
|
739
|
+
|
|
740
|
+
/**
|
|
741
|
+
* Gets all but the last element of `array` as a new dense array. Nullish input and anything without a
|
|
742
|
+
* truthy `length` yield an empty array.
|
|
743
|
+
*
|
|
744
|
+
* @param array - The array to query.
|
|
745
|
+
* @returns Returns the slice of `array`.
|
|
746
|
+
* @internal
|
|
747
|
+
*/
|
|
748
|
+
export declare function _initial<T>(array: _List<T> | null | undefined): T[];
|
|
749
|
+
|
|
750
|
+
/**
|
|
751
|
+
* Checks if `number` is between `start` and up to, but not including, `end`. If `end` is not specified,
|
|
752
|
+
* it's set to `start` with `start` then set to `0`. If `start` is greater than `end` the params are swapped
|
|
753
|
+
* to support negative ranges. The bounds are coerced to finite numbers and `number` to a number the way
|
|
754
|
+
* lodash does it, so a `NaN` bound becomes `0` and a `NaN` number is never in range.
|
|
755
|
+
*
|
|
756
|
+
* @param number - The number to check.
|
|
757
|
+
* @param start - The start of the range.
|
|
758
|
+
* @param end - The end of the range.
|
|
759
|
+
* @returns Returns `true` if `number` is in the range, else `false`.
|
|
760
|
+
* @internal
|
|
761
|
+
*/
|
|
762
|
+
export declare function _inRange(number: number, start: number, end?: number): boolean;
|
|
763
|
+
|
|
764
|
+
/**
|
|
765
|
+
* Creates an array of unique values that are included in all given arrays using SameValueZero for equality
|
|
766
|
+
* comparisons. The order and references of result values are determined by the first array, with `-0`
|
|
767
|
+
* normalised to `0`. A first argument that is not an array-like object yields an empty array, and any other
|
|
768
|
+
* argument that is not one counts as an empty array.
|
|
769
|
+
*
|
|
770
|
+
* @param arrays - The arrays to inspect.
|
|
771
|
+
* @returns Returns the new array of intersecting values.
|
|
772
|
+
* @internal
|
|
773
|
+
*/
|
|
774
|
+
export declare function _intersection<T>(...arrays: (_List<T> | null | undefined)[]): T[];
|
|
775
|
+
|
|
776
|
+
/**
|
|
777
|
+
* This method is like `_intersection` except that it accepts `iteratee` which is invoked for each element
|
|
778
|
+
* of each array to generate the criterion by which they're compared. The order and references of result
|
|
779
|
+
* values are determined by the first array. The iteratee is invoked with one argument: (value). As in
|
|
780
|
+
* lodash, the last argument is taken as the iteratee unless it is an array-like object, so an array is
|
|
781
|
+
* always a list to intersect.
|
|
782
|
+
*
|
|
783
|
+
* @param array - The first array to inspect.
|
|
784
|
+
* @param values - The other arrays to inspect.
|
|
785
|
+
* @param iteratee - The iteratee invoked per element.
|
|
786
|
+
* @returns Returns the new array of intersecting values.
|
|
787
|
+
* @internal
|
|
788
|
+
*/
|
|
789
|
+
export declare function _intersectionBy<T1, T2>(array: _List<T1> | null, values: _List<T2>, iteratee: _ValueIteratee<T1 | T2>): T1[];
|
|
790
|
+
|
|
791
|
+
/**
|
|
792
|
+
* @internal
|
|
793
|
+
*/
|
|
794
|
+
export declare function _intersectionBy<T1, T2, T3>(array: _List<T1> | null, values1: _List<T2>, values2: _List<T3>, iteratee: _ValueIteratee<T1 | T2 | T3>): T1[];
|
|
795
|
+
|
|
796
|
+
/**
|
|
797
|
+
* @internal
|
|
798
|
+
*/
|
|
799
|
+
export declare function _intersectionBy<T1, T2, T3, T4>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, ...values: (_List<T4> | _ValueIteratee<T1 | T2 | T3 | T4>)[]): T1[];
|
|
800
|
+
|
|
801
|
+
/**
|
|
802
|
+
* @internal
|
|
803
|
+
*/
|
|
804
|
+
export declare function _intersectionBy<T>(array?: _List<T> | null, ...values: _List<T>[]): T[];
|
|
805
|
+
|
|
806
|
+
/**
|
|
807
|
+
* @internal
|
|
808
|
+
*/
|
|
809
|
+
export declare function _intersectionBy<T>(...values: (_List<T> | _ValueIteratee<T>)[]): T[];
|
|
810
|
+
|
|
811
|
+
/**
|
|
812
|
+
* This method is like `_intersection` except that it accepts `comparator` which is invoked to compare
|
|
813
|
+
* elements of the arrays. The order and references of result values are determined by the first array. The
|
|
814
|
+
* comparator is invoked with two arguments: (arrVal, othVal). As in lodash, only a function in the last
|
|
815
|
+
* position is taken as the comparator, arguments that are not array-like objects count as empty, the result
|
|
816
|
+
* is deduplicated through the comparator too, and `-0` is kept as it is when a comparator is used.
|
|
817
|
+
*
|
|
818
|
+
* @param array - The first array to inspect.
|
|
819
|
+
* @param values - The other arrays to inspect.
|
|
820
|
+
* @param comparator - The comparator invoked per element.
|
|
821
|
+
* @returns Returns the new array of intersecting values.
|
|
822
|
+
* @internal
|
|
823
|
+
*/
|
|
824
|
+
export declare function _intersectionWith<T1, T2>(array: _List<T1> | null | undefined, values: _List<T2>, comparator: _Comparator2<T1, T1 | T2>): T1[];
|
|
825
|
+
|
|
826
|
+
/**
|
|
827
|
+
* @internal
|
|
828
|
+
*/
|
|
829
|
+
export declare function _intersectionWith<T1, T2, T3>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, comparator: _Comparator2<T1, T1 | T2 | T3>): T1[];
|
|
830
|
+
|
|
831
|
+
/**
|
|
832
|
+
* @internal
|
|
833
|
+
*/
|
|
834
|
+
export declare function _intersectionWith<T1, T2, T3, T4>(array: _List<T1> | null | undefined, values1: _List<T2>, values2: _List<T3>, ...values: (_List<T4> | _Comparator2<T1, T1 | T2 | T3 | T4>)[]): T1[];
|
|
835
|
+
|
|
836
|
+
/**
|
|
837
|
+
* @internal
|
|
838
|
+
*/
|
|
839
|
+
export declare function _intersectionWith<T>(array?: _List<T> | null, ...values: (_List<T> | _Comparator<T>)[]): T[];
|
|
840
|
+
|
|
841
|
+
/**
|
|
842
|
+
* Creates an object composed of the inverted keys and values of `object`. If `object` contains duplicate
|
|
843
|
+
* values, subsequent values overwrite property assignments of previous values. Only own enumerable string
|
|
844
|
+
* keyed properties are inverted. As in lodash, a value is coerced to a property key the way property
|
|
845
|
+
* assignment does it, except that a value without a callable `toString` (such as an object with a null
|
|
846
|
+
* prototype) becomes `[object Object]`; a symbol value becomes a symbol key.
|
|
847
|
+
*
|
|
848
|
+
* @param object - The object to invert.
|
|
849
|
+
* @returns Returns the new inverted object.
|
|
850
|
+
* @internal
|
|
851
|
+
*/
|
|
852
|
+
export declare function _invert(object: object): _Dictionary<string>;
|
|
853
|
+
|
|
854
|
+
/**
|
|
855
|
+
* Checks if value is empty. A value is considered empty unless it’s an arguments object, array, string, or
|
|
856
|
+
* jQuery-like collection with a length greater than 0 or an object with own enumerable properties.
|
|
857
|
+
*
|
|
858
|
+
* @param value - The value to inspect.
|
|
859
|
+
* @returns Returns true if value is empty, else false.
|
|
860
|
+
* @internal
|
|
861
|
+
*/
|
|
862
|
+
export declare function _isEmpty<T extends {
|
|
863
|
+
__trapAny: any;
|
|
864
|
+
}>(value?: T): boolean;
|
|
865
|
+
|
|
866
|
+
/**
|
|
867
|
+
* @see _isEmpty
|
|
868
|
+
* @internal
|
|
869
|
+
*/
|
|
870
|
+
export declare function _isEmpty(value: string): value is "";
|
|
871
|
+
|
|
872
|
+
/**
|
|
873
|
+
* @see _isEmpty
|
|
874
|
+
* @internal
|
|
875
|
+
*/
|
|
876
|
+
export declare function _isEmpty(value: Map<any, any> | Set<any> | _List<any> | null | undefined): boolean;
|
|
877
|
+
|
|
878
|
+
/**
|
|
879
|
+
* @see _isEmpty
|
|
880
|
+
* @internal
|
|
881
|
+
*/
|
|
882
|
+
export declare function _isEmpty(value: object): boolean;
|
|
883
|
+
|
|
884
|
+
/**
|
|
885
|
+
* @see _isEmpty
|
|
886
|
+
* @internal
|
|
887
|
+
*/
|
|
888
|
+
export declare function _isEmpty<T extends object>(value: T | null | undefined): value is _EmptyObjectOf<T> | null | undefined;
|
|
889
|
+
|
|
890
|
+
/**
|
|
891
|
+
* @see _isEmpty
|
|
892
|
+
* @internal
|
|
893
|
+
*/
|
|
894
|
+
export declare function _isEmpty(value?: any): boolean;
|
|
895
|
+
|
|
896
|
+
/**
|
|
897
|
+
* Performs a deep comparison between two values to determine if they are equivalent.
|
|
898
|
+
*
|
|
899
|
+
* Supports comparing arrays, array buffers, booleans, date objects, error objects, maps, numbers,
|
|
900
|
+
* `Object` objects, regexes, sets, strings, symbols, and typed arrays. `Object` objects are compared
|
|
901
|
+
* by their own, not inherited, enumerable properties. Functions and DOM nodes are compared by strict
|
|
902
|
+
* equality, i.e. `===`.
|
|
903
|
+
*
|
|
904
|
+
* @param value - The value to compare.
|
|
905
|
+
* @param other - The other value to compare.
|
|
906
|
+
* @returns Returns `true` if the values are equivalent, else `false`.
|
|
907
|
+
* @internal
|
|
908
|
+
*/
|
|
909
|
+
export declare function _isEqual(value: unknown, other: unknown): boolean;
|
|
910
|
+
|
|
911
|
+
/**
|
|
912
|
+
* Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, `SyntaxError`, `TypeError`,
|
|
913
|
+
* `URIError` or `DOMException` object, or a non-plain object with string `message` and `name` properties.
|
|
914
|
+
* The raw tag is used, so a faked `Symbol.toStringTag` is ignored.
|
|
915
|
+
*
|
|
916
|
+
* @param value - The value to check.
|
|
917
|
+
* @returns Returns `true` if `value` is an error object, else `false`.
|
|
918
|
+
* @internal
|
|
919
|
+
*/
|
|
920
|
+
export declare function _isError(value: unknown): value is Error;
|
|
921
|
+
|
|
922
|
+
/**
|
|
923
|
+
* @internal
|
|
924
|
+
*/
|
|
925
|
+
export declare interface IShortenTextOptions {
|
|
926
|
+
maxLength?: number;
|
|
927
|
+
}
|
|
928
|
+
|
|
929
|
+
/**
|
|
930
|
+
* Checks if `value` is a plain object, that is, an object created by the `Object` constructor or one
|
|
931
|
+
* with a `[[Prototype]]` of `null`.
|
|
932
|
+
*
|
|
933
|
+
* @param value - The value to check.
|
|
934
|
+
* @returns Returns `true` if `value` is a plain object, else `false`.
|
|
935
|
+
* @internal
|
|
936
|
+
*/
|
|
937
|
+
export declare function _isPlainObject(value?: unknown): boolean;
|
|
938
|
+
|
|
939
|
+
/**
|
|
940
|
+
* @internal
|
|
941
|
+
*/
|
|
942
|
+
export declare type _IterateeShorthand<T> = _PropertyName | [_PropertyName, any] | _PartialShallow<T>;
|
|
943
|
+
|
|
944
|
+
/**
|
|
945
|
+
* Converts `string` to kebab case: the words of the string, lower-cased and joined with hyphens.
|
|
946
|
+
*
|
|
947
|
+
* @param string - The string to convert.
|
|
948
|
+
* @returns Returns the kebab cased string.
|
|
949
|
+
* @internal
|
|
950
|
+
*/
|
|
951
|
+
export declare const _kebabCase: (string?: string) => string;
|
|
952
|
+
|
|
953
|
+
/**
|
|
954
|
+
* Creates an object composed of keys generated from the results of running each element of `collection`
|
|
955
|
+
* thru `iteratee`. The corresponding value of each key is the last element responsible for generating the
|
|
956
|
+
* key. The iteratee is invoked with one argument: (value).
|
|
957
|
+
*
|
|
958
|
+
* @param collection - The collection to iterate over.
|
|
959
|
+
* @param iteratee - The iteratee to transform keys.
|
|
960
|
+
* @returns Returns the composed aggregate object.
|
|
961
|
+
* @internal
|
|
962
|
+
*/
|
|
963
|
+
export declare function _keyBy<T>(collection: _List<T> | null | undefined, iteratee?: _ValueIterateeCustom<T, _PropertyName>): _Dictionary<T>;
|
|
964
|
+
|
|
965
|
+
/**
|
|
966
|
+
* @internal
|
|
967
|
+
*/
|
|
968
|
+
export declare function _keyBy<T extends object>(collection: T | null | undefined, iteratee?: _ValueIterateeCustom<T[keyof T], _PropertyName>): _Dictionary<T[keyof T]>;
|
|
969
|
+
|
|
970
|
+
/**
|
|
971
|
+
* @internal
|
|
972
|
+
*/
|
|
973
|
+
export declare type _List<T> = ArrayLike<T>;
|
|
974
|
+
|
|
975
|
+
/**
|
|
976
|
+
* @internal
|
|
977
|
+
*/
|
|
978
|
+
export declare type _ListIteratee<T> = _ListIterator<T, _NotVoid> | _IterateeShorthand<T>;
|
|
979
|
+
|
|
980
|
+
/**
|
|
981
|
+
* @internal
|
|
982
|
+
*/
|
|
983
|
+
export declare type _ListIterateeCustom<T, TResult> = _ListIterator<T, TResult> | _IterateeShorthand<T>;
|
|
984
|
+
|
|
985
|
+
/**
|
|
986
|
+
* @internal
|
|
987
|
+
*/
|
|
988
|
+
export declare type _ListIterator<T, TResult> = (value: T, index: number, collection: _List<T>) => TResult;
|
|
989
|
+
|
|
990
|
+
/**
|
|
991
|
+
* @internal
|
|
992
|
+
*/
|
|
993
|
+
export declare type _Many<T> = T | readonly T[];
|
|
994
|
+
|
|
995
|
+
/**
|
|
996
|
+
* The cache a memoized function keeps its results in. Keys are compared by SameValueZero, as a `Map`
|
|
997
|
+
* does, so `NaN` equals `NaN` and objects compare by reference.
|
|
998
|
+
*
|
|
999
|
+
* @internal
|
|
1000
|
+
*/
|
|
1001
|
+
export declare type _MapCache = {
|
|
1002
|
+
/** Removes `key` and its value from the cache; returns whether the entry was removed. */
|
|
1003
|
+
delete(key: unknown): boolean;
|
|
1004
|
+
/** Gets the cached value for `key`. */
|
|
1005
|
+
get(key: unknown): unknown;
|
|
1006
|
+
/** Checks if a cached value for `key` exists. */
|
|
1007
|
+
has(key: unknown): boolean;
|
|
1008
|
+
/** Sets `value` to `key` of the cache; a cache that returns itself here lets `set` be chained. */
|
|
1009
|
+
set(key: unknown, value: unknown): unknown;
|
|
1010
|
+
/** Removes all entries from the cache. */
|
|
1011
|
+
clear?: (() => void) | undefined;
|
|
1012
|
+
};
|
|
1013
|
+
|
|
1014
|
+
/**
|
|
1015
|
+
* @internal
|
|
1016
|
+
*/
|
|
1017
|
+
export declare type _MapCacheConstructor = new () => _MapCache;
|
|
1018
|
+
|
|
1019
|
+
/**
|
|
1020
|
+
* Creates an object with the same keys as `object` and values generated by running each own enumerable
|
|
1021
|
+
* string keyed property of `object` thru `iteratee`. The iteratee is invoked with three arguments:
|
|
1022
|
+
* (value, key, object). Arrays, strings and other array-likes are mapped by index.
|
|
1023
|
+
*
|
|
1024
|
+
* @param object - The object to iterate over.
|
|
1025
|
+
* @param iteratee - The function invoked per iteration, or an iteratee shorthand. Defaults to identity.
|
|
1026
|
+
* @returns Returns the new mapped object.
|
|
1027
|
+
* @internal
|
|
1028
|
+
*/
|
|
1029
|
+
export declare function _mapValues<TResult>(obj: string | null | undefined, callback: _StringIterator<TResult>): _NumericDictionary<TResult>;
|
|
1030
|
+
|
|
1031
|
+
/**
|
|
1032
|
+
* @internal
|
|
1033
|
+
*/
|
|
1034
|
+
export declare function _mapValues<T, TResult>(array: T[], callback: _ArrayIterator<T, TResult>): _NumericDictionary<TResult>;
|
|
1035
|
+
|
|
1036
|
+
/**
|
|
1037
|
+
* @internal
|
|
1038
|
+
*/
|
|
1039
|
+
export declare function _mapValues<T extends object, TResult>(obj: T | null | undefined, callback: _ObjectIterator<T, TResult>): {
|
|
1040
|
+
[P in keyof T]: TResult;
|
|
1041
|
+
};
|
|
1042
|
+
|
|
1043
|
+
/**
|
|
1044
|
+
* @internal
|
|
1045
|
+
*/
|
|
1046
|
+
export declare function _mapValues<T>(obj: _Dictionary<T> | _NumericDictionary<T> | null | undefined, iteratee: object): _Dictionary<boolean>;
|
|
1047
|
+
|
|
1048
|
+
/**
|
|
1049
|
+
* @internal
|
|
1050
|
+
*/
|
|
1051
|
+
export declare function _mapValues<T extends object>(obj: T | null | undefined, iteratee: object): {
|
|
1052
|
+
[P in keyof T]: boolean;
|
|
1053
|
+
};
|
|
1054
|
+
|
|
1055
|
+
/**
|
|
1056
|
+
* @internal
|
|
1057
|
+
*/
|
|
1058
|
+
export declare function _mapValues<T, TKey extends keyof T>(obj: _Dictionary<T> | _NumericDictionary<T> | null | undefined, iteratee: TKey): _Dictionary<T[TKey]>;
|
|
1059
|
+
|
|
1060
|
+
/**
|
|
1061
|
+
* @internal
|
|
1062
|
+
*/
|
|
1063
|
+
export declare function _mapValues<T>(obj: _Dictionary<T> | _NumericDictionary<T> | null | undefined, iteratee: string): _Dictionary<any>;
|
|
1064
|
+
|
|
1065
|
+
/**
|
|
1066
|
+
* @internal
|
|
1067
|
+
*/
|
|
1068
|
+
export declare function _mapValues<T extends object>(obj: T | null | undefined, iteratee: string): {
|
|
1069
|
+
[P in keyof T]: any;
|
|
1070
|
+
};
|
|
1071
|
+
|
|
1072
|
+
/**
|
|
1073
|
+
* @internal
|
|
1074
|
+
*/
|
|
1075
|
+
export declare function _mapValues(obj: string | null | undefined): _NumericDictionary<string>;
|
|
1076
|
+
|
|
1077
|
+
/**
|
|
1078
|
+
* @internal
|
|
1079
|
+
*/
|
|
1080
|
+
export declare function _mapValues<T>(obj: _Dictionary<T> | _NumericDictionary<T> | null | undefined): _Dictionary<T>;
|
|
1081
|
+
|
|
1082
|
+
/**
|
|
1083
|
+
* @internal
|
|
1084
|
+
*/
|
|
1085
|
+
export declare function _mapValues<T extends object>(obj: T): T;
|
|
1086
|
+
|
|
1087
|
+
/**
|
|
1088
|
+
* @internal
|
|
1089
|
+
*/
|
|
1090
|
+
export declare function _mapValues<T extends object>(obj: T | null | undefined): _PartialObject<T>;
|
|
1091
|
+
|
|
1092
|
+
/**
|
|
1093
|
+
* A matcher for suppressConsole
|
|
1094
|
+
*
|
|
1095
|
+
* @internal
|
|
1096
|
+
*/
|
|
1097
|
+
export declare type Matcher = {
|
|
1098
|
+
type: "regex";
|
|
1099
|
+
value: RegExp;
|
|
1100
|
+
} | {
|
|
1101
|
+
type: "includes" | "exact" | "startsWith";
|
|
1102
|
+
value: string;
|
|
1103
|
+
};
|
|
1104
|
+
|
|
1105
|
+
/**
|
|
1106
|
+
* A matcher function
|
|
1107
|
+
*
|
|
1108
|
+
* @internal
|
|
1109
|
+
*/
|
|
1110
|
+
export declare type MatcherFunction = (console: Record<ConsoleType, ConsoleFunction>, type: ConsoleType, message: string) => boolean;
|
|
1111
|
+
|
|
1112
|
+
/**
|
|
1113
|
+
* Computes the maximum value of `array` using the `>` operator, so mixed values coerce the way the operator
|
|
1114
|
+
* does. Nullish, `NaN` and symbol elements are skipped. If `array` is empty or falsey, `undefined` is
|
|
1115
|
+
* returned.
|
|
1116
|
+
*
|
|
1117
|
+
* @param array - The array to iterate over.
|
|
1118
|
+
* @returns Returns the maximum value.
|
|
1119
|
+
* @internal
|
|
1120
|
+
*/
|
|
1121
|
+
export declare function _max<T>(array: readonly [T, ...T[]]): T;
|
|
1122
|
+
|
|
1123
|
+
/**
|
|
1124
|
+
* @internal
|
|
1125
|
+
*/
|
|
1126
|
+
export declare function _max<T>(array: _List<T> | null | undefined): T | undefined;
|
|
1127
|
+
|
|
1128
|
+
/**
|
|
1129
|
+
* The shape of `_memoize`: the memoizing function itself plus the `Cache` constructor every memoized
|
|
1130
|
+
* function starts with.
|
|
1131
|
+
*
|
|
1132
|
+
* @internal
|
|
1133
|
+
*/
|
|
1134
|
+
export declare type _Memoize = {
|
|
1135
|
+
<T extends (...args: any) => any>(func: T, resolver?: (this: ThisParameterType<T>, ...args: Parameters<T>) => unknown): T & _MemoizedFunction;
|
|
1136
|
+
/** The constructor of the cache every memoized function starts with; a native `Map` unless replaced. */
|
|
1137
|
+
Cache: _MapCacheConstructor;
|
|
1138
|
+
};
|
|
1139
|
+
|
|
1140
|
+
/**
|
|
1141
|
+
* Creates a function that memoizes the result of `func`. If `resolver` is provided, it determines the
|
|
1142
|
+
* cache key for storing the result based on the arguments provided to the memoized function. By
|
|
1143
|
+
* default, the first argument provided to the memoized function is used as the map cache key. The
|
|
1144
|
+
* `func` is invoked with the `this` binding of the memoized function.
|
|
1145
|
+
*
|
|
1146
|
+
* **Note:** The cache is exposed as the `cache` property on the memoized function. Its creation may be
|
|
1147
|
+
* customized by replacing the `_memoize.Cache` constructor with one whose instances implement the
|
|
1148
|
+
* `Map` method interface of `clear`, `delete`, `get`, `has`, and `set`.
|
|
1149
|
+
*
|
|
1150
|
+
* @param func - The function to have its output memoized.
|
|
1151
|
+
* @param resolver - The function to resolve the cache key.
|
|
1152
|
+
* @returns Returns the new memoized function.
|
|
1153
|
+
* @internal
|
|
1154
|
+
*/
|
|
1155
|
+
export declare const _memoize: _Memoize;
|
|
1156
|
+
|
|
1157
|
+
/**
|
|
1158
|
+
* What `_memoize` adds to the function it returns.
|
|
1159
|
+
*
|
|
1160
|
+
* @internal
|
|
1161
|
+
*/
|
|
1162
|
+
export declare type _MemoizedFunction = {
|
|
1163
|
+
/** The cache of results, exposed so callers can inspect or edit it. */
|
|
1164
|
+
cache: _MapCache;
|
|
1165
|
+
};
|
|
1166
|
+
|
|
1167
|
+
/**
|
|
1168
|
+
* @internal
|
|
1169
|
+
*/
|
|
1170
|
+
export declare type _MemoListIterator<T, TResult, TList> = (prev: TResult, curr: T, index: number, list: TList) => TResult;
|
|
1171
|
+
|
|
1172
|
+
/**
|
|
1173
|
+
* @internal
|
|
1174
|
+
*/
|
|
1175
|
+
export declare type _MemoObjectIterator<T, TResult, TList> = (prev: TResult, curr: T, key: string, list: TList) => TResult;
|
|
1176
|
+
|
|
1177
|
+
/**
|
|
1178
|
+
* Recursively merges own and inherited enumerable string keyed properties of source objects into the
|
|
1179
|
+
* destination object. Source properties that resolve to `undefined` are skipped if a destination value
|
|
1180
|
+
* exists. Array and plain object properties are merged recursively. Other objects and value types are
|
|
1181
|
+
* overridden by assignment. Source objects are applied from left to right. Subsequent sources overwrite
|
|
1182
|
+
* property assignments of previous sources.
|
|
1183
|
+
*
|
|
1184
|
+
* **Note:** This method mutates `object`.
|
|
1185
|
+
*
|
|
1186
|
+
* @param object - The destination object.
|
|
1187
|
+
* @param sources - The source objects.
|
|
1188
|
+
* @returns Returns `object`.
|
|
1189
|
+
* @internal
|
|
1190
|
+
*/
|
|
1191
|
+
export declare function _merge<TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
|
|
1192
|
+
|
|
1193
|
+
/**
|
|
1194
|
+
* @internal
|
|
1195
|
+
*/
|
|
1196
|
+
export declare function _merge<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
|
|
1197
|
+
|
|
1198
|
+
/**
|
|
1199
|
+
* @internal
|
|
1200
|
+
*/
|
|
1201
|
+
export declare function _merge<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3;
|
|
1202
|
+
|
|
1203
|
+
/**
|
|
1204
|
+
* @internal
|
|
1205
|
+
*/
|
|
1206
|
+
export declare function _merge<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4;
|
|
1207
|
+
|
|
1208
|
+
/**
|
|
1209
|
+
* @internal
|
|
1210
|
+
*/
|
|
1211
|
+
export declare function _merge(object: any, ...otherArgs: any[]): any;
|
|
1212
|
+
|
|
1213
|
+
/**
|
|
1214
|
+
* This method is like `_merge` except that it accepts `customizer` which is invoked to produce the merged
|
|
1215
|
+
* values of the destination and source properties. If `customizer` returns `undefined`, merging is handled
|
|
1216
|
+
* by the method instead. The `customizer` is invoked with six arguments: (objValue, srcValue, key, object,
|
|
1217
|
+
* source, stack). It is taken from the last argument when that is a function preceded by at least one
|
|
1218
|
+
* source.
|
|
1219
|
+
*
|
|
1220
|
+
* **Note:** This method mutates `object`.
|
|
1221
|
+
*
|
|
1222
|
+
* @param object - The destination object.
|
|
1223
|
+
* @param source - The source object.
|
|
1224
|
+
* @param customizer - The function to customize assigned values.
|
|
1225
|
+
* @returns Returns `object`.
|
|
1226
|
+
* @internal
|
|
1227
|
+
*/
|
|
1228
|
+
export declare function _mergeWith<TObject, TSource>(object: TObject, source: TSource, customizer: _MergeWithCustomizer): TObject & TSource;
|
|
1229
|
+
|
|
1230
|
+
/**
|
|
1231
|
+
* @internal
|
|
1232
|
+
*/
|
|
1233
|
+
export declare function _mergeWith<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2, customizer: _MergeWithCustomizer): TObject & TSource1 & TSource2;
|
|
1234
|
+
|
|
1235
|
+
/**
|
|
1236
|
+
* @internal
|
|
1237
|
+
*/
|
|
1238
|
+
export declare function _mergeWith<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: _MergeWithCustomizer): TObject & TSource1 & TSource2 & TSource3;
|
|
1239
|
+
|
|
1240
|
+
/**
|
|
1241
|
+
* @internal
|
|
1242
|
+
*/
|
|
1243
|
+
export declare function _mergeWith<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: _MergeWithCustomizer): TObject & TSource1 & TSource2 & TSource3 & TSource4;
|
|
1244
|
+
|
|
1245
|
+
/**
|
|
1246
|
+
* @internal
|
|
1247
|
+
*/
|
|
1248
|
+
export declare function _mergeWith(object: any, ...otherArgs: any[]): any;
|
|
1249
|
+
|
|
1250
|
+
/**
|
|
1251
|
+
* The customizer of `_mergeWith`: invoked per property with the destination value, the source value, the
|
|
1252
|
+
* key, the destination and source objects being merged, and the stack of traversed source values. A result
|
|
1253
|
+
* other than `undefined` is used as the merged value.
|
|
1254
|
+
*
|
|
1255
|
+
* @internal
|
|
1256
|
+
*/
|
|
1257
|
+
export declare type _MergeWithCustomizer = (value: any, srcValue: any, key: string, object: any, source: any, stack: any) => any;
|
|
1258
|
+
|
|
1259
|
+
/**
|
|
1260
|
+
* Computes the minimum value of `array` using the `<` operator, so mixed values coerce the way the operator
|
|
1261
|
+
* does. Nullish, `NaN` and symbol elements are skipped. If `array` is empty or falsey, `undefined` is
|
|
1262
|
+
* returned.
|
|
1263
|
+
*
|
|
1264
|
+
* @param array - The array to iterate over.
|
|
1265
|
+
* @returns Returns the minimum value.
|
|
1266
|
+
* @internal
|
|
1267
|
+
*/
|
|
1268
|
+
export declare function _min<T>(array: readonly [T, ...T[]]): T;
|
|
1269
|
+
|
|
1270
|
+
/**
|
|
1271
|
+
* @internal
|
|
1272
|
+
*/
|
|
1273
|
+
export declare function _min<T>(array: _List<T> | null | undefined): T | undefined;
|
|
1274
|
+
|
|
1275
|
+
/**
|
|
1276
|
+
* Creates a function that negates the result of the predicate `predicate`. The predicate is invoked with
|
|
1277
|
+
* the `this` binding and arguments of the created function, and its result is coerced to a boolean.
|
|
1278
|
+
*
|
|
1279
|
+
* @param predicate - The predicate to negate.
|
|
1280
|
+
* @returns Returns the new negated function.
|
|
1281
|
+
* @throws TypeError when `predicate` is not a function.
|
|
1282
|
+
* @internal
|
|
1283
|
+
*/
|
|
1284
|
+
export declare function _negate<T extends unknown[]>(predicate: (...args: T) => boolean): (...args: T) => boolean;
|
|
1285
|
+
|
|
1286
|
+
/**
|
|
1287
|
+
* @internal
|
|
1288
|
+
*/
|
|
1289
|
+
export declare type _NotVoid = unknown;
|
|
1290
|
+
|
|
1291
|
+
/**
|
|
1292
|
+
* @internal
|
|
1293
|
+
*/
|
|
1294
|
+
export declare type _NumericDictionary<T> = {
|
|
1295
|
+
[index: number]: T;
|
|
1296
|
+
};
|
|
1297
|
+
|
|
1298
|
+
/**
|
|
1299
|
+
* @internal
|
|
1300
|
+
*/
|
|
1301
|
+
export declare type _ObjectIteratee<TObject> = _ObjectIterator<TObject, _NotVoid> | _IterateeShorthand<TObject[keyof TObject]>;
|
|
1302
|
+
|
|
1303
|
+
/**
|
|
1304
|
+
* @internal
|
|
1305
|
+
*/
|
|
1306
|
+
export declare type _ObjectIterator<TObject, TResult> = (value: TObject[keyof TObject], key: string, collection: TObject) => TResult;
|
|
1307
|
+
|
|
1308
|
+
/**
|
|
1309
|
+
* The opposite of `pick`; this method creates an object composed of the own and inherited enumerable
|
|
1310
|
+
* property paths of `object` that are not omitted.
|
|
1311
|
+
*
|
|
1312
|
+
* The result is always a new plain object. When any path is deep, every plain object reachable from
|
|
1313
|
+
* the result is copied first so the source is left untouched; non-plain values such as arrays, class
|
|
1314
|
+
* instances and dates are kept by reference and are therefore mutated by a deep path through them,
|
|
1315
|
+
* exactly as lodash does.
|
|
1316
|
+
*
|
|
1317
|
+
* @param object - The source object.
|
|
1318
|
+
* @param paths - The property paths to omit, given individually or in arrays.
|
|
1319
|
+
* @returns Returns the new object.
|
|
1320
|
+
* @internal
|
|
1321
|
+
*/
|
|
1322
|
+
export declare function _omit<T extends object, K extends _PropertyName[]>(object: T | null | undefined, ...paths: K): Pick<T, Exclude<keyof T, K[number]>>;
|
|
1323
|
+
|
|
1324
|
+
/**
|
|
1325
|
+
* @see _omit
|
|
1326
|
+
* @internal
|
|
1327
|
+
*/
|
|
1328
|
+
export declare function _omit<T extends object, K extends keyof T>(object: T | null | undefined, ...paths: Array<_Many<K>>): Omit<T, K>;
|
|
1329
|
+
|
|
1330
|
+
/**
|
|
1331
|
+
* @see _omit
|
|
1332
|
+
* @internal
|
|
1333
|
+
*/
|
|
1334
|
+
export declare function _omit<T extends object>(object: T | null | undefined, ...paths: Array<_Many<_PropertyName>>): _PartialObject<T>;
|
|
1335
|
+
|
|
1336
|
+
/**
|
|
1337
|
+
* The opposite of `pickBy`; this method creates an object composed of the own and inherited enumerable
|
|
1338
|
+
* string and symbol keyed properties of `object` that `predicate` doesn't return truthy for. The predicate
|
|
1339
|
+
* is invoked with two arguments: (value, key). Picked values are kept by reference.
|
|
1340
|
+
*
|
|
1341
|
+
* @param object - The source object.
|
|
1342
|
+
* @param predicate - The function invoked per property, or an iteratee shorthand. Defaults to identity.
|
|
1343
|
+
* @returns Returns the new object.
|
|
1344
|
+
* @internal
|
|
1345
|
+
*/
|
|
1346
|
+
export declare function _omitBy<T>(object: _Dictionary<T> | null | undefined, predicate?: _ValueKeyIteratee<T>): _Dictionary<T>;
|
|
1347
|
+
|
|
1348
|
+
/**
|
|
1349
|
+
* @internal
|
|
1350
|
+
*/
|
|
1351
|
+
export declare function _omitBy<T>(object: _NumericDictionary<T> | null | undefined, predicate?: _ValueKeyIteratee<T>): _NumericDictionary<T>;
|
|
1352
|
+
|
|
1353
|
+
/**
|
|
1354
|
+
* @internal
|
|
1355
|
+
*/
|
|
1356
|
+
export declare function _omitBy<T extends object>(object: T | null | undefined, predicate: _ValueKeyIteratee<T[keyof T]>): _PartialObject<T>;
|
|
1357
|
+
|
|
1358
|
+
/**
|
|
1359
|
+
* Parse string in a form of [foo, bar] to an array of objects.
|
|
1360
|
+
* Assume alphanumeric strings in the array and spaces; if some is not alphanumeric , return null
|
|
1361
|
+
* @param str - input string with the array definition
|
|
1362
|
+
* @returns parsed array of strings
|
|
1363
|
+
*
|
|
1364
|
+
* @internal
|
|
1365
|
+
*/
|
|
1366
|
+
export declare function parseStringToArray(str: string): string[] | null;
|
|
1367
|
+
|
|
1368
|
+
/**
|
|
1369
|
+
* The call signatures of `_partial`: each applied parameter is dropped from the resulting function, a
|
|
1370
|
+
* placeholder keeps its parameter in place.
|
|
1371
|
+
*
|
|
1372
|
+
* @internal
|
|
1373
|
+
*/
|
|
1374
|
+
export declare type _Partial = {
|
|
1375
|
+
<T1, T2, R>(func: _Function2<T1, T2, R>, plc1: _Placeholder, arg2: T2): _Function1<T1, R>;
|
|
1376
|
+
<T1, T2, T3, R>(func: _Function3<T1, T2, T3, R>, plc1: _Placeholder, arg2: T2): _Function2<T1, T3, R>;
|
|
1377
|
+
<T1, T2, T3, R>(func: _Function3<T1, T2, T3, R>, plc1: _Placeholder, plc2: _Placeholder, arg3: T3): _Function2<T1, T2, R>;
|
|
1378
|
+
<T1, T2, T3, R>(func: _Function3<T1, T2, T3, R>, arg1: T1, plc2: _Placeholder, arg3: T3): _Function1<T2, R>;
|
|
1379
|
+
<T1, T2, T3, R>(func: _Function3<T1, T2, T3, R>, plc1: _Placeholder, arg2: T2, arg3: T3): _Function1<T1, R>;
|
|
1380
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, arg2: T2): _Function3<T1, T3, T4, R>;
|
|
1381
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, plc2: _Placeholder, arg3: T3): _Function3<T1, T2, T4, R>;
|
|
1382
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: _Placeholder, arg3: T3): _Function2<T2, T4, R>;
|
|
1383
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, arg2: T2, arg3: T3): _Function2<T1, T4, R>;
|
|
1384
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, plc2: _Placeholder, plc3: _Placeholder, arg4: T4): _Function3<T1, T2, T3, R>;
|
|
1385
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: _Placeholder, plc3: _Placeholder, arg4: T4): _Function2<T2, T3, R>;
|
|
1386
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, arg2: T2, plc3: _Placeholder, arg4: T4): _Function2<T1, T3, R>;
|
|
1387
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: _Placeholder, arg4: T4): _Function1<T3, R>;
|
|
1388
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, plc2: _Placeholder, arg3: T3, arg4: T4): _Function2<T1, T2, R>;
|
|
1389
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: _Placeholder, arg3: T3, arg4: T4): _Function1<T2, R>;
|
|
1390
|
+
<T1, T2, T3, T4, R>(func: _Function4<T1, T2, T3, T4, R>, plc1: _Placeholder, arg2: T2, arg3: T3, arg4: T4): _Function1<T1, R>;
|
|
1391
|
+
<TS extends any[], R>(func: (...ts: TS) => R): (...ts: TS) => R;
|
|
1392
|
+
<TS extends any[], T1, R>(func: (t1: T1, ...ts: TS) => R, arg1: T1): (...ts: TS) => R;
|
|
1393
|
+
<TS extends any[], T1, T2, R>(func: (t1: T1, t2: T2, ...ts: TS) => R, t1: T1, t2: T2): (...ts: TS) => R;
|
|
1394
|
+
<TS extends any[], T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R, t1: T1, t2: T2, t3: T3): (...ts: TS) => R;
|
|
1395
|
+
<TS extends any[], T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4): (...ts: TS) => R;
|
|
1396
|
+
/** Marks a parameter of the function that is left open; `_partial.placeholder` is its only value. */
|
|
1397
|
+
placeholder: _Placeholder;
|
|
1398
|
+
};
|
|
1399
|
+
|
|
1400
|
+
/**
|
|
1401
|
+
* Creates a function that invokes `func` with `partials` prepended to the arguments it receives. This method
|
|
1402
|
+
* is like `bind` except it does **not** alter the `this` binding. The `_partial.placeholder` value may be
|
|
1403
|
+
* used as a placeholder for partially applied arguments: each placeholder takes the next argument of the
|
|
1404
|
+
* call, the remaining call arguments are appended. Calling the result with `new` constructs `func`.
|
|
1405
|
+
*
|
|
1406
|
+
* **Note:** This method doesn't set the "length" property of partially applied functions.
|
|
1407
|
+
*
|
|
1408
|
+
* @param func - The function to partially apply arguments to.
|
|
1409
|
+
* @param partials - The arguments to be partially applied.
|
|
1410
|
+
* @returns Returns the new partially applied function.
|
|
1411
|
+
* @internal
|
|
1412
|
+
*/
|
|
1413
|
+
export declare const _partial: _Partial;
|
|
1414
|
+
|
|
1415
|
+
/**
|
|
1416
|
+
* @internal
|
|
1417
|
+
*/
|
|
1418
|
+
export declare type _PartialObject<T> = Partial<T>;
|
|
1419
|
+
|
|
1420
|
+
/**
|
|
1421
|
+
* @internal
|
|
1422
|
+
*/
|
|
1423
|
+
export declare type _PartialShallow<T> = {
|
|
1424
|
+
[P in keyof T]?: T[P] extends object ? object : T[P];
|
|
1425
|
+
};
|
|
1426
|
+
|
|
1427
|
+
/**
|
|
1428
|
+
* Creates an array of elements split into two groups, the first of which contains elements `predicate`
|
|
1429
|
+
* returns truthy for, the second of which contains elements `predicate` returns falsey for. The
|
|
1430
|
+
* predicate is invoked with one argument: (value).
|
|
1431
|
+
*
|
|
1432
|
+
* @param collection - The collection to iterate over.
|
|
1433
|
+
* @param predicate - The function invoked per iteration.
|
|
1434
|
+
* @returns Returns the array of grouped elements.
|
|
1435
|
+
* @internal
|
|
1436
|
+
*/
|
|
1437
|
+
export declare function _partition<T, U extends T>(collection: _List<T> | null | undefined, predicate: _ValueIteratorTypeGuard<T, U>): [U[], Array<Exclude<T, U>>];
|
|
1438
|
+
|
|
1439
|
+
/**
|
|
1440
|
+
* @see _partition
|
|
1441
|
+
* @internal
|
|
1442
|
+
*/
|
|
1443
|
+
export declare function _partition<T>(collection: _List<T> | null | undefined, predicate: _ValueIteratee<T>): [T[], T[]];
|
|
1444
|
+
|
|
1445
|
+
/**
|
|
1446
|
+
* @see _partition
|
|
1447
|
+
* @internal
|
|
1448
|
+
*/
|
|
1449
|
+
export declare function _partition<T extends object>(collection: T | null | undefined, predicate: _ValueIteratee<T[keyof T]>): [Array<T[keyof T]>, Array<T[keyof T]>];
|
|
1450
|
+
|
|
1451
|
+
/**
|
|
1452
|
+
* Creates an object composed of the picked `object` properties, own or inherited. Paths may be given
|
|
1453
|
+
* individually or in arrays and may be deep; a deep path recreates the containers along it in the result,
|
|
1454
|
+
* while the picked value itself is kept by reference.
|
|
1455
|
+
*
|
|
1456
|
+
* @param object - The source object.
|
|
1457
|
+
* @param props - The property paths to pick, given individually or in arrays.
|
|
1458
|
+
* @returns Returns the new object.
|
|
1459
|
+
* @internal
|
|
1460
|
+
*/
|
|
1461
|
+
export declare function _pick<T extends object, U extends keyof T>(object: T, ...props: _Many<U>[]): Pick<T, U>;
|
|
1462
|
+
|
|
1463
|
+
/**
|
|
1464
|
+
* @internal
|
|
1465
|
+
*/
|
|
1466
|
+
export declare function _pick<T>(object: T | null | undefined, ...props: _Many<_PropertyPath>[]): _PartialObject<T>;
|
|
1467
|
+
|
|
1468
|
+
/**
|
|
1469
|
+
* Creates an object composed of the own and inherited enumerable string and symbol keyed properties of
|
|
1470
|
+
* `object` that `predicate` returns truthy for. The predicate is invoked with two arguments: (value, key).
|
|
1471
|
+
* Picked values are kept by reference.
|
|
1472
|
+
*
|
|
1473
|
+
* @param object - The source object.
|
|
1474
|
+
* @param predicate - The function invoked per property, or an iteratee shorthand. Defaults to identity.
|
|
1475
|
+
* @returns Returns the new object.
|
|
1476
|
+
* @internal
|
|
1477
|
+
*/
|
|
1478
|
+
export declare function _pickBy<T>(object: _Dictionary<T> | null | undefined, predicate?: _ValueKeyIteratee<T>): _Dictionary<T>;
|
|
1479
|
+
|
|
1480
|
+
/**
|
|
1481
|
+
* @internal
|
|
1482
|
+
*/
|
|
1483
|
+
export declare function _pickBy<T>(object: _NumericDictionary<T> | null | undefined, predicate?: _ValueKeyIteratee<T>): _NumericDictionary<T>;
|
|
1484
|
+
|
|
1485
|
+
/**
|
|
1486
|
+
* @internal
|
|
1487
|
+
*/
|
|
1488
|
+
export declare function _pickBy<T extends object>(object: T | null | undefined, predicate?: _ValueKeyIteratee<T[keyof T]>): _PartialObject<T>;
|
|
1489
|
+
|
|
1490
|
+
/**
|
|
1491
|
+
* The type of `_partial.placeholder`, which stands in for lodash's `_` placeholder.
|
|
1492
|
+
*
|
|
1493
|
+
* @internal
|
|
1494
|
+
*/
|
|
1495
|
+
export declare type _Placeholder = {
|
|
1496
|
+
readonly [placeholderBrand]: true;
|
|
1497
|
+
};
|
|
1498
|
+
|
|
1499
|
+
declare const placeholderBrand: unique symbol;
|
|
1500
|
+
|
|
1501
|
+
/**
|
|
1502
|
+
* @internal
|
|
1503
|
+
*/
|
|
1504
|
+
export declare type _PropertyName = string | number | symbol;
|
|
17
1505
|
|
|
18
1506
|
/**
|
|
19
|
-
* A console function, like log, warn or error
|
|
20
|
-
*
|
|
21
1507
|
* @internal
|
|
22
1508
|
*/
|
|
23
|
-
export declare type
|
|
1509
|
+
export declare type _PropertyPath = _Many<_PropertyName>;
|
|
24
1510
|
|
|
25
1511
|
/**
|
|
26
|
-
*
|
|
1512
|
+
* Generates pseudo-random string.
|
|
1513
|
+
*
|
|
1514
|
+
* @param len - length of string to be generated
|
|
1515
|
+
* @returns random string
|
|
27
1516
|
*
|
|
28
1517
|
* @internal
|
|
29
1518
|
*/
|
|
30
|
-
export declare
|
|
1519
|
+
export declare function randomString(len: number): string;
|
|
31
1520
|
|
|
32
1521
|
/**
|
|
33
|
-
*
|
|
1522
|
+
* Creates an array of numbers (positive and/or negative) progressing from `start` up to, but not
|
|
1523
|
+
* including, `end`. A step of `-1` is used if a negative `start` is specified without an `end` or
|
|
1524
|
+
* `step`. If `end` is not specified, it's set to `start` with `start` then set to `0`.
|
|
34
1525
|
*
|
|
35
|
-
*
|
|
36
|
-
*
|
|
37
|
-
* there, every pending assertion would otherwise cost a full default poll interval.
|
|
1526
|
+
* **Note:** JavaScript follows the IEEE-754 standard for resolving floating-point values which can
|
|
1527
|
+
* produce unexpected results.
|
|
38
1528
|
*
|
|
39
|
-
* @param
|
|
40
|
-
* @param
|
|
1529
|
+
* @param start - The start of the range.
|
|
1530
|
+
* @param end - The end of the range.
|
|
1531
|
+
* @param step - The value to increment or decrement by.
|
|
1532
|
+
* @returns Returns the range of numbers.
|
|
41
1533
|
* @internal
|
|
42
1534
|
*/
|
|
43
|
-
export declare function
|
|
1535
|
+
export declare function _range(start: number, end?: number, step?: number): number[];
|
|
44
1536
|
|
|
45
1537
|
/**
|
|
46
|
-
*
|
|
1538
|
+
* The iteratee form, so that `_range` can be passed straight to `map` and the like: the index and the
|
|
1539
|
+
* collection are ignored and `end` alone defines the range.
|
|
47
1540
|
*
|
|
48
|
-
* @
|
|
1541
|
+
* @see _range
|
|
49
1542
|
* @internal
|
|
50
1543
|
*/
|
|
51
|
-
export declare function
|
|
1544
|
+
export declare function _range(end: number, index: string | number, guard: object): number[];
|
|
52
1545
|
|
|
53
1546
|
/**
|
|
1547
|
+
* Reduces `collection` to a value which is the accumulated result of running each element in `collection`
|
|
1548
|
+
* thru `iteratee`, where each successive invocation is supplied the return value of the previous. If
|
|
1549
|
+
* `accumulator` is not given, the first element of `collection` is used as the initial value; whether it
|
|
1550
|
+
* was given is decided by the argument count, as in lodash. The iteratee is invoked with four arguments:
|
|
1551
|
+
* (accumulator, value, index|key, collection). Arrays and array-likes are iterated by index, strings by
|
|
1552
|
+
* character, other objects by their own enumerable string keys.
|
|
1553
|
+
*
|
|
1554
|
+
* @param collection - The collection to iterate over.
|
|
1555
|
+
* @param iteratee - The function invoked per iteration, or an iteratee shorthand.
|
|
1556
|
+
* @param accumulator - The initial value.
|
|
1557
|
+
* @returns Returns the accumulated value.
|
|
54
1558
|
* @internal
|
|
55
1559
|
*/
|
|
56
|
-
export declare
|
|
1560
|
+
export declare function _reduce<T, TResult>(collection: T[] | null | undefined, iteratee: _MemoListIterator<T, TResult, T[]>, accumulator: TResult): TResult;
|
|
57
1561
|
|
|
58
1562
|
/**
|
|
59
|
-
* Escapes special characters used in regular expressions.
|
|
60
|
-
* @param value - string to be escaped
|
|
61
|
-
* @returns escaped regular expression
|
|
62
|
-
*
|
|
63
1563
|
* @internal
|
|
64
1564
|
*/
|
|
65
|
-
export declare function
|
|
1565
|
+
export declare function _reduce<T, TResult>(collection: _List<T> | null | undefined, iteratee: _MemoListIterator<T, TResult, _List<T>>, accumulator: TResult): TResult;
|
|
66
1566
|
|
|
67
1567
|
/**
|
|
68
1568
|
* @internal
|
|
69
1569
|
*/
|
|
70
|
-
export declare
|
|
1570
|
+
export declare function _reduce<T extends object, TResult>(collection: T | null | undefined, iteratee: _MemoObjectIterator<T[keyof T], TResult, T>, accumulator: TResult): TResult;
|
|
71
1571
|
|
|
72
1572
|
/**
|
|
73
|
-
* Returns a hash code for a string.
|
|
74
|
-
*
|
|
75
|
-
* The hash code for a string object is computed as
|
|
76
|
-
* s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
|
|
77
|
-
* using number arithmetic, where s[i] is the i th character
|
|
78
|
-
* of the given string, n is the length of the string,
|
|
79
|
-
* and ^ indicates exponentiation.
|
|
80
|
-
* (The hash value of the empty string is zero.)
|
|
81
|
-
*
|
|
82
|
-
* @param value - s a string
|
|
83
|
-
* @returns a hash code value for the given string.
|
|
84
|
-
*
|
|
85
1573
|
* @internal
|
|
86
1574
|
*/
|
|
87
|
-
export declare function
|
|
1575
|
+
export declare function _reduce<T>(collection: T[] | null | undefined, iteratee: _MemoListIterator<T, T, T[]>): T | undefined;
|
|
88
1576
|
|
|
89
1577
|
/**
|
|
90
1578
|
* @internal
|
|
91
1579
|
*/
|
|
92
|
-
export declare
|
|
93
|
-
maxLength?: number;
|
|
94
|
-
}
|
|
1580
|
+
export declare function _reduce<T>(collection: _List<T> | null | undefined, iteratee: _MemoListIterator<T, T, _List<T>>): T | undefined;
|
|
95
1581
|
|
|
96
1582
|
/**
|
|
97
|
-
* A matcher for suppressConsole
|
|
98
|
-
*
|
|
99
1583
|
* @internal
|
|
100
1584
|
*/
|
|
101
|
-
export declare
|
|
102
|
-
type: "regex";
|
|
103
|
-
value: RegExp;
|
|
104
|
-
} | {
|
|
105
|
-
type: "includes" | "exact" | "startsWith";
|
|
106
|
-
value: string;
|
|
107
|
-
};
|
|
1585
|
+
export declare function _reduce<T extends object>(collection: T | null | undefined, iteratee: _MemoObjectIterator<T[keyof T], T[keyof T], T>): T[keyof T] | undefined;
|
|
108
1586
|
|
|
109
1587
|
/**
|
|
110
|
-
*
|
|
1588
|
+
* Given an object containing the parsed translation bundle, this function creates a new object which contains
|
|
1589
|
+
* only key → value mapping between translation key and the actual value.
|
|
111
1590
|
*
|
|
1591
|
+
* @param translationsWithMetadata - parsed translation bundle
|
|
112
1592
|
* @internal
|
|
113
1593
|
*/
|
|
114
|
-
export declare
|
|
1594
|
+
export declare function removeMetadata(translationsWithMetadata: Record<string, any>): Record<string, string>;
|
|
115
1595
|
|
|
116
1596
|
/**
|
|
117
|
-
*
|
|
118
|
-
* Assume alphanumeric strings in the array and spaces; if some is not alphanumeric , return null
|
|
119
|
-
* @param str - input string with the array definition
|
|
120
|
-
* @returns parsed array of strings
|
|
1597
|
+
* Handles difference between GD locale and moment.js locale identifiers
|
|
121
1598
|
*
|
|
1599
|
+
* @param intlLocale - locale identifier
|
|
122
1600
|
* @internal
|
|
123
1601
|
*/
|
|
124
|
-
export declare
|
|
1602
|
+
export declare const sanitizeLocaleForMoment: (intlLocale: string) => string;
|
|
125
1603
|
|
|
126
1604
|
/**
|
|
127
|
-
*
|
|
1605
|
+
* Sets the value at `path` of `object`. If a portion of `path` doesn't exist, it's created. Arrays are
|
|
1606
|
+
* created for missing index properties while objects are created for all other missing properties.
|
|
1607
|
+
* The segments `__proto__`, `constructor` and `prototype` are refused, which prevents prototype pollution.
|
|
128
1608
|
*
|
|
129
|
-
*
|
|
130
|
-
* @returns random string
|
|
1609
|
+
* **Note:** This method mutates `object`.
|
|
131
1610
|
*
|
|
1611
|
+
* @param object - The object to modify.
|
|
1612
|
+
* @param path - The path of the property to set.
|
|
1613
|
+
* @param value - The value to set.
|
|
1614
|
+
* @returns Returns `object`.
|
|
132
1615
|
* @internal
|
|
133
1616
|
*/
|
|
134
|
-
export declare function
|
|
1617
|
+
export declare function _set<T extends object>(object: T, path: _PropertyPath, value: unknown): T;
|
|
135
1618
|
|
|
136
1619
|
/**
|
|
137
|
-
*
|
|
138
|
-
* only key → value mapping between translation key and the actual value.
|
|
139
|
-
*
|
|
140
|
-
* @param translationsWithMetadata - parsed translation bundle
|
|
1620
|
+
* @see _set
|
|
141
1621
|
* @internal
|
|
142
1622
|
*/
|
|
143
|
-
export declare function
|
|
1623
|
+
export declare function _set<TResult>(object: object, path: _PropertyPath, value: unknown): TResult;
|
|
144
1624
|
|
|
145
1625
|
/**
|
|
146
|
-
*
|
|
1626
|
+
* The customizer of `_updateWith`: invoked for every intermediate path segment with the current value, the
|
|
1627
|
+
* key and the object holding it. A result other than `undefined` is used as the container for that segment.
|
|
147
1628
|
*
|
|
148
|
-
* @param intlLocale - locale identifier
|
|
149
1629
|
* @internal
|
|
150
1630
|
*/
|
|
151
|
-
export declare
|
|
1631
|
+
export declare type _SetWithCustomizer<T> = (nsValue: any, key: string, nsObject: T) => any;
|
|
152
1632
|
|
|
153
1633
|
/**
|
|
154
1634
|
* @internal
|
|
@@ -185,6 +1665,23 @@ export declare function shortenText(value: string, options?: IShortenTextOptions
|
|
|
185
1665
|
*/
|
|
186
1666
|
export declare function simplifyText(value: string | number | null): string;
|
|
187
1667
|
|
|
1668
|
+
/**
|
|
1669
|
+
* Creates an array of elements, sorted in ascending order by the results of running each element in a
|
|
1670
|
+
* collection through each iteratee. This method performs a stable sort, that is, it preserves the original
|
|
1671
|
+
* sort order of equal elements. The iteratees are invoked with one argument: (value).
|
|
1672
|
+
*
|
|
1673
|
+
* @param collection - The collection to iterate over.
|
|
1674
|
+
* @param iteratees - The iteratees to sort by, specified individually or in arrays.
|
|
1675
|
+
* @returns Returns the new sorted array.
|
|
1676
|
+
* @internal
|
|
1677
|
+
*/
|
|
1678
|
+
export declare function _sortBy<T>(collection: _List<T> | null | undefined, ...iteratees: _Many<_ListIteratee<T>>[]): T[];
|
|
1679
|
+
|
|
1680
|
+
/**
|
|
1681
|
+
* @internal
|
|
1682
|
+
*/
|
|
1683
|
+
export declare function _sortBy<T extends object>(collection: T | null | undefined, ...iteratees: _Many<_ObjectIteratee<T>>[]): T[keyof T][];
|
|
1684
|
+
|
|
188
1685
|
/**
|
|
189
1686
|
* A specific matcher function
|
|
190
1687
|
*
|
|
@@ -209,6 +1706,24 @@ export declare type SpecificMatcherFunction = (message: string) => boolean;
|
|
|
209
1706
|
*/
|
|
210
1707
|
export declare function strictBarrel<T extends object>(packageName: string, exports: T): T;
|
|
211
1708
|
|
|
1709
|
+
/**
|
|
1710
|
+
* @internal
|
|
1711
|
+
*/
|
|
1712
|
+
export declare type _StringIterator<TResult> = (char: string, index: number, string: string) => TResult;
|
|
1713
|
+
|
|
1714
|
+
/**
|
|
1715
|
+
* This method is like `_sum` except that it accepts `iteratee` which is invoked for each element in `array`
|
|
1716
|
+
* to generate the value to be summed. The iteratee is invoked with one argument: (value). Values are added
|
|
1717
|
+
* with the `+` operator, `undefined` results are skipped, and, as in lodash, an empty or nullish array
|
|
1718
|
+
* yields `0` while an array without any defined result yields `undefined`.
|
|
1719
|
+
*
|
|
1720
|
+
* @param array - The array to iterate over.
|
|
1721
|
+
* @param iteratee - The iteratee invoked per element, or a property shorthand.
|
|
1722
|
+
* @returns Returns the sum.
|
|
1723
|
+
* @internal
|
|
1724
|
+
*/
|
|
1725
|
+
export declare function _sumBy<T>(array: _List<T> | null | undefined, iteratee?: ((value: T) => number) | string): number;
|
|
1726
|
+
|
|
212
1727
|
/**
|
|
213
1728
|
* Suppresses certain console outputs
|
|
214
1729
|
*
|
|
@@ -230,6 +1745,249 @@ export declare function suppressConsole<T>(fn: () => T | Promise<T>, type?: Cons
|
|
|
230
1745
|
*/
|
|
231
1746
|
export declare function suppressConsole<T>(fn: () => T | Promise<T>, matcherFn: MatcherFunction): T | Promise<T>;
|
|
232
1747
|
|
|
1748
|
+
/**
|
|
1749
|
+
* Gets all but the first element of `array` as a new dense array. Nullish input and anything without a
|
|
1750
|
+
* truthy `length` yield an empty array.
|
|
1751
|
+
*
|
|
1752
|
+
* @param array - The array to query.
|
|
1753
|
+
* @returns Returns the slice of `array`.
|
|
1754
|
+
* @internal
|
|
1755
|
+
*/
|
|
1756
|
+
export declare function _tail<T extends unknown[]>(array: readonly [unknown, ...T]): T;
|
|
1757
|
+
|
|
1758
|
+
/**
|
|
1759
|
+
* @internal
|
|
1760
|
+
*/
|
|
1761
|
+
export declare function _tail<T>(array?: _List<T> | null): T[];
|
|
1762
|
+
|
|
1763
|
+
/**
|
|
1764
|
+
* Creates a throttled function that only invokes `func` at most once per every `wait` milliseconds. The
|
|
1765
|
+
* throttled function comes with a `cancel` method to cancel delayed `func` invocations and a `flush` method
|
|
1766
|
+
* to immediately invoke them. Provide `options` to indicate whether `func` should be invoked on the leading
|
|
1767
|
+
* and/or trailing edge of the `wait` timeout. The `func` is invoked with the last arguments provided to the
|
|
1768
|
+
* throttled function. Subsequent calls to the throttled function return the result of the last `func`
|
|
1769
|
+
* invocation.
|
|
1770
|
+
*
|
|
1771
|
+
* **Note:** If `leading` and `trailing` options are `true`, `func` is invoked on the trailing edge of the
|
|
1772
|
+
* timeout only if the throttled function is invoked more than once during the `wait` timeout.
|
|
1773
|
+
*
|
|
1774
|
+
* If `wait` is `0` and `leading` is `false`, `func` invocation is deferred until the next tick, similar to
|
|
1775
|
+
* `setTimeout` with a timeout of `0`.
|
|
1776
|
+
*
|
|
1777
|
+
* @param func - The function to throttle.
|
|
1778
|
+
* @param wait - The number of milliseconds to throttle invocations to. Defaults to `0`.
|
|
1779
|
+
* @param options - The options object.
|
|
1780
|
+
* @returns Returns the new throttled function.
|
|
1781
|
+
* @internal
|
|
1782
|
+
*/
|
|
1783
|
+
export declare function _throttle<T extends (...args: any) => any>(func: T, wait?: number, options?: _ThrottleSettingsLeading): _DebouncedFuncLeading<T>;
|
|
1784
|
+
|
|
1785
|
+
/**
|
|
1786
|
+
* @internal
|
|
1787
|
+
*/
|
|
1788
|
+
export declare function _throttle<T extends (...args: any) => any>(func: T, wait?: number, options?: _ThrottleSettings): _DebouncedFunc<T>;
|
|
1789
|
+
|
|
1790
|
+
/**
|
|
1791
|
+
* Options of `_throttle`.
|
|
1792
|
+
*
|
|
1793
|
+
* @internal
|
|
1794
|
+
*/
|
|
1795
|
+
export declare type _ThrottleSettings = {
|
|
1796
|
+
/** Invoke on the leading edge of the timeout. Defaults to `true`. */
|
|
1797
|
+
leading?: boolean | undefined;
|
|
1798
|
+
/** Invoke on the trailing edge of the timeout. Defaults to `true`. */
|
|
1799
|
+
trailing?: boolean | undefined;
|
|
1800
|
+
};
|
|
1801
|
+
|
|
1802
|
+
/**
|
|
1803
|
+
* {@link _ThrottleSettings} that keep `leading` switched on, which guarantees a result on every call.
|
|
1804
|
+
*
|
|
1805
|
+
* @internal
|
|
1806
|
+
*/
|
|
1807
|
+
export declare type _ThrottleSettingsLeading = (_ThrottleSettings & {
|
|
1808
|
+
leading: true;
|
|
1809
|
+
}) | Omit<_ThrottleSettings, "leading">;
|
|
1810
|
+
|
|
1811
|
+
/**
|
|
1812
|
+
* Invokes the iteratee `n` times, returning an array of the results of each invocation. The iteratee is
|
|
1813
|
+
* invoked with one argument, the index, and anything but a function is replaced by the identity, so the
|
|
1814
|
+
* indices are returned. The count is coerced to an integer the way lodash does it; a count below 1 or above
|
|
1815
|
+
* the safe integer range yields an empty array.
|
|
1816
|
+
*
|
|
1817
|
+
* @param n - The number of times to invoke `iteratee`.
|
|
1818
|
+
* @param iteratee - The function invoked per iteration.
|
|
1819
|
+
* @returns Returns the array of results.
|
|
1820
|
+
* @internal
|
|
1821
|
+
*/
|
|
1822
|
+
export declare function _times<TResult>(n: number, iteratee: (index: number) => TResult): TResult[];
|
|
1823
|
+
|
|
1824
|
+
/**
|
|
1825
|
+
* @internal
|
|
1826
|
+
*/
|
|
1827
|
+
export declare function _times(n: number): number[];
|
|
1828
|
+
|
|
1829
|
+
/**
|
|
1830
|
+
* The inverse of `_escape`; this method converts the HTML entities `&`, `<`, `>`, `"` and
|
|
1831
|
+
* `'` in `string` to their corresponding characters.
|
|
1832
|
+
*
|
|
1833
|
+
* **Note:** No other HTML entities are unescaped. To unescape additional HTML entities use a third-party
|
|
1834
|
+
* library like [he](https://mths.be/he).
|
|
1835
|
+
*
|
|
1836
|
+
* @param string - The string to unescape.
|
|
1837
|
+
* @returns Returns the unescaped string.
|
|
1838
|
+
* @internal
|
|
1839
|
+
*/
|
|
1840
|
+
export declare function _unescape(string?: string): string;
|
|
1841
|
+
|
|
1842
|
+
/**
|
|
1843
|
+
* Creates an array of unique values, in order, from all given arrays using SameValueZero for equality
|
|
1844
|
+
* comparisons. Only array-like objects are inspected; other arguments, strings included, are skipped.
|
|
1845
|
+
*
|
|
1846
|
+
* @param arrays - The arrays to inspect.
|
|
1847
|
+
* @returns Returns the new array of combined values.
|
|
1848
|
+
* @internal
|
|
1849
|
+
*/
|
|
1850
|
+
export declare function _union<T>(...arrays: (_List<T> | null | undefined)[]): T[];
|
|
1851
|
+
|
|
1852
|
+
/**
|
|
1853
|
+
* This method is like `_union` except that it accepts `iteratee` which is invoked for each element of each
|
|
1854
|
+
* array to generate the criterion by which uniqueness is computed. Result values are chosen from the first
|
|
1855
|
+
* array in which the value occurs. The iteratee is invoked with one argument: (value). As in lodash, the
|
|
1856
|
+
* last argument is taken as the iteratee unless it is an array-like object, so an array is always a list
|
|
1857
|
+
* to merge, and arguments that are not array-like objects are skipped.
|
|
1858
|
+
*
|
|
1859
|
+
* @param arrays - The arrays to inspect, followed by the optional iteratee.
|
|
1860
|
+
* @returns Returns the new array of combined values.
|
|
1861
|
+
* @internal
|
|
1862
|
+
*/
|
|
1863
|
+
export declare function _unionBy<T>(arrays: _List<T> | null | undefined, iteratee?: _ValueIteratee<T>): T[];
|
|
1864
|
+
|
|
1865
|
+
/**
|
|
1866
|
+
* @internal
|
|
1867
|
+
*/
|
|
1868
|
+
export declare function _unionBy<T>(arrays1: _List<T> | null | undefined, arrays2: _List<T> | null | undefined, iteratee?: _ValueIteratee<T>): T[];
|
|
1869
|
+
|
|
1870
|
+
/**
|
|
1871
|
+
* @internal
|
|
1872
|
+
*/
|
|
1873
|
+
export declare function _unionBy<T>(arrays1: _List<T> | null | undefined, arrays2: _List<T> | null | undefined, arrays3: _List<T> | null | undefined, iteratee?: _ValueIteratee<T>): T[];
|
|
1874
|
+
|
|
1875
|
+
/**
|
|
1876
|
+
* @internal
|
|
1877
|
+
*/
|
|
1878
|
+
export declare function _unionBy<T>(arrays1: _List<T> | null | undefined, arrays2: _List<T> | null | undefined, arrays3: _List<T> | null | undefined, arrays4: _List<T> | null | undefined, iteratee?: _ValueIteratee<T>): T[];
|
|
1879
|
+
|
|
1880
|
+
/**
|
|
1881
|
+
* @internal
|
|
1882
|
+
*/
|
|
1883
|
+
export declare function _unionBy<T>(arrays1: _List<T> | null | undefined, arrays2: _List<T> | null | undefined, arrays3: _List<T> | null | undefined, arrays4: _List<T> | null | undefined, arrays5: _List<T> | null | undefined, ...iteratee: (_ValueIteratee<T> | _List<T> | null | undefined)[]): T[];
|
|
1884
|
+
|
|
1885
|
+
/**
|
|
1886
|
+
* @internal
|
|
1887
|
+
*/
|
|
1888
|
+
export declare function _unionBy<T>(...values: (_ValueIteratee<T> | _List<T> | null | undefined)[]): T[];
|
|
1889
|
+
|
|
1890
|
+
/**
|
|
1891
|
+
* Creates a duplicate-free version of an array, using SameValueZero for equality comparisons, in which
|
|
1892
|
+
* only the first occurrence of each element is kept. The order of result values is determined by the
|
|
1893
|
+
* order they occur in the array.
|
|
1894
|
+
*
|
|
1895
|
+
* @param array - The array to inspect.
|
|
1896
|
+
* @returns Returns the new duplicate free array.
|
|
1897
|
+
* @internal
|
|
1898
|
+
*/
|
|
1899
|
+
export declare function _uniq<T>(array: _List<T> | null | undefined): T[];
|
|
1900
|
+
|
|
1901
|
+
/**
|
|
1902
|
+
* This method is like `uniq` except that it accepts `iteratee` which is invoked for each element in
|
|
1903
|
+
* `array` to generate the criterion by which uniqueness is computed. The order of result values is
|
|
1904
|
+
* determined by the order they occur in the array. The iteratee is invoked with one argument: (value).
|
|
1905
|
+
*
|
|
1906
|
+
* @param array - The array to inspect.
|
|
1907
|
+
* @param iteratee - The iteratee invoked per element.
|
|
1908
|
+
* @returns Returns the new duplicate free array.
|
|
1909
|
+
* @internal
|
|
1910
|
+
*/
|
|
1911
|
+
export declare function _uniqBy<T>(array: _List<T> | null | undefined, iteratee: _ValueIteratee<T>): T[];
|
|
1912
|
+
|
|
1913
|
+
declare const uniqueSymbol: unique symbol;
|
|
1914
|
+
|
|
1915
|
+
/**
|
|
1916
|
+
* This method is like `_uniq` except that it accepts `comparator` which is invoked to compare elements of
|
|
1917
|
+
* `array`. The order of result values is determined by the order they occur in the array. The comparator
|
|
1918
|
+
* is invoked with two arguments: (arrVal, othVal), the candidate first and then each kept element in order.
|
|
1919
|
+
* Without a function comparator, elements are compared with SameValueZero.
|
|
1920
|
+
*
|
|
1921
|
+
* @param array - The array to inspect.
|
|
1922
|
+
* @param comparator - The comparator invoked per element.
|
|
1923
|
+
* @returns Returns the new duplicate free array.
|
|
1924
|
+
* @internal
|
|
1925
|
+
*/
|
|
1926
|
+
export declare function _uniqWith<T>(array: _List<T> | null | undefined, comparator?: _Comparator<T>): T[];
|
|
1927
|
+
|
|
1928
|
+
/**
|
|
1929
|
+
* This method is like `_set` except that it accepts `updater` to produce the value to set. The updater is
|
|
1930
|
+
* invoked with one argument, the current value at `path`, which is `undefined` when the path does not exist;
|
|
1931
|
+
* a non-function updater keeps the current value. Missing segments of the path are created as lodash does,
|
|
1932
|
+
* arrays for index segments and plain objects otherwise.
|
|
1933
|
+
*
|
|
1934
|
+
* **Note:** This method mutates `object`.
|
|
1935
|
+
*
|
|
1936
|
+
* @param object - The object to modify.
|
|
1937
|
+
* @param path - The path of the property to set.
|
|
1938
|
+
* @param updater - The function to produce the updated value.
|
|
1939
|
+
* @returns Returns `object`.
|
|
1940
|
+
* @internal
|
|
1941
|
+
*/
|
|
1942
|
+
export declare function _update(object: object, path: _PropertyPath, updater: (value: any) => any): any;
|
|
1943
|
+
|
|
1944
|
+
/**
|
|
1945
|
+
* This method is like `_update` except that it accepts `customizer` which is invoked to produce the objects
|
|
1946
|
+
* of `path`. If `customizer` returns `undefined` path creation is handled by the method instead. The
|
|
1947
|
+
* `customizer` is invoked with three arguments: (nsValue, key, nsObject). Anything but a function is
|
|
1948
|
+
* ignored as a customizer, and anything but a function is the identity as an updater.
|
|
1949
|
+
*
|
|
1950
|
+
* **Note:** This method mutates `object`.
|
|
1951
|
+
*
|
|
1952
|
+
* @param object - The object to modify.
|
|
1953
|
+
* @param path - The path of the property to set.
|
|
1954
|
+
* @param updater - The function to produce the updated value.
|
|
1955
|
+
* @param customizer - The function to customize assigned values.
|
|
1956
|
+
* @returns Returns `object`.
|
|
1957
|
+
* @internal
|
|
1958
|
+
*/
|
|
1959
|
+
export declare function _updateWith<T extends object>(object: T, path: _PropertyPath, updater: (oldValue: any) => any, customizer?: _SetWithCustomizer<T>): T;
|
|
1960
|
+
|
|
1961
|
+
/**
|
|
1962
|
+
* @internal
|
|
1963
|
+
*/
|
|
1964
|
+
export declare function _updateWith<T extends object, TResult>(object: T, path: _PropertyPath, updater: (oldValue: any) => any, customizer?: _SetWithCustomizer<T>): TResult;
|
|
1965
|
+
|
|
1966
|
+
/**
|
|
1967
|
+
* An iteratee as lodash accepts it: a function, a property name or path, a `[path, value]` pair, or a
|
|
1968
|
+
* partial object to match.
|
|
1969
|
+
*
|
|
1970
|
+
* @internal
|
|
1971
|
+
*/
|
|
1972
|
+
export declare type _ValueIteratee<T> = ((value: T) => _NotVoid) | _IterateeShorthand<T>;
|
|
1973
|
+
|
|
1974
|
+
/**
|
|
1975
|
+
* @internal
|
|
1976
|
+
*/
|
|
1977
|
+
export declare type _ValueIterateeCustom<T, TResult> = ((value: T) => TResult) | _IterateeShorthand<T>;
|
|
1978
|
+
|
|
1979
|
+
/**
|
|
1980
|
+
* A predicate that narrows the element type, so functions like `_partition` can type their result.
|
|
1981
|
+
*
|
|
1982
|
+
* @internal
|
|
1983
|
+
*/
|
|
1984
|
+
export declare type _ValueIteratorTypeGuard<T, S extends T> = (value: T) => value is S;
|
|
1985
|
+
|
|
1986
|
+
/**
|
|
1987
|
+
* @internal
|
|
1988
|
+
*/
|
|
1989
|
+
export declare type _ValueKeyIteratee<T> = ((value: T, key: string) => _NotVoid) | _IterateeShorthand<T>;
|
|
1990
|
+
|
|
233
1991
|
/**
|
|
234
1992
|
* A waitFor-compatible polling function, structurally matching testing-library's waitFor.
|
|
235
1993
|
*
|
|
@@ -240,4 +1998,49 @@ export declare type WaitForFn = <T>(callback: () => T | Promise<T>, options?: {
|
|
|
240
1998
|
timeout?: number;
|
|
241
1999
|
}) => Promise<T>;
|
|
242
2000
|
|
|
2001
|
+
/**
|
|
2002
|
+
* Creates an array excluding all given values using SameValueZero for equality comparisons. The order and
|
|
2003
|
+
* references of result values are determined by the input array, with `-0` normalised to `0`. Only an
|
|
2004
|
+
* array-like object is inspected: any other `array` yields an empty array.
|
|
2005
|
+
*
|
|
2006
|
+
* **Note:** Unlike `_.pull`, this method returns a new array.
|
|
2007
|
+
*
|
|
2008
|
+
* @param array - The array to inspect.
|
|
2009
|
+
* @param values - The values to exclude.
|
|
2010
|
+
* @returns Returns the new array of filtered values.
|
|
2011
|
+
* @internal
|
|
2012
|
+
*/
|
|
2013
|
+
export declare function _without<T>(array: _List<T> | null | undefined, ...values: T[]): T[];
|
|
2014
|
+
|
|
2015
|
+
/**
|
|
2016
|
+
* Creates an array of grouped elements, the first of which contains the first elements of the given arrays,
|
|
2017
|
+
* the second of which contains the second elements of the given arrays, and so on. Shorter arrays are padded
|
|
2018
|
+
* with `undefined` up to the longest one. Only array-like objects take part; other arguments are skipped.
|
|
2019
|
+
*
|
|
2020
|
+
* @param arrays - The arrays to process.
|
|
2021
|
+
* @returns Returns the new array of grouped elements.
|
|
2022
|
+
* @internal
|
|
2023
|
+
*/
|
|
2024
|
+
export declare function _zip<T1, T2>(arrays1: _List<T1>, arrays2: _List<T2>): [T1 | undefined, T2 | undefined][];
|
|
2025
|
+
|
|
2026
|
+
/**
|
|
2027
|
+
* @internal
|
|
2028
|
+
*/
|
|
2029
|
+
export declare function _zip<T1, T2, T3>(arrays1: _List<T1>, arrays2: _List<T2>, arrays3: _List<T3>): [T1 | undefined, T2 | undefined, T3 | undefined][];
|
|
2030
|
+
|
|
2031
|
+
/**
|
|
2032
|
+
* @internal
|
|
2033
|
+
*/
|
|
2034
|
+
export declare function _zip<T1, T2, T3, T4>(arrays1: _List<T1>, arrays2: _List<T2>, arrays3: _List<T3>, arrays4: _List<T4>): [T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined][];
|
|
2035
|
+
|
|
2036
|
+
/**
|
|
2037
|
+
* @internal
|
|
2038
|
+
*/
|
|
2039
|
+
export declare function _zip<T1, T2, T3, T4, T5>(arrays1: _List<T1>, arrays2: _List<T2>, arrays3: _List<T3>, arrays4: _List<T4>, arrays5: _List<T5>): [T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined, T5 | undefined][];
|
|
2040
|
+
|
|
2041
|
+
/**
|
|
2042
|
+
* @internal
|
|
2043
|
+
*/
|
|
2044
|
+
export declare function _zip<T>(...arrays: (_List<T> | null | undefined)[]): (T | undefined)[][];
|
|
2045
|
+
|
|
243
2046
|
export { }
|