@depup/remeda 2.33.6-depup.0

package/dist/objOf.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"objOf.cjs","names":["purry"],"sources":["../src/objOf.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Creates an object containing a single `key:value` pair.\n *\n * @param value - The object value.\n * @param key - The property name.\n * @signature\n *    objOf(value, key)\n * @example\n *    objOf(10, 'a') // => { a: 10 }\n * @category Object\n */\nexport function objOf<T, K extends string>(value: T, key: K): Record<K, T>;\n\n/**\n * Creates an object containing a single `key:value` pair.\n *\n * @param key - The property name.\n * @signature\n *    objOf(key)(value)\n * @example\n *    pipe(10, objOf('a')) // => { a: 10 }\n * @category Object\n */\nexport function objOf<T, K extends string>(key: K): (value: T) => Record<K, T>;\n\nexport function objOf(...args: readonly unknown[]): unknown {\n  return purry(objOfImplementation, args);\n}\n\nconst objOfImplementation = <T, K extends string>(\n  value: T,\n  key: K,\n): Record<K, T> =>\n  // @ts-expect-error [ts2322] - I'm not sure how to get the type right here...\n  ({ [key]: value });\n"],"mappings":"kGA2BA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAOA,EAAAA,MAAM,EAAqB,EAAK,CAGzC,MAAM,GACJ,EACA,KAGC,EAAG,GAAM,EAAO"}

package/dist/objOf.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}const n=(e,t)=>({[t]:e});export{t as objOf};
+//# sourceMappingURL=objOf.js.map

package/dist/objOf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"objOf.js","names":[],"sources":["../src/objOf.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Creates an object containing a single `key:value` pair.\n *\n * @param value - The object value.\n * @param key - The property name.\n * @signature\n *    objOf(value, key)\n * @example\n *    objOf(10, 'a') // => { a: 10 }\n * @category Object\n */\nexport function objOf<T, K extends string>(value: T, key: K): Record<K, T>;\n\n/**\n * Creates an object containing a single `key:value` pair.\n *\n * @param key - The property name.\n * @signature\n *    objOf(key)(value)\n * @example\n *    pipe(10, objOf('a')) // => { a: 10 }\n * @category Object\n */\nexport function objOf<T, K extends string>(key: K): (value: T) => Record<K, T>;\n\nexport function objOf(...args: readonly unknown[]): unknown {\n  return purry(objOfImplementation, args);\n}\n\nconst objOfImplementation = <T, K extends string>(\n  value: T,\n  key: K,\n): Record<K, T> =>\n  // @ts-expect-error [ts2322] - I'm not sure how to get the type right here...\n  ({ [key]: value });\n"],"mappings":"mCA2BA,SAAgB,EAAM,GAAG,EAAmC,CAC1D,OAAO,EAAM,EAAqB,EAAK,CAGzC,MAAM,GACJ,EACA,KAGC,EAAG,GAAM,EAAO"}

package/dist/omit.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`),t=require(`./hasAtLeast.cjs`);function n(...t){return e.purry(r,t)}function r(e,n){if(!t.hasAtLeast(n,1))return{...e};if(!t.hasAtLeast(n,2)){let{[n[0]]:t,...r}=e;return r}let r={...e};for(let e of n)delete r[e];return r}exports.omit=n;
+//# sourceMappingURL=omit.cjs.map

package/dist/omit.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit.cjs","names":["purry","hasAtLeast"],"sources":["../src/omit.ts"],"sourcesContent":["import type { EmptyObject, IsNever, KeysOfUnion } from \"type-fest\";\nimport { hasAtLeast } from \"./hasAtLeast\";\nimport type { IsBounded } from \"./internal/types/IsBounded\";\nimport type { IsBoundedRecord } from \"./internal/types/IsBoundedRecord\";\nimport type { PartitionByUnion } from \"./internal/types/PartitionByUnion\";\nimport type { SimplifiedWritable } from \"./internal/types/SimplifiedWritable\";\nimport type { TupleParts } from \"./internal/types/TupleParts\";\nimport { purry } from \"./purry\";\n\ntype OmitFromArray<T, Keys extends readonly PropertyKey[]> =\n  // Distribute unions for both object types and key arrays.\n  T extends unknown\n    ? Keys extends unknown\n      ? // The output is always writable because we always create a new object!\n        SimplifiedWritable<\n          IsNever<Extract<Keys[number], keyof T>> extends true\n            ? // When none of the keys belong to T we can short-circuit and\n              // simply return T as-is because `omit` would do nothing.\n              T\n            : IsBoundedRecord<T> extends true\n              ? OmitBounded<T, Keys>\n              : OmitUnbounded<T, Keys>\n        >\n      : never\n    : never;\n\ntype OmitBounded<T, Keys extends readonly PropertyKey[]> =\n  // We build our output by first considering any key present in the keys array\n  // as being omitted. This object would contain all keys that are unaffected at\n  // all by this omit operation.\n  FixEmpty<Omit<T, Keys[number]>> &\n    // But we might be missing keys that are optional in the keys tuple (and\n    // thus might not be removed). Because these keys are optional, their props\n    // in the output also need to be optional.\n    Partial<\n      Pick<\n        T,\n        Exclude<\n          // Find all keys that can either be omitted or not, these are all keys\n          // in unions in the required parts of the keys tuple (the prefix and\n          // the suffix), as well as all keys in the optional parts and the rest\n          // item.\n          | PartitionByUnion<TupleParts<Keys>[\"required\"]>[\"union\"]\n          | TupleParts<Keys>[\"optional\"][number]\n          | TupleParts<Keys>[\"item\"]\n          | PartitionByUnion<TupleParts<Keys>[\"suffix\"]>[\"union\"],\n          // We then need to remove from these any items which *also* are\n          // ensured to always exist in the keys tuple, these are the elements\n          // of the required parts of the tuple which are singular (not unions).\n          | PartitionByUnion<TupleParts<Keys>[\"required\"]>[\"singular\"]\n          | PartitionByUnion<TupleParts<Keys>[\"suffix\"]>[\"singular\"]\n        >\n      >\n    >;\n\n/**\n * The built-in `Omit` type doesn't handle unbounded records correctly! When\n * omitting an unbounded key the result should be untouched as we can't tell\n * what got removed, and can't represent an object that had \"something\" removed\n * from it, but instead it returns `{}`(?!) The same thing applies when a key\n * is only optionally omitted for the same reasons. This is why we don't use\n * `Omit` at all for the unbounded case.\n *\n * @see https://www.typescriptlang.org/play/?#code/C4TwDgpgBAqgdgIwPYFc4BMLqgXigeQFsBLYAHgCUIBjJAJ3TIGdg7i4BzAGigCIALCABshSXgD4eLNp3EBuAFAB6JVDUA9APxA\n */\ntype OmitUnbounded<T, Keys extends readonly PropertyKey[]> = T &\n  // Any key we know for sure is being omitted needs to become \"impossible\" to\n  // access; for an unbounded record this means merging it with a bounded record\n  // with `never` value for these keys.\n  Record<\n    Bounded<\n      | PartitionByUnion<TupleParts<Keys>[\"required\"]>[\"singular\"]\n      | PartitionByUnion<TupleParts<Keys>[\"suffix\"]>[\"singular\"]\n    >,\n    never\n  >;\n\n/**\n * When `Omit` omits **all** keys from a bounded record it results in `{}` which\n * doesn't match what we'd expect to be returned in terms of a useful type as\n * the output of `Omit`.\n */\ntype FixEmpty<T> = IsNever<keyof T> extends true ? EmptyObject : T;\n\n/**\n * Filter a union of types, leaving only those that are bounded. e.g.,\n * `Bounded<\"a\" | number>` results in `\"a\"`.\n */\ntype Bounded<T> = T extends unknown\n  ? IsBounded<T> extends true\n    ? T\n    : never\n  : never;\n\n/**\n * Returns a partial copy of an object omitting the keys specified.\n *\n * @param keys - The property names.\n * @signature\n *    omit(keys)(obj);\n * @example\n *    pipe({ a: 1, b: 2, c: 3, d: 4 }, omit(['a', 'd'])) // => { b: 2, c: 3 }\n * @dataLast\n * @category Object\n */\nexport function omit<T, const Keys extends readonly KeysOfUnion<T>[]>(\n  keys: Keys,\n): (data: T) => OmitFromArray<T, Keys>;\n\n/**\n * Returns a partial copy of an object omitting the keys specified.\n *\n * @param data - The object.\n * @param keys - The property names.\n * @signature\n *    omit(obj, keys);\n * @example\n *    omit({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { b: 2, c: 3 }\n * @dataFirst\n * @category Object\n */\nexport function omit<T, const Keys extends readonly KeysOfUnion<T>[]>(\n  data: T,\n  keys: Keys,\n): OmitFromArray<T, Keys>;\n\nexport function omit(...args: readonly unknown[]): unknown {\n  return purry(omitImplementation, args);\n}\n\nfunction omitImplementation<\n  T extends object,\n  Keys extends readonly (keyof T)[],\n>(data: T, keys: Keys): OmitFromArray<T, Keys> {\n  if (!hasAtLeast(keys, 1)) {\n    // No props to omit at all!\n    // @ts-expect-error [ts2322] - TypeScript can't connect the fact that the\n    // keys array is empty and infer the expected output, and then infer that we\n    // return it correctly here.\n    return { ...data };\n  }\n\n  if (!hasAtLeast(keys, 2)) {\n    // Only one prop to omit so we can let the runtime engine deal with\n    // removing it efficiently.\n    const { [keys[0]]: _omitted, ...remaining } = data;\n\n    // @ts-expect-error [ts2322] - TypeScript can't compute the expected output\n    // correctly and then infer that we return it correctly here.\n    return remaining;\n  }\n\n  // Multiple props to omit so we have to use a loop to omit all of them.\n  const out = { ...data };\n  for (const key of keys) {\n    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- This is intentional! It is the most effective way to allow the runtime engine to optimize the object without creating excessive copies for every omitted key.\n    delete out[key];\n  }\n\n  // @ts-expect-error [ts2322] - The type is too complex and TypeScript can't\n  // \"follow\" the iterative algorithm to ensure the output makes sense.\n  return out;\n}\n"],"mappings":"gIA8HA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAOA,EAAAA,MAAM,EAAoB,EAAK,CAGxC,SAAS,EAGP,EAAS,EAAoC,CAC7C,GAAI,CAACC,EAAAA,WAAW,EAAM,EAAE,CAKtB,MAAO,CAAE,GAAG,EAAM,CAGpB,GAAI,CAACA,EAAAA,WAAW,EAAM,EAAE,CAAE,CAGxB,GAAM,EAAG,EAAK,IAAK,EAAU,GAAG,GAAc,EAI9C,OAAO,EAIT,IAAM,EAAM,CAAE,GAAG,EAAM,CACvB,IAAK,IAAM,KAAO,EAEhB,OAAO,EAAI,GAKb,OAAO"}

package/dist/omit.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";import{hasAtLeast as t}from"./hasAtLeast.js";function n(...t){return e(r,t)}function r(e,n){if(!t(n,1))return{...e};if(!t(n,2)){let{[n[0]]:t,...r}=e;return r}let r={...e};for(let e of n)delete r[e];return r}export{n as omit};
+//# sourceMappingURL=omit.js.map

package/dist/omit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit.js","names":[],"sources":["../src/omit.ts"],"sourcesContent":["import type { EmptyObject, IsNever, KeysOfUnion } from \"type-fest\";\nimport { hasAtLeast } from \"./hasAtLeast\";\nimport type { IsBounded } from \"./internal/types/IsBounded\";\nimport type { IsBoundedRecord } from \"./internal/types/IsBoundedRecord\";\nimport type { PartitionByUnion } from \"./internal/types/PartitionByUnion\";\nimport type { SimplifiedWritable } from \"./internal/types/SimplifiedWritable\";\nimport type { TupleParts } from \"./internal/types/TupleParts\";\nimport { purry } from \"./purry\";\n\ntype OmitFromArray<T, Keys extends readonly PropertyKey[]> =\n  // Distribute unions for both object types and key arrays.\n  T extends unknown\n    ? Keys extends unknown\n      ? // The output is always writable because we always create a new object!\n        SimplifiedWritable<\n          IsNever<Extract<Keys[number], keyof T>> extends true\n            ? // When none of the keys belong to T we can short-circuit and\n              // simply return T as-is because `omit` would do nothing.\n              T\n            : IsBoundedRecord<T> extends true\n              ? OmitBounded<T, Keys>\n              : OmitUnbounded<T, Keys>\n        >\n      : never\n    : never;\n\ntype OmitBounded<T, Keys extends readonly PropertyKey[]> =\n  // We build our output by first considering any key present in the keys array\n  // as being omitted. This object would contain all keys that are unaffected at\n  // all by this omit operation.\n  FixEmpty<Omit<T, Keys[number]>> &\n    // But we might be missing keys that are optional in the keys tuple (and\n    // thus might not be removed). Because these keys are optional, their props\n    // in the output also need to be optional.\n    Partial<\n      Pick<\n        T,\n        Exclude<\n          // Find all keys that can either be omitted or not, these are all keys\n          // in unions in the required parts of the keys tuple (the prefix and\n          // the suffix), as well as all keys in the optional parts and the rest\n          // item.\n          | PartitionByUnion<TupleParts<Keys>[\"required\"]>[\"union\"]\n          | TupleParts<Keys>[\"optional\"][number]\n          | TupleParts<Keys>[\"item\"]\n          | PartitionByUnion<TupleParts<Keys>[\"suffix\"]>[\"union\"],\n          // We then need to remove from these any items which *also* are\n          // ensured to always exist in the keys tuple, these are the elements\n          // of the required parts of the tuple which are singular (not unions).\n          | PartitionByUnion<TupleParts<Keys>[\"required\"]>[\"singular\"]\n          | PartitionByUnion<TupleParts<Keys>[\"suffix\"]>[\"singular\"]\n        >\n      >\n    >;\n\n/**\n * The built-in `Omit` type doesn't handle unbounded records correctly! When\n * omitting an unbounded key the result should be untouched as we can't tell\n * what got removed, and can't represent an object that had \"something\" removed\n * from it, but instead it returns `{}`(?!) The same thing applies when a key\n * is only optionally omitted for the same reasons. This is why we don't use\n * `Omit` at all for the unbounded case.\n *\n * @see https://www.typescriptlang.org/play/?#code/C4TwDgpgBAqgdgIwPYFc4BMLqgXigeQFsBLYAHgCUIBjJAJ3TIGdg7i4BzAGigCIALCABshSXgD4eLNp3EBuAFAB6JVDUA9APxA\n */\ntype OmitUnbounded<T, Keys extends readonly PropertyKey[]> = T &\n  // Any key we know for sure is being omitted needs to become \"impossible\" to\n  // access; for an unbounded record this means merging it with a bounded record\n  // with `never` value for these keys.\n  Record<\n    Bounded<\n      | PartitionByUnion<TupleParts<Keys>[\"required\"]>[\"singular\"]\n      | PartitionByUnion<TupleParts<Keys>[\"suffix\"]>[\"singular\"]\n    >,\n    never\n  >;\n\n/**\n * When `Omit` omits **all** keys from a bounded record it results in `{}` which\n * doesn't match what we'd expect to be returned in terms of a useful type as\n * the output of `Omit`.\n */\ntype FixEmpty<T> = IsNever<keyof T> extends true ? EmptyObject : T;\n\n/**\n * Filter a union of types, leaving only those that are bounded. e.g.,\n * `Bounded<\"a\" | number>` results in `\"a\"`.\n */\ntype Bounded<T> = T extends unknown\n  ? IsBounded<T> extends true\n    ? T\n    : never\n  : never;\n\n/**\n * Returns a partial copy of an object omitting the keys specified.\n *\n * @param keys - The property names.\n * @signature\n *    omit(keys)(obj);\n * @example\n *    pipe({ a: 1, b: 2, c: 3, d: 4 }, omit(['a', 'd'])) // => { b: 2, c: 3 }\n * @dataLast\n * @category Object\n */\nexport function omit<T, const Keys extends readonly KeysOfUnion<T>[]>(\n  keys: Keys,\n): (data: T) => OmitFromArray<T, Keys>;\n\n/**\n * Returns a partial copy of an object omitting the keys specified.\n *\n * @param data - The object.\n * @param keys - The property names.\n * @signature\n *    omit(obj, keys);\n * @example\n *    omit({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { b: 2, c: 3 }\n * @dataFirst\n * @category Object\n */\nexport function omit<T, const Keys extends readonly KeysOfUnion<T>[]>(\n  data: T,\n  keys: Keys,\n): OmitFromArray<T, Keys>;\n\nexport function omit(...args: readonly unknown[]): unknown {\n  return purry(omitImplementation, args);\n}\n\nfunction omitImplementation<\n  T extends object,\n  Keys extends readonly (keyof T)[],\n>(data: T, keys: Keys): OmitFromArray<T, Keys> {\n  if (!hasAtLeast(keys, 1)) {\n    // No props to omit at all!\n    // @ts-expect-error [ts2322] - TypeScript can't connect the fact that the\n    // keys array is empty and infer the expected output, and then infer that we\n    // return it correctly here.\n    return { ...data };\n  }\n\n  if (!hasAtLeast(keys, 2)) {\n    // Only one prop to omit so we can let the runtime engine deal with\n    // removing it efficiently.\n    const { [keys[0]]: _omitted, ...remaining } = data;\n\n    // @ts-expect-error [ts2322] - TypeScript can't compute the expected output\n    // correctly and then infer that we return it correctly here.\n    return remaining;\n  }\n\n  // Multiple props to omit so we have to use a loop to omit all of them.\n  const out = { ...data };\n  for (const key of keys) {\n    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- This is intentional! It is the most effective way to allow the runtime engine to optimize the object without creating excessive copies for every omitted key.\n    delete out[key];\n  }\n\n  // @ts-expect-error [ts2322] - The type is too complex and TypeScript can't\n  // \"follow\" the iterative algorithm to ensure the output makes sense.\n  return out;\n}\n"],"mappings":"gFA8HA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EAGP,EAAS,EAAoC,CAC7C,GAAI,CAAC,EAAW,EAAM,EAAE,CAKtB,MAAO,CAAE,GAAG,EAAM,CAGpB,GAAI,CAAC,EAAW,EAAM,EAAE,CAAE,CAGxB,GAAM,EAAG,EAAK,IAAK,EAAU,GAAG,GAAc,EAI9C,OAAO,EAIT,IAAM,EAAM,CAAE,GAAG,EAAM,CACvB,IAAK,IAAM,KAAO,EAEhB,OAAO,EAAI,GAKb,OAAO"}

