@vinicunca/perkakas 1.12.0 → 1.13.0

package/dist/{heap-bARaRULU.js.map → heap-BhpfhYWj.js.map}

@@ -1 +1 @@
-{"version":3,"file":"heap-bARaRULU.js","names":[],"sources":["../src/internal/heap.ts"],"sourcesContent":["/**\n * Heap related utilities.\n */\n\nimport type { CompareFunction } from './types/compare-function';\n\nimport { hasAtLeast } from '../has-at-least';\nimport { swapInPlace } from './swap-in-place';\n\n/**\n * Mutates an array into a \"max\"-heap based on `compareFn` so that for any `item` in the heap, `compareFn(heap[0], item) > 0`.\n *\n * @param heap - The array to be heapified. The array would be mutated!\n * @param compareFn - The comparator used to order items in the heap. Use the\n * same function in all calls mutating the same heap otherwise you'd get\n * unexpected results.\n */\nexport function heapify<T>(\n\n  heap: Array<T>,\n  compareFn: CompareFunction<T>,\n): void {\n  for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {\n    heapSiftDown(heap, i, compareFn);\n  }\n}\n\n/**\n * Insert an item into a heap if it's \"smaller\" (in regards to `compareFn`) than\n * the current head of the heap (which is the \"largest\" value in the heap). If\n * the item is inserted, the previous head of the heap is returned, otherwise\n * `undefined` is returned and the heap is unchanged.\n *\n * @param heap - A *mutable* array representing a heap (see `heapify`).\n * @param compareFn - The comparator used to order items in the heap. Use the.\n * @param item - The item to be inserted into the heap.\n * @returns `undefined` if the heap is unchanged, or the previous head of the\n * heap if the item was inserted.\n */\nexport function heapMaybeInsert<T>(\n\n  heap: Array<T>,\n  compareFn: CompareFunction<T>,\n  item: T,\n): T | undefined {\n  if (!hasAtLeast(heap, 1)) {\n    return undefined;\n  }\n\n  const [head] = heap;\n\n  if (compareFn(item, head) >= 0) {\n    // The item shouldn't be inserted into the heap, the heap is unchanged.\n    return undefined;\n  }\n\n  heap[0] = item;\n  heapSiftDown(heap, 0, compareFn);\n  return head;\n}\n\n/**\n * The main heap operation. Takes a `heap` and an `index` and sifts the item\n * down the heap until it reaches the correct position based on `compareFn`,\n * swapping other items in the process.\n */\nfunction heapSiftDown<T>(\n\n  heap: Array<T>,\n  index: number,\n  compareFn: CompareFunction<T>,\n): void {\n  let currentIndex = index;\n\n  // The loop continues while the currentIndex has children in the heap.\n  while (currentIndex * 2 + 1 < heap.length) {\n    const firstChildIndex = currentIndex * 2 + 1;\n\n    let swapIndex\n      = compareFn(heap[currentIndex]!, heap[firstChildIndex]!) < 0\n        // Is the parent \"smaller\" (in regards to `compareFn`) to its child?\n        ? firstChildIndex\n        : currentIndex;\n\n    const secondChildIndex = firstChildIndex + 1;\n    if (\n      secondChildIndex < heap.length\n      && compareFn(heap[swapIndex]!, heap[secondChildIndex]!) < 0\n    ) {\n      // Is there a second child? Is it the smallest of the three?\n      swapIndex = secondChildIndex;\n    }\n\n    if (swapIndex === currentIndex) {\n      // We assume the array is a heap and the existing order of items satisfies\n      // the compareFn so we can stop here.\n      return;\n    }\n\n    swapInPlace(heap, currentIndex, swapIndex);\n\n    currentIndex = swapIndex;\n  }\n}\n"],"mappings":"0FAiBA,SAAgB,EAEd,EACA,EACM,CACN,IAAK,IAAI,EAAI,KAAK,MAAM,EAAK,OAAS,EAAE,CAAG,EAAG,GAAK,EAAG,IACpD,EAAa,EAAM,EAAG,EAAU,CAgBpC,SAAgB,EAEd,EACA,EACA,EACe,CACf,GAAI,CAAC,EAAW,EAAM,EAAE,CACtB,OAGF,GAAM,CAAC,GAAQ,EAEX,OAAU,EAAM,EAAK,EAAI,GAO7B,MAFA,GAAK,GAAK,EACV,EAAa,EAAM,EAAG,EAAU,CACzB,EAQT,SAAS,EAEP,EACA,EACA,EACM,CACN,IAAI,EAAe,EAGnB,KAAO,EAAe,EAAI,EAAI,EAAK,QAAQ,CACzC,IAAM,EAAkB,EAAe,EAAI,EAEvC,EACA,EAAU,EAAK,GAAgB,EAAK,GAAkB,CAAG,EAEvD,EACA,EAEA,EAAmB,EAAkB,EAS3C,GAPE,EAAmB,EAAK,QACrB,EAAU,EAAK,GAAa,EAAK,GAAmB,CAAG,IAG1D,EAAY,GAGV,IAAc,EAGhB,OAGF,EAAY,EAAM,EAAc,EAAU,CAE1C,EAAe"}
+{"version":3,"file":"heap-BhpfhYWj.js","names":[],"sources":["../src/internal/heap.ts"],"sourcesContent":["/**\n * Heap related utilities.\n */\n\nimport type { CompareFunction } from './types/compare-function';\n\nimport { hasAtLeast } from '../has-at-least';\nimport { swapInPlace } from './swap-in-place';\n\n/**\n * Mutates an array into a \"max\"-heap based on `compareFn` so that for any `item` in the heap, `compareFn(heap[0], item) > 0`.\n *\n * @param heap - The array to be heapified. The array would be mutated!\n * @param compareFn - The comparator used to order items in the heap. Use the\n * same function in all calls mutating the same heap otherwise you'd get\n * unexpected results.\n */\nexport function heapify<T>(\n\n  heap: Array<T>,\n  compareFn: CompareFunction<T>,\n): void {\n  for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) {\n    heapSiftDown(heap, i, compareFn);\n  }\n}\n\n/**\n * Insert an item into a heap if it's \"smaller\" (in regards to `compareFn`) than\n * the current head of the heap (which is the \"largest\" value in the heap). If\n * the item is inserted, the previous head of the heap is returned, otherwise\n * `undefined` is returned and the heap is unchanged.\n *\n * @param heap - A *mutable* array representing a heap (see `heapify`).\n * @param compareFn - The comparator used to order items in the heap. Use the.\n * @param item - The item to be inserted into the heap.\n * @returns `undefined` if the heap is unchanged, or the previous head of the\n * heap if the item was inserted.\n */\nexport function heapMaybeInsert<T>(\n\n  heap: Array<T>,\n  compareFn: CompareFunction<T>,\n  item: T,\n): T | undefined {\n  if (!hasAtLeast(heap, 1)) {\n    return undefined;\n  }\n\n  const [head] = heap;\n\n  if (compareFn(item, head) >= 0) {\n    // The item shouldn't be inserted into the heap, the heap is unchanged.\n    return undefined;\n  }\n\n  heap[0] = item;\n  heapSiftDown(heap, 0, compareFn);\n  return head;\n}\n\n/**\n * The main heap operation. Takes a `heap` and an `index` and sifts the item\n * down the heap until it reaches the correct position based on `compareFn`,\n * swapping other items in the process.\n */\nfunction heapSiftDown<T>(\n\n  heap: Array<T>,\n  index: number,\n  compareFn: CompareFunction<T>,\n): void {\n  let currentIndex = index;\n\n  // The loop continues while the currentIndex has children in the heap.\n  while (currentIndex * 2 + 1 < heap.length) {\n    const firstChildIndex = currentIndex * 2 + 1;\n\n    let swapIndex\n      = compareFn(heap[currentIndex]!, heap[firstChildIndex]!) < 0\n        // Is the parent \"smaller\" (in regards to `compareFn`) to its child?\n        ? firstChildIndex\n        : currentIndex;\n\n    const secondChildIndex = firstChildIndex + 1;\n    if (\n      secondChildIndex < heap.length\n      && compareFn(heap[swapIndex]!, heap[secondChildIndex]!) < 0\n    ) {\n      // Is there a second child? Is it the smallest of the three?\n      swapIndex = secondChildIndex;\n    }\n\n    if (swapIndex === currentIndex) {\n      // We assume the array is a heap and the existing order of items satisfies\n      // the compareFn so we can stop here.\n      return;\n    }\n\n    swapInPlace(heap, currentIndex, swapIndex);\n\n    currentIndex = swapIndex;\n  }\n}\n"],"mappings":"0FAiBA,SAAgB,EAEd,EACA,EACM,CACN,IAAK,IAAI,EAAI,KAAK,MAAM,EAAK,OAAS,EAAE,CAAG,EAAG,GAAK,EAAG,IACpD,EAAa,EAAM,EAAG,EAAU,CAgBpC,SAAgB,EAEd,EACA,EACA,EACe,CACf,GAAI,CAAC,EAAW,EAAM,EAAE,CACtB,OAGF,GAAM,CAAC,GAAQ,EAEX,OAAU,EAAM,EAAK,EAAI,GAO7B,MAFA,GAAK,GAAK,EACV,EAAa,EAAM,EAAG,EAAU,CACzB,EAQT,SAAS,EAEP,EACA,EACA,EACM,CACN,IAAI,EAAe,EAGnB,KAAO,EAAe,EAAI,EAAI,EAAK,QAAQ,CACzC,IAAM,EAAkB,EAAe,EAAI,EAEvC,EACA,EAAU,EAAK,GAAgB,EAAK,GAAkB,CAAG,EAEvD,EACA,EAEA,EAAmB,EAAkB,EAS3C,GAPE,EAAmB,EAAK,QACrB,EAAU,EAAK,GAAa,EAAK,GAAmB,CAAG,IAG1D,EAAY,GAGV,IAAc,EAGhB,OAGF,EAAY,EAAM,EAAc,EAAU,CAE1C,EAAe"}

package/dist/index-by.d.cts

@@ -1,4 +1,4 @@
-import { t as BoundedPartial } from "./bounded-partial-D6ouPlXl.cjs";
+import { t as BoundedPartial } from "./bounded-partial-CtOsGqxa.cjs";
 
 //#region src/index-by.d.ts
 

package/dist/index-by.d.ts

@@ -1,4 +1,4 @@
-import { t as BoundedPartial } from "./bounded-partial-DBIIClPU.js";
+import { t as BoundedPartial } from "./bounded-partial-CPc1XU57.js";
 
 //#region src/index-by.d.ts
 

package/dist/index-by.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let[r,i]of e.entries()){let a=t(i,r,e);n[a]=i}return n}export{t as indexBy};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let[r,i]of e.entries()){let a=t(i,r,e);n[a]=i}return n}export{t as indexBy};
 //# sourceMappingURL=index-by.js.map

package/dist/index.cjs

