@gooddata/util 11.68.0-alpha.7 → 11.68.0-alpha.9

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.
Files changed (163) hide show
  1. package/NOTICE +4 -2
  2. package/esm/_/_baseClone.d.ts +17 -4
  3. package/esm/_/_baseClone.d.ts.map +1 -1
  4. package/esm/_/_baseClone.js +55 -23
  5. package/esm/_/_baseDifference.d.ts +18 -0
  6. package/esm/_/_baseDifference.d.ts.map +1 -0
  7. package/esm/_/_baseDifference.js +79 -0
  8. package/esm/_/_baseExtremum.d.ts +15 -0
  9. package/esm/_/_baseExtremum.d.ts.map +1 -0
  10. package/esm/_/_baseExtremum.js +64 -0
  11. package/esm/_/_baseIntersection.d.ts +19 -0
  12. package/esm/_/_baseIntersection.d.ts.map +1 -0
  13. package/esm/_/_baseIntersection.js +91 -0
  14. package/esm/_/_baseMerge.d.ts +7 -3
  15. package/esm/_/_baseMerge.d.ts.map +1 -1
  16. package/esm/_/_baseMerge.js +20 -11
  17. package/esm/_/_baseSet.d.ts +3 -1
  18. package/esm/_/_baseSet.d.ts.map +1 -1
  19. package/esm/_/_baseSet.js +9 -3
  20. package/esm/_/_baseSlice.d.ts +45 -0
  21. package/esm/_/_baseSlice.d.ts.map +1 -0
  22. package/esm/_/_baseSlice.js +30 -0
  23. package/esm/_/_baseSum.d.ts +42 -0
  24. package/esm/_/_baseSum.d.ts.map +1 -0
  25. package/esm/_/_baseSum.js +21 -0
  26. package/esm/_/_cloneTypedArray.d.ts +1 -1
  27. package/esm/_/_cloneTypedArray.d.ts.map +1 -1
  28. package/esm/_/_cloneTypedArray.js +3 -2
  29. package/esm/_/_flattenArrayLikeObjects.d.ts +11 -0
  30. package/esm/_/_flattenArrayLikeObjects.d.ts.map +1 -0
  31. package/esm/_/_flattenArrayLikeObjects.js +55 -0
  32. package/esm/_/assignIn.d.ts +35 -0
  33. package/esm/_/assignIn.d.ts.map +1 -0
  34. package/esm/_/assignIn.js +50 -0
  35. package/esm/_/bindAll.d.ts +16 -0
  36. package/esm/_/bindAll.d.ts.map +1 -0
  37. package/esm/_/bindAll.js +88 -0
  38. package/esm/_/chunk.d.ts +15 -0
  39. package/esm/_/chunk.d.ts.map +1 -0
  40. package/esm/_/chunk.js +61 -0
  41. package/esm/_/clamp.d.ts +17 -0
  42. package/esm/_/clamp.d.ts.map +1 -0
  43. package/esm/_/clamp.js +56 -0
  44. package/esm/_/clone.d.ts +12 -0
  45. package/esm/_/clone.d.ts.map +1 -0
  46. package/esm/_/clone.js +45 -0
  47. package/esm/_/cloneDeep.js +1 -1
  48. package/esm/_/cloneDeepWith.d.ts +18 -0
  49. package/esm/_/cloneDeepWith.d.ts.map +1 -0
  50. package/esm/_/cloneDeepWith.js +36 -0
  51. package/esm/_/constant.d.ts +39 -0
  52. package/esm/_/constant.d.ts.map +1 -0
  53. package/esm/_/constant.js +43 -0
  54. package/esm/_/defaults.d.ts +36 -0
  55. package/esm/_/defaults.d.ts.map +1 -0
  56. package/esm/_/defaults.js +51 -0
  57. package/esm/_/difference.d.ts.map +1 -1
  58. package/esm/_/difference.js +2 -23
  59. package/esm/_/differenceBy.d.ts +39 -0
  60. package/esm/_/differenceBy.d.ts.map +1 -0
  61. package/esm/_/differenceBy.js +40 -0
  62. package/esm/_/differenceWith.d.ts +27 -0
  63. package/esm/_/differenceWith.d.ts.map +1 -0
  64. package/esm/_/differenceWith.js +39 -0
  65. package/esm/_/dropRightWhile.d.ts +13 -0
  66. package/esm/_/dropRightWhile.d.ts.map +1 -0
  67. package/esm/_/dropRightWhile.js +54 -0
  68. package/esm/_/escapeRegExp.d.ts +12 -0
  69. package/esm/_/escapeRegExp.d.ts.map +1 -0
  70. package/esm/_/escapeRegExp.js +47 -0
  71. package/esm/_/findKey.d.ts +14 -0
  72. package/esm/_/findKey.d.ts.map +1 -0
  73. package/esm/_/findKey.js +58 -0
  74. package/esm/_/findLastIndex.d.ts +16 -0
  75. package/esm/_/findLastIndex.d.ts.map +1 -0
  76. package/esm/_/findLastIndex.js +67 -0
  77. package/esm/_/get.d.ts +78 -0
  78. package/esm/_/get.d.ts.map +1 -0
  79. package/esm/_/get.js +36 -0
  80. package/esm/_/inRange.d.ts +14 -0
  81. package/esm/_/inRange.d.ts.map +1 -0
  82. package/esm/_/inRange.js +51 -0
  83. package/esm/_/initial.d.ts +11 -0
  84. package/esm/_/initial.d.ts.map +1 -0
  85. package/esm/_/initial.js +44 -0
  86. package/esm/_/intersection.d.ts +13 -0
  87. package/esm/_/intersection.d.ts.map +1 -0
  88. package/esm/_/intersection.js +45 -0
  89. package/esm/_/intersectionBy.d.ts +32 -0
  90. package/esm/_/intersectionBy.d.ts.map +1 -0
  91. package/esm/_/intersectionBy.js +41 -0
  92. package/esm/_/intersectionWith.d.ts +28 -0
  93. package/esm/_/intersectionWith.d.ts.map +1 -0
  94. package/esm/_/intersectionWith.js +38 -0
  95. package/esm/_/invert.d.ts +14 -0
  96. package/esm/_/invert.d.ts.map +1 -0
  97. package/esm/_/invert.js +55 -0
  98. package/esm/_/isError.d.ts +11 -0
  99. package/esm/_/isError.d.ts.map +1 -0
  100. package/esm/_/isError.js +57 -0
  101. package/esm/_/keys.d.ts +11 -0
  102. package/esm/_/keys.d.ts.map +1 -0
  103. package/esm/_/keys.js +60 -0
  104. package/esm/_/mapValues.d.ts +63 -0
  105. package/esm/_/mapValues.d.ts.map +1 -0
  106. package/esm/_/mapValues.js +47 -0
  107. package/esm/_/max.d.ts +16 -0
  108. package/esm/_/max.d.ts.map +1 -0
  109. package/esm/_/max.js +37 -0
  110. package/esm/_/mergeWith.d.ts +34 -0
  111. package/esm/_/mergeWith.d.ts.map +1 -0
  112. package/esm/_/mergeWith.js +50 -0
  113. package/esm/_/min.d.ts +16 -0
  114. package/esm/_/min.d.ts.map +1 -0
  115. package/esm/_/min.js +37 -0
  116. package/esm/_/negate.d.ts +41 -0
  117. package/esm/_/negate.d.ts.map +1 -0
  118. package/esm/_/negate.js +48 -0
  119. package/esm/_/reduce.d.ts +37 -0
  120. package/esm/_/reduce.d.ts.map +1 -0
  121. package/esm/_/reduce.js +48 -0
  122. package/esm/_/sumBy.d.ts +14 -0
  123. package/esm/_/sumBy.d.ts.map +1 -0
  124. package/esm/_/sumBy.js +47 -0
  125. package/esm/_/tail.d.ts +15 -0
  126. package/esm/_/tail.d.ts.map +1 -0
  127. package/esm/_/tail.js +36 -0
  128. package/esm/_/times.d.ts +17 -0
  129. package/esm/_/times.d.ts.map +1 -0
  130. package/esm/_/times.js +57 -0
  131. package/esm/_/toFinite.d.ts +0 -30
  132. package/esm/_/toFinite.d.ts.map +1 -1
  133. package/esm/_/toFinite.js +2 -2
  134. package/esm/_/toInteger.d.ts +11 -0
  135. package/esm/_/toInteger.d.ts.map +1 -0
  136. package/esm/_/toInteger.js +46 -0
  137. package/esm/_/toNumber.d.ts +11 -0
  138. package/esm/_/toNumber.d.ts.map +1 -0
  139. package/esm/_/toNumber.js +69 -0
  140. package/esm/_/types.d.ts +47 -0
  141. package/esm/_/types.d.ts.map +1 -1
  142. package/esm/_/unescape.d.ts +13 -0
  143. package/esm/_/unescape.d.ts.map +1 -0
  144. package/esm/_/unescape.js +56 -0
  145. package/esm/_/union.d.ts.map +1 -1
  146. package/esm/_/union.js +2 -13
  147. package/esm/_/unionBy.d.ts +34 -0
  148. package/esm/_/unionBy.d.ts.map +1 -0
  149. package/esm/_/unionBy.js +42 -0
  150. package/esm/_/update.d.ts +17 -0
  151. package/esm/_/update.d.ts.map +1 -0
  152. package/esm/_/update.js +55 -0
  153. package/esm/_/updateWith.d.ts +23 -0
  154. package/esm/_/updateWith.d.ts.map +1 -0
  155. package/esm/_/updateWith.js +41 -0
  156. package/esm/_/without.d.ts +15 -0
  157. package/esm/_/without.d.ts.map +1 -0
  158. package/esm/_/without.js +47 -0
  159. package/esm/index.d.ts +40 -3
  160. package/esm/index.d.ts.map +1 -1
  161. package/esm/index.js +39 -2
  162. package/esm/util.d.ts +918 -1
  163. package/package.json +3 -3
