@vinicunca/perkakas 1.8.0 → 1.9.0

package/dist/concat-BOAliAPo.d.ts

@@ -0,0 +1,41 @@
+import { IterableContainer } from "./iterable-container-F9CDF7ym.js";
+
+//#region src/concat.d.ts
+
+/**
+ * Merge two or more arrays. This method does not change the existing arrays,
+ * but instead returns a new array, even if the other array is empty.
+ *
+ * @param data - The first items, these would be at the beginning of the new
+ * array.
+ * @param other - The remaining items, these would be at the end of the new
+ * array.
+ * @returns A new array with the items of the first array followed by the items
+ * of the second array.
+ * @signature
+ *    P.concat(data, other);
+ * @example
+ *    P.concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']
+ * @dataFirst
+ * @category Array
+ */
+declare function concat<T1 extends IterableContainer, T2 extends IterableContainer>(data: T1, other: T2): [...T1, ...T2];
+/**
+ * Merge two or more arrays. This method does not change the existing arrays,
+ * but instead returns a new array, even if the other array is empty.
+ *
+ * @param other - The remaining items, these would be at the end of the new
+ * array.
+ * @returns A new array with the items of the first array followed by the items
+ * of the second array.
+ * @signature
+ *    P.concat(arr2)(arr1);
+ * @example
+ *    P.concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']
+ * @dataLast
+ * @category Array
+ */
+declare function concat<T2 extends IterableContainer>(other: T2): <T1 extends IterableContainer>(data: T1) => [...T1, ...T2];
+//#endregion
+export { concat };
+//# sourceMappingURL=concat-BOAliAPo.d.ts.map

package/dist/concat-BOAliAPo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat-BOAliAPo.d.ts","names":[],"sources":["../src/concat.ts"],"sourcesContent":[],"mappings":";;;;;;AAoBA;;;;;;;;;AAoBA;;;;;;AAEmD,iBAtBnC,MAsBmC,CAAA,WArBtC,iBAqBsC,EAAA,WApBtC,iBAoBsC,CAAA,CAAA,IAAA,EAnB3C,EAmB2C,EAAA,KAAA,EAnBhC,EAmBgC,CAAA,EAAA,CAAA,GAnBvB,EAmBuB,EAAA,GAnBhB,EAmBgB,CAAA;;;;;;;;;;;;;;;;iBAFnC,kBAAkB,0BACzB,iBACM,yBAAyB,WAAW,OAAO"}

package/dist/concat.d.ts

@@ -1,3 +1,3 @@
-import "./iterable-container-wtkYslN_.js";
-import { concat } from "./concat-DeyDusex.js";
+import "./iterable-container-F9CDF7ym.js";
+import { concat } from "./concat-BOAliAPo.js";
 export { concat };

package/dist/conditional-BW7TbnuD.d.ts

