@vinicunca/perkakas 1.7.1 → 1.8.0

package/dist/clone-BcAGB1C1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-BcAGB1C1.js","names":["copiedValue: Record<PropertyKey, unknown>","copiedValue: Array<unknown>"],"sources":["../src/clone.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @param data - The object to clone.\n * @signature\n *   P.clone(data)\n * @example\n *   P.clone({foo: 'bar'}) // {foo: 'bar'}\n * @dataFirst\n * @category Object\n */\nexport function clone<T>(data: T): T;\n\n/**\n * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),\n * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are\n * assigned by reference rather than copied. Class instances or any other\n * built-in type that isn't mentioned above are not supported (but might\n * work).\n *\n * @signature\n *   P.clone()(data)\n * @example\n *   P.pipe({foo: 'bar'}, P.clone()) // {foo: 'bar'}\n * @dataLast\n * @category Object\n */\nexport function clone(): <T>(data: T) => T;\n\nexport function clone(...args: ReadonlyArray<unknown>): unknown {\n  return curry(cloneImplementation, args);\n}\n\nfunction cloneImplementation<T>(\n  value: T,\n  refFrom: Array<unknown> = [],\n  refTo: Array<unknown> = [],\n): T {\n  if (typeof value === 'function') {\n    // Functions aren't cloned, we return the same instance.\n    return value;\n  }\n\n  if (typeof value !== 'object' || value === null) {\n    // Only objects are interesting when cloning, everything else can use\n    // whatever JS does by default.\n    return structuredClone(value);\n  }\n\n  const prototype = Object.getPrototypeOf(value);\n  if (\n    !Array.isArray(value)\n    // Keep this check in sync with the same check in the impl of\n    // `isPlainObject`.\n    && prototype !== null\n    && prototype !== Object.prototype\n  ) {\n    // Our cloning logic is only designed for plain objects and arrays; other\n    // object types (like `Date`, `RegExp`, `File`, and user-defined classes)\n    // wouldn't clone properly. We fallback to the native cloning for them.\n    return structuredClone(value);\n  }\n\n  /**\n   * In order to support cyclic/self-referential structures,\n   * and to support functions _within_ objects,\n   * we need to have our own cloning logic.\n   */\n\n  // First we check if we've already cloned this value.\n  const idx = refFrom.indexOf(value);\n  if (idx >= 0) {\n    return refTo[idx] as T;\n  }\n  /**\n   * And if we haven't, we add it to our list of seen values so that it is kept\n   * and clone the deep structure.\n   */\n  refFrom.push(value);\n  return Array.isArray(value)\n    ? deepCloneArray(value, refFrom, refTo)\n    : deepCloneObject(value, refFrom, refTo);\n}\n\nfunction deepCloneObject<T extends object>(\n  value: T,\n  refFrom: Array<unknown>,\n  refTo: Array<unknown>,\n): T {\n  const copiedValue: Record<PropertyKey, unknown> = {};\n\n  /**\n   * It's important to first push the cloned ref so that it's index is kept in\n   * sync with the ref to the original value in refFrom.\n   */\n  refTo.push(copiedValue);\n\n  for (const [k, v] of Object.entries(value)) {\n    copiedValue[k] = cloneImplementation(v, refFrom, refTo);\n  }\n\n  return copiedValue as T;\n}\n\nfunction deepCloneArray<T extends ReadonlyArray<unknown>>(\n  value: T,\n  refFrom: Array<unknown>,\n  refTo: Array<unknown>,\n): T {\n  const copiedValue: Array<unknown> = [];\n\n  /**\n   * It's important to first push the cloned ref so that it's index is kept in\n   * sync with the ref to the original value in refFrom.\n   */\n  refTo.push(copiedValue);\n\n  for (const [index, item] of value.entries()) {\n    copiedValue[index] = cloneImplementation(item, refFrom, refTo);\n  }\n\n  return copiedValue as unknown as T;\n}\n"],"mappings":"4CAmCA,SAAgB,EAAM,GAAG,EAAuC,CAC9D,OAAO,EAAM,EAAqB,EAAK,CAGzC,SAAS,EACP,EACA,EAA0B,EAAE,CAC5B,EAAwB,EAAE,CACvB,CACH,GAAI,OAAO,GAAU,WAEnB,OAAO,EAGT,GAAI,OAAO,GAAU,WAAY,EAG/B,OAAO,gBAAgB,EAAM,CAG/B,IAAM,EAAY,OAAO,eAAe,EAAM,CAC9C,GACE,CAAC,MAAM,QAAQ,EAAM,EAGlB,IAAc,MACd,IAAc,OAAO,UAKxB,OAAO,gBAAgB,EAAM,CAU/B,IAAM,EAAM,EAAQ,QAAQ,EAAM,CASlC,OARI,GAAO,EACF,EAAM,IAMf,EAAQ,KAAK,EAAM,CACZ,MAAM,QAAQ,EAAM,CACvB,EAAe,EAAO,EAAS,EAAM,CACrC,EAAgB,EAAO,EAAS,EAAM,EAG5C,SAAS,EACP,EACA,EACA,EACG,CACH,IAAMA,EAA4C,EAAE,CAMpD,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAG,KAAM,OAAO,QAAQ,EAAM,CACxC,EAAY,GAAK,EAAoB,EAAG,EAAS,EAAM,CAGzD,OAAO,EAGT,SAAS,EACP,EACA,EACA,EACG,CACH,IAAMC,EAA8B,EAAE,CAMtC,EAAM,KAAK,EAAY,CAEvB,IAAK,GAAM,CAAC,EAAO,KAAS,EAAM,SAAS,CACzC,EAAY,GAAS,EAAoB,EAAM,EAAS,EAAM,CAGhE,OAAO"}