package/esm/util.d.ts CHANGED
@@ -7,6 +7,66 @@
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
+
10
70
  /**
11
71
  * Converts `string` to camel case: the words of the string, lower-cased, with every word but the first
12
72
  * capitalised, joined together.
@@ -26,6 +86,50 @@ export declare const _camelCase: (string?: string) => string;
26
86
  */
27
87
  export declare function _capitalize(string?: string): string;
28
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
+
29
133
  /**
30
134
  * Recursively clones `value`.
31
135
  *
@@ -40,6 +144,33 @@ export declare function _capitalize(string?: string): string;
40
144
  */
41
145
  export declare function _cloneDeep<T>(value: T): T;
42
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
+
43
174
  /**
44
175
  * Returns combine guard from input guards as a result type is union type of guarded types
45
176
  * Its good for array filtering base on multiple guards and its return correct result union type
@@ -63,6 +194,11 @@ export declare function _compact<T>(array: _List<T | _Falsey> | null | undefined
63
194
  */
64
195
  export declare type _Comparator<T> = (a: T, b: T) => boolean;
65
196
 
197
+ /**
198
+ * @internal
199
+ */
200
+ export declare type _Comparator2<T1, T2> = (a: T1, b: T2) => boolean;
201
+
66
202
  /**
67
203
  * A console function, like log, warn or error
68
204
  *
@@ -77,6 +213,15 @@ export declare type ConsoleFunction = (...data: any[]) => void;
77
213
  */