@@ -1 +1 @@
-const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./add-prop.cjs`),n=require(`./add.cjs`),r=require(`./all-pass.cjs`),i=require(`./any-pass.cjs`),a=require(`./ceil.cjs`),o=require(`./chunk.cjs`),s=require(`./clamp.cjs`),c=require(`./clone.cjs`),l=require(`./concat.cjs`),u=require(`./conditional-6ff4g8Sy.cjs`),d=require(`./constant.cjs`),f=require(`./count-by.cjs`),p=require(`./debounce.cjs`),m=require(`./pipe-CB7Lufqv.cjs`),h=require(`./difference-with.cjs`),g=require(`./difference.cjs`),_=require(`./divide.cjs`),v=require(`./do-nothing.cjs`),y=require(`./has-at-least-BXwOPLQK.cjs`),b=require(`./drop-first-by.cjs`),x=require(`./drop-last-while.cjs`),S=require(`./drop-last.cjs`),C=require(`./drop-while.cjs`),w=require(`./drop.cjs`),T=require(`./entries.cjs`),E=require(`./evolve.cjs`),D=require(`./filter.cjs`),O=require(`./find-index.cjs`),k=require(`./find-last-index.cjs`),A=require(`./find-last.cjs`),j=require(`./find.cjs`),M=require(`./first-by.cjs`),N=require(`./first.cjs`),P=require(`./flat-map.cjs`),F=require(`./flat.cjs`),I=require(`./floor.cjs`),L=require(`./for-each-obj.cjs`),R=require(`./for-each.cjs`),z=require(`./from-entries.cjs`),B=require(`./from-keys.cjs`),V=require(`./funnel.cjs`),H=require(`./identity.cjs`),U=require(`./sleep.cjs`),W=require(`./group-by-prop.cjs`),G=require(`./group-by.cjs`),K=require(`./is-deep-equal.cjs`),q=require(`./has-sub-object.cjs`),J=require(`./human-readable-file-size.cjs`),Y=require(`./index-by.cjs`),X=require(`./intersection.cjs`),Z=require(`./intersection-with.cjs`),Q=require(`./invert.cjs`),$=require(`./is-array.cjs`),ee=require(`./is-big-int.cjs`),te=require(`./is-boolean.cjs`),ne=require(`./is-date.cjs`),re=require(`./is-defined.cjs`),ie=require(`./is-empty.cjs`),ae=require(`./is-emptyish.cjs`),oe=require(`./is-error.cjs`),se=require(`./is-function.cjs`),ce=require(`./is-included-in.cjs`),le=require(`./is-non-null.cjs`),ue=require(`./is-non-nullish.cjs`),de=require(`./is-not.cjs`),fe=require(`./is-nullish.cjs`),pe=require(`./is-number.cjs`),me=require(`./is-object-type.cjs`),he=require(`./is-plain-object.cjs`),ge=require(`./is-promise.cjs`),_e=require(`./is-shallow-equal.cjs`),ve=require(`./is-strict-equal.cjs`),ye=require(`./is-string.cjs`),be=require(`./is-symbol.cjs`),xe=require(`./is-truthy.cjs`),Se=require(`./join.cjs`),Ce=require(`./key-codes.cjs`),we=require(`./keys.cjs`),Te=require(`./last.cjs`),Ee=require(`./length.cjs`),De=require(`./map.cjs`),Oe=require(`./map-keys.cjs`),ke=require(`./map-to-obj.cjs`),Ae=require(`./map-values.cjs`),je=require(`./map-with-feedback.cjs`),Me=require(`./mean-by.cjs`),Ne=require(`./merge.cjs`),Pe=require(`./merge-all.cjs`),Fe=require(`./merge-deep.cjs`),Ie=require(`./multiply.cjs`),Le=require(`./nth-by-Bby4vIbZ.cjs`),Re=require(`./obj-of.cjs`),ze=require(`./omit.cjs`),Be=require(`./omit-by.cjs`),Ve=require(`./once.cjs`),He=require(`./only.cjs`),Ue=require(`./partition.cjs`),We=require(`./path-or.cjs`),Ge=require(`./pick.cjs`),Ke=require(`./pick-by.cjs`),qe=require(`./piped.cjs`),Je=require(`./product.cjs`),Ye=require(`./prop.cjs`),Xe=require(`./pull-object.cjs`),Ze=require(`./random-integer.cjs`),Qe=require(`./random-string.cjs`),$e=require(`./range.cjs`),et=require(`./rank-by.cjs`),tt=require(`./reduce.cjs`),nt=require(`./reverse.cjs`),rt=require(`./round.cjs`),it=require(`./sample.cjs`),at=require(`./set.cjs`),ot=require(`./set-path.cjs`),st=require(`./shuffle.cjs`),ct=require(`./slice-string.cjs`),lt=require(`./slugify.cjs`),ut=require(`./sort.cjs`),dt=require(`./sort-by.cjs`),ft=require(`./sorted-index.cjs`),pt=require(`./sorted-index-by.cjs`),mt=require(`./sorted-index-with.cjs`),ht=require(`./sorted-last-index.cjs`),gt=require(`./sorted-last-index-by.cjs`),_t=require(`./splice.cjs`),vt=require(`./split.cjs`),yt=require(`./split-at.cjs`),bt=require(`./split-when.cjs`),xt=require(`./string-to-path.cjs`),St=require(`./subtract.cjs`),Ct=require(`./sum.cjs`),wt=require(`./sum-by.cjs`),Tt=require(`./swap-indices.cjs`),Et=require(`./swap-props.cjs`),Dt=require(`./take.cjs`),Ot=require(`./take-first-by.cjs`),kt=require(`./take-last.cjs`),At=require(`./take-last-while.cjs`),jt=require(`./take-while.cjs`),Mt=require(`./tap.cjs`),Nt=require(`./times.cjs`),Pt=require(`./to-camel-case.cjs`),Ft=require(`./to-capital-case.cjs`),It=require(`./to-constant-case.cjs`),Lt=require(`./to-no-case.cjs`),Rt=require(`./to-kebab-case.cjs`),zt=require(`./to-pascal-case.cjs`),Bt=require(`./to-pascal-snake-case.cjs`),Vt=require(`./to-sentence-case.cjs`),Ht=require(`./to-snake-case.cjs`),Ut=require(`./to-train-case.cjs`);require(`./type.helpers.cjs`);const Wt=require(`./unique.cjs`),Gt=require(`./unique-by.cjs`),Kt=require(`./unique-with.cjs`),qt=require(`./values.cjs`),Jt=require(`./zip.cjs`),Yt=require(`./zip-with.cjs`),Xt=typeof window<`u`;exports.KEY_CODES=Ce.KEY_CODES,exports.add=n.add,exports.addProp=t.addProp,exports.allPass=r.allPass,exports.anyPass=i.anyPass,exports.ceil=a.ceil,exports.chunk=o.chunk,exports.clamp=s.clamp,exports.clone=c.clone,exports.concat=l.concat,exports.conditional=u.t,exports.constant=d.constant,exports.countBy=f.countBy,exports.curry=e.t,exports.debounce=p.debounce,exports.difference=g.difference,exports.differenceWith=h.differenceWith,exports.divide=_.divide,exports.doNothing=v.doNothing,exports.drop=w.drop,exports.dropFirstBy=b.dropFirstBy,exports.dropLast=S.dropLast,exports.dropLastWhile=x.dropLastWhile,exports.dropWhile=C.dropWhile,exports.entries=T.entries,exports.evolve=E.evolve,exports.filter=D.filter,exports.find=j.find,exports.findIndex=O.findIndex,exports.findLast=A.findLast,exports.findLastIndex=k.findLastIndex,exports.first=N.first,exports.firstBy=M.firstBy,exports.flat=F.flat,exports.flatMap=P.flatMap,exports.floor=I.floor,exports.forEach=R.forEach,exports.forEachObj=L.forEachObj,exports.fromEntries=z.fromEntries,exports.fromKeys=B.fromKeys,exports.funnel=V.funnel,exports.groupBy=G.groupBy,exports.groupByProp=W.groupByProp,exports.hasAtLeast=y.t,exports.hasSubObject=q.hasSubObject,exports.humanReadableFileSize=J.humanReadableFileSize,exports.identity=H.identity,exports.indexBy=Y.indexBy,exports.intersection=X.intersection,exports.intersectionWith=Z.intersectionWith,exports.invert=Q.invert,exports.isArray=$.isArray,exports.isBigInt=ee.isBigInt,exports.isBoolean=te.isBoolean,exports.isBrowser=Xt,exports.isDate=ne.isDate,exports.isDeepEqual=K.isDeepEqual,exports.isDefined=re.isDefined,exports.isEmpty=ie.isEmpty,exports.isEmptyish=ae.isEmptyish,exports.isError=oe.isError,exports.isFunction=se.isFunction,exports.isIncludedIn=ce.isIncludedIn,exports.isNonNull=le.isNonNull,exports.isNonNullish=ue.isNonNullish,exports.isNot=de.isNot,exports.isNullish=fe.isNullish,exports.isNumber=pe.isNumber,exports.isObjectType=me.isObjectType,exports.isPlainObject=he.isPlainObject,exports.isPromise=ge.isPromise,exports.isShallowEqual=_e.isShallowEqual,exports.isStrictEqual=ve.isStrictEqual,exports.isString=ye.isString,exports.isSymbol=be.isSymbol,exports.isTruthy=xe.isTruthy,exports.join=Se.join,exports.keys=we.keys,exports.last=Te.last,exports.length=Ee.length,exports.map=De.map,exports.mapKeys=Oe.mapKeys,exports.mapToObj=ke.mapToObj,exports.mapValues=Ae.mapValues,exports.mapWithFeedback=je.mapWithFeedback,exports.meanBy=Me.meanBy,exports.merge=Ne.merge,exports.mergeAll=Pe.mergeAll,exports.mergeDeep=Fe.mergeDeep,exports.multiply=Ie.multiply,exports.nthBy=Le.t,exports.objOf=Re.objOf,exports.omit=ze.omit,exports.omitBy=Be.omitBy,exports.once=Ve.once,exports.only=He.only,exports.partition=Ue.partition,exports.pathOr=We.pathOr,exports.pick=Ge.pick,exports.pickBy=Ke.pickBy,exports.pipe=m.t,exports.piped=qe.piped,exports.product=Je.product,exports.prop=Ye.prop,exports.pullObject=Xe.pullObject,exports.randomInteger=Ze.randomInteger,exports.randomString=Qe.randomString,exports.range=$e.range,exports.rankBy=et.rankBy,exports.reduce=tt.reduce,exports.reverse=nt.reverse,exports.round=rt.round,exports.sample=it.sample,exports.set=at.set,exports.setPath=ot.setPath,exports.shuffle=st.shuffle,exports.sleep=U.sleep,exports.sliceString=ct.sliceString,exports.slugify=lt.slugify,exports.sort=ut.sort,exports.sortBy=dt.sortBy,exports.sortedIndex=ft.sortedIndex,exports.sortedIndexBy=pt.sortedIndexBy,exports.sortedIndexWith=mt.sortedIndexWith,exports.sortedLastIndex=ht.sortedLastIndex,exports.sortedLastIndexBy=gt.sortedLastIndexBy,exports.splice=_t.splice,exports.split=vt.split,exports.splitAt=yt.splitAt,exports.splitWhen=bt.splitWhen,exports.stringToPath=xt.stringToPath,exports.subtract=St.subtract,exports.sum=Ct.sum,exports.sumBy=wt.sumBy,exports.swapIndices=Tt.swapIndices,exports.swapProps=Et.swapProps,exports.take=Dt.take,exports.takeFirstBy=Ot.takeFirstBy,exports.takeLast=kt.takeLast,exports.takeLastWhile=At.takeLastWhile,exports.takeWhile=jt.takeWhile,exports.tap=Mt.tap,exports.times=Nt.times,exports.toCamelCase=Pt.toCamelCase,exports.toCapitalCase=Ft.toCapitalCase,exports.toConstantCase=It.toConstantCase,exports.toKebabCase=Rt.toKebabCase,exports.toNoCase=Lt.toNoCase,exports.toPascalCase=zt.toPascalCase,exports.toPascalSnakeCase=Bt.toPascalSnakeCase,exports.toSentenceCase=Vt.toSentenceCase,exports.toSnakeCase=Ht.toSnakeCase,exports.toTrainCase=Ut.toTrainCase,exports.unique=Wt.unique,exports.uniqueBy=Gt.uniqueBy,exports.uniqueWith=Kt.uniqueWith,exports.values=qt.values,exports.zip=Jt.zip,exports.zipWith=Yt.zipWith;
+const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./add-prop.cjs`),n=require(`./add.cjs`),r=require(`./all-pass.cjs`),i=require(`./any-pass.cjs`),a=require(`./capitalize.cjs`),o=require(`./ceil.cjs`),s=require(`./chunk.cjs`),c=require(`./clamp.cjs`),l=require(`./clone.cjs`),u=require(`./concat.cjs`),d=require(`./conditional-6ff4g8Sy.cjs`),f=require(`./constant.cjs`),p=require(`./count-by.cjs`),m=require(`./debounce.cjs`),h=require(`./pipe-CB7Lufqv.cjs`),g=require(`./difference-with.cjs`),_=require(`./difference.cjs`),v=require(`./divide.cjs`),y=require(`./do-nothing.cjs`),b=require(`./has-at-least-BXwOPLQK.cjs`),x=require(`./drop-first-by.cjs`),S=require(`./drop-last-while.cjs`),C=require(`./drop-last.cjs`),w=require(`./drop-while.cjs`),T=require(`./drop.cjs`),E=require(`./entries.cjs`),D=require(`./evolve.cjs`),O=require(`./filter.cjs`),k=require(`./find-index.cjs`),A=require(`./find-last-index.cjs`),j=require(`./find-last.cjs`),M=require(`./find.cjs`),N=require(`./first-by.cjs`),P=require(`./first.cjs`),F=require(`./flat-map.cjs`),I=require(`./flat.cjs`),L=require(`./floor.cjs`),R=require(`./for-each-obj.cjs`),z=require(`./for-each.cjs`),B=require(`./from-entries.cjs`),V=require(`./from-keys.cjs`),H=require(`./funnel.cjs`),U=require(`./identity.cjs`),W=require(`./sleep.cjs`),G=require(`./group-by-prop.cjs`),K=require(`./group-by.cjs`),q=require(`./is-deep-equal.cjs`),J=require(`./has-sub-object.cjs`),Y=require(`./human-readable-file-size.cjs`),X=require(`./index-by.cjs`),Z=require(`./intersection.cjs`),Q=require(`./intersection-with.cjs`),$=require(`./invert.cjs`),ee=require(`./is-array.cjs`),te=require(`./is-big-int.cjs`),ne=require(`./is-boolean.cjs`),re=require(`./is-date.cjs`),ie=require(`./is-defined.cjs`),ae=require(`./is-empty.cjs`),oe=require(`./is-emptyish.cjs`),se=require(`./is-error.cjs`),ce=require(`./is-function.cjs`),le=require(`./is-included-in.cjs`),ue=require(`./is-non-null.cjs`),de=require(`./is-non-nullish.cjs`),fe=require(`./is-not.cjs`),pe=require(`./is-nullish.cjs`),me=require(`./is-number.cjs`),he=require(`./is-object-type.cjs`),ge=require(`./is-plain-object.cjs`),_e=require(`./is-promise.cjs`),ve=require(`./is-shallow-equal.cjs`),ye=require(`./is-strict-equal.cjs`),be=require(`./is-string.cjs`),xe=require(`./is-symbol.cjs`),Se=require(`./is-truthy.cjs`),Ce=require(`./join.cjs`),we=require(`./key-codes.cjs`),Te=require(`./keys.cjs`),Ee=require(`./last.cjs`),De=require(`./length.cjs`),Oe=require(`./map.cjs`),ke=require(`./map-keys.cjs`),Ae=require(`./map-to-obj.cjs`),je=require(`./map-values.cjs`),Me=require(`./map-with-feedback.cjs`),Ne=require(`./mean-by.cjs`),Pe=require(`./merge.cjs`),Fe=require(`./merge-all.cjs`),Ie=require(`./merge-deep.cjs`),Le=require(`./multiply.cjs`),Re=require(`./nth-by-Bby4vIbZ.cjs`),ze=require(`./obj-of.cjs`),Be=require(`./omit.cjs`),Ve=require(`./omit-by.cjs`),He=require(`./once.cjs`),Ue=require(`./only.cjs`),We=require(`./partition.cjs`),Ge=require(`./path-or.cjs`),Ke=require(`./pick.cjs`),qe=require(`./pick-by.cjs`),Je=require(`./piped.cjs`),Ye=require(`./product.cjs`),Xe=require(`./prop.cjs`),Ze=require(`./pull-object.cjs`),Qe=require(`./random-integer.cjs`),$e=require(`./random-string.cjs`),et=require(`./range.cjs`),tt=require(`./rank-by.cjs`),nt=require(`./reduce.cjs`),rt=require(`./reverse.cjs`),it=require(`./round.cjs`),at=require(`./sample.cjs`),ot=require(`./set.cjs`),st=require(`./set-path.cjs`),ct=require(`./shuffle.cjs`),lt=require(`./slice-string.cjs`),ut=require(`./slugify.cjs`),dt=require(`./sort.cjs`),ft=require(`./sort-by.cjs`),pt=require(`./sorted-index.cjs`),mt=require(`./sorted-index-by.cjs`),ht=require(`./sorted-index-with.cjs`),gt=require(`./sorted-last-index.cjs`),_t=require(`./sorted-last-index-by.cjs`),vt=require(`./splice.cjs`),yt=require(`./split.cjs`),bt=require(`./split-at.cjs`),xt=require(`./split-when.cjs`),St=require(`./string-to-path.cjs`),Ct=require(`./subtract.cjs`),wt=require(`./sum.cjs`),Tt=require(`./sum-by.cjs`),Et=require(`./swap-indices.cjs`),Dt=require(`./swap-props.cjs`),Ot=require(`./take.cjs`),kt=require(`./take-first-by.cjs`),At=require(`./take-last.cjs`),jt=require(`./take-last-while.cjs`),Mt=require(`./take-while.cjs`),Nt=require(`./tap.cjs`),Pt=require(`./times.cjs`),Ft=require(`./to-camel-case.cjs`),It=require(`./to-kebab-case.cjs`),Lt=require(`./to-lower-case.cjs`),Rt=require(`./to-snake-case.cjs`),zt=require(`./to-title-case.cjs`),Bt=require(`./to-upper-case.cjs`);require(`./type.helpers.cjs`);const Vt=require(`./uncapitalize.cjs`),Ht=require(`./unique.cjs`),Ut=require(`./unique-by.cjs`),Wt=require(`./unique-with.cjs`),Gt=require(`./values.cjs`),Kt=require(`./zip.cjs`),qt=require(`./zip-with.cjs`),Jt=typeof window<`u`;exports.KEY_CODES=we.KEY_CODES,exports.add=n.add,exports.addProp=t.addProp,exports.allPass=r.allPass,exports.anyPass=i.anyPass,exports.capitalize=a.capitalize,exports.ceil=o.ceil,exports.chunk=s.chunk,exports.clamp=c.clamp,exports.clone=l.clone,exports.concat=u.concat,exports.conditional=d.t,exports.constant=f.constant,exports.countBy=p.countBy,exports.curry=e.t,exports.debounce=m.debounce,exports.difference=_.difference,exports.differenceWith=g.differenceWith,exports.divide=v.divide,exports.doNothing=y.doNothing,exports.drop=T.drop,exports.dropFirstBy=x.dropFirstBy,exports.dropLast=C.dropLast,exports.dropLastWhile=S.dropLastWhile,exports.dropWhile=w.dropWhile,exports.entries=E.entries,exports.evolve=D.evolve,exports.filter=O.filter,exports.find=M.find,exports.findIndex=k.findIndex,exports.findLast=j.findLast,exports.findLastIndex=A.findLastIndex,exports.first=P.first,exports.firstBy=N.firstBy,exports.flat=I.flat,exports.flatMap=F.flatMap,exports.floor=L.floor,exports.forEach=z.forEach,exports.forEachObj=R.forEachObj,exports.fromEntries=B.fromEntries,exports.fromKeys=V.fromKeys,exports.funnel=H.funnel,exports.groupBy=K.groupBy,exports.groupByProp=G.groupByProp,exports.hasAtLeast=b.t,exports.hasSubObject=J.hasSubObject,exports.humanReadableFileSize=Y.humanReadableFileSize,exports.identity=U.identity,exports.indexBy=X.indexBy,exports.intersection=Z.intersection,exports.intersectionWith=Q.intersectionWith,exports.invert=$.invert,exports.isArray=ee.isArray,exports.isBigInt=te.isBigInt,exports.isBoolean=ne.isBoolean,exports.isBrowser=Jt,exports.isDate=re.isDate,exports.isDeepEqual=q.isDeepEqual,exports.isDefined=ie.isDefined,exports.isEmpty=ae.isEmpty,exports.isEmptyish=oe.isEmptyish,exports.isError=se.isError,exports.isFunction=ce.isFunction,exports.isIncludedIn=le.isIncludedIn,exports.isNonNull=ue.isNonNull,exports.isNonNullish=de.isNonNullish,exports.isNot=fe.isNot,exports.isNullish=pe.isNullish,exports.isNumber=me.isNumber,exports.isObjectType=he.isObjectType,exports.isPlainObject=ge.isPlainObject,exports.isPromise=_e.isPromise,exports.isShallowEqual=ve.isShallowEqual,exports.isStrictEqual=ye.isStrictEqual,exports.isString=be.isString,exports.isSymbol=xe.isSymbol,exports.isTruthy=Se.isTruthy,exports.join=Ce.join,exports.keys=Te.keys,exports.last=Ee.last,exports.length=De.length,exports.map=Oe.map,exports.mapKeys=ke.mapKeys,exports.mapToObj=Ae.mapToObj,exports.mapValues=je.mapValues,exports.mapWithFeedback=Me.mapWithFeedback,exports.meanBy=Ne.meanBy,exports.merge=Pe.merge,exports.mergeAll=Fe.mergeAll,exports.mergeDeep=Ie.mergeDeep,exports.multiply=Le.multiply,exports.nthBy=Re.t,exports.objOf=ze.objOf,exports.omit=Be.omit,exports.omitBy=Ve.omitBy,exports.once=He.once,exports.only=Ue.only,exports.partition=We.partition,exports.pathOr=Ge.pathOr,exports.pick=Ke.pick,exports.pickBy=qe.pickBy,exports.pipe=h.t,exports.piped=Je.piped,exports.product=Ye.product,exports.prop=Xe.prop,exports.pullObject=Ze.pullObject,exports.randomInteger=Qe.randomInteger,exports.randomString=$e.randomString,exports.range=et.range,exports.rankBy=tt.rankBy,exports.reduce=nt.reduce,exports.reverse=rt.reverse,exports.round=it.round,exports.sample=at.sample,exports.set=ot.set,exports.setPath=st.setPath,exports.shuffle=ct.shuffle,exports.sleep=W.sleep,exports.sliceString=lt.sliceString,exports.slugify=ut.slugify,exports.sort=dt.sort,exports.sortBy=ft.sortBy,exports.sortedIndex=pt.sortedIndex,exports.sortedIndexBy=mt.sortedIndexBy,exports.sortedIndexWith=ht.sortedIndexWith,exports.sortedLastIndex=gt.sortedLastIndex,exports.sortedLastIndexBy=_t.sortedLastIndexBy,exports.splice=vt.splice,exports.split=yt.split,exports.splitAt=bt.splitAt,exports.splitWhen=xt.splitWhen,exports.stringToPath=St.stringToPath,exports.subtract=Ct.subtract,exports.sum=wt.sum,exports.sumBy=Tt.sumBy,exports.swapIndices=Et.swapIndices,exports.swapProps=Dt.swapProps,exports.take=Ot.take,exports.takeFirstBy=kt.takeFirstBy,exports.takeLast=At.takeLast,exports.takeLastWhile=jt.takeLastWhile,exports.takeWhile=Mt.takeWhile,exports.tap=Nt.tap,exports.times=Pt.times,exports.toCamelCase=Ft.toCamelCase,exports.toKebabCase=It.toKebabCase,exports.toLowerCase=Lt.toLowerCase,exports.toSnakeCase=Rt.toSnakeCase,exports.toTitleCase=zt.toTitleCase,exports.toUpperCase=Bt.toUpperCase,exports.uncapitalize=Vt.uncapitalize,exports.unique=Ht.unique,exports.uniqueBy=Ut.uniqueBy,exports.uniqueWith=Wt.uniqueWith,exports.values=Gt.values,exports.zip=Kt.zip,exports.zipWith=qt.zipWith;

