@vinicunca/perkakas 1.7.0 → 1.8.0

package/dist/group-by-prop-Gi66eXCp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-by-prop-Gi66eXCp.js","names":["output: BoundedPartial<\n    Record<AllPropValues<T, Prop>, Array<T[number]>>\n  >"],"sources":["../src/group-by-prop.ts"],"sourcesContent":["import type {\n  AllUnionFields,\n  ConditionalKeys,\n  EmptyObject,\n  IsNever,\n  Or,\n  Simplify,\n} from 'type-fest';\nimport type { ArrayRequiredPrefix } from './internal/types/array-required-prefix';\nimport type { BoundedPartial } from './internal/types/bounded-partial';\nimport type { FilteredArray } from './internal/types/filtered-array';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { TupleParts } from './internal/types/tuple-parts';\nimport { curry } from './curry';\n\ntype GroupByProp<T extends IterableContainer, Prop extends GroupableProps<T>>\n  // Distribute unions.\n  = T extends unknown\n    ? FixEmptyObject<EnsureValuesAreNonEmpty<GroupByPropRaw<T, Prop>>>\n    : never;\n\n// For each possible value of the prop we filter the input tuple with the prop\n// assigned to the value, e.g. `{ type: \"cat\" }`\ntype GroupByPropRaw<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n> = {\n  [Value in AllPropValues<T, Prop>]: FilteredArray<T, Record<Prop, Value>>;\n};\n\n// We can only group by props that only have values that could be used to key\n// an object (i.e. PropertyKey), or if they are undefined (which would filter\n// them out of the grouping).\ntype GroupableProps<T extends IterableContainer> = ConditionalKeys<\n  ItemsSuperObject<T>,\n  PropertyKey | undefined\n>;\n\n// The union of all possible values that the prop could have within the tuple.\ntype AllPropValues<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n> = Extract<ItemsSuperObject<T>[Prop], PropertyKey>;\n\n// Creates a singular object type that all items in the tuple would extend. This\n// provides us a way to check, for each prop, what are all values it would\n// have within the tuple. We use this to map which props are candidates for\n// grouping, and when a prop is selected, the full list of values that would\n// exist in the output. For example:\n// `{ a: number, b: \"cat\", c: string } | { b: \"dog\", c: Date }` is groupable\n// by 'a' and 'b', but not 'c', and when selecting by 'b', the output would\n// have a prop for \"cat\" and a prop for \"dog\".\ntype ItemsSuperObject<T extends IterableContainer> = AllUnionFields<\n  // If the input tuple contains optional elements they would add `undefined` to\n  // T[number] (and could technically show up in the array itself). Because\n  // undefined breaks AllUnionFields we need to remove it from the union. This\n  // is OK because we handle this in the implementation too.\n  Exclude<T[number], undefined>\n>;\n\n// When the input array is empty the constructed result type would be `{}`\n// because our mapped type would never run; but this doesn't represent the\n// semantics of the return value for that case, because it effectively means\n// \"any object\" and not \"empty object\". This can happen in 2 situations:\n// A union of tuples where one of the tuples doesn't have any item with the\n// groupable prop, or when the groupable prop has a value of `undefined` for\n// all items. The former is extra problematic because it would add `| {}` to the\n// result type which effectively cancels out all other parts of the union.\ntype FixEmptyObject<T> = IsNever<keyof T> extends true ? EmptyObject : T;\n\n// Group by can never return an empty tuple but our filtered arrays might not\n// represent that. We need to reshape the tuples so that they always have at\n// least one item in them.\ntype EnsureValuesAreNonEmpty<T extends Record<PropertyKey, IterableContainer>>\n  = Simplify<\n    Omit<T, PossiblyEmptyArrayKeys<T>>\n    & BoundedPartial<CoercedNonEmptyValues<Pick<T, PossiblyEmptyArrayKeys<T>>>>\n  >;\n\n// Go over the keys the object and return those that their value can accept an\n// empty array.\ntype PossiblyEmptyArrayKeys<T extends Record<PropertyKey, IterableContainer>>\n  = keyof T extends infer Key extends unknown\n    ? Key extends keyof T\n      ? IsNonEmptyArray<T[Key]> extends true\n        ? never\n        : Key\n      : never\n    : never;\n\n// An array is non-empty if any of the fixed parts are non-empty.\ntype IsNonEmptyArray<T extends IterableContainer> = Or<\n  IsNonEmptyFixedTuple<TupleParts<T>['required']>,\n  IsNonEmptyFixedTuple<TupleParts<T>['suffix']>\n>;\n\n// A fixed tuple (one without optional or a rest element in it) is non-empty if\n// we can't extract the empty tuple from it.\ntype IsNonEmptyFixedTuple<T> = IsNever<Extract<T, readonly []>>;\n\n// We coerce the arbitrary array values to have a prefix of at least one item.\ntype CoercedNonEmptyValues<T extends Record<PropertyKey, IterableContainer>> = {\n  [P in keyof T]: ArrayRequiredPrefix<T[P], 1>;\n};\n\n/**\n * Groups the elements of an array of objects based on the values of a\n * specified property of those objects. The result would contain a property for\n * each unique value of the specific property, with it's value being the input\n * array filtered to only items that have that property set to that value.\n * For any object where the property is missing, or if it's value is\n * `undefined` the item would be filtered out.\n *\n * The grouping property is enforced at the type level to exist in at least one\n * item and to never have a value that cannot be used as an object key (e.g. it\n * must be `PropertyKey | undefined`).\n *\n * The resulting arrays are filtered with the prop and it's value as a\n * type-guard, effectively narrowing the items in each output arrays. This\n * means that when the grouping property is the discriminator of a\n * discriminated union type each output array would contain just the subtype for\n * that value.\n *\n * If you need more control over the grouping you should use `groupBy` instead.\n *\n * @param data - The items to group.\n * @param prop - The property name to group by.\n * @signature\n *    P.groupByProp(data, prop)\n * @example\n *    const result = P.groupByProp(\n *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }\n *      [{ a: 'cat' }, { a: 'dog' }] as const,\n *      'a',\n *    );\n * @dataFirst\n * @category Array\n */\nexport function groupByProp<\n  T extends IterableContainer,\n  const Prop extends GroupableProps<T>,\n>(data: T, prop: Prop): GroupByProp<T, Prop>;\n\n/**\n * Groups the elements of an array of objects based on the values of a\n * specified property of those objects. The result would contain a property for\n * each unique value of the specific property, with it's value being the input\n * array filtered to only items that have that property set to that value.\n * For any object where the property is missing, or if it's value is\n * `undefined` the item would be filtered out.\n *\n * The grouping property is enforced at the type level to exist in at least one\n * item and to never have a value that cannot be used as an object key (e.g. it\n * must be `PropertyKey | undefined`).\n *\n * The resulting arrays are filtered with the prop and it's value as a\n * type-guard, effectively narrowing the items in each output arrays. This\n * means that when the grouping property is the discriminator of a\n * discriminated union type each output array would contain just the subtype for\n * that value.\n *\n * If you need more control over the grouping you should use `groupBy` instead.\n *\n * @param prop - The property name to group by.\n * @signature\n *    P.groupByProp(prop)(data);\n * @example\n *    const result = P.pipe(\n *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }\n *      [{ a: 'cat' }, { a: 'dog' }] as const,\n *      P.groupByProp('a'),\n *    );\n * @dataLast\n * @category Array\n */\nexport function groupByProp<\n  T extends IterableContainer,\n  const Prop extends GroupableProps<T>,\n>(prop: Prop): (data: T) => GroupByProp<T, Prop>;\n\nexport function groupByProp(...args: ReadonlyArray<unknown>): unknown {\n  return curry(groupByPropImplementation, args);\n}\n\nfunction groupByPropImplementation<\n  T extends IterableContainer,\n  Prop extends GroupableProps<T>,\n>(data: T, prop: Prop): GroupByProp<T, Prop> {\n  const output: BoundedPartial<\n    Record<AllPropValues<T, Prop>, Array<T[number]>>\n  > = Object.create(null);\n\n  for (const item of data) {\n    // @ts-expect-error [ts18046] -- `item` should be typed `T[number]` but TypeScript isn't inferring that correctly here, in fact, the item could also be typed as ItemsSuperObject<T> because it extends from it. When item is typed as such this error goes away, maybe in the future TypeScript would be able to infer this by itself.\n\n    const key = item?.[prop];\n    if (key !== undefined) {\n      // Once the prototype chain is fixed, it is safe to access the prop\n      // directly without needing to check existence or types.\n      // @ts-expect-error [ts7053] -- `key` should be typed `AllPropValues<T, Prop>` but TypeScript isn't inferring that correctly, causing an error when we try to access this prop on the output object.\n      const items = output[key];\n\n      if (items === undefined) {\n        // It is more performant to create a 1-element array over creating an\n        // empty array and falling through to a unified the push. It is also\n        // more performant to mutate the existing object over using spread to\n        // continually create new objects on every unique key.\n        // @ts-expect-error [ts7053] -- For the same reasons as mentioned above, TypeScript isn't inferring `key` correctly, and therefore is erroring when trying to access the output object using it.\n        output[key] = [item];\n      } else {\n        // It is more performant to add the items to an existing array instead\n        // of creating a new array via spreading every time we add an item to\n        // it (e.g., `[...current, item]`).\n        items.push(item);\n      }\n    }\n  }\n\n  // Set the prototype as if we initialized our object as a normal object (e.g.\n  // `{}`). Without this none of the built-in object methods like `toString`\n  // would work on this object and it would act differently than expected.\n  Object.setPrototypeOf(output, Object.prototype);\n\n  // @ts-expect-error [ts2322] -- This is fine! We use a broader type for output while we build it because it more accurately represents the shape of the object *while it is being built*. TypeScript can't tell that we finished building the object so can't ensure that output matches the expected output at this point.\n  return output;\n}\n"],"mappings":"4CAoLA,SAAgB,EAAY,GAAG,EAAuC,CACpE,OAAO,EAAM,EAA2B,EAAK,CAG/C,SAAS,EAGP,EAAS,EAAkC,CAC3C,IAAMA,EAEF,OAAO,OAAO,KAAK,CAEvB,IAAK,IAAM,KAAQ,EAAM,CAGvB,IAAM,EAAM,IAAO,GACnB,GAAI,IAAQ,IAAA,GAAW,CAIrB,IAAM,EAAQ,EAAO,GAEjB,IAAU,IAAA,GAMZ,EAAO,GAAO,CAAC,EAAK,CAKpB,EAAM,KAAK,EAAK,EAWtB,OAHA,OAAO,eAAe,EAAQ,OAAO,UAAU,CAGxC"}