@@ -0,0 +1,221 @@
+//#region src/internal/types/guard-type.d.ts
+/**
+ * Extracts a type predicate from a type guard function for the first argument.
+ *
+ * @example
+ * type TypeGuardFn = (x: unknown) => x is string;
+ * type Result = GuardType<TypeGuardFn>; // `string`
+ */
+type GuardType<T, Fallback = never> = T extends ((x: any, ...rest: any) => x is infer U) ? U : Fallback;
+//#endregion
+//#region src/conditional.d.ts
+type Case<In, Out, When extends (x: In) => boolean = (x: In) => boolean> = readonly [when: When, then: (x: GuardType<When, In> & In) => Out];
+type DefaultCase<In, Out> = (x: In) => Out;
+interface Utilities {
+  readonly defaultCase: typeof defaultCase;
+}
+type WithUtils<T> = T & Utilities;
+declare const conditionalPlus: WithUtils<typeof conditional>;
+/**
+ * Executes a transformer function based on the first matching predicate,
+ * functioning like a series of `if...else if...` statements. It sequentially
+ * evaluates each case and, upon finding a truthy predicate, runs the
+ * corresponding transformer, and returns, ignoring any further cases, even if
+ * they would match.
+ *
+ * NOTE*: Some type-predicates may fail to narrow the param type of their
+ * transformer; in such cases wrap your type-predicate in an anonymous arrow
+ * function: e.g., instead of
+ * `conditional(..., [myTypePredicate, myTransformer], ...)`, use
+ * `conditional(..., [($) => myTypePredicate($), myTransformer], ...)`.
+ *
+ * To add a a default, catch-all, case you can provide a single callback
+ * function (instead of a 2-tuple) as the last case. This is equivalent to
+ * adding a case with a trivial always-true predicate as it's condition (see
+ * example).
+ *
+ * For simpler cases you should also consider using `when` instead.
+ *
+ * Due to TypeScript's inability to infer the result of negating a type-
+ * predicate we can't refine the types used in subsequent cases based on
+ * previous conditions. Using a `switch (true)` statement or ternary operators
+ * is recommended for more precise type control when such type narrowing is
+ * needed.
+ *
+ * !IMPORTANT! - Unlike similar implementations in Lodash and Ramda, this
+ * implementation **doesn't** implicitly return `undefined` as a fallback when
+ * when none of the cases match; and instead **throws** an exception in those
+ * cases! You have to explicitly provide a default case, and can use
+ * `constant(undefined)` as your last case to replicate that behavior.
+ *
+ * @param cases - A list of (up to 10) cases. Each case can be either:
+ * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer
+ *   function that processes the data if the predicate matches.
+ * - A single callback function that acts as a default fallback case.
+ * @returns The output of the matched transformer. If no cases match, an
+ * exception is thrown. The return type is a union of the return types of all
+ * provided transformers.
+ * @signature
+ *   P.conditional(...cases)(data);
+ * @example
+ *   const nameOrId = 3 as string | number | boolean;
+ *
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     ),
+ *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.
+ *
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *       P.constant(undefined),
+ *     ),
+ *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.
+ *
+ *   P.pipe(
+ *     nameOrId,
+ *     P.conditional(
+ *       [P.isString, (name) => `Hello ${name}`],
+ *       [P.isNumber, (id) => `Hello ID: ${id}`],
+ *       (something) => `Hello something (${JSON.stringify(something)})`,
+ *     ),
+ *   ); //=> 'Hello ID: 3' (typed as `string`), won't throw.
+ * @dataLast
+ * @category Function
+ */
+declare function conditional<T, Fn0 extends (x: T) => boolean, Return0, Fallback = never>(case0: Case<T, Return0, Fn0>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Return0, Return1, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Return0, Return1, Return2, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Fn8 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Return8, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, case8: Case<T, Return8, Fn8>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Fn8 extends (x: T) => boolean, Fn9 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Return8, Return9, Fallback = never>(case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, case8: Case<T, Return8, Fn8>, case9: Case<T, Return9, Fn9>, fallback?: DefaultCase<T, Fallback>): (data: T) => Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9 | Fallback;
+/**
+ * Executes a transformer function based on the first matching predicate,
+ * functioning like a series of `if...else if...` statements. It sequentially
+ * evaluates each case and, upon finding a truthy predicate, runs the
+ * corresponding transformer, and returns, ignoring any further cases, even if
+ * they would match.
+ *
+ * NOTE*: Some type-predicates may fail to narrow the param type of their
+ * transformer; in such cases wrap your type-predicate in an anonymous arrow
+ * function: e.g., instead of
+ * `conditional(..., [myTypePredicate, myTransformer], ...)`, use
+ * `conditional(..., [($) => myTypePredicate($), myTransformer], ...)`.
+ *
+ * To add a a default, catch-all, case you can provide a single callback
+ * function (instead of a 2-tuple) as the last case. This is equivalent to
+ * adding a case with a trivial always-true predicate as it's condition (see
+ * example).
+ *
+ * For simpler cases you should also consider using `when` instead.
+ *
+ * Due to TypeScript's inability to infer the result of negating a type-
+ * predicate we can't refine the types used in subsequent cases based on
+ * previous conditions. Using a `switch (true)` statement or ternary operators
+ * is recommended for more precise type control when such type narrowing is
+ * needed.
+ *
+ * !IMPORTANT! - Unlike similar implementations in Lodash and Ramda, this
+ * implementation **doesn't** implicitly return `undefined` as a fallback when
+ * when none of the cases match; and instead **throws** an exception in those
+ * cases! You have to explicitly provide a default case, and can use
+ * `constant(undefined)` as your last case to replicate that behavior.
+ *
+ * @param data - The input data to be evaluated against the provided cases.
+ * @param cases - A list of (up to 10) cases. Each case can be either:
+ * - A 2-tuple consisting of a predicate (or type-predicate) and a transformer
+ *   function that processes the data if the predicate matches.
+ * - A single callback function that acts as a default fallback case.
+ * @returns The output of the matched transformer. If no cases match, an
+ * exception is thrown. The return type is a union of the return types of all
+ * provided transformers.
+ * @signature
+ *   P.conditional(data, ...cases);
+ * @example
+ *   const nameOrId = 3 as string | number | boolean;
+ *
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *   ); //=> 'Hello ID: 3' (typed as `string`), can throw!.
+ *
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     P.constant(undefined),
+ *   ); //=> 'Hello ID: 3' (typed as `string | undefined`), won't throw.
+ *
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     (something) => `Hello something (${JSON.stringify(something)})`,
+ *   ); //=> 'Hello ID: 3' (typed as `string`), won't throw.
+ * @dataFirst
+ * @category Function
+ */
+declare function conditional<T, Fn0 extends (x: T) => boolean, Return0, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, fallback?: DefaultCase<T, Fallback>): Return0 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Return0, Return1, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Return0, Return1, Return2, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Fn8 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Return8, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, case8: Case<T, Return8, Fn8>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Fallback;
+declare function conditional<T, Fn0 extends (x: T) => boolean, Fn1 extends (x: T) => boolean, Fn2 extends (x: T) => boolean, Fn3 extends (x: T) => boolean, Fn4 extends (x: T) => boolean, Fn5 extends (x: T) => boolean, Fn6 extends (x: T) => boolean, Fn7 extends (x: T) => boolean, Fn8 extends (x: T) => boolean, Fn9 extends (x: T) => boolean, Return0, Return1, Return2, Return3, Return4, Return5, Return6, Return7, Return8, Return9, Fallback = never>(data: T, case0: Case<T, Return0, Fn0>, case1: Case<T, Return1, Fn1>, case2: Case<T, Return2, Fn2>, case3: Case<T, Return3, Fn3>, case4: Case<T, Return4, Fn4>, case5: Case<T, Return5, Fn5>, case6: Case<T, Return6, Fn6>, case7: Case<T, Return7, Fn7>, case8: Case<T, Return8, Fn8>, case9: Case<T, Return9, Fn9>, fallback?: DefaultCase<T, Fallback>): Return0 | Return1 | Return2 | Return3 | Return4 | Return5 | Return6 | Return7 | Return8 | Return9 | Fallback;
+/**
+ *! **DEPRECATED**: `conditional` now accepts a default, catch-all, callback directly and no longer needs this utility wrapper. Use `constant(undefined)` as your last case instead (see example).
+ *
+ * @example
+ *   const nameOrId = 3 as string | number;
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     // Was: `P.conditional.defaultCase(),`, Now:
+ *     constant(undefined),
+ *   ); //=> 'Hello ID: 3'
+ * @deprecated `conditional` now accepts a default, catch-all, callback
+ * directly and no longer needs this utility wrapper. Use `constant(undefined)`
+ * as your last case instead (see example).
+ */
+declare function defaultCase(): Case<unknown, undefined>;
+/**
+ *! **DEPRECATED**: `conditional` now accepts a default, catch-all, callback directly and no longer needs this utility wrapper. Simply put your `then` callback as the last case (see example).
+ *
+ * @param then - You only need to provide the transformer, the predicate is
+ * implicit. @default () => undefined, which is how Lodash and Ramda handle
+ * the final fallback case.
+ * @example
+ *   const nameOrId = 3 as string | number;
+ *   P.conditional(
+ *     nameOrId,
+ *     [P.isString, (name) => `Hello ${name}`],
+ *     [P.isNumber, (id) => `Hello ID: ${id}`],
+ *     // Was: `P.conditional.defaultCase(
+ *     //  (something) => `Hello something (${JSON.stringify(something)})`,
+ *     //),`, Now:
+ *     (something) => `Hello something (${JSON.stringify(something)})`
+ *   ); //=> 'Hello ID: 3'
+ * @deprecated `conditional` now accepts a default, catch-all, callback
+ * directly and no longer needs this utility wrapper. Simply put your `then`
+ * callback as the last case.
+ */
+declare function defaultCase<In, Then extends (param: In) => unknown>(then: Then): Case<In, ReturnType<Then>>;
+//# sourceMappingURL=conditional.d.ts.map
+
+//#endregion
+export { conditionalPlus };
+//# sourceMappingURL=conditional-BW7TbnuD.d.ts.map