package/dist/clone-DyRAAJkh.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t=[],n=[]){if(typeof e==`function`)return e;if(typeof e!=`object`||!e)return structuredClone(e);let a=Object.getPrototypeOf(e);if(!Array.isArray(e)&&a!==null&&a!==Object.prototype)return structuredClone(e);let o=t.indexOf(e);return o>=0?n[o]:(t.push(e),Array.isArray(e)?i(e,t,n):r(e,t,n))}function r(e,t,r){let i={};r.push(i);for(let[a,o]of Object.entries(e))i[a]=n(o,t,r);return i}function i(e,t,r){let i=[];r.push(i);for(let[a,o]of e.entries())i[a]=n(o,t,r);return i}Object.defineProperty(exports,`clone`,{enumerable:!0,get:function(){return t}});

package/dist/clone-UasIry83.d.ts

@@ -0,0 +1,35 @@
+//#region src/clone.d.ts
+/**
+ * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),
+ * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are
+ * assigned by reference rather than copied. Class instances or any other
+ * built-in type that isn't mentioned above are not supported (but might
+ * work).
+ *
+ * @param data - The object to clone.
+ * @signature
+ *   P.clone(data)
+ * @example
+ *   P.clone({foo: 'bar'}) // {foo: 'bar'}
+ * @dataFirst
+ * @category Object
+ */
+declare function clone<T>(data: T): T;
+/**
+ * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),
+ * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are
+ * assigned by reference rather than copied. Class instances or any other
+ * built-in type that isn't mentioned above are not supported (but might
+ * work).
+ *
+ * @signature
+ *   P.clone()(data)
+ * @example
+ *   P.pipe({foo: 'bar'}, P.clone()) // {foo: 'bar'}
+ * @dataLast
+ * @category Object
+ */
+declare function clone(): <T>(data: T) => T;
+//#endregion
+export { clone };
+//# sourceMappingURL=clone-UasIry83.d.ts.map

package/dist/clone-UasIry83.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-UasIry83.d.ts","names":[],"sources":["../src/clone.ts"],"sourcesContent":[],"mappings":";;AAiBA;;;;;AAgBA;;;;;;;;;iBAhBgB,eAAe,IAAI;;;;;;;;;;;;;;;iBAgBnB,KAAA,CAAA,aAAmB,MAAM"}