package/dist/group-by-prop.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkHSNPZS6Rcjs = require('./chunk-HSNPZS6R.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.groupByProp = _chunkHSNPZS6Rcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./group-by-prop-ByeUoeXV.cjs`);exports.groupByProp=e.groupByProp;

package/dist/group-by-prop.d.cts

@@ -1,93 +1,11 @@
-import { ConditionalKeys, AllUnionFields, IfNever, Merge, And } from 'type-fest';
-import { A as ArrayRequiredPrefix } from './array-required-prefix-Ck4lHkbA.cjs';
-import { B as BoundedPartial } from './bounded-partial-BqwRN49U.cjs';
-import { F as FilteredArray } from './filtered-array-BCjySbC6.cjs';
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
-import { T as TupleParts } from './tuple-parts-v6av7LMU.cjs';
-import './clamped-integer-subtract-DZ7rsJE4.cjs';
-import './coerced-array-DRz3tqda.cjs';
-import './perkakas-type-error-8wPb8T2y.cjs';
-import './if-D4QIikQ1.cjs';
-import './is-bounded-record-C9WAwfA8.cjs';
-
-type GroupByProp<T extends IterableContainer, Prop extends GroupableProps<T>> = T extends unknown ? FixEmptyObject<EnsureValuesAreNonEmpty<{
-    [Value in AllPropValues<T, Prop>]: FilteredArray<T, Record<Prop, Value>>;
-}>> : never;
-type GroupableProps<T extends IterableContainer> = ConditionalKeys<ItemsSuperObject<T>, PropertyKey | undefined>;
-type AllPropValues<T extends IterableContainer, Prop extends GroupableProps<T>> = Extract<ItemsSuperObject<T>[Prop], PropertyKey>;
-type ItemsSuperObject<T extends IterableContainer> = AllUnionFields<Exclude<T[number], undefined>>;
-type FixEmptyObject<T> = IfNever<keyof T, Record<PropertyKey, never>, T>;
-type EnsureValuesAreNonEmpty<T extends Record<PropertyKey, IterableContainer>> = Merge<T, BoundedPartial<{
-    [P in keyof T as IsPossiblyEmpty<T[P]> extends true ? P : never]: ArrayRequiredPrefix<T[P], 1>;
-}>>;
-type IsPossiblyEmpty<T extends IterableContainer> = And<IsEmpty<TupleParts<T>['required']>, IsEmpty<TupleParts<T>['suffix']>>;
-type IsEmpty<T> = T extends readonly [] ? true : false;
-/**
- * Groups the elements of an array of objects based on the values of a
- * specified property of those objects. The result would contain a property for
- * each unique value of the specific property, with it's value being the input
- * array filtered to only items that have that property set to that value.
- * For any object where the property is missing, or if it's value is
- * `undefined` the item would be filtered out.
- *
- * The grouping property is enforced at the type level to exist in at least one
- * item and to never have a value that cannot be used as an object key (e.g. it
- * must be `PropertyKey | undefined`).
- *
- * The resulting arrays are filtered with the prop and it's value as a
- * type-guard, effectively narrowing the items in each output arrays. This
- * means that when the grouping property is the discriminator of a
- * discriminated union type each output array would contain just the subtype for
- * that value.
- *
- * If you need more control over the grouping you should use `groupBy` instead.
- *
- * @param data - The items to group.
- * @param prop - The property name to group by.
- * @signature
- *    P.groupByProp(data, prop)
- * @example
- *    const result = P.groupByProp(
- *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }
- *      [{ a: 'cat' }, { a: 'dog' }] as const,
- *      'a',
- *    );
- * @dataFirst
- * @category Array
- */
-declare function groupByProp<T extends IterableContainer, Prop extends GroupableProps<T>>(data: T, prop: Prop): GroupByProp<T, Prop>;
-/**
- * Groups the elements of an array of objects based on the values of a
- * specified property of those objects. The result would contain a property for
- * each unique value of the specific property, with it's value being the input
- * array filtered to only items that have that property set to that value.
- * For any object where the property is missing, or if it's value is
- * `undefined` the item would be filtered out.
- *
- * The grouping property is enforced at the type level to exist in at least one
- * item and to never have a value that cannot be used as an object key (e.g. it
- * must be `PropertyKey | undefined`).
- *
- * The resulting arrays are filtered with the prop and it's value as a
- * type-guard, effectively narrowing the items in each output arrays. This
- * means that when the grouping property is the discriminator of a
- * discriminated union type each output array would contain just the subtype for
- * that value.
- *
- * If you need more control over the grouping you should use `groupBy` instead.
- *
- * @param prop - The property name to group by.
- * @signature
- *    P.groupByProp(prop)(data);
- * @example
- *    const result = P.pipe(
- *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }
- *      [{ a: 'cat' }, { a: 'dog' }] as const,
- *      P.groupByProp('a'),
- *    );
- * @dataLast
- * @category Array
- */
-declare function groupByProp<T extends IterableContainer, Prop extends GroupableProps<T>>(prop: Prop): (data: T) => GroupByProp<T, Prop>;
-
-export { groupByProp };
+import "./iterable-container-V5sa0V_H.cjs";
+import "./perkakas-type-error-0tHtaPbi.cjs";
+import "./tuple-parts-BIyABPYv.cjs";
+import "./is-bounded-record-kpsb1wQA.cjs";
+import "./bounded-partial-A89bt7Kj.cjs";
+import "./clamped-integer-subtract-DId0tRjp.cjs";
+import "./coerced-array-kVJtBrMl.cjs";
+import "./filtered-array-DQcAXQDD.cjs";
+import "./array-required-prefix-FSH3Acx8.cjs";
+import { groupByProp } from "./group-by-prop-CcSzCSuu.cjs";
+export { groupByProp };

package/dist/group-by-prop.d.ts

@@ -1,93 +1,11 @@
-import { ConditionalKeys, AllUnionFields, IfNever, Merge, And } from 'type-fest';
-import { A as ArrayRequiredPrefix } from './array-required-prefix-DXv_WnmG.js';
-import { B as BoundedPartial } from './bounded-partial-BzynYDVs.js';
-import { F as FilteredArray } from './filtered-array-JKATL39M.js';
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
-import { T as TupleParts } from './tuple-parts-BTivqbtT.js';
-import './clamped-integer-subtract-DZ7rsJE4.js';
-import './coerced-array-DRz3tqda.js';
-import './perkakas-type-error-8wPb8T2y.js';
-import './if-D4QIikQ1.js';
-import './is-bounded-record-C9WAwfA8.js';
-
-type GroupByProp<T extends IterableContainer, Prop extends GroupableProps<T>> = T extends unknown ? FixEmptyObject<EnsureValuesAreNonEmpty<{
-    [Value in AllPropValues<T, Prop>]: FilteredArray<T, Record<Prop, Value>>;
-}>> : never;
-type GroupableProps<T extends IterableContainer> = ConditionalKeys<ItemsSuperObject<T>, PropertyKey | undefined>;
-type AllPropValues<T extends IterableContainer, Prop extends GroupableProps<T>> = Extract<ItemsSuperObject<T>[Prop], PropertyKey>;
-type ItemsSuperObject<T extends IterableContainer> = AllUnionFields<Exclude<T[number], undefined>>;
-type FixEmptyObject<T> = IfNever<keyof T, Record<PropertyKey, never>, T>;
-type EnsureValuesAreNonEmpty<T extends Record<PropertyKey, IterableContainer>> = Merge<T, BoundedPartial<{
-    [P in keyof T as IsPossiblyEmpty<T[P]> extends true ? P : never]: ArrayRequiredPrefix<T[P], 1>;
-}>>;
-type IsPossiblyEmpty<T extends IterableContainer> = And<IsEmpty<TupleParts<T>['required']>, IsEmpty<TupleParts<T>['suffix']>>;
-type IsEmpty<T> = T extends readonly [] ? true : false;
-/**
- * Groups the elements of an array of objects based on the values of a
- * specified property of those objects. The result would contain a property for
- * each unique value of the specific property, with it's value being the input
- * array filtered to only items that have that property set to that value.
- * For any object where the property is missing, or if it's value is
- * `undefined` the item would be filtered out.
- *
- * The grouping property is enforced at the type level to exist in at least one
- * item and to never have a value that cannot be used as an object key (e.g. it
- * must be `PropertyKey | undefined`).
- *
- * The resulting arrays are filtered with the prop and it's value as a
- * type-guard, effectively narrowing the items in each output arrays. This
- * means that when the grouping property is the discriminator of a
- * discriminated union type each output array would contain just the subtype for
- * that value.
- *
- * If you need more control over the grouping you should use `groupBy` instead.
- *
- * @param data - The items to group.
- * @param prop - The property name to group by.
- * @signature
- *    P.groupByProp(data, prop)
- * @example
- *    const result = P.groupByProp(
- *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }
- *      [{ a: 'cat' }, { a: 'dog' }] as const,
- *      'a',
- *    );
- * @dataFirst
- * @category Array
- */
-declare function groupByProp<T extends IterableContainer, Prop extends GroupableProps<T>>(data: T, prop: Prop): GroupByProp<T, Prop>;
-/**
- * Groups the elements of an array of objects based on the values of a
- * specified property of those objects. The result would contain a property for
- * each unique value of the specific property, with it's value being the input
- * array filtered to only items that have that property set to that value.
- * For any object where the property is missing, or if it's value is
- * `undefined` the item would be filtered out.
- *
- * The grouping property is enforced at the type level to exist in at least one
- * item and to never have a value that cannot be used as an object key (e.g. it
- * must be `PropertyKey | undefined`).
- *
- * The resulting arrays are filtered with the prop and it's value as a
- * type-guard, effectively narrowing the items in each output arrays. This
- * means that when the grouping property is the discriminator of a
- * discriminated union type each output array would contain just the subtype for
- * that value.
- *
- * If you need more control over the grouping you should use `groupBy` instead.
- *
- * @param prop - The property name to group by.
- * @signature
- *    P.groupByProp(prop)(data);
- * @example
- *    const result = P.pipe(
- *      //  ^? { cat: [{ a: 'cat' }], dog: [{ a: 'dog' }] }
- *      [{ a: 'cat' }, { a: 'dog' }] as const,
- *      P.groupByProp('a'),
- *    );
- * @dataLast
- * @category Array
- */
-declare function groupByProp<T extends IterableContainer, Prop extends GroupableProps<T>>(prop: Prop): (data: T) => GroupByProp<T, Prop>;
-
-export { groupByProp };
+import "./iterable-container-wtkYslN_.js";
+import "./perkakas-type-error-Da3ni385.js";
+import "./tuple-parts-BxpZLJ7r.js";
+import "./is-bounded-record-DCEYRY41.js";
+import "./bounded-partial-TshEjJC1.js";
+import "./clamped-integer-subtract-CQL8aT__.js";
+import "./coerced-array-DyA0Yc12.js";
+import "./filtered-array-BGEkFwrv.js";
+import "./array-required-prefix-BeSNHH4G.js";
+import { groupByProp } from "./group-by-prop--MehVKql.js";
+export { groupByProp };

package/dist/group-by-prop.js

@@ -1 +1 @@
-import{a}from"./chunk-6M4IYQFZ.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as groupByProp};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{groupByProp as e}from"./group-by-prop-Gi66eXCp.js";export{e as groupByProp};

package/dist/group-by-schxH1QR.d.ts

@@ -0,0 +1,69 @@
+import { NonEmptyArray } from "./non-empty-array-D3HWDPMt.js";
+import { BoundedPartial } from "./bounded-partial-TshEjJC1.js";
+
+//#region src/group-by.d.ts
+
+/**
+ * Groups the elements of a given iterable according to the string values
+ * returned by a provided callback function. The returned object has separate
+ * properties for each group, containing arrays with the elements in the group.
+ * Unlike the built in `Object.groupBy` this function also allows the callback to
+ * return `undefined` in order to exclude the item from being added to any
+ * group.
+ *
+ * If you are grouping objects by a property of theirs (e.g.
+ * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)
+ * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,
+ * as it would provide better typing.
+ *
+ * @param data - The items to group.
+ * @param callbackfn - A function to execute for each element in the iterable.
+ * It should return a value indicating the group of the current element, or
+ * `undefined` when the item should be excluded from any group.
+ * @returns An object with properties for all groups, each assigned to an array
+ * containing the elements of the associated group.
+ * @signature
+ *    P.groupBy(data, callbackfn)
+ * @example
+ *    P.groupBy([{a: 'cat'}, {a: 'dog'}] as const, P.prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
+ *    P.groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}
+ * @dataFirst
+ * @category Array
+ */
+declare function groupBy<T, Key extends PropertyKey = PropertyKey>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): BoundedPartial<Record<Key, NonEmptyArray<T>>>;
+/**
+ * Groups the elements of a given iterable according to the string values
+ * returned by a provided callback function. The returned object has separate
+ * properties for each group, containing arrays with the elements in the group.
+ * Unlike the built in `Object.groupBy` this function also allows the callback to
+ * return `undefined` in order to exclude the item from being added to any
+ * group.
+ *
+ *  If you are grouping objects by a property of theirs (e.g.
+ * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)
+ * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,
+ * as it would provide better typing.
+ *
+ * @param callbackfn - A function to execute for each element in the iterable.
+ * It should return a value indicating the group of the current element, or
+ * `undefined` when the item should be excluded from any group.
+ * @returns An object with properties for all groups, each assigned to an array
+ * containing the elements of the associated group.
+ * @signature
+ *    P.groupBy(callbackfn)(data);
+ * @example
+ *    P.pipe(
+ *      [{a: 'cat'}, {a: 'dog'}] as const,
+ *      P.groupBy(P.prop('a')),
+ *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
+ *    P.pipe(
+ *      [0, 1],
+ *      P.groupBy(x => x % 2 === 0 ? 'even' : undefined),
+ *    ); // => {even: [0]}
+ * @dataLast
+ * @category Array
+ */
+declare function groupBy<T, Key extends PropertyKey = PropertyKey>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): (items: ReadonlyArray<T>) => BoundedPartial<Record<Key, NonEmptyArray<T>>>;
+//#endregion
+export { groupBy };
+//# sourceMappingURL=group-by-schxH1QR.d.ts.map