package/dist/omitBy.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}function n(e,t){let n={...e};for(let[r,i]of Object.entries(n))t(i,r,e)&&delete n[r];return n}exports.omitBy=t;
+//# sourceMappingURL=omitBy.cjs.map

package/dist/omitBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"omitBy.cjs","names":["purry"],"sources":["../src/omitBy.ts"],"sourcesContent":["import type { IsNever, Or, Simplify } from \"type-fest\";\nimport type { EnumerableStringKeyOf } from \"./internal/types/EnumerableStringKeyOf\";\nimport type { EnumerableStringKeyedValueOf } from \"./internal/types/EnumerableStringKeyedValueOf\";\nimport type { IsBoundedRecord } from \"./internal/types/IsBoundedRecord\";\nimport { purry } from \"./purry\";\n\n// Symbols are not passed to the predicate (because they can't be enumerated\n// with the `Object.entries` function) and the output object is built from a\n// shallow copy of the input; meaning symbols would just be passed through as-\n// is.\ntype PickSymbolKeys<T extends object> = {\n  -readonly [P in keyof T as P extends symbol ? P : never]: T[P];\n};\n\n// When we don't use a type-predicate we can't say anything about what props\n// would be omitted from the output, so we need to assume any of them could be\n// filtered out. This means that we effectively make all (enumerable) keys\n// optional.\ntype PartialEnumerableKeys<T extends object> =\n  // `extends unknown` is always going to be the case and is used to convert any\n  // union into a [distributive conditional type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).\n  T extends unknown\n    ? Simplify<\n        IsBoundedRecord<T> extends true\n          ? PickSymbolKeys<T> & {\n              -readonly [P in keyof T as P extends symbol\n                ? never\n                : P]?: Required<T>[P];\n            }\n          : // This is the type you'd get from doing:\n            // `Object.fromEntries(Object.entries(x))`.\n            Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>\n      >\n    : never;\n\n// When the predicate is a type-guard we have more information to work with when\n// constructing the type of the output object. We can safely remove any property\n// which value would always be true for the predicate, AND we can also\n// assume that properties that are rejected by the predicate perfectly would\n// **always** show up in the output object. Hence to build the output object we\n// need to build and merge 2 output objects: One for the properties which have a\n// value of at type that would always yield a `false` result from the predicate,\n// these are the \"matches\", which would not change the \"optionality\" of the\n// input object's props, and one for partial matches which would also make the\n// props optional (as they could have a value that would be filtered out).\ntype PartialEnumerableKeysNarrowed<T extends object, S> = Simplify<\n  ExactProps<T, S> & PartialProps<T, S> & PickSymbolKeys<T>\n>;\n\n// The exact case, props here would always be part of the output object\ntype ExactProps<T, S> = {\n  -readonly [P in keyof T as IsExactProp<T, P, S> extends true\n    ? P\n    : never]: Exclude<T[P], S>;\n};\n\n// The partial case, props here might be part of the output object, but might\n// not be, hence they are optional.\ntype PartialProps<T, S> = {\n  -readonly [P in keyof T as IsPartialProp<T, P, S> extends true\n    ? P\n    : never]?: Exclude<T[P], S>;\n};\n\n// If the input object's value type extends itself when the type-guard is\n// excluded from it we can safely assume that the predicate would always return\n// `false` for any value of that property.\ntype IsExactProp<T, P extends keyof T, S> = P extends symbol\n  ? // Symbols are passed through via the PickSymbolKeys type\n    false\n  : T[P] extends Exclude<T[P], S>\n    ? S extends T[P]\n      ? // If S extends the T[P] it means the type the predicate is narrowing to\n        // can't narrow the rejected value any further, so we can't say what\n        // would happen for a concrete value in runtime (e.g. if T[P] is\n        // `number` and S is `1`: `Exclude<number, 1> === number`.\n        false\n      : true\n    : false;\n\n// ...and if the input object's value type isn't an exact match, but still has\n// some partial match (i.g. the extracted type-guard isn't completely disjoint)\n// then we can assume that the property can sometimes return true, and sometimes\n// false when passed to the predicate, hence it should be optional in the\n// output.\ntype IsPartialProp<T, P extends keyof T, S> = P extends symbol\n  ? // Symbols are passed through via the PickSymbolKeys type\n    false\n  : Or<IsExactProp<T, P, S>, IsNever<Exclude<Required<T>[P], S>>> extends true\n    ? false\n    : true;\n\n/**\n * Creates a shallow copy of the data, and then removes any keys that the\n * predicate rejects. Symbol keys are not passed to the predicate and would be\n * passed through to the output as-is.\n *\n * See `pickBy` for a complementary function which starts with an empty object\n * and adds the entries that the predicate accepts. Because it is additive,\n * symbol keys will not be passed through to the output object.\n *\n * @param data - The target object.\n * @param predicate - A function that takes the value, key, and the data itself\n * and returns `true` if the entry shouldn't be part of the output object, or\n * `false` to keep it. If the function is a type-guard on the value the output\n * type would be narrowed accordingly.\n * @returns A shallow copy of the input object with the rejected entries\n * removed.\n * @signature omitBy(data, predicate)\n * @example\n *    omitBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {a: 1, b: 2}\n * @dataFirst\n * @category Object\n */\nexport function omitBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): PartialEnumerableKeysNarrowed<T, S>;\nexport function omitBy<T extends object>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): PartialEnumerableKeys<T>;\n\n/**\n * Returns a partial copy of an object omitting the keys matching predicate.\n *\n * @param predicate - The predicate.\n * @signature omitBy(fn)(object)\n * @example\n *    omitBy((val, key) => key.toUpperCase() === key)({a: 1, b: 2, A: 3, B: 4}) // => {a: 1, b: 2}\n * @dataLast\n * @category Object\n */\nexport function omitBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): (data: T) => PartialEnumerableKeysNarrowed<T, S>;\nexport function omitBy<T extends object>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): (data: T) => PartialEnumerableKeys<T>;\n\nexport function omitBy(...args: readonly unknown[]): unknown {\n  return purry(omitByImplementation, args);\n}\n\nfunction omitByImplementation<T extends object>(\n  data: T,\n  predicate: (value: unknown, key: string, data: T) => boolean,\n): Record<string, unknown> {\n  const out: Partial<Record<string, unknown>> = { ...data };\n\n  for (const [key, value] of Object.entries(out)) {\n    if (predicate(value, key, data)) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- This is the best way to do it!\n      delete out[key];\n    }\n  }\n\n  return out;\n}\n"],"mappings":"kGAkKA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACyB,CACzB,IAAM,EAAwC,CAAE,GAAG,EAAM,CAEzD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAI,CACxC,EAAU,EAAO,EAAK,EAAK,EAE7B,OAAO,EAAI,GAIf,OAAO"}

package/dist/omitBy.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}function n(e,t){let n={...e};for(let[r,i]of Object.entries(n))t(i,r,e)&&delete n[r];return n}export{t as omitBy};
+//# sourceMappingURL=omitBy.js.map

package/dist/omitBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"omitBy.js","names":[],"sources":["../src/omitBy.ts"],"sourcesContent":["import type { IsNever, Or, Simplify } from \"type-fest\";\nimport type { EnumerableStringKeyOf } from \"./internal/types/EnumerableStringKeyOf\";\nimport type { EnumerableStringKeyedValueOf } from \"./internal/types/EnumerableStringKeyedValueOf\";\nimport type { IsBoundedRecord } from \"./internal/types/IsBoundedRecord\";\nimport { purry } from \"./purry\";\n\n// Symbols are not passed to the predicate (because they can't be enumerated\n// with the `Object.entries` function) and the output object is built from a\n// shallow copy of the input; meaning symbols would just be passed through as-\n// is.\ntype PickSymbolKeys<T extends object> = {\n  -readonly [P in keyof T as P extends symbol ? P : never]: T[P];\n};\n\n// When we don't use a type-predicate we can't say anything about what props\n// would be omitted from the output, so we need to assume any of them could be\n// filtered out. This means that we effectively make all (enumerable) keys\n// optional.\ntype PartialEnumerableKeys<T extends object> =\n  // `extends unknown` is always going to be the case and is used to convert any\n  // union into a [distributive conditional type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).\n  T extends unknown\n    ? Simplify<\n        IsBoundedRecord<T> extends true\n          ? PickSymbolKeys<T> & {\n              -readonly [P in keyof T as P extends symbol\n                ? never\n                : P]?: Required<T>[P];\n            }\n          : // This is the type you'd get from doing:\n            // `Object.fromEntries(Object.entries(x))`.\n            Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>\n      >\n    : never;\n\n// When the predicate is a type-guard we have more information to work with when\n// constructing the type of the output object. We can safely remove any property\n// which value would always be true for the predicate, AND we can also\n// assume that properties that are rejected by the predicate perfectly would\n// **always** show up in the output object. Hence to build the output object we\n// need to build and merge 2 output objects: One for the properties which have a\n// value of at type that would always yield a `false` result from the predicate,\n// these are the \"matches\", which would not change the \"optionality\" of the\n// input object's props, and one for partial matches which would also make the\n// props optional (as they could have a value that would be filtered out).\ntype PartialEnumerableKeysNarrowed<T extends object, S> = Simplify<\n  ExactProps<T, S> & PartialProps<T, S> & PickSymbolKeys<T>\n>;\n\n// The exact case, props here would always be part of the output object\ntype ExactProps<T, S> = {\n  -readonly [P in keyof T as IsExactProp<T, P, S> extends true\n    ? P\n    : never]: Exclude<T[P], S>;\n};\n\n// The partial case, props here might be part of the output object, but might\n// not be, hence they are optional.\ntype PartialProps<T, S> = {\n  -readonly [P in keyof T as IsPartialProp<T, P, S> extends true\n    ? P\n    : never]?: Exclude<T[P], S>;\n};\n\n// If the input object's value type extends itself when the type-guard is\n// excluded from it we can safely assume that the predicate would always return\n// `false` for any value of that property.\ntype IsExactProp<T, P extends keyof T, S> = P extends symbol\n  ? // Symbols are passed through via the PickSymbolKeys type\n    false\n  : T[P] extends Exclude<T[P], S>\n    ? S extends T[P]\n      ? // If S extends the T[P] it means the type the predicate is narrowing to\n        // can't narrow the rejected value any further, so we can't say what\n        // would happen for a concrete value in runtime (e.g. if T[P] is\n        // `number` and S is `1`: `Exclude<number, 1> === number`.\n        false\n      : true\n    : false;\n\n// ...and if the input object's value type isn't an exact match, but still has\n// some partial match (i.g. the extracted type-guard isn't completely disjoint)\n// then we can assume that the property can sometimes return true, and sometimes\n// false when passed to the predicate, hence it should be optional in the\n// output.\ntype IsPartialProp<T, P extends keyof T, S> = P extends symbol\n  ? // Symbols are passed through via the PickSymbolKeys type\n    false\n  : Or<IsExactProp<T, P, S>, IsNever<Exclude<Required<T>[P], S>>> extends true\n    ? false\n    : true;\n\n/**\n * Creates a shallow copy of the data, and then removes any keys that the\n * predicate rejects. Symbol keys are not passed to the predicate and would be\n * passed through to the output as-is.\n *\n * See `pickBy` for a complementary function which starts with an empty object\n * and adds the entries that the predicate accepts. Because it is additive,\n * symbol keys will not be passed through to the output object.\n *\n * @param data - The target object.\n * @param predicate - A function that takes the value, key, and the data itself\n * and returns `true` if the entry shouldn't be part of the output object, or\n * `false` to keep it. If the function is a type-guard on the value the output\n * type would be narrowed accordingly.\n * @returns A shallow copy of the input object with the rejected entries\n * removed.\n * @signature omitBy(data, predicate)\n * @example\n *    omitBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {a: 1, b: 2}\n * @dataFirst\n * @category Object\n */\nexport function omitBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): PartialEnumerableKeysNarrowed<T, S>;\nexport function omitBy<T extends object>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): PartialEnumerableKeys<T>;\n\n/**\n * Returns a partial copy of an object omitting the keys matching predicate.\n *\n * @param predicate - The predicate.\n * @signature omitBy(fn)(object)\n * @example\n *    omitBy((val, key) => key.toUpperCase() === key)({a: 1, b: 2, A: 3, B: 4}) // => {a: 1, b: 2}\n * @dataLast\n * @category Object\n */\nexport function omitBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): (data: T) => PartialEnumerableKeysNarrowed<T, S>;\nexport function omitBy<T extends object>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): (data: T) => PartialEnumerableKeys<T>;\n\nexport function omitBy(...args: readonly unknown[]): unknown {\n  return purry(omitByImplementation, args);\n}\n\nfunction omitByImplementation<T extends object>(\n  data: T,\n  predicate: (value: unknown, key: string, data: T) => boolean,\n): Record<string, unknown> {\n  const out: Partial<Record<string, unknown>> = { ...data };\n\n  for (const [key, value] of Object.entries(out)) {\n    if (predicate(value, key, data)) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- This is the best way to do it!\n      delete out[key];\n    }\n  }\n\n  return out;\n}\n"],"mappings":"mCAkKA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACyB,CACzB,IAAM,EAAwC,CAAE,GAAG,EAAM,CAEzD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAI,CACxC,EAAU,EAAO,EAAK,EAAK,EAE7B,OAAO,EAAI,GAIf,OAAO"}

package/dist/once.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){let t=!1,n;return()=>(t||=(n=e(),!0),n)}exports.once=e;
+//# sourceMappingURL=once.cjs.map

package/dist/once.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"once.cjs","names":[],"sources":["../src/once.ts"],"sourcesContent":["/**\n * Creates a function that is restricted to invoking `func` once. Repeat calls to the function return the value of the first invocation.\n *\n * @param fn - The function to wrap.\n * @signature once(fn)\n * @example\n * const initialize = once(createApplication);\n * initialize();\n * initialize();\n * // => `createApplication` is invoked once\n * @category Function\n */\nexport function once<T>(fn: () => T): () => T {\n  let called = false;\n  let ret: T;\n  return () => {\n    if (!called) {\n      ret = fn();\n      called = true;\n    }\n    return ret;\n  };\n}\n"],"mappings":"mEAYA,SAAgB,EAAQ,EAAsB,CAC5C,IAAI,EAAS,GACT,EACJ,WACE,AAEE,KADA,EAAM,GAAI,CACD,IAEJ"}

package/dist/once.js

@@ -0,0 +1,2 @@
+function e(e){let t=!1,n;return()=>(t||=(n=e(),!0),n)}export{e as once};
+//# sourceMappingURL=once.js.map

package/dist/once.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"once.js","names":[],"sources":["../src/once.ts"],"sourcesContent":["/**\n * Creates a function that is restricted to invoking `func` once. Repeat calls to the function return the value of the first invocation.\n *\n * @param fn - The function to wrap.\n * @signature once(fn)\n * @example\n * const initialize = once(createApplication);\n * initialize();\n * initialize();\n * // => `createApplication` is invoked once\n * @category Function\n */\nexport function once<T>(fn: () => T): () => T {\n  let called = false;\n  let ret: T;\n  return () => {\n    if (!called) {\n      ret = fn();\n      called = true;\n    }\n    return ret;\n  };\n}\n"],"mappings":"AAYA,SAAgB,EAAQ,EAAsB,CAC5C,IAAI,EAAS,GACT,EACJ,WACE,AAEE,KADA,EAAM,GAAI,CACD,IAEJ"}

package/dist/only.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}const n=e=>e.length===1?e[0]:void 0;exports.only=t;
+//# sourceMappingURL=only.cjs.map