package/dist/index.d.cts

@@ -2,15 +2,16 @@ import { addProp } from "./add-prop.cjs";
 import { add } from "./add.cjs";
 import { allPass } from "./all-pass.cjs";
 import { anyPass } from "./any-pass.cjs";
+import { capitalize } from "./capitalize.cjs";
 import { ceil } from "./ceil.cjs";
 import { chunk } from "./chunk.cjs";
 import { clamp } from "./clamp.cjs";
 import { clone } from "./clone.cjs";
 import { concat } from "./concat.cjs";
-import { t as conditionalPlus } from "./conditional-tssGt6Vy.cjs";
+import { t as conditionalPlus } from "./conditional-Br0uqqc9.cjs";
 import { constant } from "./constant.cjs";
 import { countBy } from "./count-by.cjs";
-import { t as curry } from "./curry-B20xQM_9.cjs";
+import { t as curry } from "./curry-mh6BKSIA.cjs";
 import { debounce } from "./debounce.cjs";
 import { differenceWith } from "./difference-with.cjs";
 import { difference } from "./difference.cjs";
@@ -55,7 +56,7 @@ import { isDate } from "./is-date.cjs";
 import { isDeepEqual } from "./is-deep-equal.cjs";
 import { isDefined } from "./is-defined.cjs";
 import { isEmpty } from "./is-empty.cjs";
-import { t as isEmptyish } from "./is-emptyish-oX5mpcfW.cjs";
+import { t as isEmptyish } from "./is-emptyish-9tX94IVx.cjs";
 import { isError } from "./is-error.cjs";
 import { isFunction } from "./is-function.cjs";
 import { isIncludedIn } from "./is-included-in.cjs";
@@ -84,12 +85,12 @@ import { mapValues } from "./map-values.cjs";
 import { mapWithFeedback } from "./map-with-feedback.cjs";
 import { meanBy } from "./mean-by.cjs";
 import { merge } from "./merge.cjs";
-import { t as mergeAll } from "./merge-all-CW8DGAy8.cjs";
+import { t as mergeAll } from "./merge-all-CISawx-J.cjs";
 import { mergeDeep } from "./merge-deep.cjs";
 import { multiply } from "./multiply.cjs";
 import { nthBy } from "./nth-by.cjs";
 import { objOf } from "./obj-of.cjs";
-import { omit } from "./omit.cjs";
+import { t as omit } from "./omit-DQiCiWAg.cjs";
 import { omitBy } from "./omit-by.cjs";
 import { once } from "./once.cjs";
 import { only } from "./only.cjs";
@@ -100,7 +101,7 @@ import { pickBy } from "./pick-by.cjs";
 import { pipe } from "./pipe.cjs";
 import { piped } from "./piped.cjs";
 import { product } from "./product.cjs";
-import { t as prop } from "./prop-C3rYih5m.cjs";
+import { t as prop } from "./prop-D-4cFXSd.cjs";
 import { pullObject } from "./pull-object.cjs";
 import { randomInteger } from "./random-integer.cjs";
 import { randomString } from "./random-string.cjs";
@@ -141,16 +142,13 @@ import { takeWhile } from "./take-while.cjs";
 import { tap } from "./tap.cjs";
 import { times } from "./times.cjs";
 import { toCamelCase } from "./to-camel-case.cjs";
-import { toCapitalCase } from "./to-capital-case.cjs";
-import { toConstantCase } from "./to-constant-case.cjs";
 import { toKebabCase } from "./to-kebab-case.cjs";
-import { toNoCase } from "./to-no-case.cjs";
-import { toPascalCase } from "./to-pascal-case.cjs";
-import { toPascalSnakeCase } from "./to-pascal-snake-case.cjs";
-import { toSentenceCase } from "./to-sentence-case.cjs";
+import { toLowerCase } from "./to-lower-case.cjs";
 import { toSnakeCase } from "./to-snake-case.cjs";
-import { toTrainCase } from "./to-train-case.cjs";
+import { toTitleCase } from "./to-title-case.cjs";
+import { toUpperCase } from "./to-upper-case.cjs";
 import { DeepPartial } from "./type.helpers.cjs";
+import { uncapitalize } from "./uncapitalize.cjs";
 import { unique } from "./unique.cjs";
 import { uniqueBy } from "./unique-by.cjs";
 import { uniqueWith } from "./unique-with.cjs";
@@ -161,5 +159,5 @@ import { zipWith } from "./zip-with.cjs";
 //#region src/index.d.ts
 declare const isBrowser: boolean;
 //#endregion