package/dist/group-by-schxH1QR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group-by-schxH1QR.d.ts","names":[],"sources":["../src/group-by.ts"],"sourcesContent":[],"mappings":";;;;;;;AAgCA;;;;;;;;;;;;;;;;AAyCA;;;;;;;;;AAMW,iBA/CK,OA+CL,CAAA,CAAA,EAAA,YA/C4B,WA+C5B,GA/C0C,WA+C1C,CAAA,CAAA,IAAA,EA9CH,aA8CG,CA9CW,CA8CX,CAAA,EAAA,UAAA,EAAA,CAAA,KAAA,EA5CA,CA4CA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EA1CD,aA0CC,CA1Ca,CA0Cb,CAAA,EAAA,GAzCJ,GAyCI,GAAA,SAAA,CAAA,EAxCR,cAwCQ,CAxCO,MAwCP,CAxCc,GAwCd,EAxCmB,aAwCnB,CAxCiC,CAwCjC,CAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBANK,uBAAuB,cAAc,iCAE1C,wBAED,cAAc,OACjB,0BACI,cAAc,OAAO,eAAe,OAAO,KAAK,cAAc"}

package/dist/group-by.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkGW4KDK3Dcjs = require('./chunk-GW4KDK3D.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.groupBy = _chunkGW4KDK3Dcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./group-by-057Glgkg.cjs`);exports.groupBy=e.groupBy;

package/dist/group-by.d.cts

@@ -1,69 +1,5 @@
-import { B as BoundedPartial } from './bounded-partial-BqwRN49U.cjs';
-import { N as NonEmptyArray } from './non-empty-array-C9Od1wmF.cjs';
-import './if-D4QIikQ1.cjs';
-import 'type-fest';
-import './is-bounded-record-C9WAwfA8.cjs';
-
-/**
- * Groups the elements of a given iterable according to the string values
- * returned by a provided callback function. The returned object has separate
- * properties for each group, containing arrays with the elements in the group.
- * Unlike the built in `Object.groupBy` this function also allows the callback to
- * return `undefined` in order to exclude the item from being added to any
- * group.
- *
- * If you are grouping objects by a property of theirs (e.g.
- * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)
- * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,
- * as it would provide better typing.
- *
- * @param data - The items to group.
- * @param callbackfn - A function to execute for each element in the iterable.
- * It should return a value indicating the group of the current element, or
- * `undefined` when the item should be excluded from any group.
- * @returns An object with properties for all groups, each assigned to an array
- * containing the elements of the associated group.
- * @signature
- *    P.groupBy(data, callbackfn)
- * @example
- *    P.groupBy([{a: 'cat'}, {a: 'dog'}] as const, P.prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
- *    P.groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}
- * @dataFirst
- * @category Array
- */
-declare function groupBy<T, Key extends PropertyKey = PropertyKey>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): BoundedPartial<Record<Key, NonEmptyArray<T>>>;
-/**
- * Groups the elements of a given iterable according to the string values
- * returned by a provided callback function. The returned object has separate
- * properties for each group, containing arrays with the elements in the group.
- * Unlike the built in `Object.groupBy` this function also allows the callback to
- * return `undefined` in order to exclude the item from being added to any
- * group.
- *
- *  If you are grouping objects by a property of theirs (e.g.
- * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)
- * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,
- * as it would provide better typing.
- *
- * @param callbackfn - A function to execute for each element in the iterable.
- * It should return a value indicating the group of the current element, or
- * `undefined` when the item should be excluded from any group.
- * @returns An object with properties for all groups, each assigned to an array
- * containing the elements of the associated group.
- * @signature
- *    P.groupBy(callbackfn)(data);
- * @example
- *    P.pipe(
- *      [{a: 'cat'}, {a: 'dog'}] as const,
- *      P.groupBy(P.prop('a')),
- *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
- *    P.pipe(
- *      [0, 1],
- *      P.groupBy(x => x % 2 === 0 ? 'even' : undefined),
- *    ); // => {even: [0]}
- * @dataLast
- * @category Array
- */
-declare function groupBy<T, Key extends PropertyKey = PropertyKey>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): (items: ReadonlyArray<T>) => BoundedPartial<Record<Key, NonEmptyArray<T>>>;
-
-export { groupBy };
+import "./non-empty-array-D3ZRHApS.cjs";
+import "./is-bounded-record-kpsb1wQA.cjs";
+import "./bounded-partial-A89bt7Kj.cjs";
+import { groupBy } from "./group-by-DDS1NPHf.cjs";
+export { groupBy };