package/dist/only.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"only.cjs","names":["purry"],"sources":["../src/only.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\n\ntype Only<T extends IterableContainer> = T extends\n  | readonly [...unknown[], unknown, unknown]\n  | readonly []\n  | readonly [unknown, ...unknown[], unknown]\n  | readonly [unknown, unknown, ...unknown[]]\n  ? undefined\n  : T extends readonly [unknown]\n    ? T[number]\n    : T[number] | undefined;\n\n/**\n * Returns the first and only element of `array`, or undefined otherwise.\n *\n * @param array - The target array.\n * @signature\n *    only(array)\n * @example\n *    only([]) // => undefined\n *    only([1]) // => 1\n *    only([1, 2]) // => undefined\n * @dataFirst\n * @category Array\n */\nexport function only<T extends IterableContainer>(array: Readonly<T>): Only<T>;\n\n/**\n * Returns the first and only element of `array`, or undefined otherwise.\n *\n * @signature\n *    only()(array)\n * @example\n *    pipe([], only()); // => undefined\n *    pipe([1], only()); // => 1\n *    pipe([1, 2], only()); // => undefined\n * @dataLast\n * @category Array\n */\nexport function only<T extends IterableContainer>(): (\n  array: Readonly<T>,\n) => Only<T>;\n\nexport function only(...args: readonly unknown[]): unknown {\n  return purry(onlyImplementation, args);\n}\n\nconst onlyImplementation = <T>(array: readonly T[]): T | undefined =>\n  array.length === 1 ? array[0] : undefined;\n"],"mappings":"kGA4CA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAOA,EAAAA,MAAM,EAAoB,EAAK,CAGxC,MAAM,EAAyB,GAC7B,EAAM,SAAW,EAAI,EAAM,GAAK,IAAA"}

package/dist/only.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}const n=e=>e.length===1?e[0]:void 0;export{t as only};
+//# sourceMappingURL=only.js.map

package/dist/only.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"only.js","names":[],"sources":["../src/only.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\n\ntype Only<T extends IterableContainer> = T extends\n  | readonly [...unknown[], unknown, unknown]\n  | readonly []\n  | readonly [unknown, ...unknown[], unknown]\n  | readonly [unknown, unknown, ...unknown[]]\n  ? undefined\n  : T extends readonly [unknown]\n    ? T[number]\n    : T[number] | undefined;\n\n/**\n * Returns the first and only element of `array`, or undefined otherwise.\n *\n * @param array - The target array.\n * @signature\n *    only(array)\n * @example\n *    only([]) // => undefined\n *    only([1]) // => 1\n *    only([1, 2]) // => undefined\n * @dataFirst\n * @category Array\n */\nexport function only<T extends IterableContainer>(array: Readonly<T>): Only<T>;\n\n/**\n * Returns the first and only element of `array`, or undefined otherwise.\n *\n * @signature\n *    only()(array)\n * @example\n *    pipe([], only()); // => undefined\n *    pipe([1], only()); // => 1\n *    pipe([1, 2], only()); // => undefined\n * @dataLast\n * @category Array\n */\nexport function only<T extends IterableContainer>(): (\n  array: Readonly<T>,\n) => Only<T>;\n\nexport function only(...args: readonly unknown[]): unknown {\n  return purry(onlyImplementation, args);\n}\n\nconst onlyImplementation = <T>(array: readonly T[]): T | undefined =>\n  array.length === 1 ? array[0] : undefined;\n"],"mappings":"mCA4CA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAO,EAAM,EAAoB,EAAK,CAGxC,MAAM,EAAyB,GAC7B,EAAM,SAAW,EAAI,EAAM,GAAK,IAAA"}

package/dist/partialBind.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e,...t){return(...n)=>e(...t,...n)}exports.partialBind=e;
+//# sourceMappingURL=partialBind.cjs.map

package/dist/partialBind.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"partialBind.cjs","names":[],"sources":["../src/partialBind.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { RemedaTypeError } from \"./internal/types/RemedaTypeError\";\nimport type { StrictFunction } from \"./internal/types/StrictFunction\";\nimport type { TupleSplits } from \"./internal/types/TupleSplits\";\n\ntype PartialBindError<\n  Message extends string,\n  Metadata = never,\n> = RemedaTypeError<\"partialBind\", Message, { metadata: Metadata }>;\n\ntype TuplePrefix<T extends IterableContainer> = TupleSplits<T>[\"left\"];\n\ntype RemovePrefix<\n  T extends IterableContainer,\n  Prefix extends TuplePrefix<T>,\n> = Prefix extends readonly []\n  ? T\n  : T extends readonly [infer THead, ...infer TRest]\n    ? Prefix extends readonly [infer _PrefixHead, ...infer PrefixRest]\n      ? // PrefixHead extends THead.\n        RemovePrefix<TRest, PrefixRest>\n      : // Prefix (as a whole) extends readonly THead[].\n        // Prefix could possibly be empty, so this has to be THead?.\n        [THead?, ...RemovePrefix<TRest, Prefix>]\n    : // T has an optional or rest parameter last. If T is a parameter list,\n      // this can only happen if we have optional arguments or a rest param;\n      // both cases are similar.\n      T extends readonly [(infer _THead)?, ...infer TRest]\n      ? Prefix extends readonly [infer _PrefixHead, ...infer PrefixRest]\n        ? // PrefixHead extends THead.\n          RemovePrefix<TRest, PrefixRest>\n        : // Prefix (as a whole) extends [THead?, ...TRest].\n          TRest\n      : // We got passed a parameter list that isn't what we expected; this is\n        // an internal error.\n        PartialBindError<\"Function parameter list has unexpected shape\", T>;\n\n/**\n * Creates a function that calls `func` with `partial` put before the arguments\n * it receives.\n *\n * Can be thought of as \"freezing\" some portion of a function's arguments,\n * resulting in a new function with a simplified signature.\n *\n * @param func - The function to wrap.\n * @param partial - The arguments to put before.\n * @returns A partially bound function.\n * @signature\n *    partialBind(func, ...partial);\n * @example\n *    const fn = (x: number, y: number, z: number) => x * 100 + y * 10 + z;\n *    const partialFn = partialBind(fn, 1, 2);\n *    partialFn(3); //=> 123\n *\n *    const logWithPrefix = partialBind(console.log, \"[prefix]\");\n *    logWithPrefix(\"hello\"); //=> \"[prefix] hello\"\n * @dataFirst\n * @category Function\n * @see partialLastBind\n */\nexport function partialBind<\n  F extends StrictFunction,\n  PrefixArgs extends TuplePrefix<Parameters<F>>,\n  RemovedPrefix extends RemovePrefix<Parameters<F>, PrefixArgs>,\n>(\n  func: F,\n  ...partial: PrefixArgs\n): (\n  ...rest: RemovedPrefix extends IterableContainer ? RemovedPrefix : never\n) => ReturnType<F> {\n  // @ts-expect-error [ts2345, ts2322] -- TypeScript infers the generic sub-\n  // types too eagerly, making itself blind to the fact that the types match\n  // here.\n  return (...rest) => func(...partial, ...rest);\n}\n"],"mappings":"mEA4DA,SAAgB,EAKd,EACA,GAAG,EAGc,CAIjB,OAAQ,GAAG,IAAS,EAAK,GAAG,EAAS,GAAG,EAAK"}

package/dist/partialBind.js

@@ -0,0 +1,2 @@
+function e(e,...t){return(...n)=>e(...t,...n)}export{e as partialBind};
+//# sourceMappingURL=partialBind.js.map

package/dist/partialBind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partialBind.js","names":[],"sources":["../src/partialBind.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { RemedaTypeError } from \"./internal/types/RemedaTypeError\";\nimport type { StrictFunction } from \"./internal/types/StrictFunction\";\nimport type { TupleSplits } from \"./internal/types/TupleSplits\";\n\ntype PartialBindError<\n  Message extends string,\n  Metadata = never,\n> = RemedaTypeError<\"partialBind\", Message, { metadata: Metadata }>;\n\ntype TuplePrefix<T extends IterableContainer> = TupleSplits<T>[\"left\"];\n\ntype RemovePrefix<\n  T extends IterableContainer,\n  Prefix extends TuplePrefix<T>,\n> = Prefix extends readonly []\n  ? T\n  : T extends readonly [infer THead, ...infer TRest]\n    ? Prefix extends readonly [infer _PrefixHead, ...infer PrefixRest]\n      ? // PrefixHead extends THead.\n        RemovePrefix<TRest, PrefixRest>\n      : // Prefix (as a whole) extends readonly THead[].\n        // Prefix could possibly be empty, so this has to be THead?.\n        [THead?, ...RemovePrefix<TRest, Prefix>]\n    : // T has an optional or rest parameter last. If T is a parameter list,\n      // this can only happen if we have optional arguments or a rest param;\n      // both cases are similar.\n      T extends readonly [(infer _THead)?, ...infer TRest]\n      ? Prefix extends readonly [infer _PrefixHead, ...infer PrefixRest]\n        ? // PrefixHead extends THead.\n          RemovePrefix<TRest, PrefixRest>\n        : // Prefix (as a whole) extends [THead?, ...TRest].\n          TRest\n      : // We got passed a parameter list that isn't what we expected; this is\n        // an internal error.\n        PartialBindError<\"Function parameter list has unexpected shape\", T>;\n\n/**\n * Creates a function that calls `func` with `partial` put before the arguments\n * it receives.\n *\n * Can be thought of as \"freezing\" some portion of a function's arguments,\n * resulting in a new function with a simplified signature.\n *\n * @param func - The function to wrap.\n * @param partial - The arguments to put before.\n * @returns A partially bound function.\n * @signature\n *    partialBind(func, ...partial);\n * @example\n *    const fn = (x: number, y: number, z: number) => x * 100 + y * 10 + z;\n *    const partialFn = partialBind(fn, 1, 2);\n *    partialFn(3); //=> 123\n *\n *    const logWithPrefix = partialBind(console.log, \"[prefix]\");\n *    logWithPrefix(\"hello\"); //=> \"[prefix] hello\"\n * @dataFirst\n * @category Function\n * @see partialLastBind\n */\nexport function partialBind<\n  F extends StrictFunction,\n  PrefixArgs extends TuplePrefix<Parameters<F>>,\n  RemovedPrefix extends RemovePrefix<Parameters<F>, PrefixArgs>,\n>(\n  func: F,\n  ...partial: PrefixArgs\n): (\n  ...rest: RemovedPrefix extends IterableContainer ? RemovedPrefix : never\n) => ReturnType<F> {\n  // @ts-expect-error [ts2345, ts2322] -- TypeScript infers the generic sub-\n  // types too eagerly, making itself blind to the fact that the types match\n  // here.\n  return (...rest) => func(...partial, ...rest);\n}\n"],"mappings":"AA4DA,SAAgB,EAKd,EACA,GAAG,EAGc,CAIjB,OAAQ,GAAG,IAAS,EAAK,GAAG,EAAS,GAAG,EAAK"}

package/dist/partialLastBind.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e,...t){return(...n)=>e(...n,...t)}exports.partialLastBind=e;
+//# sourceMappingURL=partialLastBind.cjs.map

package/dist/partialLastBind.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"partialLastBind.cjs","names":[],"sources":["../src/partialLastBind.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { RemedaTypeError } from \"./internal/types/RemedaTypeError\";\nimport type { StrictFunction } from \"./internal/types/StrictFunction\";\nimport type { TupleSplits } from \"./internal/types/TupleSplits\";\n\ntype PartialLastBindError<\n  Message extends string,\n  Metadata = never,\n> = RemedaTypeError<\"partialLastBind\", Message, { metadata: Metadata }>;\n\ntype TupleSuffix<T extends IterableContainer> = TupleSplits<T>[\"right\"];\n\ntype RemoveSuffix<\n  T extends IterableContainer,\n  Suffix extends TupleSuffix<T>,\n> = Suffix extends readonly []\n  ? T\n  : T extends readonly [...infer TRest, infer TLast]\n    ? Suffix extends readonly [...infer SuffixRest, infer _SuffixLast]\n      ? // SuffixLast extends TLast.\n        RemoveSuffix<TRest, SuffixRest>\n      : // Suffix (as a whole) extends readonly TLast[].\n        // Suffix could possibly be empty, so this has to be TLast?.\n        [...RemoveSuffix<TRest, Suffix>, TLast?]\n    : // T has an optional or rest parameter last. If T is a parameter list,\n      // this can only happen if we have optional arguments or a rest param;\n      // both cases are similar.\n      T extends readonly [...infer TRest, (infer _TLast)?]\n      ? Suffix extends readonly [...infer SuffixRest, infer _SuffixLast]\n        ? // SuffixLast extends TLast.\n          RemoveSuffix<TRest, SuffixRest>\n        : // Suffix (as a whole) extends [...TRest, TLast?].\n          TRest\n      : // We got passed a parameter list that isn't what we expected; this\n        // is an internal error.\n        PartialLastBindError<\"Function parameter list has unexpected shape\", T>;\n\n/**\n * Creates a function that calls `func` with `partial` put after the arguments\n * it receives. Note that this doesn't support functions with both optional\n * and rest parameters.\n *\n * Can be thought of as \"freezing\" some portion of a function's arguments,\n * resulting in a new function with a simplified signature.\n *\n * Useful for converting a data-first function to a data-last one.\n *\n * @param func - The function to wrap.\n * @param partial - The arguments to put after.\n * @returns A partially bound function.\n * @signature\n *    partialLastBind(func, ...partial);\n * @example\n *    const fn = (x: number, y: number, z: number) => x * 100 + y * 10 + z;\n *    const partialFn = partialLastBind(fn, 2, 3);\n *    partialFn(1); //=> 123\n *\n *    const parseBinary = partialLastBind(parseInt, \"2\");\n *    parseBinary(\"101\"); //=> 5\n *\n *    pipe(\n *      { a: 1 },\n *      // instead of (arg) => JSON.stringify(arg, null, 2)\n *      partialLastBind(JSON.stringify, null, 2),\n *    ); //=> '{\\n  \"a\": 1\\n}'\n * @dataFirst\n * @category Function\n * @see partialBind\n */\nexport function partialLastBind<\n  F extends StrictFunction,\n  SuffixArgs extends TupleSuffix<Parameters<F>>,\n  RemovedSuffix extends RemoveSuffix<Parameters<F>, SuffixArgs>,\n>(\n  func: F,\n  ...partial: SuffixArgs\n): (\n  ...rest: RemovedSuffix extends IterableContainer ? RemovedSuffix : never\n) => ReturnType<F> {\n  // @ts-expect-error [ts2345, ts2322] -- TypeScript infers the generic sub-\n  // types too eagerly, making itself blind to the fact that the types match\n  // here.\n  return (...rest) => func(...rest, ...partial);\n}\n"],"mappings":"mEAqEA,SAAgB,EAKd,EACA,GAAG,EAGc,CAIjB,OAAQ,GAAG,IAAS,EAAK,GAAG,EAAM,GAAG,EAAQ"}

package/dist/partialLastBind.js

@@ -0,0 +1,2 @@
+function e(e,...t){return(...n)=>e(...n,...t)}export{e as partialLastBind};
+//# sourceMappingURL=partialLastBind.js.map

package/dist/partialLastBind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partialLastBind.js","names":[],"sources":["../src/partialLastBind.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport type { RemedaTypeError } from \"./internal/types/RemedaTypeError\";\nimport type { StrictFunction } from \"./internal/types/StrictFunction\";\nimport type { TupleSplits } from \"./internal/types/TupleSplits\";\n\ntype PartialLastBindError<\n  Message extends string,\n  Metadata = never,\n> = RemedaTypeError<\"partialLastBind\", Message, { metadata: Metadata }>;\n\ntype TupleSuffix<T extends IterableContainer> = TupleSplits<T>[\"right\"];\n\ntype RemoveSuffix<\n  T extends IterableContainer,\n  Suffix extends TupleSuffix<T>,\n> = Suffix extends readonly []\n  ? T\n  : T extends readonly [...infer TRest, infer TLast]\n    ? Suffix extends readonly [...infer SuffixRest, infer _SuffixLast]\n      ? // SuffixLast extends TLast.\n        RemoveSuffix<TRest, SuffixRest>\n      : // Suffix (as a whole) extends readonly TLast[].\n        // Suffix could possibly be empty, so this has to be TLast?.\n        [...RemoveSuffix<TRest, Suffix>, TLast?]\n    : // T has an optional or rest parameter last. If T is a parameter list,\n      // this can only happen if we have optional arguments or a rest param;\n      // both cases are similar.\n      T extends readonly [...infer TRest, (infer _TLast)?]\n      ? Suffix extends readonly [...infer SuffixRest, infer _SuffixLast]\n        ? // SuffixLast extends TLast.\n          RemoveSuffix<TRest, SuffixRest>\n        : // Suffix (as a whole) extends [...TRest, TLast?].\n          TRest\n      : // We got passed a parameter list that isn't what we expected; this\n        // is an internal error.\n        PartialLastBindError<\"Function parameter list has unexpected shape\", T>;\n\n/**\n * Creates a function that calls `func` with `partial` put after the arguments\n * it receives. Note that this doesn't support functions with both optional\n * and rest parameters.\n *\n * Can be thought of as \"freezing\" some portion of a function's arguments,\n * resulting in a new function with a simplified signature.\n *\n * Useful for converting a data-first function to a data-last one.\n *\n * @param func - The function to wrap.\n * @param partial - The arguments to put after.\n * @returns A partially bound function.\n * @signature\n *    partialLastBind(func, ...partial);\n * @example\n *    const fn = (x: number, y: number, z: number) => x * 100 + y * 10 + z;\n *    const partialFn = partialLastBind(fn, 2, 3);\n *    partialFn(1); //=> 123\n *\n *    const parseBinary = partialLastBind(parseInt, \"2\");\n *    parseBinary(\"101\"); //=> 5\n *\n *    pipe(\n *      { a: 1 },\n *      // instead of (arg) => JSON.stringify(arg, null, 2)\n *      partialLastBind(JSON.stringify, null, 2),\n *    ); //=> '{\\n  \"a\": 1\\n}'\n * @dataFirst\n * @category Function\n * @see partialBind\n */\nexport function partialLastBind<\n  F extends StrictFunction,\n  SuffixArgs extends TupleSuffix<Parameters<F>>,\n  RemovedSuffix extends RemoveSuffix<Parameters<F>, SuffixArgs>,\n>(\n  func: F,\n  ...partial: SuffixArgs\n): (\n  ...rest: RemovedSuffix extends IterableContainer ? RemovedSuffix : never\n) => ReturnType<F> {\n  // @ts-expect-error [ts2345, ts2322] -- TypeScript infers the generic sub-\n  // types too eagerly, making itself blind to the fact that the types match\n  // here.\n  return (...rest) => func(...rest, ...partial);\n}\n"],"mappings":"AAqEA,SAAgB,EAKd,EACA,GAAG,EAGc,CAIjB,OAAQ,GAAG,IAAS,EAAK,GAAG,EAAM,GAAG,EAAQ"}