-export { DeepPartial, KEY_CODES, add, addProp, allPass, anyPass, ceil, chunk, clamp, clone, concat, conditionalPlus as conditional, constant, countBy, curry, debounce, difference, differenceWith, divide, doNothing, drop, dropFirstBy, dropLast, dropLastWhile, dropWhile, entries, evolve, filter, find, findIndex, findLast, findLastIndex, first, firstBy, flat, flatMap, floor, forEach, forEachObj, fromEntries, fromKeys, funnel, groupBy, groupByProp, hasAtLeast, hasSubObject, humanReadableFileSize, identity, indexBy, intersection, intersectionWith, invert, isArray, isBigInt, isBoolean, isBrowser, isDate, isDeepEqual, isDefined, isEmpty, isEmptyish, isError, isFunction, isIncludedIn, isNonNull, isNonNullish, isNot, isNullish, isNumber, isObjectType, isPlainObject, isPromise, isShallowEqual, isStrictEqual, isString, isSymbol, isTruthy, join, keys, last, length, map, mapKeys, mapToObj, mapValues, mapWithFeedback, meanBy, merge, mergeAll, mergeDeep, multiply, nthBy, objOf, omit, omitBy, once, only, partition, pathOr, pick, pickBy, pipe, piped, product, prop, pullObject, randomInteger, randomString, range, rankBy, reduce, reverse, round, sample, set, setPath, shuffle, sleep, sliceString, slugify, sort, sortBy, sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy, splice, split, splitAt, splitWhen, stringToPath, subtract, sum, sumBy, swapIndices, swapProps, take, takeFirstBy, takeLast, takeLastWhile, takeWhile, tap, times, toCamelCase, toCapitalCase, toConstantCase, toKebabCase, toNoCase, toPascalCase, toPascalSnakeCase, toSentenceCase, toSnakeCase, toTrainCase, unique, uniqueBy, uniqueWith, values, zip, zipWith };
+export { DeepPartial, KEY_CODES, add, addProp, allPass, anyPass, capitalize, ceil, chunk, clamp, clone, concat, conditionalPlus as conditional, constant, countBy, curry, debounce, difference, differenceWith, divide, doNothing, drop, dropFirstBy, dropLast, dropLastWhile, dropWhile, entries, evolve, filter, find, findIndex, findLast, findLastIndex, first, firstBy, flat, flatMap, floor, forEach, forEachObj, fromEntries, fromKeys, funnel, groupBy, groupByProp, hasAtLeast, hasSubObject, humanReadableFileSize, identity, indexBy, intersection, intersectionWith, invert, isArray, isBigInt, isBoolean, isBrowser, isDate, isDeepEqual, isDefined, isEmpty, isEmptyish, isError, isFunction, isIncludedIn, isNonNull, isNonNullish, isNot, isNullish, isNumber, isObjectType, isPlainObject, isPromise, isShallowEqual, isStrictEqual, isString, isSymbol, isTruthy, join, keys, last, length, map, mapKeys, mapToObj, mapValues, mapWithFeedback, meanBy, merge, mergeAll, mergeDeep, multiply, nthBy, objOf, omit, omitBy, once, only, partition, pathOr, pick, pickBy, pipe, piped, product, prop, pullObject, randomInteger, randomString, range, rankBy, reduce, reverse, round, sample, set, setPath, shuffle, sleep, sliceString, slugify, sort, sortBy, sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy, splice, split, splitAt, splitWhen, stringToPath, subtract, sum, sumBy, swapIndices, swapProps, take, takeFirstBy, takeLast, takeLastWhile, takeWhile, tap, times, toCamelCase, toKebabCase, toLowerCase, toSnakeCase, toTitleCase, toUpperCase, uncapitalize, unique, uniqueBy, uniqueWith, values, zip, zipWith };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgKa"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8Ja"}

package/dist/index.d.ts

@@ -2,15 +2,16 @@ import { addProp } from "./add-prop.js";
 import { add } from "./add.js";
 import { allPass } from "./all-pass.js";
 import { anyPass } from "./any-pass.js";
+import { capitalize } from "./capitalize.js";
 import { ceil } from "./ceil.js";
 import { chunk } from "./chunk.js";
 import { clamp } from "./clamp.js";
 import { clone } from "./clone.js";
 import { concat } from "./concat.js";
-import { t as conditionalPlus } from "./conditional-F_nq8vtA.js";
+import { t as conditionalPlus } from "./conditional-CDez6uXp.js";
 import { constant } from "./constant.js";
 import { countBy } from "./count-by.js";
-import { t as curry } from "./curry-d8_p_Jzt.js";
+import { t as curry } from "./curry-CKDQ1osk.js";
 import { debounce } from "./debounce.js";
 import { differenceWith } from "./difference-with.js";
 import { difference } from "./difference.js";
@@ -55,7 +56,7 @@ import { isDate } from "./is-date.js";
 import { isDeepEqual } from "./is-deep-equal.js";
 import { isDefined } from "./is-defined.js";
 import { isEmpty } from "./is-empty.js";
-import { t as isEmptyish } from "./is-emptyish-CIxZzxxz.js";
+import { t as isEmptyish } from "./is-emptyish-DVFGJe-T.js";
 import { isError } from "./is-error.js";
 import { isFunction } from "./is-function.js";
 import { isIncludedIn } from "./is-included-in.js";
@@ -84,12 +85,12 @@ import { mapValues } from "./map-values.js";
 import { mapWithFeedback } from "./map-with-feedback.js";
 import { meanBy } from "./mean-by.js";
 import { merge } from "./merge.js";
-import { t as mergeAll } from "./merge-all-B9JBhVzy.js";
+import { t as mergeAll } from "./merge-all-DJ6n7R1b.js";
 import { mergeDeep } from "./merge-deep.js";
 import { multiply } from "./multiply.js";
 import { nthBy } from "./nth-by.js";
 import { objOf } from "./obj-of.js";
-import { omit } from "./omit.js";
+import { t as omit } from "./omit-DI8DRDHj.js";
 import { omitBy } from "./omit-by.js";
 import { once } from "./once.js";
 import { only } from "./only.js";
@@ -100,7 +101,7 @@ import { pickBy } from "./pick-by.js";
 import { pipe } from "./pipe.js";
 import { piped } from "./piped.js";
 import { product } from "./product.js";
-import { t as prop } from "./prop-DulcbWGG.js";
+import { t as prop } from "./prop-DL-oRBeN.js";
 import { pullObject } from "./pull-object.js";
 import { randomInteger } from "./random-integer.js";
 import { randomString } from "./random-string.js";
@@ -141,16 +142,13 @@ import { takeWhile } from "./take-while.js";
 import { tap } from "./tap.js";
 import { times } from "./times.js";
 import { toCamelCase } from "./to-camel-case.js";
-import { toCapitalCase } from "./to-capital-case.js";
-import { toConstantCase } from "./to-constant-case.js";
 import { toKebabCase } from "./to-kebab-case.js";
-import { toNoCase } from "./to-no-case.js";
-import { toPascalCase } from "./to-pascal-case.js";
-import { toPascalSnakeCase } from "./to-pascal-snake-case.js";
-import { toSentenceCase } from "./to-sentence-case.js";
+import { toLowerCase } from "./to-lower-case.js";
 import { toSnakeCase } from "./to-snake-case.js";
-import { toTrainCase } from "./to-train-case.js";
+import { toTitleCase } from "./to-title-case.js";
+import { toUpperCase } from "./to-upper-case.js";
 import { DeepPartial } from "./type.helpers.js";
+import { uncapitalize } from "./uncapitalize.js";
 import { unique } from "./unique.js";
 import { uniqueBy } from "./unique-by.js";
 import { uniqueWith } from "./unique-with.js";
@@ -161,5 +159,5 @@ import { zipWith } from "./zip-with.js";
 //#region src/index.d.ts
 declare const isBrowser: boolean;
 //#endregion
-export { DeepPartial, KEY_CODES, add, addProp, allPass, anyPass, ceil, chunk, clamp, clone, concat, conditionalPlus as conditional, constant, countBy, curry, debounce, difference, differenceWith, divide, doNothing, drop, dropFirstBy, dropLast, dropLastWhile, dropWhile, entries, evolve, filter, find, findIndex, findLast, findLastIndex, first, firstBy, flat, flatMap, floor, forEach, forEachObj, fromEntries, fromKeys, funnel, groupBy, groupByProp, hasAtLeast, hasSubObject, humanReadableFileSize, identity, indexBy, intersection, intersectionWith, invert, isArray, isBigInt, isBoolean, isBrowser, isDate, isDeepEqual, isDefined, isEmpty, isEmptyish, isError, isFunction, isIncludedIn, isNonNull, isNonNullish, isNot, isNullish, isNumber, isObjectType, isPlainObject, isPromise, isShallowEqual, isStrictEqual, isString, isSymbol, isTruthy, join, keys, last, length, map, mapKeys, mapToObj, mapValues, mapWithFeedback, meanBy, merge, mergeAll, mergeDeep, multiply, nthBy, objOf, omit, omitBy, once, only, partition, pathOr, pick, pickBy, pipe, piped, product, prop, pullObject, randomInteger, randomString, range, rankBy, reduce, reverse, round, sample, set, setPath, shuffle, sleep, sliceString, slugify, sort, sortBy, sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy, splice, split, splitAt, splitWhen, stringToPath, subtract, sum, sumBy, swapIndices, swapProps, take, takeFirstBy, takeLast, takeLastWhile, takeWhile, tap, times, toCamelCase, toCapitalCase, toConstantCase, toKebabCase, toNoCase, toPascalCase, toPascalSnakeCase, toSentenceCase, toSnakeCase, toTrainCase, unique, uniqueBy, uniqueWith, values, zip, zipWith };
+export { DeepPartial, KEY_CODES, add, addProp, allPass, anyPass, capitalize, ceil, chunk, clamp, clone, concat, conditionalPlus as conditional, constant, countBy, curry, debounce, difference, differenceWith, divide, doNothing, drop, dropFirstBy, dropLast, dropLastWhile, dropWhile, entries, evolve, filter, find, findIndex, findLast, findLastIndex, first, firstBy, flat, flatMap, floor, forEach, forEachObj, fromEntries, fromKeys, funnel, groupBy, groupByProp, hasAtLeast, hasSubObject, humanReadableFileSize, identity, indexBy, intersection, intersectionWith, invert, isArray, isBigInt, isBoolean, isBrowser, isDate, isDeepEqual, isDefined, isEmpty, isEmptyish, isError, isFunction, isIncludedIn, isNonNull, isNonNullish, isNot, isNullish, isNumber, isObjectType, isPlainObject, isPromise, isShallowEqual, isStrictEqual, isString, isSymbol, isTruthy, join, keys, last, length, map, mapKeys, mapToObj, mapValues, mapWithFeedback, meanBy, merge, mergeAll, mergeDeep, multiply, nthBy, objOf, omit, omitBy, once, only, partition, pathOr, pick, pickBy, pipe, piped, product, prop, pullObject, randomInteger, randomString, range, rankBy, reduce, reverse, round, sample, set, setPath, shuffle, sleep, sliceString, slugify, sort, sortBy, sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy, splice, split, splitAt, splitWhen, stringToPath, subtract, sum, sumBy, swapIndices, swapProps, take, takeFirstBy, takeLast, takeLastWhile, takeWhile, tap, times, toCamelCase, toKebabCase, toLowerCase, toSnakeCase, toTitleCase, toUpperCase, uncapitalize, unique, uniqueBy, uniqueWith, values, zip, zipWith };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgKa"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8Ja"}