package/dist/conditional-BW7TbnuD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-BW7TbnuD.d.ts","names":[],"sources":["../src/internal/types/guard-type.ts","../src/conditional.ts"],"sourcesContent":[],"mappings":";;AAOA;;;;;;KAAY,iCAAiC,qDAMzC,IACA;;;AAPJ,KCFK,IDEO,CAAA,EAAA,EAAA,GAAS,EAAA,aAAA,CAAA,CAAA,ECCF,EDDE,EAAA,GAAA,OAAA,GAAA,CAAA,CAAA,ECCmB,EDDnB,EAAA,GAAA,OAAA,CAAA,GAAA,SAAA,CAAA,IAAA,ECED,IDFC,EAAA,IAAA,EAAA,CAAA,CAAA,ECEe,SDFf,CCEyB,IDFzB,ECE+B,EDF/B,CAAA,GCEqC,EDFrC,EAAA,GCE4C,GDF5C,CAAA;KCIhB,WDJgB,CAAA,EAAA,EAAA,GAAA,CAAA,GAAA,CAAA,CAAA,ECIW,EDJX,EAAA,GCIkB,GDJlB;UCUX,SAAA,CDVmC;WAMzC,WAAA,EAAA,OCK2B,WDL3B;;KCOC,SDNO,CAAA,CAAA,CAAA,GCMQ,CDNR,GCMY,SDNZ;cCQN,iBAAiB,iBAAiB;;AApBqB;;;;;;;;;;;AAOO;;;;;AAE1B;AAOA;;;;;AAET;;;;;AAMS;;;;;;;;;;;;;;AAmFR;;;;;;;;;;;;;;;;;;;;AAcU;;;;;;;;;;iBAvBnC,WAoCQ,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EAlCC,CAkCD,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,KAAA,EA7BR,IA6BQ,CA7BH,CA6BG,EA7BA,OA6BA,EA7BS,GA6BT,CAAA,EAAA,QAAA,CAAA,EA5BJ,WA4BI,CA5BQ,CA4BR,EA5BW,QA4BX,CAAA,CAAA,EAAA,CAAA,IAAA,EA3BP,CA2BO,EAAA,GA3BD,OA2BC,GA3BS,QA2BT;iBAzBR,WAyBiB,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EAvBR,CAuBQ,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EArBR,CAqBQ,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,KAAA,EAhBjB,IAgBiB,CAhBZ,CAgBY,EAhBT,OAgBS,EAhBA,GAgBA,CAAA,EAAA,KAAA,EAfjB,IAeiB,CAfZ,CAeY,EAfT,OAeS,EAfA,GAeA,CAAA,EAAA,QAAA,CAAA,EAdb,WAca,CAdD,CAcC,EAdE,QAcF,CAAA,CAAA,EAAA,CAAA,IAAA,EAbhB,CAagB,EAAA,GAbV,OAaU,GAbA,OAaA,GAbU,QAaV;iBAXjB,WAWA,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EATS,CAST,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EARS,CAQT,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAPS,CAOT,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,KAAA,EADA,IACA,CADK,CACL,EADQ,OACR,EADiB,GACjB,CAAA,EAAA,KAAA,EAAA,IAAA,CAAK,CAAL,EAAQ,OAAR,EAAiB,GAAjB,CAAA,EAAA,KAAA,EACA,IADA,CACK,CADL,EACQ,OADR,EACiB,GADjB,CAAA,EAAA,QAAA,CAAA,EAEI,WAFJ,CAEgB,CAFhB,EAEmB,QAFnB,CAAA,CAAA,EAAA,CAAA,IAAA,EAGC,CAHD,EAAA,GAGO,OAHP,GAGiB,OAHjB,GAG2B,OAH3B,GAGqC,QAHrC;iBAKA,WAJK,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EAMI,CANJ,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAOI,CAPJ,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAQI,CARJ,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EASI,CATJ,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,KAAA,EAgBL,IAhBK,CAgBA,CAhBA,EAgBG,OAhBH,EAgBY,GAhBZ,CAAA,EAAA,KAAA,EAiBL,IAjBK,CAiBA,CAjBA,EAiBG,OAjBH,EAiBY,GAjBZ,CAAA,EAAA,KAAA,EAkBL,IAlBK,CAkBA,CAlBA,EAkBG,OAlBH,EAkBY,GAlBZ,CAAA,EAAA,KAAA,EAmBL,IAnBK,CAmBA,CAnBA,EAmBG,OAnBH,EAmBY,GAnBZ,CAAA,EAAA,QAAA,CAAA,EAoBD,WApBC,CAoBW,CApBX,EAoBc,QApBd,CAAA,CAAA,EAAA,CAAA,IAAA,EAqBJ,CArBI,EAAA,GAqBE,OArBF,GAqBY,OArBZ,GAqBsB,OArBtB,GAqBgC,OArBhC,GAqB0C,QArB1C;iBAuBL,WAvBQ,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EAyBC,CAzBD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA0BC,CA1BD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA2BC,CA3BD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA4BC,CA5BD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA6BC,CA7BD,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,KAAA,EAqCR,IArCQ,CAqCH,CArCG,EAqCA,OArCA,EAqCS,GArCT,CAAA,EAAA,KAAA,EAsCR,IAtCQ,CAsCH,CAtCG,EAsCA,OAtCA,EAsCS,GAtCT,CAAA,EAAA,KAAA,EAuCR,IAvCQ,CAuCH,CAvCG,EAuCA,OAvCA,EAuCS,GAvCT,CAAA,EAAA,KAAA,EAwCR,IAxCQ,CAwCH,CAxCG,EAwCA,OAxCA,EAwCS,GAxCT,CAAA,EAAA,KAAA,EAyCR,IAzCQ,CAyCH,CAzCG,EAyCA,OAzCA,EAyCS,GAzCT,CAAA,EAAA,QAAA,CAAA,EA0CJ,WA1CI,CA0CQ,CA1CR,EA0CW,QA1CX,CAAA,CAAA,EAAA,CAAA,IAAA,EA2CP,CA3CO,EAAA,GA2CD,OA3CC,GA2CS,OA3CT,GA2CmB,OA3CnB,GA2C6B,OA3C7B,GA2CuC,OA3CvC,GA2CiD,QA3CjD;iBA6CR,WA7CiB,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EA+CR,CA/CQ,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAgDR,CAhDQ,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAiDR,CAjDQ,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAkDR,CAlDQ,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAmDR,CAnDQ,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAoDR,CApDQ,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,KAAA,EA6DjB,IA7DiB,CA6DZ,CA7DY,EA6DT,OA7DS,EA6DA,GA7DA,CAAA,EAAA,KAAA,EA8DjB,IA9DiB,CA8DZ,CA9DY,EA8DT,OA9DS,EA8DA,GA9DA,CAAA,EAAA,KAAA,EA+DjB,IA/DiB,CA+DZ,CA/DY,EA+DT,OA/DS,EA+DA,GA/DA,CAAA,EAAA,KAAA,EAgEjB,IAhEiB,CAgEZ,CAhEY,EAgET,OAhES,EAgEA,GAhEA,CAAA,EAAA,KAAA,EAiEjB,IAjEiB,CAiEZ,CAjEY,EAiET,OAjES,EAiEA,GAjEA,CAAA,EAAA,KAAA,EAkEjB,IAlEiB,CAkEZ,CAlEY,EAkET,OAlES,EAkEA,GAlEA,CAAA,EAAA,QAAA,CAAA,EAmEb,WAnEa,CAmED,CAnEC,EAmEE,QAnEF,CAAA,CAAA,EAAA,CAAA,IAAA,EAqElB,CArEkB,EAAA,GAsErB,OAtEqB,GAsEX,OAtEW,GAsED,OAtEC,GAsES,OAtET,GAsEmB,OAtEnB,GAsE6B,OAtE7B,GAsEuC,QAtEvC;iBAwEjB,WAxEA,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EA0ES,CA1ET,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA2ES,CA3ET,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA4ES,CA5ET,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA6ES,CA7ET,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA8ES,CA9ET,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA+ES,CA/ET,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAgFS,CAhFT,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,KAAA,EA0FA,IA1FA,CA0FK,CA1FL,EA0FQ,OA1FR,EA0FiB,GA1FjB,CAAA,EAAA,KAAA,EA2FA,IA3FA,CA2FK,CA3FL,EA2FQ,OA3FR,EA2FiB,GA3FjB,CAAA,EAAA,KAAA,EA4FA,IA5FA,CA4FK,CA5FL,EA4FQ,OA5FR,EA4FiB,GA5FjB,CAAA,EAAA,KAAA,EA6FA,IA7FA,CA6FK,CA7FL,EA6FQ,OA7FR,EA6FiB,GA7FjB,CAAA,EAAA,KAAA,EA8FA,IA9FA,CA8FK,CA9FL,EA8FQ,OA9FR,EA8FiB,GA9FjB,CAAA,EAAA,KAAA,EA+FA,IA/FA,CA+FK,CA/FL,EA+FQ,OA/FR,EA+FiB,GA/FjB,CAAA,EAAA,KAAA,EAgGA,IAhGA,CAgGK,CAhGL,EAgGQ,OAhGR,EAgGiB,GAhGjB,CAAA,EAAA,QAAA,CAAA,EAiGI,WAjGJ,CAiGgB,CAjGhB,EAiGmB,QAjGnB,CAAA,CAAA,EAAA,CAAA,IAAA,EAmGD,CAnGC,EAAA,GAqGL,OArGK,GAsGL,OAtGK,GAuGL,OAvGK,GAwGL,OAxGK,GAyGL,OAzGK,GA0GL,OA1GK,GA2GL,OA3GK,GA4GL,QA5GK;iBA8GA,WA7GgB,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EA+GP,CA/GO,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAgHP,CAhHO,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAiHP,CAjHO,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAkHP,CAlHO,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAmHP,CAnHO,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAoHP,CApHO,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAqHP,CArHO,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAsHP,CAtHO,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,KAAA,EAiIhB,IAjIgB,CAiIX,CAjIW,EAiIR,OAjIQ,EAiIC,GAjID,CAAA,EAAA,KAAA,EAkIhB,IAlIgB,CAkIX,CAlIW,EAkIR,OAlIQ,EAkIC,GAlID,CAAA,EAAA,KAAA,EAmIhB,IAnIgB,CAmIX,CAnIW,EAmIR,OAnIQ,EAmIC,GAnID,CAAA,EAAA,KAAA,EAoIhB,IApIgB,CAoIX,CApIW,EAoIR,OApIQ,EAoIC,GApID,CAAA,EAAA,KAAA,EAqIhB,IArIgB,CAqIX,CArIW,EAqIR,OArIQ,EAqIC,GArID,CAAA,EAAA,KAAA,EAsIhB,IAtIgB,CAsIX,CAtIW,EAsIR,OAtIQ,EAsIC,GAtID,CAAA,EAAA,KAAA,EAuIhB,IAvIgB,CAuIX,CAvIW,EAuIR,OAvIQ,EAuIC,GAvID,CAAA,EAAA,KAAA,EAwIhB,IAxIgB,CAwIX,CAxIW,EAwIR,OAxIQ,EAwIC,GAxID,CAAA,EAAA,QAAA,CAAA,EAyIZ,WAzIY,CAyIA,CAzIA,EAyIG,QAzIH,CAAA,CAAA,EAAA,CAAA,IAAA,EA2IjB,CA3IiB,EAAA,GA6IrB,OA7IqB,GA8IrB,OA9IqB,GA+IrB,OA/IqB,GAgJrB,OAhJqB,GAiJrB,OAjJqB,GAkJrB,OAlJqB,GAmJrB,OAnJqB,GAoJrB,OApJqB,GAqJrB,QArJqB;iBAuJhB,WAvJmB,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EAyJV,CAzJU,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA0JV,CA1JU,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA2JV,CA3JU,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA4JV,CA5JU,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA6JV,CA7JU,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA8JV,CA9JU,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA+JV,CA/JU,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAgKV,CAhKU,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAiKV,CAjKU,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,KAAA,EA6KnB,IA7KmB,CA6Kd,CA7Kc,EA6KX,OA7KW,EA6KF,GA7KE,CAAA,EAAA,KAAA,EA8KnB,IA9KmB,CA8Kd,CA9Kc,EA8KX,OA9KW,EA8KF,GA9KE,CAAA,EAAA,KAAA,EA+KnB,IA/KmB,CA+Kd,CA/Kc,EA+KX,OA/KW,EA+KF,GA/KE,CAAA,EAAA,KAAA,EAgLnB,IAhLmB,CAgLd,CAhLc,EAgLX,OAhLW,EAgLF,GAhLE,CAAA,EAAA,KAAA,EAiLnB,IAjLmB,CAiLd,CAjLc,EAiLX,OAjLW,EAiLF,GAjLE,CAAA,EAAA,KAAA,EAkLnB,IAlLmB,CAkLd,CAlLc,EAkLX,OAlLW,EAkLF,GAlLE,CAAA,EAAA,KAAA,EAmLnB,IAnLmB,CAmLd,CAnLc,EAmLX,OAnLW,EAmLF,GAnLE,CAAA,EAAA,KAAA,EAoLnB,IApLmB,CAoLd,CApLc,EAoLX,OApLW,EAoLF,GApLE,CAAA,EAAA,KAAA,EAqLnB,IArLmB,CAqLd,CArLc,EAqLX,OArLW,EAqLF,GArLE,CAAA,EAAA,QAAA,CAAA,EAsLf,WAtLe,CAsLH,CAtLG,EAsLA,QAtLA,CAAA,CAAA,EAAA,CAAA,IAAA,EAwLpB,CAxLoB,EAAA,GA0LxB,OA1LwB,GA2LxB,OA3LwB,GA4LxB,OA5LwB,GA6LxB,OA7LwB,GA8LxB,OA9LwB,GA+LxB,OA/LwB,GAgMxB,OAhMwB,GAiMxB,OAjMwB,GAkMxB,OAlMwB,GAmMxB,QAnMwB;iBAqMnB,WArMI,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EAuMK,CAvML,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAwMK,CAxML,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAyMK,CAzML,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA0MK,CA1ML,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA2MK,CA3ML,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA4MK,CA5ML,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA6MK,CA7ML,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA8MK,CA9ML,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA+MK,CA/ML,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAgNK,CAhNL,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,KAAA,EA6NJ,IA7NI,CA6NC,CA7ND,EA6NI,OA7NJ,EA6Na,GA7Nb,CAAA,EAAA,KAAA,EA8NJ,IA9NI,CA8NC,CA9ND,EA8NI,OA9NJ,EA8Na,GA9Nb,CAAA,EAAA,KAAA,EA+NJ,IA/NI,CA+NC,CA/ND,EA+NI,OA/NJ,EA+Na,GA/Nb,CAAA,EAAA,KAAA,EAgOJ,IAhOI,CAgOC,CAhOD,EAgOI,OAhOJ,EAgOa,GAhOb,CAAA,EAAA,KAAA,EAiOJ,IAjOI,CAiOC,CAjOD,EAiOI,OAjOJ,EAiOa,GAjOb,CAAA,EAAA,KAAA,EAkOJ,IAlOI,CAkOC,CAlOD,EAkOI,OAlOJ,EAkOa,GAlOb,CAAA,EAAA,KAAA,EAmOJ,IAnOI,CAmOC,CAnOD,EAmOI,OAnOJ,EAmOa,GAnOb,CAAA,EAAA,KAAA,EAoOJ,IApOI,CAoOC,CApOD,EAoOI,OApOJ,EAoOa,GApOb,CAAA,EAAA,KAAA,EAqOJ,IArOI,CAqOC,CArOD,EAqOI,OArOJ,EAqOa,GArOb,CAAA,EAAA,KAAA,EAsOJ,IAtOI,CAsOC,CAtOD,EAsOI,OAtOJ,EAsOa,GAtOb,CAAA,EAAA,QAAA,CAAA,EAuOA,WAvOA,CAuOY,CAvOZ,EAuOe,QAvOf,CAAA,CAAA,EAAA,CAAA,IAAA,EAyOL,CAzOK,EAAA,GA2OT,OA3OS,GA4OT,OA5OS,GA6OT,OA7OS,GA8OT,OA9OS,GA+OT,OA/OS,GAgPT,OAhPS,GAiPT,OAjPS,GAkPT,OAlPS,GAmPT,OAnPS,GAoPT,OApPS,GAqPT,QArPS;;;;;;;AACyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsSvD,WAjRI,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EAmRK,CAnRL,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,IAAA,EAuRL,CAvRK,EAAA,KAAA,EAwRJ,IAxRI,CAwRC,CAxRD,EAwRI,OAxRJ,EAwRa,GAxRb,CAAA,EAAA,QAAA,CAAA,EAyRA,WAzRA,CAyRY,CAzRZ,EAyRe,QAzRf,CAAA,CAAA,EA0RV,OA1RU,GA0RA,QA1RA;iBA4RJ,WA3RC,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EA6RQ,CA7RR,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA8RQ,CA9RR,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,IAAA,EAmSF,CAnSE,EAAA,KAAA,EAoSD,IApSC,CAoSI,CApSJ,EAoSO,OApSP,EAoSgB,GApShB,CAAA,EAAA,KAAA,EAqSD,IArSC,CAqSI,CArSJ,EAqSO,OArSP,EAqSgB,GArShB,CAAA,EAAA,QAAA,CAAA,EAsSG,WAtSH,CAsSe,CAtSf,EAsSkB,QAtSlB,CAAA,CAAA,EAuSP,OAvSO,GAuSG,OAvSH,GAuSa,QAvSb;iBAySD,WAzSO,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EA2SE,CA3SF,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA4SE,CA5SF,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA6SE,CA7SF,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,IAAA,EAmTR,CAnTQ,EAAA,KAAA,EAoTP,IApTO,CAoTF,CApTE,EAoTC,OApTD,EAoTU,GApTV,CAAA,EAAA,KAAA,EAqTP,IArTO,CAqTF,CArTE,EAqTC,OArTD,EAqTU,GArTV,CAAA,EAAA,KAAA,EAsTP,IAtTO,CAsTF,CAtTE,EAsTC,OAtTD,EAsTU,GAtTV,CAAA,EAAA,QAAA,CAAA,EAuTH,WAvTG,CAuTS,CAvTT,EAuTY,QAvTZ,CAAA,CAAA,EAwTb,OAxTa,GAwTH,OAxTG,GAwTO,OAxTP,GAwTiB,QAxTjB;iBA0TP,WA1TiB,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EA4TR,CA5TQ,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA6TR,CA7TQ,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA8TR,CA9TQ,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA+TR,CA/TQ,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,IAAA,EAsUlB,CAtUkB,EAAA,KAAA,EAuUjB,IAvUiB,CAuUZ,CAvUY,EAuUT,OAvUS,EAuUA,GAvUA,CAAA,EAAA,KAAA,EAwUjB,IAxUiB,CAwUZ,CAxUY,EAwUT,OAxUS,EAwUA,GAxUA,CAAA,EAAA,KAAA,EAyUjB,IAzUiB,CAyUZ,CAzUY,EAyUT,OAzUS,EAyUA,GAzUA,CAAA,EAAA,KAAA,EA0UjB,IA1UiB,CA0UZ,CA1UY,EA0UT,OA1US,EA0UA,GA1UA,CAAA,EAAA,QAAA,CAAA,EA2Ub,WA3Ua,CA2UD,CA3UC,EA2UE,QA3UF,CAAA,CAAA,EA4UvB,OA5UuB,GA4Ub,OA5Ua,GA4UH,OA5UG,GA4UO,OA5UP,GA4UiB,QA5UjB;iBA8UjB,WA9U2B,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EAgVlB,CAhVkB,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAiVlB,CAjVkB,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAkVlB,CAlVkB,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAmVlB,CAnVkB,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAoVlB,CApVkB,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,IAAA,EA4V5B,CA5V4B,EAAA,KAAA,EA6V3B,IA7V2B,CA6VtB,CA7VsB,EA6VnB,OA7VmB,EA6VV,GA7VU,CAAA,EAAA,KAAA,EA8V3B,IA9V2B,CA8VtB,CA9VsB,EA8VnB,OA9VmB,EA8VV,GA9VU,CAAA,EAAA,KAAA,EA+V3B,IA/V2B,CA+VtB,CA/VsB,EA+VnB,OA/VmB,EA+VV,GA/VU,CAAA,EAAA,KAAA,EAgW3B,IAhW2B,CAgWtB,CAhWsB,EAgWnB,OAhWmB,EAgWV,GAhWU,CAAA,EAAA,KAAA,EAiW3B,IAjW2B,CAiWtB,CAjWsB,EAiWnB,OAjWmB,EAiWV,GAjWU,CAAA,EAAA,QAAA,CAAA,EAkWvB,WAlWuB,CAkWX,CAlWW,EAkWR,QAlWQ,CAAA,CAAA,EAmWjC,OAnWiC,GAmWvB,OAnWuB,GAmWb,OAnWa,GAmWH,OAnWG,GAmWO,OAnWP,GAmWiB,QAnWjB;iBAqW3B,WArWqC,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EAuW5B,CAvW4B,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAwW5B,CAxW4B,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAyW5B,CAzW4B,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA0W5B,CA1W4B,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA2W5B,CA3W4B,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA4W5B,CA5W4B,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,IAAA,EAqXtC,CArXsC,EAAA,KAAA,EAsXrC,IAtXqC,CAsXhC,CAtXgC,EAsX7B,OAtX6B,EAsXpB,GAtXoB,CAAA,EAAA,KAAA,EAuXrC,IAvXqC,CAuXhC,CAvXgC,EAuX7B,OAvX6B,EAuXpB,GAvXoB,CAAA,EAAA,KAAA,EAwXrC,IAxXqC,CAwXhC,CAxXgC,EAwX7B,OAxX6B,EAwXpB,GAxXoB,CAAA,EAAA,KAAA,EAyXrC,IAzXqC,CAyXhC,CAzXgC,EAyX7B,OAzX6B,EAyXpB,GAzXoB,CAAA,EAAA,KAAA,EA0XrC,IA1XqC,CA0XhC,CA1XgC,EA0X7B,OA1X6B,EA0XpB,GA1XoB,CAAA,EAAA,KAAA,EA2XrC,IA3XqC,CA2XhC,CA3XgC,EA2X7B,OA3X6B,EA2XpB,GA3XoB,CAAA,EAAA,QAAA,CAAA,EA4XjC,WA5XiC,CA4XrB,CA5XqB,EA4XlB,QA5XkB,CAAA,CAAA,EA6X3C,OA7X2C,GA6XjC,OA7XiC,GA6XvB,OA7XuB,GA6Xb,OA7Xa,GA6XH,OA7XG,GA6XO,OA7XP,GA6XiB,QA7XjB;iBA+XrC,WA/X+C,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EAiYtC,CAjYsC,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAkYtC,CAlYsC,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAmYtC,CAnYsC,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAoYtC,CApYsC,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAqYtC,CArYsC,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAsYtC,CAtYsC,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAuYtC,CAvYsC,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,IAAA,EAiZhD,CAjZgD,EAAA,KAAA,EAkZ/C,IAlZ+C,CAkZ1C,CAlZ0C,EAkZvC,OAlZuC,EAkZ9B,GAlZ8B,CAAA,EAAA,KAAA,EAmZ/C,IAnZ+C,CAmZ1C,CAnZ0C,EAmZvC,OAnZuC,EAmZ9B,GAnZ8B,CAAA,EAAA,KAAA,EAoZ/C,IApZ+C,CAoZ1C,CApZ0C,EAoZvC,OApZuC,EAoZ9B,GApZ8B,CAAA,EAAA,KAAA,EAqZ/C,IArZ+C,CAqZ1C,CArZ0C,EAqZvC,OArZuC,EAqZ9B,GArZ8B,CAAA,EAAA,KAAA,EAsZ/C,IAtZ+C,CAsZ1C,CAtZ0C,EAsZvC,OAtZuC,EAsZ9B,GAtZ8B,CAAA,EAAA,KAAA,EAuZ/C,IAvZ+C,CAuZ1C,CAvZ0C,EAuZvC,OAvZuC,EAuZ9B,GAvZ8B,CAAA,EAAA,KAAA,EAwZ/C,IAxZ+C,CAwZ1C,CAxZ0C,EAwZvC,OAxZuC,EAwZ9B,GAxZ8B,CAAA,EAAA,QAAA,CAAA,EAyZ3C,WAzZ2C,CAyZ/B,CAzZ+B,EAyZ5B,QAzZ4B,CAAA,CAAA,EA2ZpD,OA3ZoD,GA4ZpD,OA5ZoD,GA6ZpD,OA7ZoD,GA8ZpD,OA9ZoD,GA+ZpD,OA/ZoD,GAgapD,OAhaoD,GAiapD,OAjaoD,GAkapD,QAlaoD;iBAoa/C,WApayD,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EAsahD,CAtagD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAuahD,CAvagD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAwahD,CAxagD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAyahD,CAzagD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA0ahD,CA1agD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA2ahD,CA3agD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA4ahD,CA5agD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA6ahD,CA7agD,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,IAAA,EAwb1D,CAxb0D,EAAA,KAAA,EAybzD,IAzbyD,CAybpD,CAzboD,EAybjD,OAzbiD,EAybxC,GAzbwC,CAAA,EAAA,KAAA,EA0bzD,IA1byD,CA0bpD,CA1boD,EA0bjD,OA1biD,EA0bxC,GA1bwC,CAAA,EAAA,KAAA,EA2bzD,IA3byD,CA2bpD,CA3boD,EA2bjD,OA3biD,EA2bxC,GA3bwC,CAAA,EAAA,KAAA,EA4bzD,IA5byD,CA4bpD,CA5boD,EA4bjD,OA5biD,EA4bxC,GA5bwC,CAAA,EAAA,KAAA,EA6bzD,IA7byD,CA6bpD,CA7boD,EA6bjD,OA7biD,EA6bxC,GA7bwC,CAAA,EAAA,KAAA,EA8bzD,IA9byD,CA8bpD,CA9boD,EA8bjD,OA9biD,EA8bxC,GA9bwC,CAAA,EAAA,KAAA,EA+bzD,IA/byD,CA+bpD,CA/boD,EA+bjD,OA/biD,EA+bxC,GA/bwC,CAAA,EAAA,KAAA,EAgczD,IAhcyD,CAgcpD,CAhcoD,EAgcjD,OAhciD,EAgcxC,GAhcwC,CAAA,EAAA,QAAA,CAAA,EAicrD,WAjcqD,CAiczC,CAjcyC,EAictC,QAjcsC,CAAA,CAAA,EAmc9D,OAnc8D,GAoc9D,OApc8D,GAqc9D,OArc8D,GAsc9D,OAtc8D,GAuc9D,OAvc8D,GAwc9D,OAxc8D,GAyc9D,OAzc8D,GA0c9D,OA1c8D,GA2c9D,QA3c8D;iBA6czD,WA7ciE,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EA+cxD,CA/cwD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAgdxD,CAhdwD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAidxD,CAjdwD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAkdxD,CAldwD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAmdxD,CAndwD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAodxD,CApdwD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAqdxD,CArdwD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAsdxD,CAtdwD,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAudxD,CAvdwD,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,IAAA,EAmelE,CAnekE,EAAA,KAAA,EAoejE,IApeiE,CAoe5D,CApe4D,EAoezD,OApeyD,EAoehD,GApegD,CAAA,EAAA,KAAA,EAqejE,IAreiE,CAqe5D,CAre4D,EAqezD,OAreyD,EAqehD,GAregD,CAAA,EAAA,KAAA,EAsejE,IAteiE,CAse5D,CAte4D,EAsezD,OAteyD,EAsehD,GAtegD,CAAA,EAAA,KAAA,EAuejE,IAveiE,CAue5D,CAve4D,EAuezD,OAveyD,EAuehD,GAvegD,CAAA,EAAA,KAAA,EAwejE,IAxeiE,CAwe5D,CAxe4D,EAwezD,OAxeyD,EAwehD,GAxegD,CAAA,EAAA,KAAA,EAyejE,IAzeiE,CAye5D,CAze4D,EAyezD,OAzeyD,EAyehD,GAzegD,CAAA,EAAA,KAAA,EA0ejE,IA1eiE,CA0e5D,CA1e4D,EA0ezD,OA1eyD,EA0ehD,GA1egD,CAAA,EAAA,KAAA,EA2ejE,IA3eiE,CA2e5D,CA3e4D,EA2ezD,OA3eyD,EA2ehD,GA3egD,CAAA,EAAA,KAAA,EA4ejE,IA5eiE,CA4e5D,CA5e4D,EA4ezD,OA5eyD,EA4ehD,GA5egD,CAAA,EAAA,QAAA,CAAA,EA6e7D,WA7e6D,CA6ejD,CA7eiD,EA6e9C,QA7e8C,CAAA,CAAA,EA+etE,OA/esE,GAgftE,OAhfsE,GAiftE,OAjfsE,GAkftE,OAlfsE,GAmftE,OAnfsE,GAoftE,OApfsE,GAqftE,OArfsE,GAsftE,OAtfsE,GAuftE,OAvfsE,GAwftE,QAxfsE;AAAA,iBA0fjE,WAxfW,CAAA,CAAA,EAAA,YAAA,CAAA,CAAA,EA0fF,CA1fE,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA2fF,CA3fE,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA4fF,CA5fE,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA6fF,CA7fE,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA8fF,CA9fE,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EA+fF,CA/fE,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAggBF,CAhgBE,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAigBF,CAjgBE,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAkgBF,CAlgBE,EAAA,GAAA,OAAA,EAAA,YAAA,CAAA,CAAA,EAmgBF,CAngBE,EAAA,GAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,OAAA,EAAA,WAAA,KAAA,CAAA,CAAA,IAAA,EAghBZ,CAhhBY,EAAA,KAAA,EAihBX,IAjhBW,CAihBN,CAjhBM,EAihBH,OAjhBG,EAihBM,GAjhBN,CAAA,EAAA,KAAA,EAkhBX,IAlhBW,CAkhBN,CAlhBM,EAkhBH,OAlhBG,EAkhBM,GAlhBN,CAAA,EAAA,KAAA,EAmhBX,IAnhBW,CAmhBN,CAnhBM,EAmhBH,OAnhBG,EAmhBM,GAnhBN,CAAA,EAAA,KAAA,EAohBX,IAphBW,CAohBN,CAphBM,EAohBH,OAphBG,EAohBM,GAphBN,CAAA,EAAA,KAAA,EAqhBX,IArhBW,CAqhBN,CArhBM,EAqhBH,OArhBG,EAqhBM,GArhBN,CAAA,EAAA,KAAA,EAshBX,IAthBW,CAshBN,CAthBM,EAshBH,OAthBG,EAshBM,GAthBN,CAAA,EAAA,KAAA,EAuhBX,IAvhBW,CAuhBN,CAvhBM,EAuhBH,OAvhBG,EAuhBM,GAvhBN,CAAA,EAAA,KAAA,EAwhBX,IAxhBW,CAwhBN,CAxhBM,EAwhBH,OAxhBG,EAwhBM,GAxhBN,CAAA,EAAA,KAAA,EAyhBX,IAzhBW,CAyhBN,CAzhBM,EAyhBH,OAzhBG,EAyhBM,GAzhBN,CAAA,EAAA,KAAA,EA0hBX,IA1hBW,CA0hBN,CA1hBM,EA0hBH,OA1hBG,EA0hBM,GA1hBN,CAAA,EAAA,QAAA,CAAA,EA2hBP,WA3hBO,CA2hBK,CA3hBL,EA2hBQ,QA3hBR,CAAA,CAAA,EA6hBhB,OA7hBgB,GA8hBhB,OA9hBgB,GA+hBhB,OA/hBgB,GAgiBhB,OAhiBgB,GAiiBhB,OAjiBgB,GAkiBhB,OAliBgB,GAmiBhB,OAniBgB,GAoiBhB,OApiBgB,GAqiBhB,OAriBgB,GAsiBhB,OAtiBgB,GAuiBhB,QAviBgB;;;;;;;;;;;;;;;;;iBAgmBX,WAAA,CAAA,CA9kBQ,EA8kBO,IA9kBP,CAAA,OAAA,EAAA,SAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;iBAqmBR,WA9lB0B,CAAA,EAAA,EAAA,aAAA,CAAA,KAAA,EA8lBW,EA9lBX,EAAA,GAAA,OAAA,CAAA,CAAA,IAAA,EA+lB3B,IA/lB2B,CAAA,EAgmBhC,IAhmBgC,CAgmB3B,EAhmB2B,EAgmBvB,UAhmBuB,CAgmBZ,IAhmBY,CAAA,CAAA"}