package/dist/clone.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkQGF2XNZScjs = require('./chunk-QGF2XNZS.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.clone = _chunkQGF2XNZScjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./clone-DyRAAJkh.cjs`);exports.clone=e.clone;

package/dist/clone.d.cts

@@ -1,33 +1,2 @@
-/**
- * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),
- * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are
- * assigned by reference rather than copied. Class instances or any other
- * built-in type that isn't mentioned above are not supported (but might
- * work).
- *
- * @param data - The object to clone.
- * @signature
- *   P.clone(data)
- * @example
- *   P.clone({foo: 'bar'}) // {foo: 'bar'}
- * @dataFirst
- * @category Object
- */
-declare function clone<T>(data: T): T;
-/**
- * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),
- * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are
- * assigned by reference rather than copied. Class instances or any other
- * built-in type that isn't mentioned above are not supported (but might
- * work).
- *
- * @signature
- *   P.clone()(data)
- * @example
- *   P.pipe({foo: 'bar'}, P.clone()) // {foo: 'bar'}
- * @dataLast
- * @category Object
- */
-declare function clone(): <T>(data: T) => T;
-
-export { clone };
+import { clone } from "./clone-1QjPrzdD.cjs";
+export { clone };

package/dist/clone.d.ts

@@ -1,33 +1,2 @@
-/**
- * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),
- * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are
- * assigned by reference rather than copied. Class instances or any other
- * built-in type that isn't mentioned above are not supported (but might
- * work).
- *
- * @param data - The object to clone.
- * @signature
- *   P.clone(data)
- * @example
- *   P.clone({foo: 'bar'}) // {foo: 'bar'}
- * @dataFirst
- * @category Object
- */
-declare function clone<T>(data: T): T;
-/**
- * Creates a deep copy of the value. Supported types: [plain objects](#isPlainObject),
- * `Array`, `number`, `string`, `boolean`, `Date`, and `RegExp`. Functions are
- * assigned by reference rather than copied. Class instances or any other
- * built-in type that isn't mentioned above are not supported (but might
- * work).
- *
- * @signature
- *   P.clone()(data)
- * @example
- *   P.pipe({foo: 'bar'}, P.clone()) // {foo: 'bar'}
- * @dataLast
- * @category Object
- */
-declare function clone(): <T>(data: T) => T;
-
-export { clone };
+import { clone } from "./clone-UasIry83.js";
+export { clone };

package/dist/clone.js

@@ -1 +1 @@
-import{a}from"./chunk-JYWIRZ2Z.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as clone};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{clone as e}from"./clone-BcAGB1C1.js";export{e as clone};

package/dist/coerced-array-DyA0Yc12.d.ts

@@ -0,0 +1,17 @@
+import { IsNever } from "type-fest";
+
+//#region src/internal/types/coerced-array.d.ts
+
+/**
+ * `never[]` and `[]` are not the same type, and in some cases they aren't
+ * interchangeable.
+ *
+ * This type makes it easier to use the result of TupleParts when the input is a
+ * fixed-length tuple but we still want to spread the rest of the array. e.g.
+ * `[...CoercedArray<TupleParts<T>["item"]>, ...TupleParts<T>["suffix"]]`.
+ *
+ */
+type CoercedArray<T> = IsNever<T> extends true ? [] : Array<T>;
+//#endregion
+export { CoercedArray };
+//# sourceMappingURL=coerced-array-DyA0Yc12.d.ts.map

package/dist/coerced-array-DyA0Yc12.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coerced-array-DyA0Yc12.d.ts","names":[],"sources":["../src/internal/types/coerced-array.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;KAAY,kBAAkB,QAAQ,uBAAuB,MAAM"}

package/dist/coerced-array-kVJtBrMl.d.cts

@@ -0,0 +1,17 @@
+import { IsNever } from "type-fest";
+
+//#region src/internal/types/coerced-array.d.ts
+
+/**
+ * `never[]` and `[]` are not the same type, and in some cases they aren't
+ * interchangeable.
+ *
+ * This type makes it easier to use the result of TupleParts when the input is a
+ * fixed-length tuple but we still want to spread the rest of the array. e.g.
+ * `[...CoercedArray<TupleParts<T>["item"]>, ...TupleParts<T>["suffix"]]`.
+ *
+ */
+type CoercedArray<T> = IsNever<T> extends true ? [] : Array<T>;
+//#endregion
+export { CoercedArray };
+//# sourceMappingURL=coerced-array-kVJtBrMl.d.cts.map

package/dist/coerced-array-kVJtBrMl.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coerced-array-kVJtBrMl.d.cts","names":[],"sources":["../src/internal/types/coerced-array.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;KAAY,kBAAkB,QAAQ,uBAAuB,MAAM"}

package/dist/concat-BdgaaV6q.d.cts

@@ -0,0 +1,41 @@
+import { IterableContainer } from "./iterable-container-V5sa0V_H.cjs";
+
+//#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-BdgaaV6q.d.cts.map

package/dist/concat-BdgaaV6q.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat-BdgaaV6q.d.cts","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-CVEXmYnw.js

@@ -0,0 +1,2 @@
+import{curry as e}from"./curry-CzZjDrpv.js";function t(...t){return e(n,t)}function n(e,t){return[...e,...t]}export{t as concat};
+//# sourceMappingURL=concat-CVEXmYnw.js.map

package/dist/concat-CVEXmYnw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat-CVEXmYnw.js","names":[],"sources":["../src/concat.ts"],"sourcesContent":["import type { IterableContainer } from './internal/types/iterable-container';\nimport { curry } from './curry';\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param data - The first items, these would be at the beginning of the new\n * array.\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    P.concat(data, other);\n * @example\n *    P.concat([1, 2, 3], ['a']) // [1, 2, 3, 'a']\n * @dataFirst\n * @category Array\n */\nexport function concat<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(data: T1, other: T2): [...T1, ...T2];\n\n/**\n * Merge two or more arrays. This method does not change the existing arrays,\n * but instead returns a new array, even if the other array is empty.\n *\n * @param other - The remaining items, these would be at the end of the new\n * array.\n * @returns A new array with the items of the first array followed by the items\n * of the second array.\n * @signature\n *    P.concat(arr2)(arr1);\n * @example\n *    P.concat(['a'])([1, 2, 3]) // [1, 2, 3, 'a']\n * @dataLast\n * @category Array\n */\nexport function concat<T2 extends IterableContainer>(\n  other: T2,\n): <T1 extends IterableContainer>(data: T1) => [...T1, ...T2];\n\nexport function concat(...args: ReadonlyArray<unknown>): unknown {\n  return curry(concatImplementation, args);\n}\n\nfunction concatImplementation<\n  T1 extends IterableContainer,\n  T2 extends IterableContainer,\n>(\n  arr1: T1,\n  arr2: T2,\n): [...T1, ...T2] {\n  return [...arr1, ...arr2];\n};\n"],"mappings":"4CA4CA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EAIP,EACA,EACgB,CAChB,MAAO,CAAC,GAAG,EAAM,GAAG,EAAK"}

package/dist/concat-Cg3I4d7x.cjs

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

package/dist/concat-DeyDusex.d.ts

@@ -0,0 +1,41 @@
+import { IterableContainer } from "./iterable-container-wtkYslN_.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-DeyDusex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"concat-DeyDusex.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.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkYJDSLML5cjs = require('./chunk-YJDSLML5.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.concat = _chunkYJDSLML5cjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./concat-Cg3I4d7x.cjs`);exports.concat=e.concat;

package/dist/concat.d.cts

@@ -1,38 +1,3 @@
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.cjs';
-
-/**
- * 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];
-
-export { concat };
+import "./iterable-container-V5sa0V_H.cjs";
+import { concat } from "./concat-BdgaaV6q.cjs";
+export { concat };

package/dist/concat.d.ts

@@ -1,38 +1,3 @@
-import { I as IterableContainer } from './iterable-container-BTpDVdNc.js';
-
-/**
- * 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];
-
-export { concat };
+import "./iterable-container-wtkYslN_.js";
+import { concat } from "./concat-DeyDusex.js";
+export { concat };

package/dist/concat.js

@@ -1 +1 @@
-import{a}from"./chunk-32JKKR4M.js";import"./chunk-J6WPJH72.js";import"./chunk-KGPDVVVV.js";import"./chunk-EK7ODJWE.js";export{a as concat};
+import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{concat as e}from"./concat-CVEXmYnw.js";export{e as concat};

package/dist/conditional-81kit9Lg.cjs

@@ -0,0 +1 @@
+function e(e,t,n){return e(n[0])?e=>t(e,...n):t(...n)}const t=Object.assign(n,{defaultCase:a});function n(...t){return e(i,r,t)}function r(e,...t){for(let n of t){if(typeof n==`function`)return n(e);let[t,r]=n;if(t(e))return r(e)}throw Error(`conditional: data failed for all cases`)}function i(e){if(!Array.isArray(e))return!1;let[t,n,...r]=e;return typeof t==`function`&&t.length<=1&&typeof n==`function`&&n.length<=1&&r.length===0}function a(e=s){return[o,e]}function o(){return!0}function s(){}Object.defineProperty(exports,`conditionalPlus`,{enumerable:!0,get:function(){return t}});

package/dist/conditional-BivA0O7M.d.cts

@@ -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-BivA0O7M.d.cts.map