package/dist/partition.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}const n=(e,t)=>{let n=[[],[]];for(let[r,i]of e.entries())t(i,r,e)?n[0].push(i):n[1].push(i);return n};exports.partition=t;
+//# sourceMappingURL=partition.cjs.map

package/dist/partition.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.cjs","names":["purry"],"sources":["../src/partition.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Splits a collection into two groups, the first of which contains elements the\n * `predicate` type guard passes, and the second one containing the rest.\n *\n * @param data - The items to split.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to add the element to the first partition, and and\n * `false` to add the element to the other partition. A type-predicate can also\n * be used to narrow the result.\n * @returns A 2-tuple of arrays where the first array contains the elements that\n * passed the predicate, and the second array contains the elements that did\n * not. The items are in the same order as they were in the original array.\n * @signature\n *    partition(data, predicate)\n * @example\n *    partition(\n *      ['one', 'two', 'forty two'],\n *      x => x.length === 3,\n *    ); // => [['one', 'two'], ['forty two']]\n * @dataFirst\n * @category Array\n */\nexport function partition<T, S extends T>(\n  data: readonly T[],\n  predicate: (value: T, index: number, data: readonly T[]) => value is S,\n): [S[], Exclude<T, S>[]];\nexport function partition<T>(\n  data: readonly T[],\n  predicate: (value: T, index: number, data: readonly T[]) => boolean,\n): [T[], T[]];\n\n/**\n * Splits a collection into two groups, the first of which contains elements the\n * `predicate` type guard passes, and the second one containing the rest.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to add the element to the first partition, and and\n * `false` to add the element to the other partition. A type-predicate can also\n * be used to narrow the result.\n * @returns A 2-tuple of arrays where the first array contains the elements that\n * passed the predicate, and the second array contains the elements that did\n * not. The items are in the same order as they were in the original array.\n * @signature\n *    partition(predicate)(data)\n * @example\n *    pipe(\n *      ['one', 'two', 'forty two'],\n *      partition(x => x.length === 3),\n *    ); // => [['one', 'two'], ['forty two']]\n * @dataLast\n * @category Array\n */\nexport function partition<T, S extends T>(\n  predicate: (value: T, index: number, data: readonly T[]) => value is S,\n): (data: readonly T[]) => [S[], Exclude<T, S>[]];\nexport function partition<T>(\n  predicate: (value: T, index: number, data: readonly T[]) => boolean,\n): (data: readonly T[]) => [T[], T[]];\n\nexport function partition(...args: readonly unknown[]): unknown {\n  return purry(partitionImplementation, args);\n}\n\nconst partitionImplementation = <T, S extends T>(\n  data: readonly T[],\n  predicate: (value: T, index: number, data: readonly T[]) => value is S,\n): [S[], T[]] => {\n  const ret: [S[], T[]] = [[], []];\n  for (const [index, item] of data.entries()) {\n    if (predicate(item, index, data)) {\n      ret[0].push(item);\n    } else {\n      ret[1].push(item);\n    }\n  }\n  return ret;\n};\n"],"mappings":"kGA6DA,SAAgB,EAAU,GAAG,EAAmC,CAC9D,OAAOA,EAAAA,MAAM,EAAyB,EAAK,CAG7C,MAAM,GACJ,EACA,IACe,CACf,IAAM,EAAkB,CAAC,EAAE,CAAE,EAAE,CAAC,CAChC,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CACpC,EAAU,EAAM,EAAO,EAAK,CAC9B,EAAI,GAAG,KAAK,EAAK,CAEjB,EAAI,GAAG,KAAK,EAAK,CAGrB,OAAO"}

package/dist/partition.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}const n=(e,t)=>{let n=[[],[]];for(let[r,i]of e.entries())t(i,r,e)?n[0].push(i):n[1].push(i);return n};export{t as partition};
+//# sourceMappingURL=partition.js.map

package/dist/partition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.js","names":[],"sources":["../src/partition.ts"],"sourcesContent":["import { purry } from \"./purry\";\n\n/**\n * Splits a collection into two groups, the first of which contains elements the\n * `predicate` type guard passes, and the second one containing the rest.\n *\n * @param data - The items to split.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to add the element to the first partition, and and\n * `false` to add the element to the other partition. A type-predicate can also\n * be used to narrow the result.\n * @returns A 2-tuple of arrays where the first array contains the elements that\n * passed the predicate, and the second array contains the elements that did\n * not. The items are in the same order as they were in the original array.\n * @signature\n *    partition(data, predicate)\n * @example\n *    partition(\n *      ['one', 'two', 'forty two'],\n *      x => x.length === 3,\n *    ); // => [['one', 'two'], ['forty two']]\n * @dataFirst\n * @category Array\n */\nexport function partition<T, S extends T>(\n  data: readonly T[],\n  predicate: (value: T, index: number, data: readonly T[]) => value is S,\n): [S[], Exclude<T, S>[]];\nexport function partition<T>(\n  data: readonly T[],\n  predicate: (value: T, index: number, data: readonly T[]) => boolean,\n): [T[], T[]];\n\n/**\n * Splits a collection into two groups, the first of which contains elements the\n * `predicate` type guard passes, and the second one containing the rest.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to add the element to the first partition, and and\n * `false` to add the element to the other partition. A type-predicate can also\n * be used to narrow the result.\n * @returns A 2-tuple of arrays where the first array contains the elements that\n * passed the predicate, and the second array contains the elements that did\n * not. The items are in the same order as they were in the original array.\n * @signature\n *    partition(predicate)(data)\n * @example\n *    pipe(\n *      ['one', 'two', 'forty two'],\n *      partition(x => x.length === 3),\n *    ); // => [['one', 'two'], ['forty two']]\n * @dataLast\n * @category Array\n */\nexport function partition<T, S extends T>(\n  predicate: (value: T, index: number, data: readonly T[]) => value is S,\n): (data: readonly T[]) => [S[], Exclude<T, S>[]];\nexport function partition<T>(\n  predicate: (value: T, index: number, data: readonly T[]) => boolean,\n): (data: readonly T[]) => [T[], T[]];\n\nexport function partition(...args: readonly unknown[]): unknown {\n  return purry(partitionImplementation, args);\n}\n\nconst partitionImplementation = <T, S extends T>(\n  data: readonly T[],\n  predicate: (value: T, index: number, data: readonly T[]) => value is S,\n): [S[], T[]] => {\n  const ret: [S[], T[]] = [[], []];\n  for (const [index, item] of data.entries()) {\n    if (predicate(item, index, data)) {\n      ret[0].push(item);\n    } else {\n      ret[1].push(item);\n    }\n  }\n  return ret;\n};\n"],"mappings":"mCA6DA,SAAgB,EAAU,GAAG,EAAmC,CAC9D,OAAO,EAAM,EAAyB,EAAK,CAG7C,MAAM,GACJ,EACA,IACe,CACf,IAAM,EAAkB,CAAC,EAAE,CAAE,EAAE,CAAC,CAChC,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CACpC,EAAU,EAAM,EAAO,EAAK,CAC9B,EAAI,GAAG,KAAK,EAAK,CAEjB,EAAI,GAAG,KAAK,EAAK,CAGrB,OAAO"}

package/dist/pathOr.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}function n(e,t,n){let r=e;for(let e of t){if(r==null)break;r=r[e]}return r??n}exports.pathOr=t;
+//# sourceMappingURL=pathOr.cjs.map

package/dist/pathOr.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathOr.cjs","names":["purry"],"sources":["../src/pathOr.ts"],"sourcesContent":["/* eslint-disable jsdoc/require-param, jsdoc/require-example, jsdoc/require-description -- allow us to deprecate all overloads of the function, not just those that have the docblock directly above them. */\n\nimport { purry } from \"./purry\";\n\n/**\n * Given a union of indexable types `T`, we derive an indexable type\n * containing all of the keys of each variant of `T`. If a key is\n * present in multiple variants of `T`, then the corresponding type in\n * `Pathable<T>` will be the intersection of all types for that key.\n *\n * @example\n *    type T1 = Pathable<{a: number} | {a: string; b: boolean}>\n *    // {a: number | string; b: boolean}\n *\n *    type T2 = Pathable<{a?: {b: string}}\n *    // {a: {b: string} | undefined}\n *\n *    type T3 = Pathable<{a: string} | number>\n *    // {a: string}\n *\n *    type T4 = Pathable<{a: number} | {a: string} | {b: boolean}>\n *    // {a: number | string; b: boolean}\n *\n * This type lets us answer the questions:\n * - Given some object of type `T`, what keys might this object have?\n * - If this object did happen to have a particular key, what values\n *   might that key have?\n */\ntype Pathable<T> = { [K in AllKeys<T>]: TypesForKey<T, K> };\n\ntype AllKeys<T> = T extends infer I ? keyof I : never;\ntype TypesForKey<T, K extends PropertyKey> = T extends infer I\n  ? K extends keyof I\n    ? I[K]\n    : never\n  : never;\n\n// Like Required<T>, but also removes explicit null and undefined typings */\ntype StrictlyRequired<T> = { [K in keyof T]-?: NonNullable<T[K]> };\n\n/**\n * Given some `A` which is a key of at least one variant of `T`, derive\n * `T[A]` for the cases where `A` is present in `T`, and `T[A]` is not\n * null or undefined.\n */\ntype PathValue1<T, A extends keyof Pathable<T>> = StrictlyRequired<\n  Pathable<T>\n>[A];\n/** All possible options after successfully reaching `T[A]`. */\ntype Pathable1<T, A extends keyof Pathable<T>> = Pathable<PathValue1<T, A>>;\n\n/** As `PathValue1`, but for `T[A][B]`. */\ntype PathValue2<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n> = StrictlyRequired<Pathable1<T, A>>[B];\n/** As `Pathable1`, but for `T[A][B]`. */\ntype Pathable2<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n> = Pathable<PathValue2<T, A, B>>;\n\n/** As `PathValue1`, but for `T[A][B][C]`. */\ntype PathValue3<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n  C extends keyof Pathable2<T, A, B>,\n> = StrictlyRequired<Pathable2<T, A, B>>[C];\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is `null` or `undefined`, the `defaultValue` is returned in its place.\n *\n * **DEPRECATED**: Use `defaultTo(prop(object, ...path), defaultValue)`\n * instead!\n *\n * @param object - The target object.\n * @param path - The path of the property to get.\n * @param defaultValue - The default value.\n * @signature pathOr(object, array, defaultValue)\n * @example\n *    pathOr({x: 10}, ['y'], 2) // 2\n *    pathOr({y: 10}, ['y'], 2) // 10\n * @dataFirst\n * @category Object\n * @deprecated Use `defaultTo(prop(object, ...path), defaultValue)` instead.\n */\nexport function pathOr<T, A extends keyof Pathable<T>>(\n  object: T,\n  path: readonly [A],\n  defaultValue: PathValue1<T, A>,\n): PathValue1<T, A>;\n\n/**\n * @deprecated Use `defaultTo(prop(object, ...path), defaultValue)` instead.\n */\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n>(\n  object: T,\n  path: readonly [A, B],\n  defaultValue: PathValue2<T, A, B>,\n): PathValue2<T, A, B>;\n\n/**\n * @deprecated Use `defaultTo(prop(object, ...path), defaultValue)` instead.\n */\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n  C extends keyof Pathable2<T, A, B>,\n>(\n  object: T,\n  path: readonly [A, B, C],\n  defaultValue: PathValue3<T, A, B, C>,\n): PathValue3<T, A, B, C>;\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place.\n *\n * **DEPRECATED**: Use `($) => defaultTo(prop($, ...path), defaultValue)`\n * instead, or if already inside a `pipe`, replace the call to `pathOr` with:\n * `pipe(..., prop(...path), defaultTo(defaultValue), ...)`.\n *\n * @param path - The path of the property to get.\n * @param defaultValue - The default value.\n * @signature pathOr(array, defaultValue)(object)\n * @example\n *    pipe({x: 10}, pathOr(['y'], 2)) // 2\n *    pipe({y: 10}, pathOr(['y'], 2)) // 10\n * @dataLast\n * @category Object\n * @deprecated Use `($) => defaultTo(prop($, ...path), defaultValue)` instead,\n * or if already inside a `pipe`, replace the call to `pathOr` with:\n * `pipe(..., prop(...path), defaultTo(defaultValue), ...)`.\n */\nexport function pathOr<T, A extends keyof Pathable<T>>(\n  path: readonly [A],\n  defaultValue: PathValue1<T, A>,\n): (object: T) => PathValue1<T, A>;\n\n/**\n * @deprecated Use `($) => defaultTo(prop($, ...path), defaultValue)` instead,\n * or if already inside a `pipe`, replace the call to `pathOr` with:\n * `pipe(..., prop(...path), defaultTo(defaultValue), ...)`.\n */\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n>(\n  path: readonly [A, B],\n  defaultValue: PathValue2<T, A, B>,\n): (object: T) => PathValue2<T, A, B>;\n\n/**\n * @deprecated Use `($) => defaultTo(prop($, ...path), defaultValue)` instead,\n * or if already inside a `pipe`, replace the call to `pathOr` with:\n * `pipe(..., prop(...path), defaultTo(defaultValue), ...)`.\n */\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n  C extends keyof Pathable2<T, A, B>,\n>(\n  path: readonly [A, B, C],\n  defaultValue: PathValue3<T, A, B, C>,\n): (object: T) => PathValue3<T, A, B, C>;\n\n// TODO [>2]: Remove this function!\nexport function pathOr(...args: readonly unknown[]): unknown {\n  return purry(pathOrImplementation, args);\n}\n\nfunction pathOrImplementation(\n  data: unknown,\n  path: readonly PropertyKey[],\n  defaultValue: unknown,\n): unknown {\n  let current = data;\n  for (const prop of path) {\n    if (current === null || current === undefined) {\n      break;\n    }\n    current = (current as Record<PropertyKey, unknown>)[prop];\n  }\n\n  return current ?? defaultValue;\n}\n"],"mappings":"kGAgLA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACA,EACS,CACT,IAAI,EAAU,EACd,IAAK,IAAM,KAAQ,EAAM,CACvB,GAAI,GAAY,KACd,MAEF,EAAW,EAAyC,GAGtD,OAAO,GAAW"}

package/dist/pathOr.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}function n(e,t,n){let r=e;for(let e of t){if(r==null)break;r=r[e]}return r??n}export{t as pathOr};
+//# sourceMappingURL=pathOr.js.map