package/dist/conditional.d.ts

@@ -1,2 +1,2 @@
-import { conditionalPlus } from "./conditional-DeaF48-8.js";
+import { conditionalPlus } from "./conditional-BW7TbnuD.js";
 export { conditionalPlus as conditional };

package/dist/constant-BoufjloF.d.ts

@@ -0,0 +1,32 @@
+//#region src/constant.d.ts
+/**
+ * A function that takes any arguments and returns the provided `value` on every
+ * invocation. This is useful to provide trivial implementations for APIs or in
+ * combination with a ternary or other conditional execution to allow to short-
+ * circuit more complex implementations for a specific case.
+ *
+ * Notice that this is a dataLast impl where the function needs to be invoked
+ * to get the "do nothing" function.
+ *
+ * See also:
+ * `doNothing` - A function that doesn't return anything.
+ * `identity` - A function that returns the first argument it receives.
+ *
+ * @param value - The constant value that would be returned on every invocation.
+ * The value is not copied/cloned on every invocation so care should be taken
+ * with mutable objects (like arrays, objects, Maps, etc...).
+ * @signature
+ *   P.constant(value);
+ * @example
+ *   P.map([1, 2, 3], P.constant('a')); // => ['a', 'a', 'a']
+ *   P.map(
+ *     [1, 2, 3],
+ *     isDemoMode ? P.add(1) : P.constant(0),
+ *   ); // => [2, 3, 4] or [0, 0, 0]
+ * @dataLast
+ * @category Function
+ */
+declare function constant<const T>(value: T): <Args extends ReadonlyArray<unknown>>(...args: Args) => T;
+//#endregion
+export { constant };
+//# sourceMappingURL=constant-BoufjloF.d.ts.map