78
214
  export declare type ConsoleType = "error" | "warn" | "log" | "debug" | "info";
79
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
+
80
225
  /**
81
226
  * Wraps a testing-library waitFor so it polls every millisecond instead of the default 50ms.
82
227
  *
@@ -165,6 +310,57 @@ export declare type _DebounceSettingsLeading = _DebounceSettings & {
165
310
  leading: true;
166
311
  };
167
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
+
168
364
  /**
169
365
  * Returns a promise which will resolve after the provided number of milliseconds.
170
366
  *
@@ -193,6 +389,91 @@ export declare type _Dictionary<T> = {
193
389
  */
194
390
  export declare function _difference<T>(array: _List<T> | null | undefined, ...values: _List<T>[]): T[];
195
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
+
196
477
  /**
197
478
  * @internal
198
479
  */
@@ -233,12 +514,52 @@ export declare function _escape(string?: string): string;
233
514
  */
234
515
  export declare function escapeRegExp(value: string): string;
235
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
+
236
529
  /** Common interface between Arrays and jQuery objects */
237
530
  /**
238
531
  * @internal
239
532
  */
240
533
  export declare type _Falsey = null | undefined | false | "" | 0 | 0n;
241
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
+
242
563
  /**
243
564
  * @internal
244
565
  */