package/dist/pathOr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathOr.js","names":[],"sources":["../src/pathOr.ts"],"sourcesContent":["/* eslint-disable jsdoc/require-param, jsdoc/require-example, jsdoc/require-description -- allow us to deprecate all overloads of the function, not just those that have the docblock directly above them. */\n\nimport { purry } from \"./purry\";\n\n/**\n * Given a union of indexable types `T`, we derive an indexable type\n * containing all of the keys of each variant of `T`. If a key is\n * present in multiple variants of `T`, then the corresponding type in\n * `Pathable<T>` will be the intersection of all types for that key.\n *\n * @example\n *    type T1 = Pathable<{a: number} | {a: string; b: boolean}>\n *    // {a: number | string; b: boolean}\n *\n *    type T2 = Pathable<{a?: {b: string}}\n *    // {a: {b: string} | undefined}\n *\n *    type T3 = Pathable<{a: string} | number>\n *    // {a: string}\n *\n *    type T4 = Pathable<{a: number} | {a: string} | {b: boolean}>\n *    // {a: number | string; b: boolean}\n *\n * This type lets us answer the questions:\n * - Given some object of type `T`, what keys might this object have?\n * - If this object did happen to have a particular key, what values\n *   might that key have?\n */\ntype Pathable<T> = { [K in AllKeys<T>]: TypesForKey<T, K> };\n\ntype AllKeys<T> = T extends infer I ? keyof I : never;\ntype TypesForKey<T, K extends PropertyKey> = T extends infer I\n  ? K extends keyof I\n    ? I[K]\n    : never\n  : never;\n\n// Like Required<T>, but also removes explicit null and undefined typings */\ntype StrictlyRequired<T> = { [K in keyof T]-?: NonNullable<T[K]> };\n\n/**\n * Given some `A` which is a key of at least one variant of `T`, derive\n * `T[A]` for the cases where `A` is present in `T`, and `T[A]` is not\n * null or undefined.\n */\ntype PathValue1<T, A extends keyof Pathable<T>> = StrictlyRequired<\n  Pathable<T>\n>[A];\n/** All possible options after successfully reaching `T[A]`. */\ntype Pathable1<T, A extends keyof Pathable<T>> = Pathable<PathValue1<T, A>>;\n\n/** As `PathValue1`, but for `T[A][B]`. */\ntype PathValue2<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n> = StrictlyRequired<Pathable1<T, A>>[B];\n/** As `Pathable1`, but for `T[A][B]`. */\ntype Pathable2<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n> = Pathable<PathValue2<T, A, B>>;\n\n/** As `PathValue1`, but for `T[A][B][C]`. */\ntype PathValue3<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n  C extends keyof Pathable2<T, A, B>,\n> = StrictlyRequired<Pathable2<T, A, B>>[C];\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is `null` or `undefined`, the `defaultValue` is returned in its place.\n *\n * **DEPRECATED**: Use `defaultTo(prop(object, ...path), defaultValue)`\n * instead!\n *\n * @param object - The target object.\n * @param path - The path of the property to get.\n * @param defaultValue - The default value.\n * @signature pathOr(object, array, defaultValue)\n * @example\n *    pathOr({x: 10}, ['y'], 2) // 2\n *    pathOr({y: 10}, ['y'], 2) // 10\n * @dataFirst\n * @category Object\n * @deprecated Use `defaultTo(prop(object, ...path), defaultValue)` instead.\n */\nexport function pathOr<T, A extends keyof Pathable<T>>(\n  object: T,\n  path: readonly [A],\n  defaultValue: PathValue1<T, A>,\n): PathValue1<T, A>;\n\n/**\n * @deprecated Use `defaultTo(prop(object, ...path), defaultValue)` instead.\n */\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n>(\n  object: T,\n  path: readonly [A, B],\n  defaultValue: PathValue2<T, A, B>,\n): PathValue2<T, A, B>;\n\n/**\n * @deprecated Use `defaultTo(prop(object, ...path), defaultValue)` instead.\n */\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n  C extends keyof Pathable2<T, A, B>,\n>(\n  object: T,\n  path: readonly [A, B, C],\n  defaultValue: PathValue3<T, A, B, C>,\n): PathValue3<T, A, B, C>;\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place.\n *\n * **DEPRECATED**: Use `($) => defaultTo(prop($, ...path), defaultValue)`\n * instead, or if already inside a `pipe`, replace the call to `pathOr` with:\n * `pipe(..., prop(...path), defaultTo(defaultValue), ...)`.\n *\n * @param path - The path of the property to get.\n * @param defaultValue - The default value.\n * @signature pathOr(array, defaultValue)(object)\n * @example\n *    pipe({x: 10}, pathOr(['y'], 2)) // 2\n *    pipe({y: 10}, pathOr(['y'], 2)) // 10\n * @dataLast\n * @category Object\n * @deprecated Use `($) => defaultTo(prop($, ...path), defaultValue)` instead,\n * or if already inside a `pipe`, replace the call to `pathOr` with:\n * `pipe(..., prop(...path), defaultTo(defaultValue), ...)`.\n */\nexport function pathOr<T, A extends keyof Pathable<T>>(\n  path: readonly [A],\n  defaultValue: PathValue1<T, A>,\n): (object: T) => PathValue1<T, A>;\n\n/**\n * @deprecated Use `($) => defaultTo(prop($, ...path), defaultValue)` instead,\n * or if already inside a `pipe`, replace the call to `pathOr` with:\n * `pipe(..., prop(...path), defaultTo(defaultValue), ...)`.\n */\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n>(\n  path: readonly [A, B],\n  defaultValue: PathValue2<T, A, B>,\n): (object: T) => PathValue2<T, A, B>;\n\n/**\n * @deprecated Use `($) => defaultTo(prop($, ...path), defaultValue)` instead,\n * or if already inside a `pipe`, replace the call to `pathOr` with:\n * `pipe(..., prop(...path), defaultTo(defaultValue), ...)`.\n */\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n  C extends keyof Pathable2<T, A, B>,\n>(\n  path: readonly [A, B, C],\n  defaultValue: PathValue3<T, A, B, C>,\n): (object: T) => PathValue3<T, A, B, C>;\n\n// TODO [>2]: Remove this function!\nexport function pathOr(...args: readonly unknown[]): unknown {\n  return purry(pathOrImplementation, args);\n}\n\nfunction pathOrImplementation(\n  data: unknown,\n  path: readonly PropertyKey[],\n  defaultValue: unknown,\n): unknown {\n  let current = data;\n  for (const prop of path) {\n    if (current === null || current === undefined) {\n      break;\n    }\n    current = (current as Record<PropertyKey, unknown>)[prop];\n  }\n\n  return current ?? defaultValue;\n}\n"],"mappings":"mCAgLA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACA,EACS,CACT,IAAI,EAAU,EACd,IAAK,IAAM,KAAQ,EAAM,CACvB,GAAI,GAAY,KACd,MAEF,EAAW,EAAyC,GAGtD,OAAO,GAAW"}

package/dist/pick.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}function n(e,t){let n={};for(let r of t)r in e&&(n[r]=e[r]);return n}exports.pick=t;
+//# sourceMappingURL=pick.cjs.map

package/dist/pick.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick.cjs","names":["purry"],"sources":["../src/pick.ts"],"sourcesContent":["import type { EmptyObject, IsNever, KeysOfUnion, Writable } from \"type-fest\";\nimport type { IsBounded } from \"./internal/types/IsBounded\";\nimport type { IsBoundedRecord } from \"./internal/types/IsBoundedRecord\";\nimport type { PartitionByUnion } from \"./internal/types/PartitionByUnion\";\nimport type { TupleParts } from \"./internal/types/TupleParts\";\nimport { purry } from \"./purry\";\n\ntype PickFromArray<T, Keys extends readonly KeysOfUnion<T>[]> =\n  // Distribute unions for both object types and key arrays.\n  T extends unknown\n    ? Keys extends unknown\n      ? // When T is a union (or when Keys is empty) the picked props might\n        // not exist in some of its sub-types, e.g.,\n        //   `pick(... as { a: string } | { b: number }, ['a'])`,\n        // if we simply let the regular \"constructive\" logic run, the\n        // resulting type would be `{}` which doesn't behave like an empty\n        // object! instead, we want to use a more explicit *empty* type.\n        IsNever<Extract<Keys[number], keyof T>> extends true\n        ? EmptyObject\n        : // Remove `readonly` modifiers from picked props since we return a\n          // new, mutable, object. We don't wrap the result with `Simplify` to\n          // flatten it because `Writable` does the same thing implicitly.\n          Writable<\n            IsBoundedRecord<T> extends true\n              ? PickBoundedFromArray<T, Keys>\n              : PickUnbounded<T, Extract<Keys[number], keyof T>>\n          >\n      : never\n    : never;\n\n/**\n * Bounded records have bounded keys and result in a bounded output. The only\n * question left is whether to add the prop as-is, or make it optional. This\n * can be determined by the part of the keys array the prop is defined in, and\n * the way that element is defined: if the array contains a singular literal\n * key in either the required prefix or the suffix, we know that prop should be\n * picked as-is, otherwise, the key might not be present in the keys array so it\n * can only be picked optionally.\n */\ntype PickBoundedFromArray<T, Keys extends readonly KeysOfUnion<T>[]> =\n  // Literal keys in the prefix/suffix are guaranteed present.\n  Pick<\n    T,\n    // When T is a union the keys need to be narrowed to just those that are\n    // keys of the specific sub-type being built\n    Extract<\n      | PartitionByUnion<TupleParts<Keys>[\"required\"]>[\"singular\"]\n      | PartitionByUnion<TupleParts<Keys>[\"suffix\"]>[\"singular\"],\n      keyof T\n    >\n  > &\n    // Union keys, optional elements, and rest elements are optional.\n    Partial<\n      Pick<\n        T,\n        // When T is a union the keys need to be narrowed to just those that are\n        // keys of the specific sub-type being built.\n        Extract<\n          | PartitionByUnion<TupleParts<Keys>[\"required\"]>[\"union\"]\n          // TODO: the optional part of the keys array will always be empty because its impossible to provide the pick function with a tuple with optional elements; this is because optional elements are always implicitly `undefined` too; which breaks the constraint that all keys are keys of T (`undefined` is not a key of anything). We can lift this restriction by supporting `undefined` in the runtime and relaxing the type constraint to allow it, but this relaxed constraint enables a niche feature (optional tuple elements) at the expense of better type-safety for the more common cases of fixed tuples and arrays. Anyway... if we ever change it, this part of the output type will ensure the output is still correct:\n          | TupleParts<Keys>[\"optional\"][number]\n          | TupleParts<Keys>[\"item\"]\n          | PartitionByUnion<TupleParts<Keys>[\"suffix\"]>[\"union\"],\n          keyof T\n        >\n      >\n    >;\n\n/**\n * The built-in `Pick` is weird when it comes to picking bounded keys from\n * unbounded records. It reconstructs the output object regardless of the shape\n * of the input: `Pick<Record<string, \"world\">, \"hello\">` results in the type\n * `{ hello: \"world\" }`, but you'd expect it to be optional because we don't\n * know if the record contains a `hello` prop or not!\n *\n * !Important: We assume T is unbounded and don't test for it!\n *\n * See: https://www.typescriptlang.org/play/?#code/PTAEE0HsFcHIBNQFMAeAHJBjALqAGqNpKAEZKigAGA3qABZIA2jkA-AFygBEA7pAE6N4XUAF9KAGlLRcAQ0ayAzgChsATwz5QAXlAAFAJaYA1gB4ASlgHxTi7PwMA7AOZTeAoVwB8bhs0jeANzKIBSgAHqsykA.\n */\ntype PickUnbounded<T, Keys extends keyof T> =\n  IsBounded<Keys> extends true ? Partial<Pick<T, Keys>> : Pick<T, Keys>;\n\n/**\n * Creates an object composed of the picked `data` properties.\n *\n * @param keys - The property names.\n * @signature pick([prop1, prop2])(object)\n * @example\n *    pipe({ a: 1, b: 2, c: 3, d: 4 }, pick(['a', 'd'])) // => { a: 1, d: 4 }\n * @dataLast\n * @category Object\n */\nexport function pick<\n  T extends object,\n  const Keys extends readonly KeysOfUnion<T>[],\n>(keys: Keys): (data: T) => PickFromArray<T, Keys>;\n\n/**\n * Creates an object composed of the picked `data` properties.\n *\n * @param data - The target object.\n * @param keys - The property names.\n * @signature pick(object, [prop1, prop2])\n * @example\n *    pick({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { a: 1, d: 4 }\n * @dataFirst\n * @category Object\n */\nexport function pick<\n  T extends object,\n  const Keys extends readonly KeysOfUnion<T>[],\n>(data: T, keys: Keys): PickFromArray<T, Keys>;\n\nexport function pick(...args: readonly unknown[]): unknown {\n  return purry(pickImplementation, args);\n}\n\nfunction pickImplementation<\n  T extends object,\n  Keys extends readonly (keyof T)[],\n>(object: T, keys: Keys): PickFromArray<T, Keys> {\n  const out: Partial<Pick<T, Keys[number]>> = {};\n  for (const key of keys) {\n    if (key in object) {\n      out[key] = object[key];\n    }\n  }\n  // @ts-expect-error [ts2322] - We build the type incrementally, there's no way to make typescript infer that we \"finished\" building the object and to treat it as such.\n  return out;\n}\n"],"mappings":"kGAiHA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAOA,EAAAA,MAAM,EAAoB,EAAK,CAGxC,SAAS,EAGP,EAAW,EAAoC,CAC/C,IAAM,EAAsC,EAAE,CAC9C,IAAK,IAAM,KAAO,EACZ,KAAO,IACT,EAAI,GAAO,EAAO,IAItB,OAAO"}

package/dist/pick.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}function n(e,t){let n={};for(let r of t)r in e&&(n[r]=e[r]);return n}export{t as pick};
+//# sourceMappingURL=pick.js.map

package/dist/pick.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick.js","names":[],"sources":["../src/pick.ts"],"sourcesContent":["import type { EmptyObject, IsNever, KeysOfUnion, Writable } from \"type-fest\";\nimport type { IsBounded } from \"./internal/types/IsBounded\";\nimport type { IsBoundedRecord } from \"./internal/types/IsBoundedRecord\";\nimport type { PartitionByUnion } from \"./internal/types/PartitionByUnion\";\nimport type { TupleParts } from \"./internal/types/TupleParts\";\nimport { purry } from \"./purry\";\n\ntype PickFromArray<T, Keys extends readonly KeysOfUnion<T>[]> =\n  // Distribute unions for both object types and key arrays.\n  T extends unknown\n    ? Keys extends unknown\n      ? // When T is a union (or when Keys is empty) the picked props might\n        // not exist in some of its sub-types, e.g.,\n        //   `pick(... as { a: string } | { b: number }, ['a'])`,\n        // if we simply let the regular \"constructive\" logic run, the\n        // resulting type would be `{}` which doesn't behave like an empty\n        // object! instead, we want to use a more explicit *empty* type.\n        IsNever<Extract<Keys[number], keyof T>> extends true\n        ? EmptyObject\n        : // Remove `readonly` modifiers from picked props since we return a\n          // new, mutable, object. We don't wrap the result with `Simplify` to\n          // flatten it because `Writable` does the same thing implicitly.\n          Writable<\n            IsBoundedRecord<T> extends true\n              ? PickBoundedFromArray<T, Keys>\n              : PickUnbounded<T, Extract<Keys[number], keyof T>>\n          >\n      : never\n    : never;\n\n/**\n * Bounded records have bounded keys and result in a bounded output. The only\n * question left is whether to add the prop as-is, or make it optional. This\n * can be determined by the part of the keys array the prop is defined in, and\n * the way that element is defined: if the array contains a singular literal\n * key in either the required prefix or the suffix, we know that prop should be\n * picked as-is, otherwise, the key might not be present in the keys array so it\n * can only be picked optionally.\n */\ntype PickBoundedFromArray<T, Keys extends readonly KeysOfUnion<T>[]> =\n  // Literal keys in the prefix/suffix are guaranteed present.\n  Pick<\n    T,\n    // When T is a union the keys need to be narrowed to just those that are\n    // keys of the specific sub-type being built\n    Extract<\n      | PartitionByUnion<TupleParts<Keys>[\"required\"]>[\"singular\"]\n      | PartitionByUnion<TupleParts<Keys>[\"suffix\"]>[\"singular\"],\n      keyof T\n    >\n  > &\n    // Union keys, optional elements, and rest elements are optional.\n    Partial<\n      Pick<\n        T,\n        // When T is a union the keys need to be narrowed to just those that are\n        // keys of the specific sub-type being built.\n        Extract<\n          | PartitionByUnion<TupleParts<Keys>[\"required\"]>[\"union\"]\n          // TODO: the optional part of the keys array will always be empty because its impossible to provide the pick function with a tuple with optional elements; this is because optional elements are always implicitly `undefined` too; which breaks the constraint that all keys are keys of T (`undefined` is not a key of anything). We can lift this restriction by supporting `undefined` in the runtime and relaxing the type constraint to allow it, but this relaxed constraint enables a niche feature (optional tuple elements) at the expense of better type-safety for the more common cases of fixed tuples and arrays. Anyway... if we ever change it, this part of the output type will ensure the output is still correct:\n          | TupleParts<Keys>[\"optional\"][number]\n          | TupleParts<Keys>[\"item\"]\n          | PartitionByUnion<TupleParts<Keys>[\"suffix\"]>[\"union\"],\n          keyof T\n        >\n      >\n    >;\n\n/**\n * The built-in `Pick` is weird when it comes to picking bounded keys from\n * unbounded records. It reconstructs the output object regardless of the shape\n * of the input: `Pick<Record<string, \"world\">, \"hello\">` results in the type\n * `{ hello: \"world\" }`, but you'd expect it to be optional because we don't\n * know if the record contains a `hello` prop or not!\n *\n * !Important: We assume T is unbounded and don't test for it!\n *\n * See: https://www.typescriptlang.org/play/?#code/PTAEE0HsFcHIBNQFMAeAHJBjALqAGqNpKAEZKigAGA3qABZIA2jkA-AFygBEA7pAE6N4XUAF9KAGlLRcAQ0ayAzgChsATwz5QAXlAAFAJaYA1gB4ASlgHxTi7PwMA7AOZTeAoVwB8bhs0jeANzKIBSgAHqsykA.\n */\ntype PickUnbounded<T, Keys extends keyof T> =\n  IsBounded<Keys> extends true ? Partial<Pick<T, Keys>> : Pick<T, Keys>;\n\n/**\n * Creates an object composed of the picked `data` properties.\n *\n * @param keys - The property names.\n * @signature pick([prop1, prop2])(object)\n * @example\n *    pipe({ a: 1, b: 2, c: 3, d: 4 }, pick(['a', 'd'])) // => { a: 1, d: 4 }\n * @dataLast\n * @category Object\n */\nexport function pick<\n  T extends object,\n  const Keys extends readonly KeysOfUnion<T>[],\n>(keys: Keys): (data: T) => PickFromArray<T, Keys>;\n\n/**\n * Creates an object composed of the picked `data` properties.\n *\n * @param data - The target object.\n * @param keys - The property names.\n * @signature pick(object, [prop1, prop2])\n * @example\n *    pick({ a: 1, b: 2, c: 3, d: 4 }, ['a', 'd']) // => { a: 1, d: 4 }\n * @dataFirst\n * @category Object\n */\nexport function pick<\n  T extends object,\n  const Keys extends readonly KeysOfUnion<T>[],\n>(data: T, keys: Keys): PickFromArray<T, Keys>;\n\nexport function pick(...args: readonly unknown[]): unknown {\n  return purry(pickImplementation, args);\n}\n\nfunction pickImplementation<\n  T extends object,\n  Keys extends readonly (keyof T)[],\n>(object: T, keys: Keys): PickFromArray<T, Keys> {\n  const out: Partial<Pick<T, Keys[number]>> = {};\n  for (const key of keys) {\n    if (key in object) {\n      out[key] = object[key];\n    }\n  }\n  // @ts-expect-error [ts2322] - We build the type incrementally, there's no way to make typescript infer that we \"finished\" building the object and to treat it as such.\n  return out;\n}\n"],"mappings":"mCAiHA,SAAgB,EAAK,GAAG,EAAmC,CACzD,OAAO,EAAM,EAAoB,EAAK,CAGxC,SAAS,EAGP,EAAW,EAAoC,CAC/C,IAAM,EAAsC,EAAE,CAC9C,IAAK,IAAM,KAAO,EACZ,KAAO,IACT,EAAI,GAAO,EAAO,IAItB,OAAO"}