package/dist/constant-BoufjloF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant-BoufjloF.d.ts","names":[],"sources":["../src/constant.ts"],"sourcesContent":[],"mappings":";;AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,yBACP,kBACQ,iCAAiC,SAAS"}

package/dist/constant.d.ts

@@ -1,2 +1,2 @@
-import { constant } from "./constant-XCH8hVM0.js";
+import { constant } from "./constant-BoufjloF.js";
 export { constant };

package/dist/count-by-gwHw1EiK.d.ts

@@ -0,0 +1,42 @@
+import { BoundedPartial } from "./bounded-partial-DfemQln9.js";
+
+//#region src/count-by.d.ts
+
+/**
+ * Categorize and count elements in an array using a defined callback function.
+ * The callback function is applied to each element in the array to determine
+ * its category and then counts how many elements fall into each category.
+ *
+ * @param data - The array.
+ * @param categorizationFn - The categorization function.
+ * @signature
+ *   P.countBy(data, categorizationFn)
+ * @example
+ *    P.countBy(
+ *      ["a", "b", "c", "B", "A", "a"],
+ *      toLowerCase
+ *    ); //=> { a: 3, b: 2, c: 1 }
+ * @dataFirst
+ * @category Array
+ */
+declare function countBy<T, K extends PropertyKey>(data: ReadonlyArray<T>, categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): BoundedPartial<Record<K, number>>;
+/**
+ * Categorize and count elements in an array using a defined callback function.
+ * The callback function is applied to each element in the array to determine
+ * its category and then counts how many elements fall into each category.
+ *
+ * @param categorizationFn - The categorization function.
+ * @signature
+ *   P.countBy(categorizationFn)(data)
+ * @example
+ *    P.pipe(
+ *      ["a", "b", "c", "B", "A", "a"],
+ *      P.countBy(toLowerCase),
+ *    ); //=> { a: 3, b: 2, c: 1 }
+ * @dataLast
+ * @category Array
+ */
+declare function countBy<T, K extends PropertyKey>(categorizationFn: (value: T, index: number, data: ReadonlyArray<T>) => K | undefined): (data: ReadonlyArray<T>) => BoundedPartial<Record<K, number>>;
+//#endregion
+export { countBy };
+//# sourceMappingURL=count-by-gwHw1EiK.d.ts.map