package/dist/group-by.d.ts

@@ -1,69 +1,5 @@
-import { B as BoundedPartial } from './bounded-partial-BzynYDVs.js';
-import { N as NonEmptyArray } from './non-empty-array-C9Od1wmF.js';
-import './if-D4QIikQ1.js';
-import 'type-fest';
-import './is-bounded-record-C9WAwfA8.js';
-
-/**
- * Groups the elements of a given iterable according to the string values
- * returned by a provided callback function. The returned object has separate
- * properties for each group, containing arrays with the elements in the group.
- * Unlike the built in `Object.groupBy` this function also allows the callback to
- * return `undefined` in order to exclude the item from being added to any
- * group.
- *
- * If you are grouping objects by a property of theirs (e.g.
- * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)
- * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,
- * as it would provide better typing.
- *
- * @param data - The items to group.
- * @param callbackfn - A function to execute for each element in the iterable.
- * It should return a value indicating the group of the current element, or
- * `undefined` when the item should be excluded from any group.
- * @returns An object with properties for all groups, each assigned to an array
- * containing the elements of the associated group.
- * @signature
- *    P.groupBy(data, callbackfn)
- * @example
- *    P.groupBy([{a: 'cat'}, {a: 'dog'}] as const, P.prop('a')) // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
- *    P.groupBy([0, 1], x => x % 2 === 0 ? 'even' : undefined) // => {even: [0]}
- * @dataFirst
- * @category Array
- */
-declare function groupBy<T, Key extends PropertyKey = PropertyKey>(data: ReadonlyArray<T>, callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): BoundedPartial<Record<Key, NonEmptyArray<T>>>;
-/**
- * Groups the elements of a given iterable according to the string values
- * returned by a provided callback function. The returned object has separate
- * properties for each group, containing arrays with the elements in the group.
- * Unlike the built in `Object.groupBy` this function also allows the callback to
- * return `undefined` in order to exclude the item from being added to any
- * group.
- *
- *  If you are grouping objects by a property of theirs (e.g.
- * `groupBy(data, ({ myProp }) => myProp)` or `groupBy(data, prop('myProp'))`)
- * consider using `groupByProp` (e.g. `groupByProp(data, 'myProp')`) instead,
- * as it would provide better typing.
- *
- * @param callbackfn - A function to execute for each element in the iterable.
- * It should return a value indicating the group of the current element, or
- * `undefined` when the item should be excluded from any group.
- * @returns An object with properties for all groups, each assigned to an array
- * containing the elements of the associated group.
- * @signature
- *    P.groupBy(callbackfn)(data);
- * @example
- *    P.pipe(
- *      [{a: 'cat'}, {a: 'dog'}] as const,
- *      P.groupBy(P.prop('a')),
- *    ); // => {cat: [{a: 'cat'}], dog: [{a: 'dog'}]}
- *    P.pipe(
- *      [0, 1],
- *      P.groupBy(x => x % 2 === 0 ? 'even' : undefined),
- *    ); // => {even: [0]}
- * @dataLast
- * @category Array
- */
-declare function groupBy<T, Key extends PropertyKey = PropertyKey>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): (items: ReadonlyArray<T>) => BoundedPartial<Record<Key, NonEmptyArray<T>>>;
-
-export { groupBy };
+import "./non-empty-array-D3HWDPMt.js";
+import "./is-bounded-record-DCEYRY41.js";
+import "./bounded-partial-TshEjJC1.js";
+import { groupBy } from "./group-by-schxH1QR.js";
+export { groupBy };