package/dist/pickBy.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}function n(e,t){let n={};for(let[r,i]of Object.entries(e))t(i,r,e)&&(n[r]=i);return n}exports.pickBy=t;
+//# sourceMappingURL=pickBy.cjs.map

package/dist/pickBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pickBy.cjs","names":["purry"],"sources":["../src/pickBy.ts"],"sourcesContent":["import type { IsNever, Simplify } from \"type-fest\";\nimport type { EnumerableStringKeyOf } from \"./internal/types/EnumerableStringKeyOf\";\nimport type { EnumerableStringKeyedValueOf } from \"./internal/types/EnumerableStringKeyedValueOf\";\nimport type { IsBoundedRecord } from \"./internal/types/IsBoundedRecord\";\nimport type { ToString } from \"./internal/types/ToString\";\nimport { purry } from \"./purry\";\n\n// When the predicate isn't a type-guard we don't know which properties would be\n// part of the output and which wouldn't so we can only safely downgrade the\n// whole object to a Partial of the input.\ntype EnumeratedPartial<T> = T extends unknown\n  ? Simplify<\n      IsBoundedRecord<T> extends true\n        ? {\n            // Object.entries returns keys as strings.\n            -readonly [P in keyof T as ToString<P>]?: Required<T>[P];\n          }\n        : // For unbounded records (a simple Record with primitive `string` or\n          // `number` keys) the return type here could technically be T; but for\n          // cases where the record is unbounded but is more complex (like\n          // `symbol` keys) we want to \"reconstruct\" the record from just its\n          // enumerable components (which are the ones accessible via\n          // `Object.entries`).\n          Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>\n    >\n  : never;\n\n// When the predicate is a type-guard we have more information to work with when\n// constructing the type of the output object. We can safely remove any property\n// which value would never come up true for the predicate, AND we can also\n// assume that properties that match the predicate perfectly would **always**\n// show up in the output object. Hence to build the output object we need to\n// build and merge 2 output objects: One for the properties which have a value\n// of at type that would always yield a `true` result from the predicate, these\n// are the \"matches\", which would not change the \"optionality\" of the input\n// object's props, and one for partial matches which would also make the props\n// optional (as they could have a value that would be filtered out).\ntype EnumeratedPartialNarrowed<T, S> = T extends unknown\n  ? Simplify<\n      IsBoundedRecord<T> extends true\n        ? ExactProps<T, S> & PartialProps<T, S>\n        : // For unbounded records we need to \"reconstruct\" the record and\n          // narrow the value types. Similar to the non-narrowed case, we need\n          // to also ignore `symbol` keys and any values that are only relevant\n          // to them.\n          Record<\n            EnumerableStringKeyOf<T>,\n            Extract<EnumerableStringKeyedValueOf<T>, S>\n          >\n    >\n  : never;\n\n// The exact case, props here would always be part of the output object\ntype ExactProps<T, S> = {\n  // Object.entries returns keys as strings.\n  -readonly [P in keyof T as ToString<\n    IsExactProp<T, P, S> extends true ? P : never\n  >]: Extract<Required<T>[P], S>;\n};\n\n// The partial case, props here might be part of the output object, but might\n// not be, hence they are optional.\ntype PartialProps<T, S> = {\n  // Object.entries returns keys as strings.\n  -readonly [P in keyof T as ToString<\n    IsPartialProp<T, P, S> extends true ? P : never\n  >]?: IsNever<Extract<T[P], S>> extends true\n    ? // If the result of extracting S from T[P] is never but S still extends\n      // it, it means that T[P] is too wide and S can't be extracted from it:\n      // e.g. if T[P] is `number` S is `1` then `Extract<number, 1> === never`.\n      // For these cases we can return S directly as the type as it's already\n      // very narrowed compared to T[P].\n      S extends T[P]\n      ? S\n      : never\n    : Extract<T[P], S>;\n};\n\n// If the input object's value type extends itself when the type-guard is\n// extracted from it we can safely assume that the predicate would always return\n// true for any value of that property.\ntype IsExactProp<T, P extends keyof T, S> =\n  T[P] extends Extract<T[P], S> ? true : false;\n\n// ...and if the input object's value type isn't an exact match, but still has\n// some partial match (i.g. the extracted type-guard isn't completely disjoint)\n// then we can assume that the property can sometimes return true, and sometimes\n// false when passed to the predicate, hence it should be optional in the\n// output.\ntype IsPartialProp<T, P extends keyof T, S> =\n  IsExactProp<T, P, S> extends true\n    ? false\n    : IsNever<Extract<T[P], S>> extends true\n      ? S extends T[P]\n        ? // If the result of extracting S from T[P] is never but S still\n          // extends it, it means that T[P] is too wide and S can't be\n          // extracted from it: e.g. if T[P] is `number` S is `1` then\n          // `Extract<number, 1> === never`, but `1` extends `number`. We need\n          // to handle these cases when we extract the value too (see above).\n          true\n        : false\n      : true;\n\n/**\n * Iterates over the entries of `data` and reconstructs the object using only\n * entries that `predicate` accepts. Symbol keys are not passed to the predicate\n * and would be filtered out from the output object.\n *\n * See `omitBy` for a complementary function which starts with a shallow copy of\n * the input object and removes the entries that the predicate rejects. Because\n * it is subtractive symbol keys would be copied over to the output object.\n * See also `entries`, `filter`, and `fromEntries` which could be used to build\n * your own version of `pickBy` if you need more control (though the resulting\n * type might be less precise).\n *\n * @param data - The target object.\n * @param predicate - A function that takes the value, key, and the data itself\n * and returns true if the entry should be part of the output object, or `false`\n * to remove it. If the function is a type-guard on the value the output type\n * would be narrowed accordingly.\n * @returns A shallow copy of the input object with the rejected entries\n * removed.\n * @signature pickBy(data, predicate)\n * @example\n *    pickBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {A: 3, B: 4}\n * @dataFirst\n * @category Object\n */\nexport function pickBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): EnumeratedPartialNarrowed<T, S>;\nexport function pickBy<T extends object>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): EnumeratedPartial<T>;\n\n/**\n * Iterates over the entries of `data` and reconstructs the object using only\n * entries that `predicate` accepts. Symbol keys are not passed to the predicate\n * and would be filtered out from the output object.\n *\n * See `omitBy` for a complementary function which starts with a shallow copy of\n * the input object and removes the entries that the predicate rejects. Because\n * it is subtractive symbol keys would be copied over to the output object.\n * See also `entries`, `filter`, and `fromEntries` which could be used to build\n * your own version of `pickBy` if you need more control (though the resulting\n * type might be less precise).\n *\n * @param predicate - A function that takes the value, key, and the data itself\n * and returns true if the entry should be part of the output object, or `false`\n * to remove it. If the function is a type-guard on the value the output type\n * would be narrowed accordingly.\n * @signature\n *   pickBy(predicate)(data)\n * @example\n *    pipe({a: 1, b: 2, A: 3, B: 4}, pickBy((val, key) => key.toUpperCase() === key)); // => {A: 3, B: 4}\n * @dataLast\n * @category Object\n */\nexport function pickBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): (data: T) => EnumeratedPartialNarrowed<T, S>;\nexport function pickBy<T extends object>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): (data: T) => EnumeratedPartial<T>;\n\nexport function pickBy(...args: readonly unknown[]): unknown {\n  return purry(pickByImplementation, args);\n}\n\nfunction pickByImplementation<T extends object>(\n  data: T,\n  predicate: (value: unknown, key: string, data: T) => boolean,\n): Record<string, unknown> {\n  const out: Partial<Record<string, unknown>> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    if (predicate(value, key, data)) {\n      out[key] = value;\n    }\n  }\n\n  return out;\n}\n"],"mappings":"kGA6LA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAOA,EAAAA,MAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACyB,CACzB,IAAM,EAAwC,EAAE,CAEhD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CACzC,EAAU,EAAO,EAAK,EAAK,GAC7B,EAAI,GAAO,GAIf,OAAO"}

package/dist/pickBy.js

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

package/dist/pickBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pickBy.js","names":[],"sources":["../src/pickBy.ts"],"sourcesContent":["import type { IsNever, Simplify } from \"type-fest\";\nimport type { EnumerableStringKeyOf } from \"./internal/types/EnumerableStringKeyOf\";\nimport type { EnumerableStringKeyedValueOf } from \"./internal/types/EnumerableStringKeyedValueOf\";\nimport type { IsBoundedRecord } from \"./internal/types/IsBoundedRecord\";\nimport type { ToString } from \"./internal/types/ToString\";\nimport { purry } from \"./purry\";\n\n// When the predicate isn't a type-guard we don't know which properties would be\n// part of the output and which wouldn't so we can only safely downgrade the\n// whole object to a Partial of the input.\ntype EnumeratedPartial<T> = T extends unknown\n  ? Simplify<\n      IsBoundedRecord<T> extends true\n        ? {\n            // Object.entries returns keys as strings.\n            -readonly [P in keyof T as ToString<P>]?: Required<T>[P];\n          }\n        : // For unbounded records (a simple Record with primitive `string` or\n          // `number` keys) the return type here could technically be T; but for\n          // cases where the record is unbounded but is more complex (like\n          // `symbol` keys) we want to \"reconstruct\" the record from just its\n          // enumerable components (which are the ones accessible via\n          // `Object.entries`).\n          Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>\n    >\n  : never;\n\n// When the predicate is a type-guard we have more information to work with when\n// constructing the type of the output object. We can safely remove any property\n// which value would never come up true for the predicate, AND we can also\n// assume that properties that match the predicate perfectly would **always**\n// show up in the output object. Hence to build the output object we need to\n// build and merge 2 output objects: One for the properties which have a value\n// of at type that would always yield a `true` result from the predicate, these\n// are the \"matches\", which would not change the \"optionality\" of the input\n// object's props, and one for partial matches which would also make the props\n// optional (as they could have a value that would be filtered out).\ntype EnumeratedPartialNarrowed<T, S> = T extends unknown\n  ? Simplify<\n      IsBoundedRecord<T> extends true\n        ? ExactProps<T, S> & PartialProps<T, S>\n        : // For unbounded records we need to \"reconstruct\" the record and\n          // narrow the value types. Similar to the non-narrowed case, we need\n          // to also ignore `symbol` keys and any values that are only relevant\n          // to them.\n          Record<\n            EnumerableStringKeyOf<T>,\n            Extract<EnumerableStringKeyedValueOf<T>, S>\n          >\n    >\n  : never;\n\n// The exact case, props here would always be part of the output object\ntype ExactProps<T, S> = {\n  // Object.entries returns keys as strings.\n  -readonly [P in keyof T as ToString<\n    IsExactProp<T, P, S> extends true ? P : never\n  >]: Extract<Required<T>[P], S>;\n};\n\n// The partial case, props here might be part of the output object, but might\n// not be, hence they are optional.\ntype PartialProps<T, S> = {\n  // Object.entries returns keys as strings.\n  -readonly [P in keyof T as ToString<\n    IsPartialProp<T, P, S> extends true ? P : never\n  >]?: IsNever<Extract<T[P], S>> extends true\n    ? // If the result of extracting S from T[P] is never but S still extends\n      // it, it means that T[P] is too wide and S can't be extracted from it:\n      // e.g. if T[P] is `number` S is `1` then `Extract<number, 1> === never`.\n      // For these cases we can return S directly as the type as it's already\n      // very narrowed compared to T[P].\n      S extends T[P]\n      ? S\n      : never\n    : Extract<T[P], S>;\n};\n\n// If the input object's value type extends itself when the type-guard is\n// extracted from it we can safely assume that the predicate would always return\n// true for any value of that property.\ntype IsExactProp<T, P extends keyof T, S> =\n  T[P] extends Extract<T[P], S> ? true : false;\n\n// ...and if the input object's value type isn't an exact match, but still has\n// some partial match (i.g. the extracted type-guard isn't completely disjoint)\n// then we can assume that the property can sometimes return true, and sometimes\n// false when passed to the predicate, hence it should be optional in the\n// output.\ntype IsPartialProp<T, P extends keyof T, S> =\n  IsExactProp<T, P, S> extends true\n    ? false\n    : IsNever<Extract<T[P], S>> extends true\n      ? S extends T[P]\n        ? // If the result of extracting S from T[P] is never but S still\n          // extends it, it means that T[P] is too wide and S can't be\n          // extracted from it: e.g. if T[P] is `number` S is `1` then\n          // `Extract<number, 1> === never`, but `1` extends `number`. We need\n          // to handle these cases when we extract the value too (see above).\n          true\n        : false\n      : true;\n\n/**\n * Iterates over the entries of `data` and reconstructs the object using only\n * entries that `predicate` accepts. Symbol keys are not passed to the predicate\n * and would be filtered out from the output object.\n *\n * See `omitBy` for a complementary function which starts with a shallow copy of\n * the input object and removes the entries that the predicate rejects. Because\n * it is subtractive symbol keys would be copied over to the output object.\n * See also `entries`, `filter`, and `fromEntries` which could be used to build\n * your own version of `pickBy` if you need more control (though the resulting\n * type might be less precise).\n *\n * @param data - The target object.\n * @param predicate - A function that takes the value, key, and the data itself\n * and returns true if the entry should be part of the output object, or `false`\n * to remove it. If the function is a type-guard on the value the output type\n * would be narrowed accordingly.\n * @returns A shallow copy of the input object with the rejected entries\n * removed.\n * @signature pickBy(data, predicate)\n * @example\n *    pickBy({a: 1, b: 2, A: 3, B: 4}, (val, key) => key.toUpperCase() === key) // => {A: 3, B: 4}\n * @dataFirst\n * @category Object\n */\nexport function pickBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): EnumeratedPartialNarrowed<T, S>;\nexport function pickBy<T extends object>(\n  data: T,\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): EnumeratedPartial<T>;\n\n/**\n * Iterates over the entries of `data` and reconstructs the object using only\n * entries that `predicate` accepts. Symbol keys are not passed to the predicate\n * and would be filtered out from the output object.\n *\n * See `omitBy` for a complementary function which starts with a shallow copy of\n * the input object and removes the entries that the predicate rejects. Because\n * it is subtractive symbol keys would be copied over to the output object.\n * See also `entries`, `filter`, and `fromEntries` which could be used to build\n * your own version of `pickBy` if you need more control (though the resulting\n * type might be less precise).\n *\n * @param predicate - A function that takes the value, key, and the data itself\n * and returns true if the entry should be part of the output object, or `false`\n * to remove it. If the function is a type-guard on the value the output type\n * would be narrowed accordingly.\n * @signature\n *   pickBy(predicate)(data)\n * @example\n *    pipe({a: 1, b: 2, A: 3, B: 4}, pickBy((val, key) => key.toUpperCase() === key)); // => {A: 3, B: 4}\n * @dataLast\n * @category Object\n */\nexport function pickBy<\n  T extends object,\n  S extends EnumerableStringKeyedValueOf<T>,\n>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => value is S,\n): (data: T) => EnumeratedPartialNarrowed<T, S>;\nexport function pickBy<T extends object>(\n  predicate: (\n    value: EnumerableStringKeyedValueOf<T>,\n    key: EnumerableStringKeyOf<T>,\n    data: T,\n  ) => boolean,\n): (data: T) => EnumeratedPartial<T>;\n\nexport function pickBy(...args: readonly unknown[]): unknown {\n  return purry(pickByImplementation, args);\n}\n\nfunction pickByImplementation<T extends object>(\n  data: T,\n  predicate: (value: unknown, key: string, data: T) => boolean,\n): Record<string, unknown> {\n  const out: Partial<Record<string, unknown>> = {};\n\n  for (const [key, value] of Object.entries(data)) {\n    if (predicate(value, key, data)) {\n      out[key] = value;\n    }\n  }\n\n  return out;\n}\n"],"mappings":"mCA6LA,SAAgB,EAAO,GAAG,EAAmC,CAC3D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACyB,CACzB,IAAM,EAAwC,EAAE,CAEhD,IAAK,GAAM,CAAC,EAAK,KAAU,OAAO,QAAQ,EAAK,CACzC,EAAU,EAAO,EAAK,EAAK,GAC7B,EAAI,GAAO,GAIf,OAAO"}