package/dist/count-by-gwHw1EiK.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"count-by-gwHw1EiK.d.ts","names":[],"sources":["../src/count-by.ts"],"sourcesContent":[],"mappings":";;;;;;AAoBA;;;;;;;;;;;;;AAyBA;;AAAqC,iBAzBrB,OAyBqB,CAAA,CAAA,EAAA,UAzBA,WAyBA,CAAA,CAAA,IAAA,EAxB7B,aAwB6B,CAxBf,CAwBe,CAAA,EAAA,gBAAA,EAAA,CAAA,KAAA,EAtB1B,CAsB0B,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EApB3B,aAoB2B,CApBb,CAoBa,CAAA,EAAA,GAnB9B,CAmB8B,GAAA,SAAA,CAAA,EAlBlC,cAkBkC,CAlBnB,MAkBmB,CAlBZ,CAkBY,EAAA,MAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;iBAArB,qBAAqB,uCAE1B,wBAED,cAAc,OACjB,uBACG,cAAc,OAAO,eAAe,OAAO"}

package/dist/count-by.d.ts

@@ -1,4 +1,4 @@
-import "./is-bounded-record-DCEYRY41.js";
-import "./bounded-partial-TshEjJC1.js";
-import { countBy } from "./count-by-oQGTg_br.js";
+import "./is-bounded-record-DEQ2a3_Y.js";
+import "./bounded-partial-DfemQln9.js";
+import { countBy } from "./count-by-gwHw1EiK.js";
 export { countBy };