@@ -264,6 +585,97 @@ export declare type _Function3<T1, T2, T3, R> = (t1: T1, t2: T2, t3: T3) => R;
264
585
  */
265
586
  export declare type _Function4<T1, T2, T3, T4, R> = (t1: T1, t2: T2, t3: T3, t4: T4) => R;
266
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
+
267
679
  /**
268
680
  * Creates an object composed of keys generated from the results of running each element of
269
681
  * `collection` thru `iteratee`. The order of grouped values is determined by the order they occur in
@@ -323,7 +735,121 @@ export declare function _has<T>(object: T, path: _PropertyPath): boolean;
323
735
  *
324
736
  * @internal
325
737
  */
326
- export declare function hashCodeString(value: string): number;
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>;
327
853
 
328
854
  /**
329
855
  * Checks if value is empty. A value is considered empty unless it’s an arguments object, array, string, or
@@ -382,6 +908,17 @@ export declare function _isEmpty(value?: any): boolean;
382
908
  */
383
909
  export declare function _isEqual(value: unknown, other: unknown): boolean;
384
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
+
385
922
  /**
386
923
  * @internal
387
924
  */
@@ -440,6 +977,11 @@ export declare type _List<T> = ArrayLike<T>;
440
977
  */
441
978
  export declare type _ListIteratee<T> = _ListIterator<T, _NotVoid> | _IterateeShorthand<T>;
442
979
 
980
+ /**
981
+ * @internal
982
+ */
983
+ export declare type _ListIterateeCustom<T, TResult> = _ListIterator<T, TResult> | _IterateeShorthand<T>;
984
+
443
985
  /**
444
986
  * @internal
445
987
  */