package/dist/index.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-BcQ8Up1_.js";import{addProp as t}from"./add-prop.js";import{add as n}from"./add.js";import{allPass as r}from"./all-pass.js";import{anyPass as i}from"./any-pass.js";import{ceil as a}from"./ceil.js";import{chunk as o}from"./chunk.js";import{clamp as s}from"./clamp.js";import{clone as c}from"./clone.js";import{concat as l}from"./concat.js";import{t as u}from"./conditional-lp8ZHACd.js";import{constant as d}from"./constant.js";import{countBy as f}from"./count-by.js";import{debounce as p}from"./debounce.js";import{t as m}from"./pipe-BGazHnZ_.js";import{differenceWith as h}from"./difference-with.js";import{difference as g}from"./difference.js";import{divide as _}from"./divide.js";import{doNothing as v}from"./do-nothing.js";import{t as y}from"./has-at-least-DyIhWZJH.js";import{dropFirstBy as b}from"./drop-first-by.js";import{dropLastWhile as x}from"./drop-last-while.js";import{dropLast as S}from"./drop-last.js";import{dropWhile as C}from"./drop-while.js";import{drop as w}from"./drop.js";import{entries as T}from"./entries.js";import{evolve as E}from"./evolve.js";import{filter as D}from"./filter.js";import{findIndex as O}from"./find-index.js";import{findLastIndex as k}from"./find-last-index.js";import{findLast as A}from"./find-last.js";import{find as j}from"./find.js";import{firstBy as M}from"./first-by.js";import{first as N}from"./first.js";import{flatMap as P}from"./flat-map.js";import{flat as F}from"./flat.js";import{floor as I}from"./floor.js";import{forEachObj as L}from"./for-each-obj.js";import{forEach as R}from"./for-each.js";import{fromEntries as z}from"./from-entries.js";import{fromKeys as B}from"./from-keys.js";import{funnel as V}from"./funnel.js";import{identity as H}from"./identity.js";import{sleep as U}from"./sleep.js";import{groupByProp as W}from"./group-by-prop.js";import{groupBy as G}from"./group-by.js";import{isDeepEqual as K}from"./is-deep-equal.js";import{hasSubObject as q}from"./has-sub-object.js";import{humanReadableFileSize as J}from"./human-readable-file-size.js";import{indexBy as Y}from"./index-by.js";import{intersection as X}from"./intersection.js";import{intersectionWith as Z}from"./intersection-with.js";import{invert as Q}from"./invert.js";import{isArray as $}from"./is-array.js";import{isBigInt as ee}from"./is-big-int.js";import{isBoolean as te}from"./is-boolean.js";import{isDate as ne}from"./is-date.js";import{isDefined as re}from"./is-defined.js";import{isEmpty as ie}from"./is-empty.js";import{isEmptyish as ae}from"./is-emptyish.js";import{isError as oe}from"./is-error.js";import{isFunction as se}from"./is-function.js";import{isIncludedIn as ce}from"./is-included-in.js";import{isNonNull as le}from"./is-non-null.js";import{isNonNullish as ue}from"./is-non-nullish.js";import{isNot as de}from"./is-not.js";import{isNullish as fe}from"./is-nullish.js";import{isNumber as pe}from"./is-number.js";import{isObjectType as me}from"./is-object-type.js";import{isPlainObject as he}from"./is-plain-object.js";import{isPromise as ge}from"./is-promise.js";import{isShallowEqual as _e}from"./is-shallow-equal.js";import{isStrictEqual as ve}from"./is-strict-equal.js";import{isString as ye}from"./is-string.js";import{isSymbol as be}from"./is-symbol.js";import{isTruthy as xe}from"./is-truthy.js";import{join as Se}from"./join.js";import{KEY_CODES as Ce}from"./key-codes.js";import{keys as we}from"./keys.js";import{last as Te}from"./last.js";import{length as Ee}from"./length.js";import{map as De}from"./map.js";import{mapKeys as Oe}from"./map-keys.js";import{mapToObj as ke}from"./map-to-obj.js";import{mapValues as Ae}from"./map-values.js";import{mapWithFeedback as je}from"./map-with-feedback.js";import{meanBy as Me}from"./mean-by.js";import{merge as Ne}from"./merge.js";import{mergeAll as Pe}from"./merge-all.js";import{mergeDeep as Fe}from"./merge-deep.js";import{multiply as Ie}from"./multiply.js";import{t as Le}from"./nth-by-Bs6FNGL-.js";import{objOf as Re}from"./obj-of.js";import{omit as ze}from"./omit.js";import{omitBy as Be}from"./omit-by.js";import{once as Ve}from"./once.js";import{only as He}from"./only.js";import{partition as Ue}from"./partition.js";import{pathOr as We}from"./path-or.js";import{pick as Ge}from"./pick.js";import{pickBy as Ke}from"./pick-by.js";import{piped as qe}from"./piped.js";import{product as Je}from"./product.js";import{prop as Ye}from"./prop.js";import{pullObject as Xe}from"./pull-object.js";import{randomInteger as Ze}from"./random-integer.js";import{randomString as Qe}from"./random-string.js";import{range as $e}from"./range.js";import{rankBy as et}from"./rank-by.js";import{reduce as tt}from"./reduce.js";import{reverse as nt}from"./reverse.js";import{round as rt}from"./round.js";import{sample as it}from"./sample.js";import{set as at}from"./set.js";import{setPath as ot}from"./set-path.js";import{shuffle as st}from"./shuffle.js";import{sliceString as ct}from"./slice-string.js";import{slugify as lt}from"./slugify.js";import{sort as ut}from"./sort.js";import{sortBy as dt}from"./sort-by.js";import{sortedIndex as ft}from"./sorted-index.js";import{sortedIndexBy as pt}from"./sorted-index-by.js";import{sortedIndexWith as mt}from"./sorted-index-with.js";import{sortedLastIndex as ht}from"./sorted-last-index.js";import{sortedLastIndexBy as gt}from"./sorted-last-index-by.js";import{splice as _t}from"./splice.js";import{split as vt}from"./split.js";import{splitAt as yt}from"./split-at.js";import{splitWhen as bt}from"./split-when.js";import{stringToPath as xt}from"./string-to-path.js";import{subtract as St}from"./subtract.js";import{sum as Ct}from"./sum.js";import{sumBy as wt}from"./sum-by.js";import{swapIndices as Tt}from"./swap-indices.js";import{swapProps as Et}from"./swap-props.js";import{take as Dt}from"./take.js";import{takeFirstBy as Ot}from"./take-first-by.js";import{takeLast as kt}from"./take-last.js";import{takeLastWhile as At}from"./take-last-while.js";import{takeWhile as jt}from"./take-while.js";import{tap as Mt}from"./tap.js";import{times as Nt}from"./times.js";import{toCamelCase as Pt}from"./to-camel-case.js";import{toCapitalCase as Ft}from"./to-capital-case.js";import{toConstantCase as It}from"./to-constant-case.js";import{toNoCase as Lt}from"./to-no-case.js";import{toKebabCase as Rt}from"./to-kebab-case.js";import{toPascalCase as zt}from"./to-pascal-case.js";import{toPascalSnakeCase as Bt}from"./to-pascal-snake-case.js";import{toSentenceCase as Vt}from"./to-sentence-case.js";import{toSnakeCase as Ht}from"./to-snake-case.js";import{toTrainCase as Ut}from"./to-train-case.js";import"./type.helpers.js";import{unique as Wt}from"./unique.js";import{uniqueBy as Gt}from"./unique-by.js";import{uniqueWith as Kt}from"./unique-with.js";import{values as qt}from"./values.js";import{zip as Jt}from"./zip.js";import{zipWith as Yt}from"./zip-with.js";const Xt=typeof window<`u`;export{Ce as KEY_CODES,n as add,t as addProp,r as allPass,i as anyPass,a as ceil,o as chunk,s as clamp,c as clone,l as concat,u as conditional,d as constant,f as countBy,e as curry,p as debounce,g as difference,h as differenceWith,_ as divide,v as doNothing,w as drop,b as dropFirstBy,S as dropLast,x as dropLastWhile,C as dropWhile,T as entries,E as evolve,D as filter,j as find,O as findIndex,A as findLast,k as findLastIndex,N as first,M as firstBy,F as flat,P as flatMap,I as floor,R as forEach,L as forEachObj,z as fromEntries,B as fromKeys,V as funnel,G as groupBy,W as groupByProp,y as hasAtLeast,q as hasSubObject,J as humanReadableFileSize,H as identity,Y as indexBy,X as intersection,Z as intersectionWith,Q as invert,$ as isArray,ee as isBigInt,te as isBoolean,Xt as isBrowser,ne as isDate,K as isDeepEqual,re as isDefined,ie as isEmpty,ae as isEmptyish,oe as isError,se as isFunction,ce as isIncludedIn,le as isNonNull,ue as isNonNullish,de as isNot,fe as isNullish,pe as isNumber,me as isObjectType,he as isPlainObject,ge as isPromise,_e as isShallowEqual,ve as isStrictEqual,ye as isString,be as isSymbol,xe as isTruthy,Se as join,we as keys,Te as last,Ee as length,De as map,Oe as mapKeys,ke as mapToObj,Ae as mapValues,je as mapWithFeedback,Me as meanBy,Ne as merge,Pe as mergeAll,Fe as mergeDeep,Ie as multiply,Le as nthBy,Re as objOf,ze as omit,Be as omitBy,Ve as once,He as only,Ue as partition,We as pathOr,Ge as pick,Ke as pickBy,m as pipe,qe as piped,Je as product,Ye as prop,Xe as pullObject,Ze as randomInteger,Qe as randomString,$e as range,et as rankBy,tt as reduce,nt as reverse,rt as round,it as sample,at as set,ot as setPath,st as shuffle,U as sleep,ct as sliceString,lt as slugify,ut as sort,dt as sortBy,ft as sortedIndex,pt as sortedIndexBy,mt as sortedIndexWith,ht as sortedLastIndex,gt as sortedLastIndexBy,_t as splice,vt as split,yt as splitAt,bt as splitWhen,xt as stringToPath,St as subtract,Ct as sum,wt as sumBy,Tt as swapIndices,Et as swapProps,Dt as take,Ot as takeFirstBy,kt as takeLast,At as takeLastWhile,jt as takeWhile,Mt as tap,Nt as times,Pt as toCamelCase,Ft as toCapitalCase,It as toConstantCase,Rt as toKebabCase,Lt as toNoCase,zt as toPascalCase,Bt as toPascalSnakeCase,Vt as toSentenceCase,Ht as toSnakeCase,Ut as toTrainCase,Wt as unique,Gt as uniqueBy,Kt as uniqueWith,qt as values,Jt as zip,Yt as zipWith};
+import{t as e}from"./curry-NmniqyJ0.js";import{addProp as t}from"./add-prop.js";import{add as n}from"./add.js";import{allPass as r}from"./all-pass.js";import{anyPass as i}from"./any-pass.js";import{capitalize as a}from"./capitalize.js";import{ceil as o}from"./ceil.js";import{chunk as s}from"./chunk.js";import{clamp as c}from"./clamp.js";import{clone as l}from"./clone.js";import{concat as u}from"./concat.js";import{t as d}from"./conditional-WbmvQs8H.js";import{constant as f}from"./constant.js";import{countBy as p}from"./count-by.js";import{debounce as m}from"./debounce.js";import{t as h}from"./pipe-CZKusDA-.js";import{differenceWith as g}from"./difference-with.js";import{difference as _}from"./difference.js";import{divide as v}from"./divide.js";import{doNothing as y}from"./do-nothing.js";import{t as b}from"./has-at-least-Coy9sM-B.js";import{dropFirstBy as x}from"./drop-first-by.js";import{dropLastWhile as S}from"./drop-last-while.js";import{dropLast as C}from"./drop-last.js";import{dropWhile as w}from"./drop-while.js";import{drop as T}from"./drop.js";import{entries as E}from"./entries.js";import{evolve as D}from"./evolve.js";import{filter as O}from"./filter.js";import{findIndex as k}from"./find-index.js";import{findLastIndex as A}from"./find-last-index.js";import{findLast as j}from"./find-last.js";import{find as M}from"./find.js";import{firstBy as N}from"./first-by.js";import{first as P}from"./first.js";import{flatMap as F}from"./flat-map.js";import{flat as I}from"./flat.js";import{floor as L}from"./floor.js";import{forEachObj as R}from"./for-each-obj.js";import{forEach as z}from"./for-each.js";import{fromEntries as B}from"./from-entries.js";import{fromKeys as V}from"./from-keys.js";import{funnel as H}from"./funnel.js";import{identity as U}from"./identity.js";import{sleep as W}from"./sleep.js";import{groupByProp as G}from"./group-by-prop.js";import{groupBy as K}from"./group-by.js";import{isDeepEqual as q}from"./is-deep-equal.js";import{hasSubObject as J}from"./has-sub-object.js";import{humanReadableFileSize as Y}from"./human-readable-file-size.js";import{indexBy as X}from"./index-by.js";import{intersection as Z}from"./intersection.js";import{intersectionWith as Q}from"./intersection-with.js";import{invert as $}from"./invert.js";import{isArray as ee}from"./is-array.js";import{isBigInt as te}from"./is-big-int.js";import{isBoolean as ne}from"./is-boolean.js";import{isDate as re}from"./is-date.js";import{isDefined as ie}from"./is-defined.js";import{isEmpty as ae}from"./is-empty.js";import{isEmptyish as oe}from"./is-emptyish.js";import{isError as se}from"./is-error.js";import{isFunction as ce}from"./is-function.js";import{isIncludedIn as le}from"./is-included-in.js";import{isNonNull as ue}from"./is-non-null.js";import{isNonNullish as de}from"./is-non-nullish.js";import{isNot as fe}from"./is-not.js";import{isNullish as pe}from"./is-nullish.js";import{isNumber as me}from"./is-number.js";import{isObjectType as he}from"./is-object-type.js";import{isPlainObject as ge}from"./is-plain-object.js";import{isPromise as _e}from"./is-promise.js";import{isShallowEqual as ve}from"./is-shallow-equal.js";import{isStrictEqual as ye}from"./is-strict-equal.js";import{isString as be}from"./is-string.js";import{isSymbol as xe}from"./is-symbol.js";import{isTruthy as Se}from"./is-truthy.js";import{join as Ce}from"./join.js";import{KEY_CODES as we}from"./key-codes.js";import{keys as Te}from"./keys.js";import{last as Ee}from"./last.js";import{length as De}from"./length.js";import{map as Oe}from"./map.js";import{mapKeys as ke}from"./map-keys.js";import{mapToObj as Ae}from"./map-to-obj.js";import{mapValues as je}from"./map-values.js";import{mapWithFeedback as Me}from"./map-with-feedback.js";import{meanBy as Ne}from"./mean-by.js";import{merge as Pe}from"./merge.js";import{mergeAll as Fe}from"./merge-all.js";import{mergeDeep as Ie}from"./merge-deep.js";import{multiply as Le}from"./multiply.js";import{t as Re}from"./nth-by-JP3-Htbo.js";import{objOf as ze}from"./obj-of.js";import{omit as Be}from"./omit.js";import{omitBy as Ve}from"./omit-by.js";import{once as He}from"./once.js";import{only as Ue}from"./only.js";import{partition as We}from"./partition.js";import{pathOr as Ge}from"./path-or.js";import{pick as Ke}from"./pick.js";import{pickBy as qe}from"./pick-by.js";import{piped as Je}from"./piped.js";import{product as Ye}from"./product.js";import{prop as Xe}from"./prop.js";import{pullObject as Ze}from"./pull-object.js";import{randomInteger as Qe}from"./random-integer.js";import{randomString as $e}from"./random-string.js";import{range as et}from"./range.js";import{rankBy as tt}from"./rank-by.js";import{reduce as nt}from"./reduce.js";import{reverse as rt}from"./reverse.js";import{round as it}from"./round.js";import{sample as at}from"./sample.js";import{set as ot}from"./set.js";import{setPath as st}from"./set-path.js";import{shuffle as ct}from"./shuffle.js";import{sliceString as lt}from"./slice-string.js";import{slugify as ut}from"./slugify.js";import{sort as dt}from"./sort.js";import{sortBy as ft}from"./sort-by.js";import{sortedIndex as pt}from"./sorted-index.js";import{sortedIndexBy as mt}from"./sorted-index-by.js";import{sortedIndexWith as ht}from"./sorted-index-with.js";import{sortedLastIndex as gt}from"./sorted-last-index.js";import{sortedLastIndexBy as _t}from"./sorted-last-index-by.js";import{splice as vt}from"./splice.js";import{split as yt}from"./split.js";import{splitAt as bt}from"./split-at.js";import{splitWhen as xt}from"./split-when.js";import{stringToPath as St}from"./string-to-path.js";import{subtract as Ct}from"./subtract.js";import{sum as wt}from"./sum.js";import{sumBy as Tt}from"./sum-by.js";import{swapIndices as Et}from"./swap-indices.js";import{swapProps as Dt}from"./swap-props.js";import{take as Ot}from"./take.js";import{takeFirstBy as kt}from"./take-first-by.js";import{takeLast as At}from"./take-last.js";import{takeLastWhile as jt}from"./take-last-while.js";import{takeWhile as Mt}from"./take-while.js";import{tap as Nt}from"./tap.js";import{times as Pt}from"./times.js";import{toCamelCase as Ft}from"./to-camel-case.js";import{toKebabCase as It}from"./to-kebab-case.js";import{toLowerCase as Lt}from"./to-lower-case.js";import{toSnakeCase as Rt}from"./to-snake-case.js";import{toTitleCase as zt}from"./to-title-case.js";import{toUpperCase as Bt}from"./to-upper-case.js";import"./type.helpers.js";import{uncapitalize as Vt}from"./uncapitalize.js";import{unique as Ht}from"./unique.js";import{uniqueBy as Ut}from"./unique-by.js";import{uniqueWith as Wt}from"./unique-with.js";import{values as Gt}from"./values.js";import{zip as Kt}from"./zip.js";import{zipWith as qt}from"./zip-with.js";const Jt=typeof window<`u`;export{we as KEY_CODES,n as add,t as addProp,r as allPass,i as anyPass,a as capitalize,o as ceil,s as chunk,c as clamp,l as clone,u as concat,d as conditional,f as constant,p as countBy,e as curry,m as debounce,_ as difference,g as differenceWith,v as divide,y as doNothing,T as drop,x as dropFirstBy,C as dropLast,S as dropLastWhile,w as dropWhile,E as entries,D as evolve,O as filter,M as find,k as findIndex,j as findLast,A as findLastIndex,P as first,N as firstBy,I as flat,F as flatMap,L as floor,z as forEach,R as forEachObj,B as fromEntries,V as fromKeys,H as funnel,K as groupBy,G as groupByProp,b as hasAtLeast,J as hasSubObject,Y as humanReadableFileSize,U as identity,X as indexBy,Z as intersection,Q as intersectionWith,$ as invert,ee as isArray,te as isBigInt,ne as isBoolean,Jt as isBrowser,re as isDate,q as isDeepEqual,ie as isDefined,ae as isEmpty,oe as isEmptyish,se as isError,ce as isFunction,le as isIncludedIn,ue as isNonNull,de as isNonNullish,fe as isNot,pe as isNullish,me as isNumber,he as isObjectType,ge as isPlainObject,_e as isPromise,ve as isShallowEqual,ye as isStrictEqual,be as isString,xe as isSymbol,Se as isTruthy,Ce as join,Te as keys,Ee as last,De as length,Oe as map,ke as mapKeys,Ae as mapToObj,je as mapValues,Me as mapWithFeedback,Ne as meanBy,Pe as merge,Fe as mergeAll,Ie as mergeDeep,Le as multiply,Re as nthBy,ze as objOf,Be as omit,Ve as omitBy,He as once,Ue as only,We as partition,Ge as pathOr,Ke as pick,qe as pickBy,h as pipe,Je as piped,Ye as product,Xe as prop,Ze as pullObject,Qe as randomInteger,$e as randomString,et as range,tt as rankBy,nt as reduce,rt as reverse,it as round,at as sample,ot as set,st as setPath,ct as shuffle,W as sleep,lt as sliceString,ut as slugify,dt as sort,ft as sortBy,pt as sortedIndex,mt as sortedIndexBy,ht as sortedIndexWith,gt as sortedLastIndex,_t as sortedLastIndexBy,vt as splice,yt as split,bt as splitAt,xt as splitWhen,St as stringToPath,Ct as subtract,wt as sum,Tt as sumBy,Et as swapIndices,Dt as swapProps,Ot as take,kt as takeFirstBy,At as takeLast,jt as takeLastWhile,Mt as takeWhile,Nt as tap,Pt as times,Ft as toCamelCase,It as toKebabCase,Lt as toLowerCase,Rt as toSnakeCase,zt as toTitleCase,Bt as toUpperCase,Vt as uncapitalize,Ht as unique,Ut as uniqueBy,Wt as uniqueWith,Gt as values,Kt as zip,qt as zipWith};
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["export * from './add';\nexport * from './add-prop';\nexport * from './all-pass';\nexport * from './any-pass';\nexport * from './ceil';\nexport * from './chunk';\nexport * from './clamp';\nexport * from './clone';\nexport * from './concat';\nexport * from './conditional';\nexport * from './constant';\nexport * from './count-by';\nexport * from './curry';\nexport * from './debounce';\nexport * from './difference';\nexport * from './difference-with';\nexport * from './divide';\nexport * from './do-nothing';\nexport * from './drop';\nexport * from './drop-first-by';\nexport * from './drop-last';\nexport * from './drop-last-while';\nexport * from './drop-while';\nexport * from './entries';\nexport * from './evolve';\nexport * from './filter';\nexport * from './find';\nexport * from './find-index';\nexport * from './find-last';\nexport * from './find-last-index';\nexport * from './first';\nexport * from './first-by';\nexport * from './flat';\nexport * from './flat-map';\nexport * from './floor';\nexport * from './for-each';\nexport * from './for-each-obj';\nexport * from './from-entries';\nexport * from './from-keys';\nexport * from './funnel';\nexport * from './group-by';\nexport * from './group-by-prop';\nexport * from './has-at-least';\nexport * from './has-sub-object';\nexport * from './human-readable-file-size';\nexport * from './identity';\nexport * from './index-by';\nexport * from './intersection';\nexport * from './intersection-with';\nexport * from './invert';\nexport * from './is-array';\nexport * from './is-big-int';\nexport * from './is-boolean';\nexport * from './is-date';\nexport * from './is-deep-equal';\nexport * from './is-defined';\nexport * from './is-empty';\nexport * from './is-emptyish';\nexport * from './is-error';\nexport * from './is-function';\nexport * from './is-included-in';\nexport * from './is-non-null';\nexport * from './is-non-nullish';\nexport * from './is-not';\nexport * from './is-nullish';\nexport * from './is-number';\nexport * from './is-object-type';\nexport * from './is-plain-object';\nexport * from './is-promise';\nexport * from './is-shallow-equal';\nexport * from './is-strict-equal';\nexport * from './is-string';\nexport * from './is-symbol';\nexport * from './is-truthy';\nexport * from './join';\nexport * from './key-codes';\nexport * from './keys';\nexport * from './last';\nexport * from './length';\nexport * from './map';\nexport * from './map-keys';\nexport * from './map-to-obj';\nexport * from './map-values';\nexport * from './map-with-feedback';\nexport * from './mean-by';\nexport * from './merge';\nexport * from './merge-all';\nexport * from './merge-deep';\nexport * from './multiply';\nexport * from './nth-by';\nexport * from './obj-of';\nexport * from './omit';\nexport * from './omit-by';\nexport * from './once';\nexport * from './only';\nexport * from './partition';\nexport * from './path-or';\nexport * from './pick';\nexport * from './pick-by';\nexport * from './pipe';\nexport * from './piped';\nexport * from './product';\nexport * from './prop';\nexport * from './pull-object';\nexport * from './random-integer';\nexport * from './random-string';\nexport * from './range';\nexport * from './rank-by';\nexport * from './reduce';\nexport * from './reverse';\nexport * from './round';\nexport * from './sample';\nexport * from './set';\nexport * from './set-path';\nexport * from './shuffle';\nexport * from './sleep';\nexport * from './slice-string';\nexport * from './slugify';\nexport * from './sort';\nexport * from './sort-by';\nexport * from './sorted-index';\nexport * from './sorted-index-by';\nexport * from './sorted-index-with';\nexport * from './sorted-last-index';\nexport * from './sorted-last-index-by';\nexport * from './splice';\nexport * from './split';\nexport * from './split-at';\nexport * from './split-when';\nexport * from './string-to-path';\nexport * from './subtract';\nexport * from './sum';\nexport * from './sum-by';\nexport * from './swap-indices';\nexport * from './swap-props';\nexport * from './take';\nexport * from './take-first-by';\nexport * from './take-last';\nexport * from './take-last-while';\nexport * from './take-while';\nexport * from './tap';\nexport * from './times';\nexport * from './to-camel-case';\nexport * from './to-capital-case';\nexport * from './to-constant-case';\nexport * from './to-kebab-case';\nexport * from './to-no-case';\nexport * from './to-pascal-case';\nexport * from './to-pascal-snake-case';\nexport * from './to-sentence-case';\nexport * from './to-snake-case';\nexport * from './to-train-case';\nexport * from './type.helpers';\nexport * from './unique';\nexport * from './unique-by';\nexport * from './unique-with';\nexport * from './values';\nexport * from './zip';\nexport * from './zip-with';\n\nexport const isBrowser = typeof window !== 'undefined';\n"],"mappings":"upNAgKA,MAAa,GAAY,OAAO,OAAW"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["export * from './add';\nexport * from './add-prop';\nexport * from './all-pass';\nexport * from './any-pass';\nexport * from './capitalize';\nexport * from './ceil';\nexport * from './chunk';\nexport * from './clamp';\nexport * from './clone';\nexport * from './concat';\nexport * from './conditional';\nexport * from './constant';\nexport * from './count-by';\nexport * from './curry';\nexport * from './debounce';\nexport * from './difference';\nexport * from './difference-with';\nexport * from './divide';\nexport * from './do-nothing';\nexport * from './drop';\nexport * from './drop-first-by';\nexport * from './drop-last';\nexport * from './drop-last-while';\nexport * from './drop-while';\nexport * from './entries';\nexport * from './evolve';\nexport * from './filter';\nexport * from './find';\nexport * from './find-index';\nexport * from './find-last';\nexport * from './find-last-index';\nexport * from './first';\nexport * from './first-by';\nexport * from './flat';\nexport * from './flat-map';\nexport * from './floor';\nexport * from './for-each';\nexport * from './for-each-obj';\nexport * from './from-entries';\nexport * from './from-keys';\nexport * from './funnel';\nexport * from './group-by';\nexport * from './group-by-prop';\nexport * from './has-at-least';\nexport * from './has-sub-object';\nexport * from './human-readable-file-size';\nexport * from './identity';\nexport * from './index-by';\nexport * from './intersection';\nexport * from './intersection-with';\nexport * from './invert';\nexport * from './is-array';\nexport * from './is-big-int';\nexport * from './is-boolean';\nexport * from './is-date';\nexport * from './is-deep-equal';\nexport * from './is-defined';\nexport * from './is-empty';\nexport * from './is-emptyish';\nexport * from './is-error';\nexport * from './is-function';\nexport * from './is-included-in';\nexport * from './is-non-null';\nexport * from './is-non-nullish';\nexport * from './is-not';\nexport * from './is-nullish';\nexport * from './is-number';\nexport * from './is-object-type';\nexport * from './is-plain-object';\nexport * from './is-promise';\nexport * from './is-shallow-equal';\nexport * from './is-strict-equal';\nexport * from './is-string';\nexport * from './is-symbol';\nexport * from './is-truthy';\nexport * from './join';\nexport * from './key-codes';\nexport * from './keys';\nexport * from './last';\nexport * from './length';\nexport * from './map';\nexport * from './map-keys';\nexport * from './map-to-obj';\nexport * from './map-values';\nexport * from './map-with-feedback';\nexport * from './mean-by';\nexport * from './merge';\nexport * from './merge-all';\nexport * from './merge-deep';\nexport * from './multiply';\nexport * from './nth-by';\nexport * from './obj-of';\nexport * from './omit';\nexport * from './omit-by';\nexport * from './once';\nexport * from './only';\nexport * from './partition';\nexport * from './path-or';\nexport * from './pick';\nexport * from './pick-by';\nexport * from './pipe';\nexport * from './piped';\nexport * from './product';\nexport * from './prop';\nexport * from './pull-object';\nexport * from './random-integer';\nexport * from './random-string';\nexport * from './range';\nexport * from './rank-by';\nexport * from './reduce';\nexport * from './reverse';\nexport * from './round';\nexport * from './sample';\nexport * from './set';\nexport * from './set-path';\nexport * from './shuffle';\nexport * from './sleep';\nexport * from './slice-string';\nexport * from './slugify';\nexport * from './sort';\nexport * from './sort-by';\nexport * from './sorted-index';\nexport * from './sorted-index-by';\nexport * from './sorted-index-with';\nexport * from './sorted-last-index';\nexport * from './sorted-last-index-by';\nexport * from './splice';\nexport * from './split';\nexport * from './split-at';\nexport * from './split-when';\nexport * from './string-to-path';\nexport * from './subtract';\nexport * from './sum';\nexport * from './sum-by';\nexport * from './swap-indices';\nexport * from './swap-props';\nexport * from './take';\nexport * from './take-first-by';\nexport * from './take-last';\nexport * from './take-last-while';\nexport * from './take-while';\nexport * from './tap';\nexport * from './times';\nexport * from './to-camel-case';\nexport * from './to-kebab-case';\nexport * from './to-lower-case';\nexport * from './to-snake-case';\nexport * from './to-title-case';\nexport * from './to-upper-case';\nexport * from './type.helpers';\nexport * from './uncapitalize';\nexport * from './unique';\nexport * from './unique-by';\nexport * from './unique-with';\nexport * from './values';\nexport * from './zip';\nexport * from './zip-with';\n\nexport const isBrowser = typeof window !== 'undefined';\n"],"mappings":"shNA8JA,MAAa,GAAY,OAAO,OAAW"}