package/dist/group-by.js

@@ -1 +1 @@
-import{a}from"./chunk-44LUF6RO.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as groupBy};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{groupBy as e}from"./group-by-8exEDbij.js";export{e as groupBy};

package/dist/has-at-least-6iRvhsST.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){return e.length>=t}export{t as hasAtLeast};
+//# sourceMappingURL=has-at-least-6iRvhsST.js.map

package/dist/has-at-least-6iRvhsST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-at-least-6iRvhsST.js","names":[],"sources":["../src/has-at-least.ts"],"sourcesContent":["import type { IsNumericLiteral } from 'type-fest';\nimport type { ArrayRequiredPrefix } from './internal/types/array-required-prefix';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Checks if the given array has at least the defined number of elements. When\n * the minimum used is a literal (e.g. `3`) the output is refined accordingly so\n * that those indices are defined when accessing the array even when using\n * typescript's 'noUncheckedIndexAccess'.\n *\n * @param data - The input array.\n * @param minimum - The minimum number of elements the array must have.\n * @returns True if the array's length is *at least* `minimum`. When `minimum`\n * is a literal value, the output is narrowed to ensure the first items are\n * guaranteed.\n * @signature\n *   P.hasAtLeast(data, minimum)\n * @example\n *   P.hasAtLeast([], 4); // => false\n *\n *   const data: number[] = [1,2,3,4];\n *   P.hasAtLeast(data, 1); // => true\n *   data[0]; // 1, with type `number`\n * @dataFirst\n * @category Array\n */\nexport function hasAtLeast<T extends IterableContainer, N extends number>(\n  data: IterableContainer | T,\n  minimum: IsNumericLiteral<N> extends true ? N : never,\n): data is ArrayRequiredPrefix<T, N>;\nexport function hasAtLeast(data: IterableContainer, minimum: number): boolean;\n\n/**\n * Checks if the given array has at least the defined number of elements. When\n * the minimum used is a literal (e.g. `3`) the output is refined accordingly so\n * that those indices are defined when accessing the array even when using\n * typescript's 'noUncheckedIndexAccess'.\n *\n * @param minimum - The minimum number of elements the array must have.\n * @returns True if the array's length is *at least* `minimum`. When `minimum`\n * is a literal value, the output is narrowed to ensure the first items are\n * guaranteed.\n * @signature\n *   P.hasAtLeast(minimum)(data)\n * @example\n *   P.pipe([], P.hasAtLeast(4)); // => false\n *\n *   const data = [[1,2], [3], [4,5]];\n *   P.pipe(\n *     data,\n *     P.filter(P.hasAtLeast(2)),\n *     P.map(([, second]) => second),\n *   ); // => [2,5], with type `number[]`\n * @dataLast\n * @category Array\n */\nexport function hasAtLeast<N extends number>(\n  minimum: IsNumericLiteral<N> extends true ? N : never,\n): <T extends IterableContainer>(\n  data: IterableContainer | T,\n) => data is ArrayRequiredPrefix<T, N>;\nexport function hasAtLeast(\n  minimum: number,\n): (data: IterableContainer) => boolean;\n\nexport function hasAtLeast(...args: ReadonlyArray<unknown>): unknown {\n  return curry(hasAtLeastImplementation, args);\n}\n\nfunction hasAtLeastImplementation(\n  data: IterableContainer,\n  minimum: number,\n): boolean {\n  return data.length >= minimum;\n}\n"],"mappings":"4CAkEA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAM,EAA0B,EAAK,CAG9C,SAAS,EACP,EACA,EACS,CACT,OAAO,EAAK,QAAU"}