@@ -474,6 +1016,79 @@ export declare type _MapCache = {
474
1016
  */
475
1017
  export declare type _MapCacheConstructor = new () => _MapCache;
476
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
+
477
1092
  /**
478
1093
  * A matcher for suppressConsole
479
1094
  *
@@ -494,6 +1109,22 @@ export declare type Matcher = {
494
1109
  */
495
1110
  export declare type MatcherFunction = (console: Record<ConsoleType, ConsoleFunction>, type: ConsoleType, message: string) => boolean;
496
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
+
497
1128
  /**
498
1129
  * The shape of `_memoize`: the memoizing function itself plus the `Cache` constructor every memoized
499
1130
  * function starts with.
@@ -533,6 +1164,16 @@ export declare type _MemoizedFunction = {
533
1164
  cache: _MapCache;
534
1165
  };
535
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
+
536
1177
  /**
537
1178
  * Recursively merges own and inherited enumerable string keyed properties of source objects into the
538
1179
  * destination object. Source properties that resolve to `undefined` are skipped if a destination value
@@ -569,6 +1210,79 @@ export declare function _merge<TObject, TSource1, TSource2, TSource3, TSource4>(
569
1210
  */
570
1211
  export declare function _merge(object: any, ...otherArgs: any[]): any;
571
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
+
572
1286
  /**
573
1287
  * @internal
574
1288
  */
@@ -829,6 +1543,47 @@ export declare function _range(start: number, end?: number, step?: number): numb
829
1543
  */
830
1544
  export declare function _range(end: number, index: string | number, guard: object): number[];
831
1545
 
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.
1558
+ * @internal
1559
+ */
1560
+ export declare function _reduce<T, TResult>(collection: T[] | null | undefined, iteratee: _MemoListIterator<T, TResult, T[]>, accumulator: TResult): TResult;
1561
+
1562
+ /**
1563
+ * @internal
1564
+ */
1565
+ export declare function _reduce<T, TResult>(collection: _List<T> | null | undefined, iteratee: _MemoListIterator<T, TResult, _List<T>>, accumulator: TResult): TResult;
1566
+
1567
+ /**
1568
+ * @internal
1569
+ */
1570
+ export declare function _reduce<T extends object, TResult>(collection: T | null | undefined, iteratee: _MemoObjectIterator<T[keyof T], TResult, T>, accumulator: TResult): TResult;
1571
+
1572
+ /**
1573
+ * @internal
1574
+ */
1575
+ export declare function _reduce<T>(collection: T[] | null | undefined, iteratee: _MemoListIterator<T, T, T[]>): T | undefined;
1576
+
1577
+ /**
1578
+ * @internal
1579
+ */
1580
+ export declare function _reduce<T>(collection: _List<T> | null | undefined, iteratee: _MemoListIterator<T, T, _List<T>>): T | undefined;
1581
+
1582
+ /**
1583
+ * @internal
1584
+ */
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;
1586
+
832
1587
  /**
833
1588
  * Given an object containing the parsed translation bundle, this function creates a new object which contains
834
1589
  * only key → value mapping between translation key and the actual value.
@@ -867,6 +1622,14 @@ export declare function _set<T extends object>(object: T, path: _PropertyPath, v
867
1622
  */
868
1623
  export declare function _set<TResult>(object: object, path: _PropertyPath, value: unknown): TResult;
869
1624
 
1625
+ /**
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.
1628
+ *
1629
+ * @internal
1630
+ */
1631
+ export declare type _SetWithCustomizer<T> = (nsValue: any, key: string, nsObject: T) => any;
1632
+
870
1633
  /**
871
1634
  * @internal
872
1635
  */
@@ -943,6 +1706,24 @@ export declare type SpecificMatcherFunction = (message: string) => boolean;
943
1706
  */
944
1707
  export declare function strictBarrel<T extends object>(packageName: string, exports: T): T;
945
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
+
946
1727
  /**
947
1728
  * Suppresses certain console outputs
948
1729
  *
@@ -964,6 +1745,21 @@ export declare function suppressConsole<T>(fn: () => T | Promise<T>, type?: Cons
964
1745
  */
965
1746
  export declare function suppressConsole<T>(fn: () => T | Promise<T>, matcherFn: MatcherFunction): T | Promise<T>;
966
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
+
967
1763
  /**
968
1764
  * Creates a throttled function that only invokes `func` at most once per every `wait` milliseconds. The
969
1765
  * throttled function comes with a `cancel` method to cancel delayed `func` invocations and a `flush` method
@@ -1012,6 +1808,37 @@ export declare type _ThrottleSettingsLeading = (_ThrottleSettings & {
1012
1808
  leading: true;
1013
1809
  }) | Omit<_ThrottleSettings, "leading">;
1014
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 `&amp;`, `&lt;`, `&gt;`, `&quot;` and
1831
+ * `&#39;` 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
+
1015
1842
  /**
1016
1843
  * Creates an array of unique values, in order, from all given arrays using SameValueZero for equality
1017
1844
  * comparisons. Only array-like objects are inspected; other arguments, strings included, are skipped.
@@ -1022,6 +1849,44 @@ export declare type _ThrottleSettingsLeading = (_ThrottleSettings & {
1022
1849
  */
1023
1850
  export declare function _union<T>(...arrays: (_List<T> | null | undefined)[]): T[];
1024
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
+
1025
1890
  /**
1026
1891
  * Creates a duplicate-free version of an array, using SameValueZero for equality comparisons, in which
1027
1892
  * only the first occurrence of each element is kept. The order of result values is determined by the
@@ -1060,6 +1925,44 @@ declare const uniqueSymbol: unique symbol;
1060
1925
  */
1061
1926
  export declare function _uniqWith<T>(array: _List<T> | null | undefined, comparator?: _Comparator<T>): T[];
1062
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
+
1063
1966
  /**
1064
1967
  * An iteratee as lodash accepts it: a function, a property name or path, a `[path, value]` pair, or a
1065
1968
  * partial object to match.
@@ -1095,6 +1998,20 @@ export declare type WaitForFn = <T>(callback: () => T | Promise<T>, options?: {
1095
1998
  timeout?: number;
1096
1999
  }) => Promise<T>;
1097
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
+
1098
2015
  /**
1099
2016
  * Creates an array of grouped elements, the first of which contains the first elements of the given arrays,
1100
2017
  * the second of which contains the second elements of the given arrays, and so on. Shorter arrays are padded