package/dist/curry-2mBj-wsI.d.ts

@@ -0,0 +1,68 @@
+//#region src/internal/types/lazy-result.d.ts
+type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
+interface LazyEmpty {
+  done: boolean;
+  hasNext: false;
+  hasMany?: false | undefined;
+  next?: undefined;
+}
+interface LazyNext<T> {
+  done: boolean;
+  hasNext: true;
+  hasMany?: false | undefined;
+  next: T;
+}
+interface LazyMany<T> {
+  done: boolean;
+  hasNext: true;
+  hasMany: true;
+  next: ReadonlyArray<T>;
+}
+//#endregion
+//#region src/internal/types/lazy-evaluator.d.ts
+type LazyEvaluator<T = unknown, R = T> = (item: T, index: number, data: ReadonlyArray<T>) => LazyResult<R>;
+//#endregion
+//#region src/curry.d.ts
+/**
+ * Creates a function with `dataFirst` and `dataLast` signatures.
+ *
+ * `curry` is a dynamic function and it's not type safe. It should be wrapped by
+ * a function that have proper typings. Refer to the example below for correct
+ * usage.
+ *
+ * !IMPORTANT: functions that simply call `curry` and return the result (like
+ * almost all functions in this library) should return `unknown` themselves if
+ * an explicit return type is required. This is because we currently don't
+ * provide a generic return type that is built from the input function, and
+ * crafting one manually isn't worthwhile as we rely on function declaration
+ * overloading to combine the types for dataFirst and dataLast invocations!
+ *
+ * @param fn - The function to curry.
+ * @param args - The arguments.
+ * @param lazy - A lazy version of the function to curry.
+ * @signature P.curry(fn, args);
+ * @example
+ *    function _findIndex(array, fn) {
+ *      for (let i = 0; i < array.length; i++) {
+ *        if (fn(array[i])) {
+ *          return i;
+ *        }
+ *      }
+ *      return -1;
+ *    }
+ *
+ *    // data-first
+ *    function findIndex<T>(array: T[], fn: (item: T) => boolean): number;
+ *
+ *    // data-last
+ *    function findIndex<T>(fn: (item: T) => boolean): (array: T[]) => number;
+ *
+ *    function findIndex(...args: unknown[]) {
+ *      return P.curry(_findIndex, args);
+ *    }
+ * @category Function
+ */
+declare function curry(fn: (...args: any) => unknown, args: ReadonlyArray<unknown>, lazy?: (...args: any) => LazyEvaluator): unknown;
+//#endregion
+export { curry };
+//# sourceMappingURL=curry-2mBj-wsI.d.ts.map