package/dist/pipe.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./utilityEvaluators-CW0M8vMV.cjs`);function t(e,...t){let a=e,o=t.map(e=>`lazy`in e?r(e):void 0),s=0;for(;s<t.length;){if(o[s]===void 0||!i(a)){let e=t[s];a=e(a),s+=1;continue}let e=[];for(let n=s;n<t.length;n++){let t=o[n];if(t===void 0||(e.push(t),t.isSingle))break}let r=[];for(let t of a)if(n(t,r,e))break;let{isSingle:c}=e.at(-1);a=c?r[0]:r,s+=e.length}return a}function n(t,r,i){if(i.length===0)return r.push(t),!1;let a=t,o=e.t,s=!1;for(let[e,t]of i.entries()){let{index:c,items:l}=t;if(l.push(a),o=t(a,c,l),t.index+=1,o.hasNext){if(o.hasMany??!1){for(let t of o.next)if(n(t,r,i.slice(e+1)))return!0;return s}a=o.next}if(!o.hasNext)break;o.done&&(s=!0)}return o.hasNext&&r.push(a),s}function r(e){let{lazy:t,lazyArgs:n}=e,r=t(...n);return Object.assign(r,{isSingle:t.single??!1,index:0,items:[]})}function i(e){return typeof e==`string`||typeof e==`object`&&!!e&&Symbol.iterator in e}exports.pipe=t;
+//# sourceMappingURL=pipe.cjs.map

package/dist/pipe.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.cjs","names":["SKIP_ITEM"],"sources":["../src/pipe.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable jsdoc/check-param-names -- we don't document the op params, it'd be redundant */\n\nimport type { LazyDefinition } from \"./internal/types/LazyDefinition\";\nimport type { LazyEvaluator } from \"./internal/types/LazyEvaluator\";\nimport type { LazyResult } from \"./internal/types/LazyResult\";\nimport { SKIP_ITEM } from \"./internal/utilityEvaluators\";\n\ntype PreparedLazyFunction = LazyEvaluator & {\n  readonly isSingle: boolean;\n\n  // These are intentionally mutable, they maintain the lazy piped state.\n  index: number;\n  items: unknown[];\n};\n\ntype LazyFunction = LazyDefinition & ((input: unknown) => unknown);\n\n/**\n * Performs left-to-right function composition, passing data through functions\n * in sequence. Each function receives the output of the previous function,\n * creating a readable top-to-bottom data flow that matches how the\n * transformation is executed. This enables converting deeply nested function\n * calls into clear, sequential steps without temporary variables.\n *\n * When consecutive functions with a `lazy` tag (e.g., `map`, `filter`, `take`,\n * `drop`, `forEach`, etc...) are used together, they process data item-by-item\n * rather than creating intermediate arrays. This enables early termination\n * when only partial results are needed, improving performance for large\n * datasets and expensive operations.\n *\n * Functions are only evaluated lazily when their data-last form is used\n * directly in the pipe. To disable lazy evaluation, use data-first calls via\n * arrow functions: `($) => map($, callback)` instead of `map(callback)`.\n *\n * Any function can be used in pipes, not just Remeda utilities. For creating\n * custom functions with currying and lazy evaluation support, see the `purry`\n * utility.\n *\n * A \"headless\" variant `piped` is available for creating reusable pipe\n * functions without initial data.\n *\n * IMPORTANT: During lazy evaluation, callbacks using the third parameter (the\n * input array) receive only items processed up to that point, not the complete\n * array.\n *\n * @param data - The input data.\n * @param functions - A sequence of functions that take one argument and\n * return a value.\n * @signature\n *   pipe(data, ...functions);\n * @example\n *    pipe([1, 2, 3], map(multiply(3))); //=> [3, 6, 9]\n *\n *    // = Early termination with lazy evaluation =\n *    pipe(\n *      hugeArray,\n *      map(expensiveComputation),\n *      filter(complexPredicate),\n *      // Only processes items until 2 results are found, then stops.\n *      // Most of hugeArray never gets processed.\n *      take(2),\n *    );\n *\n *    // = Custom logic within a pipe =\n *    pipe(\n *      input,\n *      toLowerCase(),\n *      normalize,\n *      ($) => validate($, CONFIG),\n *      split(\",\"),\n *      unique(),\n *    );\n *\n *    // = Migrating nested transformations to pipes =\n *    // Nested\n *    const result = prop(\n *      mapValues(groupByProp(users, \"department\"), length()),\n *      \"engineering\",\n *    );\n *\n *    // Piped\n *    const result = pipe(\n *      users,\n *      groupByProp(\"department\"),\n *      mapValues(length()),\n *      prop(\"engineering\"),\n *    );\n *\n *    // = Using the 3rd param of a callback =\n *    // The following would print out `data` in its entirety for each value\n *    // of `data`.\n *    forEach([1, 2, 3, 4], (_item, _index, data) => {\n *      console.log(data);\n *    }); //=> \"[1, 2, 3, 4]\" logged 4 times\n *\n *    // But with `pipe` data would only contain the items up to the current\n *    // index\n *    pipe([1, 2, 3, 4], forEach((_item, _index, data) => {\n *      console.log(data);\n *    })); //=> \"[1]\", \"[1, 2]\", \"[1, 2, 3]\", \"[1, 2, 3, 4]\"\n * @dataFirst\n * @category Function\n */\nexport function pipe<A>(data: A): A;\n\nexport function pipe<A, B>(data: A, funcA: (input: A) => B): B;\n\nexport function pipe<A, B, C>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n): C;\n\nexport function pipe<A, B, C, D>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n): D;\n\nexport function pipe<A, B, C, D, E>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n): E;\n\nexport function pipe<A, B, C, D, E, F>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n): F;\n\nexport function pipe<A, B, C, D, E, F, G>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n): G;\n\nexport function pipe<A, B, C, D, E, F, G, H>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n): H;\n\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n): I;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n): J;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n): K;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n): L;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n): M;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n): N;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n  funcN: (input: N) => O,\n): O;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n  funcN: (input: N) => O,\n  funcO: (input: O) => P,\n): P;\n\nexport function pipe(\n  input: unknown,\n  ...functions: readonly (LazyFunction | ((value: any) => unknown))[]\n): any {\n  let output = input;\n\n  const lazyFunctions = functions.map((op) =>\n    \"lazy\" in op ? prepareLazyFunction(op) : undefined,\n  );\n\n  let functionIndex = 0;\n  while (functionIndex < functions.length) {\n    const lazyFunction = lazyFunctions[functionIndex];\n    if (lazyFunction === undefined || !isIterable(output)) {\n      const func = functions[functionIndex]!;\n      output = func(output);\n      functionIndex += 1;\n      continue;\n    }\n\n    const lazySequence: PreparedLazyFunction[] = [];\n    for (let index = functionIndex; index < functions.length; index++) {\n      const lazyOp = lazyFunctions[index];\n      if (lazyOp === undefined) {\n        break;\n      }\n\n      lazySequence.push(lazyOp);\n      if (lazyOp.isSingle) {\n        break;\n      }\n    }\n\n    const accumulator: unknown[] = [];\n\n    for (const value of output) {\n      const shouldExitEarly = processItem(value, accumulator, lazySequence);\n      if (shouldExitEarly) {\n        break;\n      }\n    }\n\n    const { isSingle } = lazySequence.at(-1)!;\n    output = isSingle ? accumulator[0] : accumulator;\n    functionIndex += lazySequence.length;\n  }\n  return output;\n}\n\nfunction processItem(\n  item: unknown,\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentionally mutable, we use the accumulator directly to accumulate the results.\n  accumulator: unknown[],\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentionally mutable, the lazy sequence is stateful and contains the state needed to compute the next value lazily.\n  lazySequence: readonly PreparedLazyFunction[],\n): boolean {\n  if (lazySequence.length === 0) {\n    accumulator.push(item);\n    return false;\n  }\n\n  let currentItem = item;\n\n  let lazyResult: LazyResult<any> = SKIP_ITEM;\n  let isDone = false;\n  for (const [functionsIndex, lazyFn] of lazySequence.entries()) {\n    const { index, items } = lazyFn;\n    items.push(currentItem);\n    lazyResult = lazyFn(currentItem, index, items);\n    lazyFn.index += 1;\n    if (lazyResult.hasNext) {\n      if (lazyResult.hasMany ?? false) {\n        for (const subItem of lazyResult.next as readonly unknown[]) {\n          const subResult = processItem(\n            subItem,\n            accumulator,\n            lazySequence.slice(functionsIndex + 1),\n          );\n          if (subResult) {\n            return true;\n          }\n        }\n        return isDone;\n      }\n      currentItem = lazyResult.next;\n    }\n    if (!lazyResult.hasNext) {\n      break;\n    }\n    // process remaining functions in the pipe\n    // but don't process remaining elements in the input array\n    if (lazyResult.done) {\n      isDone = true;\n    }\n  }\n  if (lazyResult.hasNext) {\n    accumulator.push(currentItem);\n  }\n  return isDone;\n}\n\nfunction prepareLazyFunction(func: LazyFunction): PreparedLazyFunction {\n  const { lazy, lazyArgs } = func;\n  const fn = lazy(...lazyArgs);\n  return Object.assign(fn, {\n    isSingle: lazy.single ?? false,\n    index: 0,\n    items: [] as unknown[],\n  });\n}\n\nfunction isIterable(something: unknown): something is Iterable<unknown> {\n  // Check for null and undefined to avoid errors when accessing Symbol.iterator\n  return (\n    typeof something === \"string\" ||\n    (typeof something === \"object\" &&\n      something !== null &&\n      Symbol.iterator in something)\n  );\n}\n"],"mappings":"uHA2RA,SAAgB,EACd,EACA,GAAG,EACE,CACL,IAAI,EAAS,EAEP,EAAgB,EAAU,IAAK,GACnC,SAAU,EAAK,EAAoB,EAAG,CAAG,IAAA,GAC1C,CAEG,EAAgB,EACpB,KAAO,EAAgB,EAAU,QAAQ,CAEvC,GADqB,EAAc,KACd,IAAA,IAAa,CAAC,EAAW,EAAO,CAAE,CACrD,IAAM,EAAO,EAAU,GACvB,EAAS,EAAK,EAAO,CACrB,GAAiB,EACjB,SAGF,IAAM,EAAuC,EAAE,CAC/C,IAAK,IAAI,EAAQ,EAAe,EAAQ,EAAU,OAAQ,IAAS,CACjE,IAAM,EAAS,EAAc,GAM7B,GALI,IAAW,IAAA,KAIf,EAAa,KAAK,EAAO,CACrB,EAAO,UACT,MAIJ,IAAM,EAAyB,EAAE,CAEjC,IAAK,IAAM,KAAS,EAElB,GADwB,EAAY,EAAO,EAAa,EAAa,CAEnE,MAIJ,GAAM,CAAE,YAAa,EAAa,GAAG,GAAG,CACxC,EAAS,EAAW,EAAY,GAAK,EACrC,GAAiB,EAAa,OAEhC,OAAO,EAGT,SAAS,EACP,EAEA,EAEA,EACS,CACT,GAAI,EAAa,SAAW,EAE1B,OADA,EAAY,KAAK,EAAK,CACf,GAGT,IAAI,EAAc,EAEd,EAA8BA,EAAAA,EAC9B,EAAS,GACb,IAAK,GAAM,CAAC,EAAgB,KAAW,EAAa,SAAS,CAAE,CAC7D,GAAM,CAAE,QAAO,SAAU,EAIzB,GAHA,EAAM,KAAK,EAAY,CACvB,EAAa,EAAO,EAAa,EAAO,EAAM,CAC9C,EAAO,OAAS,EACZ,EAAW,QAAS,CACtB,GAAI,EAAW,SAAW,GAAO,CAC/B,IAAK,IAAM,KAAW,EAAW,KAM/B,GALkB,EAChB,EACA,EACA,EAAa,MAAM,EAAiB,EAAE,CACvC,CAEC,MAAO,GAGX,OAAO,EAET,EAAc,EAAW,KAE3B,GAAI,CAAC,EAAW,QACd,MAIE,EAAW,OACb,EAAS,IAMb,OAHI,EAAW,SACb,EAAY,KAAK,EAAY,CAExB,EAGT,SAAS,EAAoB,EAA0C,CACrE,GAAM,CAAE,OAAM,YAAa,EACrB,EAAK,EAAK,GAAG,EAAS,CAC5B,OAAO,OAAO,OAAO,EAAI,CACvB,SAAU,EAAK,QAAU,GACzB,MAAO,EACP,MAAO,EAAE,CACV,CAAC,CAGJ,SAAS,EAAW,EAAoD,CAEtE,OACE,OAAO,GAAc,UACpB,OAAO,GAAc,YACpB,GACA,OAAO,YAAY"}

package/dist/pipe.js

@@ -0,0 +1,2 @@
+import{t as e}from"./utilityEvaluators-BQqW5Ir5.js";function t(e,...t){let a=e,o=t.map(e=>`lazy`in e?r(e):void 0),s=0;for(;s<t.length;){if(o[s]===void 0||!i(a)){let e=t[s];a=e(a),s+=1;continue}let e=[];for(let n=s;n<t.length;n++){let t=o[n];if(t===void 0||(e.push(t),t.isSingle))break}let r=[];for(let t of a)if(n(t,r,e))break;let{isSingle:c}=e.at(-1);a=c?r[0]:r,s+=e.length}return a}function n(t,r,i){if(i.length===0)return r.push(t),!1;let a=t,o=e,s=!1;for(let[e,t]of i.entries()){let{index:c,items:l}=t;if(l.push(a),o=t(a,c,l),t.index+=1,o.hasNext){if(o.hasMany??!1){for(let t of o.next)if(n(t,r,i.slice(e+1)))return!0;return s}a=o.next}if(!o.hasNext)break;o.done&&(s=!0)}return o.hasNext&&r.push(a),s}function r(e){let{lazy:t,lazyArgs:n}=e,r=t(...n);return Object.assign(r,{isSingle:t.single??!1,index:0,items:[]})}function i(e){return typeof e==`string`||typeof e==`object`&&!!e&&Symbol.iterator in e}export{t as pipe};
+//# sourceMappingURL=pipe.js.map

package/dist/pipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.js","names":[],"sources":["../src/pipe.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable jsdoc/check-param-names -- we don't document the op params, it'd be redundant */\n\nimport type { LazyDefinition } from \"./internal/types/LazyDefinition\";\nimport type { LazyEvaluator } from \"./internal/types/LazyEvaluator\";\nimport type { LazyResult } from \"./internal/types/LazyResult\";\nimport { SKIP_ITEM } from \"./internal/utilityEvaluators\";\n\ntype PreparedLazyFunction = LazyEvaluator & {\n  readonly isSingle: boolean;\n\n  // These are intentionally mutable, they maintain the lazy piped state.\n  index: number;\n  items: unknown[];\n};\n\ntype LazyFunction = LazyDefinition & ((input: unknown) => unknown);\n\n/**\n * Performs left-to-right function composition, passing data through functions\n * in sequence. Each function receives the output of the previous function,\n * creating a readable top-to-bottom data flow that matches how the\n * transformation is executed. This enables converting deeply nested function\n * calls into clear, sequential steps without temporary variables.\n *\n * When consecutive functions with a `lazy` tag (e.g., `map`, `filter`, `take`,\n * `drop`, `forEach`, etc...) are used together, they process data item-by-item\n * rather than creating intermediate arrays. This enables early termination\n * when only partial results are needed, improving performance for large\n * datasets and expensive operations.\n *\n * Functions are only evaluated lazily when their data-last form is used\n * directly in the pipe. To disable lazy evaluation, use data-first calls via\n * arrow functions: `($) => map($, callback)` instead of `map(callback)`.\n *\n * Any function can be used in pipes, not just Remeda utilities. For creating\n * custom functions with currying and lazy evaluation support, see the `purry`\n * utility.\n *\n * A \"headless\" variant `piped` is available for creating reusable pipe\n * functions without initial data.\n *\n * IMPORTANT: During lazy evaluation, callbacks using the third parameter (the\n * input array) receive only items processed up to that point, not the complete\n * array.\n *\n * @param data - The input data.\n * @param functions - A sequence of functions that take one argument and\n * return a value.\n * @signature\n *   pipe(data, ...functions);\n * @example\n *    pipe([1, 2, 3], map(multiply(3))); //=> [3, 6, 9]\n *\n *    // = Early termination with lazy evaluation =\n *    pipe(\n *      hugeArray,\n *      map(expensiveComputation),\n *      filter(complexPredicate),\n *      // Only processes items until 2 results are found, then stops.\n *      // Most of hugeArray never gets processed.\n *      take(2),\n *    );\n *\n *    // = Custom logic within a pipe =\n *    pipe(\n *      input,\n *      toLowerCase(),\n *      normalize,\n *      ($) => validate($, CONFIG),\n *      split(\",\"),\n *      unique(),\n *    );\n *\n *    // = Migrating nested transformations to pipes =\n *    // Nested\n *    const result = prop(\n *      mapValues(groupByProp(users, \"department\"), length()),\n *      \"engineering\",\n *    );\n *\n *    // Piped\n *    const result = pipe(\n *      users,\n *      groupByProp(\"department\"),\n *      mapValues(length()),\n *      prop(\"engineering\"),\n *    );\n *\n *    // = Using the 3rd param of a callback =\n *    // The following would print out `data` in its entirety for each value\n *    // of `data`.\n *    forEach([1, 2, 3, 4], (_item, _index, data) => {\n *      console.log(data);\n *    }); //=> \"[1, 2, 3, 4]\" logged 4 times\n *\n *    // But with `pipe` data would only contain the items up to the current\n *    // index\n *    pipe([1, 2, 3, 4], forEach((_item, _index, data) => {\n *      console.log(data);\n *    })); //=> \"[1]\", \"[1, 2]\", \"[1, 2, 3]\", \"[1, 2, 3, 4]\"\n * @dataFirst\n * @category Function\n */\nexport function pipe<A>(data: A): A;\n\nexport function pipe<A, B>(data: A, funcA: (input: A) => B): B;\n\nexport function pipe<A, B, C>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n): C;\n\nexport function pipe<A, B, C, D>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n): D;\n\nexport function pipe<A, B, C, D, E>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n): E;\n\nexport function pipe<A, B, C, D, E, F>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n): F;\n\nexport function pipe<A, B, C, D, E, F, G>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n): G;\n\nexport function pipe<A, B, C, D, E, F, G, H>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n): H;\n\nexport function pipe<A, B, C, D, E, F, G, H, I>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n): I;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n): J;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n): K;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n): L;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n): M;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n): N;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n  funcN: (input: N) => O,\n): O;\n\nexport function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  data: A,\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n  funcN: (input: N) => O,\n  funcO: (input: O) => P,\n): P;\n\nexport function pipe(\n  input: unknown,\n  ...functions: readonly (LazyFunction | ((value: any) => unknown))[]\n): any {\n  let output = input;\n\n  const lazyFunctions = functions.map((op) =>\n    \"lazy\" in op ? prepareLazyFunction(op) : undefined,\n  );\n\n  let functionIndex = 0;\n  while (functionIndex < functions.length) {\n    const lazyFunction = lazyFunctions[functionIndex];\n    if (lazyFunction === undefined || !isIterable(output)) {\n      const func = functions[functionIndex]!;\n      output = func(output);\n      functionIndex += 1;\n      continue;\n    }\n\n    const lazySequence: PreparedLazyFunction[] = [];\n    for (let index = functionIndex; index < functions.length; index++) {\n      const lazyOp = lazyFunctions[index];\n      if (lazyOp === undefined) {\n        break;\n      }\n\n      lazySequence.push(lazyOp);\n      if (lazyOp.isSingle) {\n        break;\n      }\n    }\n\n    const accumulator: unknown[] = [];\n\n    for (const value of output) {\n      const shouldExitEarly = processItem(value, accumulator, lazySequence);\n      if (shouldExitEarly) {\n        break;\n      }\n    }\n\n    const { isSingle } = lazySequence.at(-1)!;\n    output = isSingle ? accumulator[0] : accumulator;\n    functionIndex += lazySequence.length;\n  }\n  return output;\n}\n\nfunction processItem(\n  item: unknown,\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentionally mutable, we use the accumulator directly to accumulate the results.\n  accumulator: unknown[],\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Intentionally mutable, the lazy sequence is stateful and contains the state needed to compute the next value lazily.\n  lazySequence: readonly PreparedLazyFunction[],\n): boolean {\n  if (lazySequence.length === 0) {\n    accumulator.push(item);\n    return false;\n  }\n\n  let currentItem = item;\n\n  let lazyResult: LazyResult<any> = SKIP_ITEM;\n  let isDone = false;\n  for (const [functionsIndex, lazyFn] of lazySequence.entries()) {\n    const { index, items } = lazyFn;\n    items.push(currentItem);\n    lazyResult = lazyFn(currentItem, index, items);\n    lazyFn.index += 1;\n    if (lazyResult.hasNext) {\n      if (lazyResult.hasMany ?? false) {\n        for (const subItem of lazyResult.next as readonly unknown[]) {\n          const subResult = processItem(\n            subItem,\n            accumulator,\n            lazySequence.slice(functionsIndex + 1),\n          );\n          if (subResult) {\n            return true;\n          }\n        }\n        return isDone;\n      }\n      currentItem = lazyResult.next;\n    }\n    if (!lazyResult.hasNext) {\n      break;\n    }\n    // process remaining functions in the pipe\n    // but don't process remaining elements in the input array\n    if (lazyResult.done) {\n      isDone = true;\n    }\n  }\n  if (lazyResult.hasNext) {\n    accumulator.push(currentItem);\n  }\n  return isDone;\n}\n\nfunction prepareLazyFunction(func: LazyFunction): PreparedLazyFunction {\n  const { lazy, lazyArgs } = func;\n  const fn = lazy(...lazyArgs);\n  return Object.assign(fn, {\n    isSingle: lazy.single ?? false,\n    index: 0,\n    items: [] as unknown[],\n  });\n}\n\nfunction isIterable(something: unknown): something is Iterable<unknown> {\n  // Check for null and undefined to avoid errors when accessing Symbol.iterator\n  return (\n    typeof something === \"string\" ||\n    (typeof something === \"object\" &&\n      something !== null &&\n      Symbol.iterator in something)\n  );\n}\n"],"mappings":"oDA2RA,SAAgB,EACd,EACA,GAAG,EACE,CACL,IAAI,EAAS,EAEP,EAAgB,EAAU,IAAK,GACnC,SAAU,EAAK,EAAoB,EAAG,CAAG,IAAA,GAC1C,CAEG,EAAgB,EACpB,KAAO,EAAgB,EAAU,QAAQ,CAEvC,GADqB,EAAc,KACd,IAAA,IAAa,CAAC,EAAW,EAAO,CAAE,CACrD,IAAM,EAAO,EAAU,GACvB,EAAS,EAAK,EAAO,CACrB,GAAiB,EACjB,SAGF,IAAM,EAAuC,EAAE,CAC/C,IAAK,IAAI,EAAQ,EAAe,EAAQ,EAAU,OAAQ,IAAS,CACjE,IAAM,EAAS,EAAc,GAM7B,GALI,IAAW,IAAA,KAIf,EAAa,KAAK,EAAO,CACrB,EAAO,UACT,MAIJ,IAAM,EAAyB,EAAE,CAEjC,IAAK,IAAM,KAAS,EAElB,GADwB,EAAY,EAAO,EAAa,EAAa,CAEnE,MAIJ,GAAM,CAAE,YAAa,EAAa,GAAG,GAAG,CACxC,EAAS,EAAW,EAAY,GAAK,EACrC,GAAiB,EAAa,OAEhC,OAAO,EAGT,SAAS,EACP,EAEA,EAEA,EACS,CACT,GAAI,EAAa,SAAW,EAE1B,OADA,EAAY,KAAK,EAAK,CACf,GAGT,IAAI,EAAc,EAEd,EAA8B,EAC9B,EAAS,GACb,IAAK,GAAM,CAAC,EAAgB,KAAW,EAAa,SAAS,CAAE,CAC7D,GAAM,CAAE,QAAO,SAAU,EAIzB,GAHA,EAAM,KAAK,EAAY,CACvB,EAAa,EAAO,EAAa,EAAO,EAAM,CAC9C,EAAO,OAAS,EACZ,EAAW,QAAS,CACtB,GAAI,EAAW,SAAW,GAAO,CAC/B,IAAK,IAAM,KAAW,EAAW,KAM/B,GALkB,EAChB,EACA,EACA,EAAa,MAAM,EAAiB,EAAE,CACvC,CAEC,MAAO,GAGX,OAAO,EAET,EAAc,EAAW,KAE3B,GAAI,CAAC,EAAW,QACd,MAIE,EAAW,OACb,EAAS,IAMb,OAHI,EAAW,SACb,EAAY,KAAK,EAAY,CAExB,EAGT,SAAS,EAAoB,EAA0C,CACrE,GAAM,CAAE,OAAM,YAAa,EACrB,EAAK,EAAK,GAAG,EAAS,CAC5B,OAAO,OAAO,OAAO,EAAI,CACvB,SAAU,EAAK,QAAU,GACzB,MAAO,EACP,MAAO,EAAE,CACV,CAAC,CAGJ,SAAS,EAAW,EAAoD,CAEtE,OACE,OAAO,GAAc,UACpB,OAAO,GAAc,YACpB,GACA,OAAO,YAAY"}

package/dist/piped.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./pipe.cjs`);function t(...t){return n=>e.pipe(n,...t)}exports.piped=t;
+//# sourceMappingURL=piped.cjs.map