package/dist/has-at-least-BbYfXc8L.d.cts

@@ -0,0 +1,59 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+import { ArrayRequiredPrefix } from "./array-required-prefix-FSH3Acx8.cjs";
+import { IsNumericLiteral } from "type-fest";
+
+//#region src/has-at-least.d.ts
+
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param data - The input array.
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   P.hasAtLeast(data, minimum)
+ * @example
+ *   P.hasAtLeast([], 4); // => false
+ *
+ *   const data: number[] = [1,2,3,4];
+ *   P.hasAtLeast(data, 1); // => true
+ *   data[0]; // 1, with type `number`
+ * @dataFirst
+ * @category Array
+ */
+declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArrayRequiredPrefix<T, N>;
+declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   P.hasAtLeast(minimum)(data)
+ * @example
+ *   P.pipe([], P.hasAtLeast(4)); // => false
+ *
+ *   const data = [[1,2], [3], [4,5]];
+ *   P.pipe(
+ *     data,
+ *     P.filter(P.hasAtLeast(2)),
+ *     P.map(([, second]) => second),
+ *   ); // => [2,5], with type `number[]`
+ * @dataLast
+ * @category Array
+ */
+declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArrayRequiredPrefix<T, N>;
+declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
+//#endregion
+export { hasAtLeast };
+//# sourceMappingURL=has-at-least-BbYfXc8L.d.cts.map