package/dist/curry-2mBj-wsI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-2mBj-wsI.d.ts","names":[],"sources":["../src/internal/types/lazy-result.ts","../src/internal/types/lazy-evaluator.ts","../src/curry.ts"],"sourcesContent":[],"mappings":";KAAY,gBAAgB,YAAY,SAAS,KAAK,SAAS;AAA/D,UAEU,SAAA,CAFY;EAAA,IAAA,EAAA,OAAA;SAAM,EAAA,KAAA;SAAqB,CAAA,EAAA,KAAA,GAAA,SAAA;MAAT,CAAA,EAAA,SAAA;;UAS9B,QAT4C,CAAA,CAAA,CAAA,CAAA;EAAQ,IAAA,EAAA,OAAA;EAEpD,OAAA,EAAA,IAAS;EAOT,OAAA,CAAA,EAAA,KAAQ,GAAA,SAIT;EAGC,IAAA,EAHF,CAGE;;UAAA,QAIY,CAAA,CAAA,CAAA,CAAA;MAAd,EAAA,OAAA;EAAa,OAAA,EAAA,IAAA;;QAAb,cAAc;;;;AApBV,KCEA,aDFU,CAAA,IAAA,OAAA,EAAA,ICEqB,CDFrB,CAAA,GAAA,CAAA,IAAA,ECGd,CDHc,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,ECKd,aDLc,CCKA,CDLA,CAAA,EAAA,GCMjB,UDNiB,CCMN,CDNM,CAAA;;;AAAtB;;;;;;;;AAAkE;AAE/C;AAWV;;;;;;;;ACXT;;;;;;;;;;;;AC0CA;;;;;;;;;iBAAgB,KAAA,sCAER,iDACmB"}

package/dist/curry-order-rules-D2zI7gpB.d.ts

@@ -0,0 +1,48 @@
+//#region src/internal/curry-order-rules.d.ts
+declare const COMPARATORS: {
+  readonly asc: <T>(x: T, y: T) => boolean;
+  readonly desc: <T>(x: T, y: T) => boolean;
+};
+/**
+ * An order rule defines a projection/extractor that returns a comparable from
+ * the data being compared. It would be run on each item being compared, and a
+ * comparator would then be used on the results to determine the order.
+ *
+ * There are 2 forms of the order rule, a simple one which only provides the
+ * projection function and assumes ordering is ascending, and a 2-tuple where
+ * the first element is the projection function and the second is the direction;
+ * this allows changing the direction without defining a more complex projection
+ * to simply negate the value (e.g. `(x) => -x`).
+ *
+ * We rely on the javascript implementation of `<` and `>` for comparison, which
+ * will attempt to transform both operands into a primitive comparable value via
+ * the built in `valueOf` function (and then `toString`). It's up to the caller
+ * to make sure that the projection is returning a value that makes sense for
+ * this logic.
+ *
+ * It's important to note that there is no built-in caching/memoization of
+ * projection function and therefore no guarantee that it would only be called
+ * once.
+ */
+type OrderRule<T> = Projection<T> | readonly [projection: Projection<T>, direction: keyof typeof COMPARATORS];
+type Projection<T> = (x: T) => Comparable;
+type Comparable = ComparablePrimitive | {
+  [Symbol.toPrimitive]: (hint: string) => ComparablePrimitive;
+} | {
+  toString: () => string;
+} | {
+  valueOf: () => ComparablePrimitive;
+};
+type ComparablePrimitive = bigint | boolean | number | string;
+/**
+ * Allows functions that want to handle a variadic number of order rules a
+ * a simplified API that hides most of the implementation details. The only
+ * thing users of this function need to do is provide a function that would take
+ * the data, and a compare function that can be used to determine the order
+ * between the items of the array.
+ * This functions takes care of the rest; it will parse rules, built the
+ * comparer, and manage the currying of the input arguments.
+ */
+//#endregion
+export { OrderRule };
+//# sourceMappingURL=curry-order-rules-D2zI7gpB.d.ts.map

package/dist/curry-order-rules-D2zI7gpB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curry-order-rules-D2zI7gpB.d.ts","names":[],"sources":["../src/internal/curry-order-rules.ts"],"sourcesContent":[],"mappings":";AAAgE,cAM1D,WAGI,EAAA;EAAA,SAAA,GAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAFI,CAEJ,EAAA,CAAA,EAFU,CAEV,EAAA,GAAA,OAAA;WAFI,IAAA,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EACC,CADD,EAAA,CAAA,EACO,CADP,EAAA,GAAA,OAAA;;;;;AAyBd;;;;;;;;AAEgF;;;;;AAEvC;;;;;AASlB,KAbX,SAaW,CAAA,CAAA,CAAA,GAZjB,UAYiB,CAZN,CAYM,CAAA,GAAA,SAAA,CAAA,UAAA,EAXK,UAWL,CAXgB,CAWhB,CAAA,EAAA,SAAA,EAAA,MAAA,OAX4C,WAW5C,CAAA;KATlB,UASqC,CAAA,CAAA,CAAA,GAAA,CAAA,CAAA,EATjB,CASiB,EAAA,GATX,UASW;AAAA,KAJrC,UAAA,GACC,mBAOkB,GAAA;GANf,MAAA,CAAO,WAAA,qBAAgC;;;;iBAEzB;;KAIlB,mBAAA"}

package/dist/curry.d.ts

@@ -1,2 +1,2 @@
-import { curry } from "./curry-B-8l-0vq.js";
+import { curry } from "./curry-2mBj-wsI.js";
 export { curry };