package/dist/{int-range-inclusive-ClGdUant.d.ts → int-range-inclusive-BlGXX6Cz.d.ts}

@@ -12,4 +12,4 @@ import { IntRange } from "type-fest";
 type IntRangeInclusive<From extends number, To extends number> = IntRange<From, To> | To;
 //#endregion
 export { IntRangeInclusive as t };
-//# sourceMappingURL=int-range-inclusive-ClGdUant.d.ts.map
+//# sourceMappingURL=int-range-inclusive-BlGXX6Cz.d.ts.map

package/dist/{int-range-inclusive-ClGdUant.d.ts.map → int-range-inclusive-BlGXX6Cz.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"int-range-inclusive-ClGdUant.d.ts","names":[],"sources":["../src/internal/types/int-range-inclusive.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;;;AAEQ,KAFI,iBAEJ,CAAA,aAAA,MAAA,EAAA,WAAA,MAAA,CAAA,GADF,QACE,CADO,IACP,EADa,EACb,CAAA,GAAF,EAAE"}
+{"version":3,"file":"int-range-inclusive-BlGXX6Cz.d.ts","names":[],"sources":["../src/internal/types/int-range-inclusive.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;;;AAEQ,KAFI,iBAEJ,CAAA,aAAA,MAAA,EAAA,WAAA,MAAA,CAAA,GADF,QACE,CADO,IACP,EADa,EACb,CAAA,GAAF,EAAE"}

package/dist/{int-range-inclusive-q-Jb7w6P.d.cts → int-range-inclusive-KocNpK0p.d.cts}

@@ -12,4 +12,4 @@ import { IntRange } from "type-fest";
 type IntRangeInclusive<From extends number, To extends number> = IntRange<From, To> | To;
 //#endregion
 export { IntRangeInclusive as t };
-//# sourceMappingURL=int-range-inclusive-q-Jb7w6P.d.cts.map
+//# sourceMappingURL=int-range-inclusive-KocNpK0p.d.cts.map

package/dist/{int-range-inclusive-q-Jb7w6P.d.cts.map → int-range-inclusive-KocNpK0p.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"int-range-inclusive-q-Jb7w6P.d.cts","names":[],"sources":["../src/internal/types/int-range-inclusive.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;;;AAEQ,KAFI,iBAEJ,CAAA,aAAA,MAAA,EAAA,WAAA,MAAA,CAAA,GADF,QACE,CADO,IACP,EADa,EACb,CAAA,GAAF,EAAE"}
+{"version":3,"file":"int-range-inclusive-KocNpK0p.d.cts","names":[],"sources":["../src/internal/types/int-range-inclusive.ts"],"sourcesContent":[],"mappings":";;;;;;AASA;;;;;AAEQ,KAFI,iBAEJ,CAAA,aAAA,MAAA,EAAA,WAAA,MAAA,CAAA,GADF,QACE,CADO,IACP,EADa,EACb,CAAA,GAAF,EAAE"}

package/dist/intersection-with.js

@@ -1,2 +1,2 @@
-import{t as e}from"./utility-evaluators-BwYLtB8b.js";import{t}from"./curry-from-lazy-CYtJvyas.js";function n(...e){return t(r,e)}function r(t,n){return r=>t.some(e=>n(r,e))?{done:!1,hasNext:!0,next:r}:e}export{n as intersectionWith};
+import{t as e}from"./utility-evaluators-Boc-TMbq.js";import{t}from"./curry-from-lazy-PQ0BbG-7.js";function n(...e){return t(r,e)}function r(t,n){return r=>t.some(e=>n(r,e))?{done:!1,hasNext:!0,next:r}:e}export{n as intersectionWith};
 //# sourceMappingURL=intersection-with.js.map

package/dist/intersection.js

@@ -1,2 +1,2 @@
-import{n as e,t}from"./utility-evaluators-BwYLtB8b.js";import{t as n}from"./curry-from-lazy-CYtJvyas.js";function r(...e){return n(i,e)}function i(n){if(n.length===0)return e;let r=new Map;for(let e of n)r.set(e,(r.get(e)??0)+1);return e=>{let n=r.get(e);return n===void 0||n===0?t:(n===1?r.delete(e):r.set(e,n-1),{hasNext:!0,next:e,done:r.size===0})}}export{r as intersection};
+import{n as e,t}from"./utility-evaluators-Boc-TMbq.js";import{t as n}from"./curry-from-lazy-PQ0BbG-7.js";function r(...e){return n(i,e)}function i(n){if(n.length===0)return e;let r=new Map;for(let e of n)r.set(e,(r.get(e)??0)+1);return e=>{let n=r.get(e);return n===void 0||n===0?t:(n===1?r.delete(e):r.set(e,n-1),{hasNext:!0,next:e,done:r.size===0})}}export{r as intersection};
 //# sourceMappingURL=intersection.js.map

package/dist/invert.d.cts

@@ -1,4 +1,4 @@
-import { t as ToString } from "./to-string-Se4KcQka.cjs";
+import { t as ToString } from "./to-string-DkC3zRUJ.cjs";
 import { Simplify } from "type-fest";
 
 //#region src/invert.d.ts

package/dist/invert.d.ts

@@ -1,4 +1,4 @@
-import { t as ToString } from "./to-string-C6_OnZ6e.js";
+import { t as ToString } from "./to-string-YIFx2KS6.js";
 import { Simplify } from "type-fest";
 
 //#region src/invert.d.ts

package/dist/invert.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e){let t={};for(let[n,r]of Object.entries(e))t[r]=n;return t}export{t as invert};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e){let t={};for(let[n,r]of Object.entries(e))t[r]=n;return t}export{t as invert};
 //# sourceMappingURL=invert.js.map

package/dist/is-array.d.cts

@@ -1,4 +1,4 @@
-import { t as NarrowedTo } from "./narrowed-to-Yf5qTOcD.cjs";
+import { t as NarrowedTo } from "./narrowed-to-D_6H-aZW.cjs";
 
 //#region src/is-array.d.ts
 

package/dist/is-array.d.ts

@@ -1,4 +1,4 @@
-import { t as NarrowedTo } from "./narrowed-to-j75i8Rl2.js";
+import { t as NarrowedTo } from "./narrowed-to-B7tkuY2k.js";
 
 //#region src/is-array.d.ts
 

package/dist/is-big-int.d.cts

@@ -1,4 +1,4 @@
-import { t as NarrowedTo } from "./narrowed-to-Yf5qTOcD.cjs";
+import { t as NarrowedTo } from "./narrowed-to-D_6H-aZW.cjs";
 
 //#region src/is-big-int.d.ts
 

package/dist/is-big-int.d.ts

@@ -1,4 +1,4 @@
-import { t as NarrowedTo } from "./narrowed-to-j75i8Rl2.js";
+import { t as NarrowedTo } from "./narrowed-to-B7tkuY2k.js";
 
 //#region src/is-big-int.d.ts
 

package/dist/is-boolean.d.cts

@@ -1,4 +1,4 @@
-import { t as NarrowedTo } from "./narrowed-to-Yf5qTOcD.cjs";
+import { t as NarrowedTo } from "./narrowed-to-D_6H-aZW.cjs";
 
 //#region src/is-boolean.d.ts
 

package/dist/is-boolean.d.ts

@@ -1,4 +1,4 @@
-import { t as NarrowedTo } from "./narrowed-to-j75i8Rl2.js";
+import { t as NarrowedTo } from "./narrowed-to-B7tkuY2k.js";
 
 //#region src/is-boolean.d.ts
 

package/dist/{is-bounded-record-BGclJjRX.d.ts → is-bounded-record-Bx4n8QB0.d.ts}

@@ -31,4 +31,4 @@ type IsBoundedString<T> = T extends string ? IsStringLiteral<T> extends true ? S
 type IsBoundedRecord<T> = IsBounded<KeysOfUnion<T>>;
 //#endregion
 export { IsBounded as n, IsBoundedRecord as t };
-//# sourceMappingURL=is-bounded-record-BGclJjRX.d.ts.map
+//# sourceMappingURL=is-bounded-record-Bx4n8QB0.d.ts.map

package/dist/{is-bounded-record-BGclJjRX.d.ts.map → is-bounded-record-Bx4n8QB0.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"is-bounded-record-BGclJjRX.d.ts","names":[],"sources":["../src/internal/types/is-bounded.ts","../src/internal/types/is-bounded-record.ts"],"sourcesContent":[],"mappings":";;;;;;AAcA;;;;AAKmD,KALvC,SAKuC,CAAA,CAAA,CAAA,GAAA,CAD/C,CAC+C,SAAA,OAAA,GAA3C,EAA2C,CAAxC,eAAwC,CAAxB,CAAwB,CAAA,EAApB,EAAoB,CAAjB,gBAAiB,CAAA,CAAA,CAAA,EAAI,eAAJ,CAAoB,CAApB,CAAA,CAAA,CAAA,GAAA,KAAA,CAAA,SAAA,IAAA,GAAA,IAAA,GAAA,KAAA;;;;;;KAgB9C,eAhBK,CAAA,CAAA,CAAA,GAgBgB,CAhBhB,SAAA,MAAA,GAiBN,eAjBM,CAiBU,CAjBV,CAAA,SAAA,IAAA,GAmBJ,KAnBI,CAmBE,CAnBF,EAAA,EAAA,CAAA,CAAA,MAAA,CAAA,SAAA,KAAA,EAAA,GAAA,CAAA,GAAA,MAAA,EAAA,CAAA,SAAA,CAqBqB,CArBrB,CAAA,GAAA,KAAA,GAAA,CAAA,MAAA,CAAA,SAAA,CAuBoB,CAvBpB,CAAA,GAAA,KAAA,GAAA,IAAA,GAAA,KAAA,GAAA,KAAA,GAAA,KAAA;;;;AALV;;;;;;;;;;AAKU,KCLE,eDKF,CAAA,CAAA,CAAA,GCLuB,SDKvB,CCLiC,WDKjC,CCL6C,CDK7C,CAAA,CAAA"}
+{"version":3,"file":"is-bounded-record-Bx4n8QB0.d.ts","names":[],"sources":["../src/internal/types/is-bounded.ts","../src/internal/types/is-bounded-record.ts"],"sourcesContent":[],"mappings":";;;;;;AAcA;;;;AAKmD,KALvC,SAKuC,CAAA,CAAA,CAAA,GAAA,CAD/C,CAC+C,SAAA,OAAA,GAA3C,EAA2C,CAAxC,eAAwC,CAAxB,CAAwB,CAAA,EAApB,EAAoB,CAAjB,gBAAiB,CAAA,CAAA,CAAA,EAAI,eAAJ,CAAoB,CAApB,CAAA,CAAA,CAAA,GAAA,KAAA,CAAA,SAAA,IAAA,GAAA,IAAA,GAAA,KAAA;;;;;;KAgB9C,eAhBK,CAAA,CAAA,CAAA,GAgBgB,CAhBhB,SAAA,MAAA,GAiBN,eAjBM,CAiBU,CAjBV,CAAA,SAAA,IAAA,GAmBJ,KAnBI,CAmBE,CAnBF,EAAA,EAAA,CAAA,CAAA,MAAA,CAAA,SAAA,KAAA,EAAA,GAAA,CAAA,GAAA,MAAA,EAAA,CAAA,SAAA,CAqBqB,CArBrB,CAAA,GAAA,KAAA,GAAA,CAAA,MAAA,CAAA,SAAA,CAuBoB,CAvBpB,CAAA,GAAA,KAAA,GAAA,IAAA,GAAA,KAAA,GAAA,KAAA,GAAA,KAAA;;;;AALV;;;;;;;;;;AAKU,KCLE,eDKF,CAAA,CAAA,CAAA,GCLuB,SDKvB,CCLiC,WDKjC,CCL6C,CDK7C,CAAA,CAAA"}

package/dist/{is-bounded-record-D9YK_OC8.d.cts → is-bounded-record-DV6ZQk9H.d.cts}

@@ -31,4 +31,4 @@ type IsBoundedString<T> = T extends string ? IsStringLiteral<T> extends true ? S
 type IsBoundedRecord<T> = IsBounded<KeysOfUnion<T>>;
 //#endregion
 export { IsBounded as n, IsBoundedRecord as t };
-//# sourceMappingURL=is-bounded-record-D9YK_OC8.d.cts.map
+//# sourceMappingURL=is-bounded-record-DV6ZQk9H.d.cts.map

package/dist/{is-bounded-record-D9YK_OC8.d.cts.map → is-bounded-record-DV6ZQk9H.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"is-bounded-record-D9YK_OC8.d.cts","names":[],"sources":["../src/internal/types/is-bounded.ts","../src/internal/types/is-bounded-record.ts"],"sourcesContent":[],"mappings":";;;;;;AAcA;;;;AAKmD,KALvC,SAKuC,CAAA,CAAA,CAAA,GAAA,CAD/C,CAC+C,SAAA,OAAA,GAA3C,EAA2C,CAAxC,eAAwC,CAAxB,CAAwB,CAAA,EAApB,EAAoB,CAAjB,gBAAiB,CAAA,CAAA,CAAA,EAAI,eAAJ,CAAoB,CAApB,CAAA,CAAA,CAAA,GAAA,KAAA,CAAA,SAAA,IAAA,GAAA,IAAA,GAAA,KAAA;;;;;;KAgB9C,eAhBK,CAAA,CAAA,CAAA,GAgBgB,CAhBhB,SAAA,MAAA,GAiBN,eAjBM,CAiBU,CAjBV,CAAA,SAAA,IAAA,GAmBJ,KAnBI,CAmBE,CAnBF,EAAA,EAAA,CAAA,CAAA,MAAA,CAAA,SAAA,KAAA,EAAA,GAAA,CAAA,GAAA,MAAA,EAAA,CAAA,SAAA,CAqBqB,CArBrB,CAAA,GAAA,KAAA,GAAA,CAAA,MAAA,CAAA,SAAA,CAuBoB,CAvBpB,CAAA,GAAA,KAAA,GAAA,IAAA,GAAA,KAAA,GAAA,KAAA,GAAA,KAAA;;;;AALV;;;;;;;;;;AAKU,KCLE,eDKF,CAAA,CAAA,CAAA,GCLuB,SDKvB,CCLiC,WDKjC,CCL6C,CDK7C,CAAA,CAAA"}
+{"version":3,"file":"is-bounded-record-DV6ZQk9H.d.cts","names":[],"sources":["../src/internal/types/is-bounded.ts","../src/internal/types/is-bounded-record.ts"],"sourcesContent":[],"mappings":";;;;;;AAcA;;;;AAKmD,KALvC,SAKuC,CAAA,CAAA,CAAA,GAAA,CAD/C,CAC+C,SAAA,OAAA,GAA3C,EAA2C,CAAxC,eAAwC,CAAxB,CAAwB,CAAA,EAApB,EAAoB,CAAjB,gBAAiB,CAAA,CAAA,CAAA,EAAI,eAAJ,CAAoB,CAApB,CAAA,CAAA,CAAA,GAAA,KAAA,CAAA,SAAA,IAAA,GAAA,IAAA,GAAA,KAAA;;;;;;KAgB9C,eAhBK,CAAA,CAAA,CAAA,GAgBgB,CAhBhB,SAAA,MAAA,GAiBN,eAjBM,CAiBU,CAjBV,CAAA,SAAA,IAAA,GAmBJ,KAnBI,CAmBE,CAnBF,EAAA,EAAA,CAAA,CAAA,MAAA,CAAA,SAAA,KAAA,EAAA,GAAA,CAAA,GAAA,MAAA,EAAA,CAAA,SAAA,CAqBqB,CArBrB,CAAA,GAAA,KAAA,GAAA,CAAA,MAAA,CAAA,SAAA,CAuBoB,CAvBpB,CAAA,GAAA,KAAA,GAAA,IAAA,GAAA,KAAA,GAAA,KAAA,GAAA,KAAA;;;;AALV;;;;;;;;;;AAKU,KCLE,eDKF,CAAA,CAAA,CAAA,GCLuB,SDKvB,CCLiC,WDKjC,CCL6C,CDK7C,CAAA,CAAA"}

package/dist/is-deep-equal.js

@@ -1,2 +1,2 @@
-import{t as e}from"./curry-BcQ8Up1_.js";function t(...t){return e(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||typeof t!=`object`||e===null||t===null||Object.getPrototypeOf(e)!==Object.getPrototypeOf(t))return!1;if(Array.isArray(e))return r(e,t);if(e instanceof Map)return i(e,t);if(e instanceof Set)return a(e,t);if(e instanceof Date)return e.getTime()===t.getTime();if(e instanceof RegExp)return e.toString()===t.toString();if(Object.keys(e).length!==Object.keys(t).length)return!1;for(let[r,i]of Object.entries(e))if(!(r in t)||!n(i,t[r]))return!1;return!0}function r(e,t){if(e.length!==t.length)return!1;for(let[r,i]of e.entries())if(!n(i,t[r]))return!1;return!0}function i(e,t){if(e.size!==t.size)return!1;for(let[r,i]of e.entries())if(!t.has(r)||!n(i,t.get(r)))return!1;return!0}function a(e,t){if(e.size!==t.size)return!1;let r=[...t];for(let t of e){let e=!1;for(let[i,a]of r.entries())if(n(t,a)){e=!0,r.splice(i,1);break}if(!e)return!1}return!0}export{t as isDeepEqual};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||typeof t!=`object`||e===null||t===null||Object.getPrototypeOf(e)!==Object.getPrototypeOf(t))return!1;if(Array.isArray(e))return r(e,t);if(e instanceof Map)return i(e,t);if(e instanceof Set)return a(e,t);if(e instanceof Date)return e.getTime()===t.getTime();if(e instanceof RegExp)return e.toString()===t.toString();if(Object.keys(e).length!==Object.keys(t).length)return!1;for(let[r,i]of Object.entries(e))if(!(r in t)||!n(i,t[r]))return!1;return!0}function r(e,t){if(e.length!==t.length)return!1;for(let[r,i]of e.entries())if(!n(i,t[r]))return!1;return!0}function i(e,t){if(e.size!==t.size)return!1;for(let[r,i]of e.entries())if(!t.has(r)||!n(i,t.get(r)))return!1;return!0}function a(e,t){if(e.size!==t.size)return!1;let r=[...t];for(let t of e){let e=!1;for(let[i,a]of r.entries())if(n(t,a)){e=!0,r.splice(i,1);break}if(!e)return!1}return!0}export{t as isDeepEqual};
 //# sourceMappingURL=is-deep-equal.js.map