package/dist/has-at-least-BbYfXc8L.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-at-least-BbYfXc8L.d.cts","names":[],"sources":["../src/has-at-least.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA2BA;;;;;;;;;;;;AAIA;AA0BA;;;;;;;AAG4B,iBAjCZ,UAiCY,CAAA,UAjCS,iBAiCT,EAAA,UAAA,MAAA,CAAA,CAAA,IAAA,EAhCpB,iBAgCoB,GAhCA,CAgCA,EAAA,OAAA,EA/BjB,gBA+BiB,CA/BA,CA+BA,CAAA,SAAA,IAAA,GA/BkB,CA+BlB,GAAA,KAAA,CAAA,EAAA,IAAA,IA9BjB,mBA8BiB,CA9BG,CA8BH,EA9BM,CA8BN,CAAA;AACK,iBA9BjB,UAAA,CA8BiB,IAAA,EA9BA,iBA8BA,EAAA,OAAA,EAAA,MAAA,CAAA,EAAA,OAAA;;;;AACjC;;;;;;;;;;;;;;;;;;;;;iBALgB,sCACL,iBAAiB,kBAAkB,uBAChC,yBACN,oBAAoB,cACf,oBAAoB,GAAG;iBACpB,UAAA,0BAEN"}

package/dist/has-at-least-D-ahiJB6.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){return e.length>=t}Object.defineProperty(exports,`hasAtLeast`,{enumerable:!0,get:function(){return t}});