package/dist/piped.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"piped.cjs","names":["pipe"],"sources":["../src/piped.ts"],"sourcesContent":["import { pipe } from \"./pipe\";\n\n/**\n * Data-last version of `pipe`. See `pipe` documentation for full details.\n *\n * Use `piped` when you need to pass a transformation as a callback to\n * functions like `map` and `filter`, where the data type can be inferred\n * from the call site.\n *\n * IMPORTANT: `piped` does not work as a \"function factory\" in order to create\n * standalone utility functions; because TypeScript cannot infer the input data\n * type (without requiring to explicitly define all type params for all\n * functions in the pipe). We recommend defining the function explicitly, and\n * then use `pipe` in its implementation.\n *\n * @signature\n *    piped(...functions)(data);\n * @example\n *    map(\n *      [{ a: 1 }, { a: 2 }, { a: 3 }],\n *      piped(prop('a'), add(1)),\n *    ); //=> [2, 3, 4]\n * @dataLast\n * @category Function\n */\nexport function piped<A>(): (data: A) => A;\n\nexport function piped<A, B>(funcA: (input: A) => B): (data: A) => B;\n\nexport function piped<A, B, C>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n): (data: A) => C;\n\nexport function piped<A, B, C, D>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n): (data: A) => D;\n\nexport function piped<A, B, C, D, E>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n): (data: A) => E;\n\nexport function piped<A, B, C, D, E, F>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n): (data: A) => F;\n\nexport function piped<A, B, C, D, E, F, G>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n): (data: A) => G;\n\nexport function piped<A, B, C, D, E, F, G, H>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n): (data: A) => H;\n\nexport function piped<A, B, C, D, E, F, G, H, I>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n): (data: A) => I;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n): (data: A) => J;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J, K>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n): (data: A) => K;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J, K, L>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n): (data: A) => L;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n): (data: A) => M;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n): (data: A) => N;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n  funcN: (input: N) => O,\n): (data: A) => O;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n  funcN: (input: N) => O,\n  funcO: (input: O) => P,\n): (data: A) => P;\n\nexport function piped(...functions: readonly ((input: unknown) => unknown)[]) {\n  return (value: unknown): unknown =>\n    pipe(\n      value,\n      // @ts-expect-error [ts2556] - We can't avoid this error because pipe is typed for users and this is an internal function\n      ...functions,\n    );\n}\n"],"mappings":"iGA8LA,SAAgB,EAAM,GAAG,EAAqD,CAC5E,MAAQ,IACNA,EAAAA,KACE,EAEA,GAAG,EACJ"}

package/dist/piped.js

@@ -0,0 +1,2 @@
+import{pipe as e}from"./pipe.js";function t(...t){return n=>e(n,...t)}export{t as piped};
+//# sourceMappingURL=piped.js.map

package/dist/piped.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"piped.js","names":[],"sources":["../src/piped.ts"],"sourcesContent":["import { pipe } from \"./pipe\";\n\n/**\n * Data-last version of `pipe`. See `pipe` documentation for full details.\n *\n * Use `piped` when you need to pass a transformation as a callback to\n * functions like `map` and `filter`, where the data type can be inferred\n * from the call site.\n *\n * IMPORTANT: `piped` does not work as a \"function factory\" in order to create\n * standalone utility functions; because TypeScript cannot infer the input data\n * type (without requiring to explicitly define all type params for all\n * functions in the pipe). We recommend defining the function explicitly, and\n * then use `pipe` in its implementation.\n *\n * @signature\n *    piped(...functions)(data);\n * @example\n *    map(\n *      [{ a: 1 }, { a: 2 }, { a: 3 }],\n *      piped(prop('a'), add(1)),\n *    ); //=> [2, 3, 4]\n * @dataLast\n * @category Function\n */\nexport function piped<A>(): (data: A) => A;\n\nexport function piped<A, B>(funcA: (input: A) => B): (data: A) => B;\n\nexport function piped<A, B, C>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n): (data: A) => C;\n\nexport function piped<A, B, C, D>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n): (data: A) => D;\n\nexport function piped<A, B, C, D, E>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n): (data: A) => E;\n\nexport function piped<A, B, C, D, E, F>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n): (data: A) => F;\n\nexport function piped<A, B, C, D, E, F, G>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n): (data: A) => G;\n\nexport function piped<A, B, C, D, E, F, G, H>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n): (data: A) => H;\n\nexport function piped<A, B, C, D, E, F, G, H, I>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n): (data: A) => I;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n): (data: A) => J;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J, K>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n): (data: A) => K;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J, K, L>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n): (data: A) => L;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J, K, L, M>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n): (data: A) => M;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n): (data: A) => N;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n  funcN: (input: N) => O,\n): (data: A) => O;\n\nexport function piped<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  funcA: (input: A) => B,\n  funcB: (input: B) => C,\n  funcC: (input: C) => D,\n  funcD: (input: D) => E,\n  funcE: (input: E) => F,\n  funcF: (input: F) => G,\n  funcG: (input: G) => H,\n  funcH: (input: H) => I,\n  funcI: (input: I) => J,\n  funcJ: (input: J) => K,\n  funcK: (input: K) => L,\n  funcL: (input: L) => M,\n  funcM: (input: M) => N,\n  funcN: (input: N) => O,\n  funcO: (input: O) => P,\n): (data: A) => P;\n\nexport function piped(...functions: readonly ((input: unknown) => unknown)[]) {\n  return (value: unknown): unknown =>\n    pipe(\n      value,\n      // @ts-expect-error [ts2556] - We can't avoid this error because pipe is typed for users and this is an internal function\n      ...functions,\n    );\n}\n"],"mappings":"iCA8LA,SAAgB,EAAM,GAAG,EAAqD,CAC5E,MAAQ,IACN,EACE,EAEA,GAAG,EACJ"}

package/dist/product.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./purry.cjs`);function t(...t){return e.purry(n,t)}function n(e){let t=typeof e[0]==`bigint`?1n:1;for(let n of e)t*=n;return t}exports.product=t;
+//# sourceMappingURL=product.cjs.map

package/dist/product.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"product.cjs","names":["purry"],"sources":["../src/product.ts"],"sourcesContent":["import type { IterableContainer } from \"./internal/types/IterableContainer\";\nimport { purry } from \"./purry\";\n\ntype Product<T extends IterableContainer<bigint> | IterableContainer<number>> =\n  // Empty arrays would always result in a product of (a non-bigint) 1\n  T extends readonly []\n    ? 1\n    : // Non-empty bigint arrays will always result in a bigint product.\n      T extends readonly [bigint, ...(readonly unknown[])]\n      ? bigint\n      : // But an empty bigint array would result in a non-bigint 1.\n        T[number] extends bigint\n        ? bigint | 1\n        : // Non-bigint arrays are always handled correctly.\n          number;\n\n/**\n * Compute the product of the numbers in the array, or return 1 for an empty\n * array.\n *\n * Works for both `number` and `bigint` arrays, but not arrays that contain both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 1 (`number`) regardless of\n * the type of the array; to avoid adding this to the return type for cases\n * where the array is known to be non-empty you can use `hasAtLeast` or\n * `isEmpty` to guard against this case.\n *\n * @param data - The array of numbers.\n * @signature\n *   product(data);\n * @example\n *   product([1, 2, 3]); // => 6\n *   product([1n, 2n, 3n]); // => 6n\n *   product([]); // => 1\n * @dataFirst\n * @category Number\n */\nexport function product<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): Product<T>;\n\n/**\n * Compute the product of the numbers in the array, or return 1 for an empty\n * array.\n *\n * Works for both `number` and `bigint` arrays, but not arrays that contain both\n * types.\n *\n * IMPORTANT: The result for empty arrays would be 1 (`number`) regardless of\n * the type of the array; to avoid adding this to the return type for cases\n * where the array is known to be non-empty you can use `hasAtLeast` or\n * `isEmpty` to guard against this case.\n *\n * @signature\n *   product()(data);\n * @example\n *   pipe([1, 2, 3], product()); // => 6\n *   pipe([1n, 2n, 3n], product()); // => 6n\n *   pipe([], product()); // => 1\n * @dataLast\n * @category Number\n */\nexport function product(): <\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(\n  data: T,\n) => Product<T>;\n\nexport function product(...args: readonly unknown[]): unknown {\n  return purry(productImplementation, args);\n}\n\nfunction productImplementation<\n  T extends IterableContainer<bigint> | IterableContainer<number>,\n>(data: T): T[number] {\n  // eslint-disable-next-line @typescript-eslint/no-magic-numbers -- The rule differentiates 1 and 1n :(\n  let out = typeof data[0] === \"bigint\" ? 1n : 1;\n  for (const value of data) {\n    // @ts-expect-error [ts2365] -- Typescript can't infer that all elements will be a number of the same type.\n    out *= value;\n  }\n  return out;\n}\n"],"mappings":"kGAqEA,SAAgB,EAAQ,GAAG,EAAmC,CAC5D,OAAOA,EAAAA,MAAM,EAAuB,EAAK,CAG3C,SAAS,EAEP,EAAoB,CAEpB,IAAI,EAAM,OAAO,EAAK,IAAO,SAAW,GAAK,EAC7C,IAAK,IAAM,KAAS,EAElB,GAAO,EAET,OAAO"}

package/dist/product.js

@@ -0,0 +1,2 @@
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}function n(e){let t=typeof e[0]==`bigint`?1n:1;for(let n of e)t*=n;return t}export{t as product};
+//# sourceMappingURL=product.js.map