@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.
Files changed (397) hide show
  1. package/LICENSE +1 -1
  2. package/NOTICE +179 -0
  3. package/esm/_/_assignValue.d.ts +12 -0
  4. package/esm/_/_assignValue.d.ts.map +1 -0
  5. package/esm/_/_assignValue.js +49 -0
  6. package/esm/_/_baseAssignValue.d.ts +41 -0
  7. package/esm/_/_baseAssignValue.d.ts.map +1 -0
  8. package/esm/_/_baseAssignValue.js +48 -0
  9. package/esm/_/_baseClone.d.ts +28 -0
  10. package/esm/_/_baseClone.d.ts.map +1 -0
  11. package/esm/_/_baseClone.js +229 -0
  12. package/esm/_/_baseDifference.d.ts +18 -0
  13. package/esm/_/_baseDifference.d.ts.map +1 -0
  14. package/esm/_/_baseDifference.js +79 -0
  15. package/esm/_/_baseEach.d.ts +11 -0
  16. package/esm/_/_baseEach.d.ts.map +1 -0
  17. package/esm/_/_baseEach.js +62 -0
  18. package/esm/_/_baseExtremum.d.ts +15 -0
  19. package/esm/_/_baseExtremum.d.ts.map +1 -0
  20. package/esm/_/_baseExtremum.js +64 -0
  21. package/esm/_/_baseGet.d.ts +10 -0
  22. package/esm/_/_baseGet.d.ts.map +1 -0
  23. package/esm/_/_baseGet.js +50 -0
  24. package/esm/_/_baseGetTag.d.ts +9 -0
  25. package/esm/_/_baseGetTag.d.ts.map +1 -0
  26. package/esm/_/_baseGetTag.js +48 -0
  27. package/esm/_/_baseIntersection.d.ts +19 -0
  28. package/esm/_/_baseIntersection.d.ts.map +1 -0
  29. package/esm/_/_baseIntersection.js +91 -0
  30. package/esm/_/_baseIsEqual.d.ts +34 -0
  31. package/esm/_/_baseIsEqual.d.ts.map +1 -0
  32. package/esm/_/_baseIsEqual.js +278 -0
  33. package/esm/_/_baseIsMatch.d.ts +13 -0
  34. package/esm/_/_baseIsMatch.d.ts.map +1 -0
  35. package/esm/_/_baseIsMatch.js +67 -0
  36. package/esm/_/_baseIteratee.d.ts +15 -0
  37. package/esm/_/_baseIteratee.d.ts.map +1 -0
  38. package/esm/_/_baseIteratee.js +65 -0
  39. package/esm/_/_baseKeys.d.ts +12 -0
  40. package/esm/_/_baseKeys.d.ts.map +1 -0
  41. package/esm/_/_baseKeys.js +46 -0
  42. package/esm/_/_baseMatches.d.ts +10 -0
  43. package/esm/_/_baseMatches.d.ts.map +1 -0
  44. package/esm/_/_baseMatches.js +50 -0
  45. package/esm/_/_baseMatchesProperty.d.ts +11 -0
  46. package/esm/_/_baseMatchesProperty.d.ts.map +1 -0
  47. package/esm/_/_baseMatchesProperty.js +59 -0
  48. package/esm/_/_baseMerge.d.ts +19 -0
  49. package/esm/_/_baseMerge.d.ts.map +1 -0
  50. package/esm/_/_baseMerge.js +146 -0
  51. package/esm/_/_baseOrderBy.d.ts +11 -0
  52. package/esm/_/_baseOrderBy.d.ts.map +1 -0
  53. package/esm/_/_baseOrderBy.js +70 -0
  54. package/esm/_/_basePickBy.d.ts +14 -0
  55. package/esm/_/_basePickBy.d.ts.map +1 -0
  56. package/esm/_/_basePickBy.js +57 -0
  57. package/esm/_/_baseSet.d.ts +13 -0
  58. package/esm/_/_baseSet.d.ts.map +1 -0
  59. package/esm/_/_baseSet.js +74 -0
  60. package/esm/_/_baseSlice.d.ts +45 -0
  61. package/esm/_/_baseSlice.d.ts.map +1 -0
  62. package/esm/_/_baseSlice.js +30 -0
  63. package/esm/_/_baseSum.d.ts +42 -0
  64. package/esm/_/_baseSum.d.ts.map +1 -0
  65. package/esm/_/_baseSum.js +21 -0
  66. package/esm/_/_baseUniq.d.ts +43 -0
  67. package/esm/_/_baseUniq.d.ts.map +1 -0
  68. package/esm/_/_baseUniq.js +57 -0
  69. package/esm/_/_baseUnset.d.ts +13 -0
  70. package/esm/_/_baseUnset.d.ts.map +1 -0
  71. package/esm/_/_baseUnset.js +62 -0
  72. package/esm/_/_castPath.d.ts +10 -0
  73. package/esm/_/_castPath.d.ts.map +1 -0
  74. package/esm/_/_castPath.js +48 -0
  75. package/esm/_/_cloneArrayBuffer.d.ts +39 -0
  76. package/esm/_/_cloneArrayBuffer.d.ts.map +1 -0
  77. package/esm/_/_cloneArrayBuffer.js +45 -0
  78. package/esm/_/_cloneTypedArray.d.ts +10 -0
  79. package/esm/_/_cloneTypedArray.d.ts.map +1 -0
  80. package/esm/_/_cloneTypedArray.js +50 -0
  81. package/esm/_/_compareAscending.d.ts +12 -0
  82. package/esm/_/_compareAscending.d.ts.map +1 -0
  83. package/esm/_/_compareAscending.js +78 -0
  84. package/esm/_/_createCompounder.d.ts +11 -0
  85. package/esm/_/_createCompounder.d.ts.map +1 -0
  86. package/esm/_/_createCompounder.js +47 -0
  87. package/esm/_/_flattenArrayLikeObjects.d.ts +11 -0
  88. package/esm/_/_flattenArrayLikeObjects.d.ts.map +1 -0
  89. package/esm/_/_flattenArrayLikeObjects.js +55 -0
  90. package/esm/_/_getAllKeys.d.ts +9 -0
  91. package/esm/_/_getAllKeys.d.ts.map +1 -0
  92. package/esm/_/_getAllKeys.js +43 -0
  93. package/esm/_/_getAllKeysIn.d.ts +12 -0
  94. package/esm/_/_getAllKeysIn.d.ts.map +1 -0
  95. package/esm/_/_getAllKeysIn.js +59 -0
  96. package/esm/_/_getMatchData.d.ts +16 -0
  97. package/esm/_/_getMatchData.d.ts.map +1 -0
  98. package/esm/_/_getMatchData.js +46 -0
  99. package/esm/_/_getRawTag.d.ts +43 -0
  100. package/esm/_/_getRawTag.d.ts.map +1 -0
  101. package/esm/_/_getRawTag.js +65 -0
  102. package/esm/_/_hasPath.d.ts +13 -0
  103. package/esm/_/_hasPath.d.ts.map +1 -0
  104. package/esm/_/_hasPath.js +70 -0
  105. package/esm/_/_initCloneObject.d.ts +10 -0
  106. package/esm/_/_initCloneObject.d.ts.map +1 -0
  107. package/esm/_/_initCloneObject.js +48 -0
  108. package/esm/_/_isIndex.d.ts +11 -0
  109. package/esm/_/_isIndex.d.ts.map +1 -0
  110. package/esm/_/_isIndex.js +51 -0
  111. package/esm/_/_isIterateeCall.d.ts +13 -0
  112. package/esm/_/_isIterateeCall.d.ts.map +1 -0
  113. package/esm/_/_isIterateeCall.js +55 -0
  114. package/esm/_/_isKey.d.ts +12 -0
  115. package/esm/_/_isKey.d.ts.map +1 -0
  116. package/esm/_/_isKey.js +58 -0
  117. package/esm/_/_isPrototype.d.ts +39 -0
  118. package/esm/_/_isPrototype.d.ts.map +1 -0
  119. package/esm/_/_isPrototype.js +43 -0
  120. package/esm/_/_isStrictComparable.d.ts +9 -0
  121. package/esm/_/_isStrictComparable.d.ts.map +1 -0
  122. package/esm/_/_isStrictComparable.js +42 -0
  123. package/esm/_/_matchesStrictComparable.d.ts +41 -0
  124. package/esm/_/_matchesStrictComparable.d.ts.map +1 -0
  125. package/esm/_/_matchesStrictComparable.js +50 -0
  126. package/esm/_/_stringToPath.d.ts +10 -0
  127. package/esm/_/_stringToPath.d.ts.map +1 -0
  128. package/esm/_/_stringToPath.js +64 -0
  129. package/esm/_/_toKey.d.ts +9 -0
  130. package/esm/_/_toKey.d.ts.map +1 -0
  131. package/esm/_/_toKey.js +46 -0
  132. package/esm/_/_unicode.d.ts +27 -0
  133. package/esm/_/_unicode.d.ts.map +1 -0
  134. package/esm/_/_unicode.js +120 -0
  135. package/esm/_/assignIn.d.ts +35 -0
  136. package/esm/_/assignIn.d.ts.map +1 -0
  137. package/esm/_/assignIn.js +50 -0
  138. package/esm/_/bindAll.d.ts +16 -0
  139. package/esm/_/bindAll.d.ts.map +1 -0
  140. package/esm/_/bindAll.js +88 -0
  141. package/esm/_/camelCase.d.ts +10 -0
  142. package/esm/_/camelCase.d.ts.map +1 -0
  143. package/esm/_/camelCase.js +45 -0
  144. package/esm/_/capitalize.d.ts +9 -0
  145. package/esm/_/capitalize.d.ts.map +1 -0
  146. package/esm/_/capitalize.js +43 -0
  147. package/esm/_/chunk.d.ts +15 -0
  148. package/esm/_/chunk.d.ts.map +1 -0
  149. package/esm/_/chunk.js +61 -0
  150. package/esm/_/clamp.d.ts +17 -0
  151. package/esm/_/clamp.d.ts.map +1 -0
  152. package/esm/_/clamp.js +56 -0
  153. package/esm/_/clone.d.ts +12 -0
  154. package/esm/_/clone.d.ts.map +1 -0
  155. package/esm/_/clone.js +45 -0
  156. package/esm/_/cloneDeep.d.ts +14 -0
  157. package/esm/_/cloneDeep.d.ts.map +1 -0
  158. package/esm/_/cloneDeep.js +47 -0
  159. package/esm/_/cloneDeepWith.d.ts +18 -0
  160. package/esm/_/cloneDeepWith.d.ts.map +1 -0
  161. package/esm/_/cloneDeepWith.js +36 -0
  162. package/esm/_/compact.d.ts +46 -0
  163. package/esm/_/compact.d.ts.map +1 -0
  164. package/esm/_/compact.js +23 -0
  165. package/esm/_/constant.d.ts +39 -0
  166. package/esm/_/constant.d.ts.map +1 -0
  167. package/esm/_/constant.js +43 -0
  168. package/esm/_/debounce.d.ts +70 -0
  169. package/esm/_/debounce.d.ts.map +1 -0
  170. package/esm/_/debounce.js +136 -0
  171. package/esm/_/deburr.d.ts +10 -0
  172. package/esm/_/deburr.d.ts.map +1 -0
  173. package/esm/_/deburr.js +243 -0
  174. package/esm/_/defaults.d.ts +36 -0
  175. package/esm/_/defaults.d.ts.map +1 -0
  176. package/esm/_/defaults.js +51 -0
  177. package/esm/_/difference.d.ts +14 -0
  178. package/esm/_/difference.d.ts.map +1 -0
  179. package/esm/_/difference.js +46 -0
  180. package/esm/_/differenceBy.d.ts +39 -0
  181. package/esm/_/differenceBy.d.ts.map +1 -0
  182. package/esm/_/differenceBy.js +40 -0
  183. package/esm/_/differenceWith.d.ts +27 -0
  184. package/esm/_/differenceWith.d.ts.map +1 -0
  185. package/esm/_/differenceWith.js +39 -0
  186. package/esm/_/dropRightWhile.d.ts +13 -0
  187. package/esm/_/dropRightWhile.d.ts.map +1 -0
  188. package/esm/_/dropRightWhile.js +54 -0
  189. package/esm/_/eq.d.ts +41 -0
  190. package/esm/_/eq.d.ts.map +1 -0
  191. package/esm/_/eq.js +43 -0
  192. package/esm/_/escape.d.ts +13 -0
  193. package/esm/_/escape.d.ts.map +1 -0
  194. package/esm/_/escape.js +56 -0
  195. package/esm/_/escapeRegExp.d.ts +12 -0
  196. package/esm/_/escapeRegExp.d.ts.map +1 -0
  197. package/esm/_/escapeRegExp.js +47 -0
  198. package/esm/_/findKey.d.ts +14 -0
  199. package/esm/_/findKey.d.ts.map +1 -0
  200. package/esm/_/findKey.js +58 -0
  201. package/esm/_/findLastIndex.d.ts +16 -0
  202. package/esm/_/findLastIndex.d.ts.map +1 -0
  203. package/esm/_/findLastIndex.js +67 -0
  204. package/esm/_/get.d.ts +78 -0
  205. package/esm/_/get.d.ts.map +1 -0
  206. package/esm/_/get.js +36 -0
  207. package/esm/_/groupBy.d.ts +19 -0
  208. package/esm/_/groupBy.d.ts.map +1 -0
  209. package/esm/_/groupBy.js +49 -0
  210. package/esm/_/has.d.ts +23 -0
  211. package/esm/_/has.d.ts.map +1 -0
  212. package/esm/_/has.js +35 -0
  213. package/esm/_/inRange.d.ts +14 -0
  214. package/esm/_/inRange.d.ts.map +1 -0
  215. package/esm/_/inRange.js +51 -0
  216. package/esm/_/initial.d.ts +11 -0
  217. package/esm/_/initial.d.ts.map +1 -0
  218. package/esm/_/initial.js +44 -0
  219. package/esm/_/intersection.d.ts +13 -0
  220. package/esm/_/intersection.d.ts.map +1 -0
  221. package/esm/_/intersection.js +45 -0
  222. package/esm/_/intersectionBy.d.ts +32 -0
  223. package/esm/_/intersectionBy.d.ts.map +1 -0
  224. package/esm/_/intersectionBy.js +41 -0
  225. package/esm/_/intersectionWith.d.ts +28 -0
  226. package/esm/_/intersectionWith.d.ts.map +1 -0
  227. package/esm/_/intersectionWith.js +38 -0
  228. package/esm/_/invert.d.ts +14 -0
  229. package/esm/_/invert.d.ts.map +1 -0
  230. package/esm/_/invert.js +55 -0
  231. package/esm/_/isArguments.d.ts +9 -0
  232. package/esm/_/isArguments.d.ts.map +1 -0
  233. package/esm/_/isArguments.js +45 -0
  234. package/esm/_/isArray.d.ts +61 -0
  235. package/esm/_/isArray.d.ts.map +1 -0
  236. package/esm/_/isArray.js +62 -0
  237. package/esm/_/isArrayLike.d.ts +25 -0
  238. package/esm/_/isArrayLike.d.ts.map +1 -0
  239. package/esm/_/isArrayLike.js +35 -0
  240. package/esm/_/isEmpty.d.ts +49 -0
  241. package/esm/_/isEmpty.d.ts.map +1 -0
  242. package/esm/_/isEmpty.js +57 -0
  243. package/esm/_/isEqual.d.ts +15 -0
  244. package/esm/_/isEqual.d.ts.map +1 -0
  245. package/esm/_/isEqual.js +48 -0
  246. package/esm/_/isError.d.ts +11 -0
  247. package/esm/_/isError.d.ts.map +1 -0
  248. package/esm/_/isError.js +57 -0
  249. package/esm/_/isLength.d.ts +41 -0
  250. package/esm/_/isLength.d.ts.map +1 -0
  251. package/esm/_/isLength.js +43 -0
  252. package/esm/_/isObject.d.ts +40 -0
  253. package/esm/_/isObject.d.ts.map +1 -0
  254. package/esm/_/isObject.js +42 -0
  255. package/esm/_/isObjectLike.d.ts +40 -0
  256. package/esm/_/isObjectLike.d.ts.map +1 -0
  257. package/esm/_/isObjectLike.js +42 -0
  258. package/esm/_/isPlainObject.d.ts +10 -0
  259. package/esm/_/isPlainObject.d.ts.map +1 -0
  260. package/esm/_/isPlainObject.js +58 -0
  261. package/esm/_/isSymbol.d.ts +9 -0
  262. package/esm/_/isSymbol.d.ts.map +1 -0
  263. package/esm/_/isSymbol.js +45 -0
  264. package/esm/_/isTypedArray.d.ts +43 -0
  265. package/esm/_/isTypedArray.d.ts.map +1 -0
  266. package/esm/_/isTypedArray.js +45 -0
  267. package/esm/_/kebabCase.d.ts +9 -0
  268. package/esm/_/kebabCase.d.ts.map +1 -0
  269. package/esm/_/kebabCase.js +40 -0
  270. package/esm/_/keyBy.d.ts +17 -0
  271. package/esm/_/keyBy.d.ts.map +1 -0
  272. package/esm/_/keyBy.js +43 -0
  273. package/esm/_/keys.d.ts +11 -0
  274. package/esm/_/keys.d.ts.map +1 -0
  275. package/esm/_/keys.js +60 -0
  276. package/esm/_/keysIn.d.ts +10 -0
  277. package/esm/_/keysIn.d.ts.map +1 -0
  278. package/esm/_/keysIn.js +54 -0
  279. package/esm/_/mapValues.d.ts +63 -0
  280. package/esm/_/mapValues.d.ts.map +1 -0
  281. package/esm/_/mapValues.js +47 -0
  282. package/esm/_/max.d.ts +16 -0
  283. package/esm/_/max.d.ts.map +1 -0
  284. package/esm/_/max.js +37 -0
  285. package/esm/_/memoize.d.ts +89 -0
  286. package/esm/_/memoize.d.ts.map +1 -0
  287. package/esm/_/memoize.js +36 -0
  288. package/esm/_/merge.d.ts +32 -0
  289. package/esm/_/merge.d.ts.map +1 -0
  290. package/esm/_/merge.js +45 -0
  291. package/esm/_/mergeWith.d.ts +34 -0
  292. package/esm/_/mergeWith.d.ts.map +1 -0
  293. package/esm/_/mergeWith.js +50 -0
  294. package/esm/_/min.d.ts +16 -0
  295. package/esm/_/min.d.ts.map +1 -0
  296. package/esm/_/min.js +37 -0
  297. package/esm/_/negate.d.ts +41 -0
  298. package/esm/_/negate.d.ts.map +1 -0
  299. package/esm/_/negate.js +48 -0
  300. package/esm/_/omit.d.ts +27 -0
  301. package/esm/_/omit.d.ts.map +1 -0
  302. package/esm/_/omit.js +76 -0
  303. package/esm/_/omitBy.d.ts +21 -0
  304. package/esm/_/omitBy.d.ts.map +1 -0
  305. package/esm/_/omitBy.js +37 -0
  306. package/esm/_/partial.d.ts +87 -0
  307. package/esm/_/partial.d.ts.map +1 -0
  308. package/esm/_/partial.js +30 -0
  309. package/esm/_/partition.d.ts +23 -0
  310. package/esm/_/partition.d.ts.map +1 -0
  311. package/esm/_/partition.js +42 -0
  312. package/esm/_/pick.d.ts +18 -0
  313. package/esm/_/pick.d.ts.map +1 -0
  314. package/esm/_/pick.js +48 -0
  315. package/esm/_/pickBy.d.ts +21 -0
  316. package/esm/_/pickBy.d.ts.map +1 -0
  317. package/esm/_/pickBy.js +36 -0
  318. package/esm/_/range.d.ts +24 -0
  319. package/esm/_/range.d.ts.map +1 -0
  320. package/esm/_/range.js +56 -0
  321. package/esm/_/reduce.d.ts +37 -0
  322. package/esm/_/reduce.d.ts.map +1 -0
  323. package/esm/_/reduce.js +48 -0
  324. package/esm/_/set.d.ts +25 -0
  325. package/esm/_/set.d.ts.map +1 -0
  326. package/esm/_/set.js +35 -0
  327. package/esm/_/sortBy.d.ts +17 -0
  328. package/esm/_/sortBy.d.ts.map +1 -0
  329. package/esm/_/sortBy.js +46 -0
  330. package/esm/_/sumBy.d.ts +14 -0
  331. package/esm/_/sumBy.d.ts.map +1 -0
  332. package/esm/_/sumBy.js +47 -0
  333. package/esm/_/tail.d.ts +15 -0
  334. package/esm/_/tail.d.ts.map +1 -0
  335. package/esm/_/tail.js +36 -0
  336. package/esm/_/throttle.d.ts +76 -0
  337. package/esm/_/throttle.d.ts.map +1 -0
  338. package/esm/_/throttle.js +45 -0
  339. package/esm/_/times.d.ts +17 -0
  340. package/esm/_/times.d.ts.map +1 -0
  341. package/esm/_/times.js +57 -0
  342. package/esm/_/toFinite.d.ts +10 -0
  343. package/esm/_/toFinite.d.ts.map +1 -0
  344. package/esm/_/toFinite.js +50 -0
  345. package/esm/_/toInteger.d.ts +11 -0
  346. package/esm/_/toInteger.d.ts.map +1 -0
  347. package/esm/_/toInteger.js +46 -0
  348. package/esm/_/toNumber.d.ts +11 -0
  349. package/esm/_/toNumber.d.ts.map +1 -0
  350. package/esm/_/toNumber.js +69 -0
  351. package/esm/_/toString.d.ts +11 -0
  352. package/esm/_/toString.d.ts.map +1 -0
  353. package/esm/_/toString.js +57 -0
  354. package/esm/_/types.d.ts +181 -0
  355. package/esm/_/types.d.ts.map +1 -0
  356. package/esm/_/types.js +2 -0
  357. package/esm/_/unescape.d.ts +13 -0
  358. package/esm/_/unescape.d.ts.map +1 -0
  359. package/esm/_/unescape.js +56 -0
  360. package/esm/_/union.d.ts +11 -0
  361. package/esm/_/union.d.ts.map +1 -0
  362. package/esm/_/union.js +44 -0
  363. package/esm/_/unionBy.d.ts +34 -0
  364. package/esm/_/unionBy.d.ts.map +1 -0
  365. package/esm/_/unionBy.js +42 -0
  366. package/esm/_/uniq.d.ts +12 -0
  367. package/esm/_/uniq.d.ts.map +1 -0
  368. package/esm/_/uniq.js +47 -0
  369. package/esm/_/uniqBy.d.ts +13 -0
  370. package/esm/_/uniqBy.d.ts.map +1 -0
  371. package/esm/_/uniqBy.js +49 -0
  372. package/esm/_/uniqWith.d.ts +14 -0
  373. package/esm/_/uniqWith.d.ts.map +1 -0
  374. package/esm/_/uniqWith.js +59 -0
  375. package/esm/_/update.d.ts +17 -0
  376. package/esm/_/update.d.ts.map +1 -0
  377. package/esm/_/update.js +55 -0
  378. package/esm/_/updateWith.d.ts +23 -0
  379. package/esm/_/updateWith.d.ts.map +1 -0
  380. package/esm/_/updateWith.js +41 -0
  381. package/esm/_/upperFirst.d.ts +10 -0
  382. package/esm/_/upperFirst.d.ts.map +1 -0
  383. package/esm/_/upperFirst.js +46 -0
  384. package/esm/_/without.d.ts +15 -0
  385. package/esm/_/without.d.ts.map +1 -0
  386. package/esm/_/without.js +47 -0
  387. package/esm/_/words.d.ts +9 -0
  388. package/esm/_/words.d.ts.map +1 -0
  389. package/esm/_/words.js +50 -0
  390. package/esm/_/zip.d.ts +28 -0
  391. package/esm/_/zip.d.ts.map +1 -0
  392. package/esm/_/zip.js +38 -0
  393. package/esm/index.d.ts +69 -0
  394. package/esm/index.d.ts.map +1 -1
  395. package/esm/index.js +69 -0
  396. package/esm/util.d.ts +1870 -67
  397. 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 ConsoleFunction = (...data: any[]) => void;