package/dist/has-at-least-D1A8i5J3.d.ts

@@ -0,0 +1,59 @@
+import { IterableContainer } from "./iterable-container-wtkYslN_.js";
+import { ArrayRequiredPrefix } from "./array-required-prefix-BeSNHH4G.js";
+import { IsNumericLiteral } from "type-fest";
+
+//#region src/has-at-least.d.ts
+
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param data - The input array.
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   P.hasAtLeast(data, minimum)
+ * @example
+ *   P.hasAtLeast([], 4); // => false
+ *
+ *   const data: number[] = [1,2,3,4];
+ *   P.hasAtLeast(data, 1); // => true
+ *   data[0]; // 1, with type `number`
+ * @dataFirst
+ * @category Array
+ */
+declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArrayRequiredPrefix<T, N>;
+declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
+/**
+ * Checks if the given array has at least the defined number of elements. When
+ * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
+ * that those indices are defined when accessing the array even when using
+ * typescript's 'noUncheckedIndexAccess'.
+ *
+ * @param minimum - The minimum number of elements the array must have.
+ * @returns True if the array's length is *at least* `minimum`. When `minimum`
+ * is a literal value, the output is narrowed to ensure the first items are
+ * guaranteed.
+ * @signature
+ *   P.hasAtLeast(minimum)(data)
+ * @example
+ *   P.pipe([], P.hasAtLeast(4)); // => false
+ *
+ *   const data = [[1,2], [3], [4,5]];
+ *   P.pipe(
+ *     data,
+ *     P.filter(P.hasAtLeast(2)),
+ *     P.map(([, second]) => second),
+ *   ); // => [2,5], with type `number[]`
+ * @dataLast
+ * @category Array
+ */
+declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArrayRequiredPrefix<T, N>;
+declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
+//#endregion
+export { hasAtLeast };
+//# sourceMappingURL=has-at-least-D1A8i5J3.d.ts.map

package/dist/has-at-least-D1A8i5J3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-at-least-D1A8i5J3.d.ts","names":[],"sources":["../src/has-at-least.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA2BA;;;;;;;;;;;;AAIA;AA0BA;;;;;;;AAG4B,iBAjCZ,UAiCY,CAAA,UAjCS,iBAiCT,EAAA,UAAA,MAAA,CAAA,CAAA,IAAA,EAhCpB,iBAgCoB,GAhCA,CAgCA,EAAA,OAAA,EA/BjB,gBA+BiB,CA/BA,CA+BA,CAAA,SAAA,IAAA,GA/BkB,CA+BlB,GAAA,KAAA,CAAA,EAAA,IAAA,IA9BjB,mBA8BiB,CA9BG,CA8BH,EA9BM,CA8BN,CAAA;AACK,iBA9BjB,UAAA,CA8BiB,IAAA,EA9BA,iBA8BA,EAAA,OAAA,EAAA,MAAA,CAAA,EAAA,OAAA;;;;AACjC;;;;;;;;;;;;;;;;;;;;;iBALgB,sCACL,iBAAiB,kBAAkB,uBAChC,yBACN,oBAAoB,cACf,oBAAoB,GAAG;iBACpB,UAAA,0BAEN"}

package/dist/has-at-least.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk66JP4PUGcjs = require('./chunk-66JP4PUG.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.hasAtLeast = _chunk66JP4PUGcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./has-at-least-D-ahiJB6.cjs`);exports.hasAtLeast=e.hasAtLeast;