package/dist/is-empty.d.cts

@@ -1,4 +1,4 @@
-import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
 
 //#region src/is-empty.d.ts
 

package/dist/is-empty.d.ts

@@ -1,4 +1,4 @@
-import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
 
 //#region src/is-empty.d.ts
 

package/dist/{is-emptyish-CIxZzxxz.d.ts → is-emptyish-9tX94IVx.d.cts}

@@ -1,5 +1,4 @@
-import { t as TupleParts } from "./tuple-parts-Bhbm4jiu.js";
-import { t as NoInfer } from "./no-infer-BIHbaQcD.js";
+import { t as TupleParts } from "./tuple-parts-CzQQupgi.cjs";
 import { And, HasRequiredKeys, IsAny, IsEqual, IsNever, IsNumericLiteral, IsUnknown, OmitIndexSignature, Or, Tagged, ValueOf } from "type-fest";
 
 //#region src/internal/types/has-writable-keys.d.ts
@@ -71,4 +70,4 @@ declare function isEmptyish<T>(data: ShouldNotNarrow<T> extends true ? never : T
 declare function isEmptyish(data: unknown): boolean;
 //#endregion
 export { isEmptyish as t };
-//# sourceMappingURL=is-emptyish-CIxZzxxz.d.ts.map
+//# sourceMappingURL=is-emptyish-9tX94IVx.d.cts.map

package/dist/is-emptyish-9tX94IVx.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-emptyish-9tX94IVx.d.cts","names":[],"sources":["../src/internal/types/has-writable-keys.ts","../src/is-emptyish.ts"],"sourcesContent":[],"mappings":";;;;KAGY,qBAIR,QAAQ,SAAS,IAAI;;;cCUX;ADdd,KCqBK,KDrBO,CAAA,CAAA,CAAA,GCqBI,MDrBW,CCqBJ,CDrBI,EAAA,OCqBM,cDrBN,CAAA;KCyBtB,QDrBgB,CAAA,CAAA,CAAA,GAAA,CCuBd,CDvBc,SAAA,MAAA,GAAA,EAAA,GAAA,KAAA,CAAA,GAAA,CCwBd,CDxBc,SAAA,MAAA,GCwBK,kBDxBL,CCwBwB,CDxBxB,CAAA,GAAA,KAAA,CAAA,GAAA,CCyBd,CDzBc,SAAA,IAAA,GAAA,IAAA,GAAA,KAAA,CAAA,GAAA,CC0Bd,CD1Bc,SAAA,SAAA,GAAA,SAAA,GAAA,KAAA,CAAA;KC+BhB,kBD/BO,CAAA,UAAA,MAAA,CAAA,GCgCR,CDhCQ,SCgCE,aDhCF,CAAA,OAAA,CAAA,GCiCN,aDjCM,CCiCQ,CDjCR,CAAA,GCkCN,CDlCM,SCkCI,WDlCJ,CAAA,KAAA,IAAA,EAAA,OAAA,CAAA,GCmCJ,CDnCI,SCmCM,GDnCN,CAAA,OAAA,EAAA,OAAA,CAAA,GCqCF,KDrCE,CCqCI,CDrCJ,CAAA,GCuCF,WDvCE,CCuCU,GDvCV,EAAA,KAAA,CAAA,GCwCJ,CDxCI,SCwCM,WDxCN,CAAA,OAAA,CAAA,GCyCF,CDzCE,SCyCQ,GDzCR,CAAA,OAAA,CAAA,GC2CA,KD3CA,CC2CM,CD3CN,CAAA,GC6CA,WD7CA,CAAA,KAAA,CAAA,GC8CF,cD9CE,CC8Ca,CD9Cb,CAAA;KCgDP,aDhDoB,CAAA,UCgDI,aDhDJ,CAAA,OAAA,CAAA,CAAA,GCgD8B,CDhD9B,SAAA,SAAA,EAAA,GCkDrB,CDlDqB,GCmDrB,GDnDqB,CCoDrB,ODpDqB,CCoDb,UDpDa,CCoDF,CDpDE,CAAA,CAAA,UAAA,CAAA,EAAA,EAAA,CAAA,ECqDrB,ODrDqB,CCqDb,UDrDa,CCqDF,CDrDE,CAAA,CAAA,QAAA,CAAA,EAAA,EAAA,CAAA,CAAA,SAAA,IAAA,GCuDnB,CDvDmB,SCuDT,KDvDS,CAAA,OAAA,CAAA,GCyDjB,KDzDiB,CCyDX,CDzDW,CAAA,GAAA,SAAA,EAAA,GAAA,KAAA;KCgEpB,cDhED,CAAA,UAAA,MAAA,CAAA,GCgEoC,CDhEpC,SAAA;EAAO,MAAA,EAAA,KAAA,gBAAA,MAAA;ICmEP,2BAOE,kBAAkB,GAAG,UACvB;;IAGE,kBAAkB,GAAG,QACrB,QAAQ,QAAQ,mBAGd,IACA,gBAAgB,mBAAmB,2BAIjC,gBAAgB,kBAEd,MAAM,sBA/EJ,MAiFqB,CAjFQ,GAAA,KAAA,EAAA;KAsFtC,iBA/EkB,CAAA,CAAA,EAAA,CAAA,CAAA,GAgFnB,gBAhFmB,CAgFF,CAhFE,CAAA,SAAA,IAAA,GAAA,CAAA,CAAA,CAAA,SAAA,CAiFJ,CAjFI,CAAA,GAAA,CAkFZ,CAlFY,CAAA,SAAA,CAAA,CAAA,CAAA,GAqFT,CArFS,GAwFT,KAxFS,CAwFH,CAxFG,CAAA,GAAA,KAAA,GA8FjB,KA9FiB,CA8FX,CA9FW,CAAA;KAmGlB,eAnG4B,CAAA,CAAA,CAAA,GAmGP,EAnGO,CAoG/B,EApG+B,CAoG5B,KApG4B,CAoGtB,CApGsB,CAAA,EAoGlB,SApGkB,CAoGR,CApGQ,CAAA,CAAA,EAqG/B,OArG+B,CAsG7B,CAtG6B,EAAA,CAAA,CAAA,CAAA,CAAA;;;AAAX;;;;;;;;AASd;;;;;;;;;;;;;;;;;;;;;;;AAoBgB;;;;;;;;;;;;;;;;AAkBnB,iBA8GW,UA9GG,CAAA,CAAA,CAAA,CAAA,IAAA,EA+GX,eA/GW,CA+GK,CA/GL,CAAA,SAAA,IAAA,GAAA,KAAA,GAiHb,CAjHa,GAiHT,QAjHS,CAiHA,QAjHA,CAiHS,OAjHT,CAiHiB,CAjHjB,CAAA,CAAA,CAAA,CAAA,EAAA,IAAA,IAkHR,eAlHQ,CAkHQ,CAlHR,CAAA,SAAA,IAAA,GAAA,KAAA,GAoHf,CApHe,SAAA,OAAA,GAqHb,QArHa,CAqHJ,OArHI,CAqHI,CArHJ,CAAA,CAAA,GAAA,KAAA;AAAqB,iBAuHxB,UAAA,CAvHwB,IAAA,EAAA,OAAA,CAAA,EAAA,OAAA"}

package/dist/{is-emptyish-oX5mpcfW.d.cts → is-emptyish-DVFGJe-T.d.ts}

@@ -1,5 +1,4 @@
-import { t as TupleParts } from "./tuple-parts-BJQEORxn.cjs";
-import { t as NoInfer } from "./no-infer-BVbyldno.cjs";
+import { t as TupleParts } from "./tuple-parts-BYI4o8Vk.js";
 import { And, HasRequiredKeys, IsAny, IsEqual, IsNever, IsNumericLiteral, IsUnknown, OmitIndexSignature, Or, Tagged, ValueOf } from "type-fest";
 
 //#region src/internal/types/has-writable-keys.d.ts
@@ -71,4 +70,4 @@ declare function isEmptyish<T>(data: ShouldNotNarrow<T> extends true ? never : T
 declare function isEmptyish(data: unknown): boolean;
 //#endregion
 export { isEmptyish as t };
-//# sourceMappingURL=is-emptyish-oX5mpcfW.d.cts.map
+//# sourceMappingURL=is-emptyish-DVFGJe-T.d.ts.map