1509
+ export declare type _PropertyPath = _Many<_PropertyName>;
24
1510
 
25
1511
  /**
26
- * A type of console to suppress
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 type ConsoleType = "error" | "warn" | "log" | "debug" | "info";
1519
+ export declare function randomString(len: number): string;
31
1520
 
32
1521
  /**
33
- * Wraps a testing-library waitFor so it polls every millisecond instead of the default 50ms.
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
- * @remarks
36
- * Use in tests where the awaited work settles on the next microtask or a resolved promise -
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 waitFor - the consumer's waitFor (e.g. from `@testing-library/react`)
40
- * @param interval - the polling interval in milliseconds, 1 by default
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 createTightWaitFor(waitFor: WaitForFn, interval?: number): <T>(callback: () => T | Promise<T>) => Promise<T>;
1535
+ export declare function _range(start: number, end?: number, step?: number): number[];
44
1536
 
45
1537
  /**
46
- * Returns a promise which will resolve after the provided number of milliseconds.
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
- * @param timeout - resolve timeout in milliseconds
1541
+ * @see _range
49
1542
  * @internal
50
1543
  */
51
- export declare function delay(timeout?: number): Promise<void>;
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 type EmptyObject = Record<never, never>;
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 escapeRegExp(value: string): string;
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 type GuardType<T> = T extends ((o: unknown) => o is infer U) ? U : never;
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 hashCodeString(value: string): number;
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 interface IShortenTextOptions {
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 type Matcher = {
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
- * A matcher function
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 type MatcherFunction = (console: Record<ConsoleType, ConsoleFunction>, type: ConsoleType, message: string) => boolean;
1594
+ export declare function removeMetadata(translationsWithMetadata: Record<string, any>): Record<string, string>;
115
1595
 
116
1596
  /**
117
- * Parse string in a form of [foo, bar] to an array of objects.
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 function parseStringToArray(str: string): string[] | null;
1602
+ export declare const sanitizeLocaleForMoment: (intlLocale: string) => string;
125
1603
 
126
1604
  /**
127
- * Generates pseudo-random string.
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
- * @param len - length of string to be generated
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 randomString(len: number): string;
1617
+ export declare function _set<T extends object>(object: T, path: _PropertyPath, value: unknown): T;
135
1618
 
136
1619
  /**
137
- * Given an object containing the parsed translation bundle, this function creates a new object which contains
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 removeMetadata(translationsWithMetadata: Record<string, any>): Record<string, string>;
1623
+ export declare function _set<TResult>(object: object, path: _PropertyPath, value: unknown): TResult;
144
1624
 
145
1625
  /**
146
- * Handles difference between GD locale and moment.js locale identifiers
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 const sanitizeLocaleForMoment: (intlLocale: string) => string;
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 `&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
+
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 { }