@vinicunca/perkakas 1.7.1 → 1.9.0

package/dist/partition-CIBacxWc.d.ts

@@ -0,0 +1,51 @@
+//#region src/partition.d.ts
+/**
+ * Splits a collection into two groups, the first of which contains elements the
+ * `predicate` type guard passes, and the second one containing the rest.
+ *
+ * @param data - The items to split.
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to add the element to the first partition, and and
+ * `false` to add the element to the other partition. A type-predicate can also
+ * be used to narrow the result.
+ * @returns A 2-tuple of arrays where the first array contains the elements that
+ * passed the predicate, and the second array contains the elements that did
+ * not. The items are in the same order as they were in the original array.
+ * @signature
+ *    P.partition(data, predicate)
+ * @example
+ *    P.partition(
+ *      ['one', 'two', 'forty two'],
+ *      x => x.length === 3,
+ *    ); // => [['one', 'two'], ['forty two']]
+ * @dataFirst
+ * @category Array
+ */
+declare function partition<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): [Array<S>, Array<Exclude<T, S>>];
+declare function partition<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): [Array<T>, Array<T>];
+/**
+ * Splits a collection into two groups, the first of which contains elements the
+ * `predicate` type guard passes, and the second one containing the rest.
+ *
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to add the element to the first partition, and and
+ * `false` to add the element to the other partition. A type-predicate can also
+ * be used to narrow the result.
+ * @returns A 2-tuple of arrays where the first array contains the elements that
+ * passed the predicate, and the second array contains the elements that did
+ * not. The items are in the same order as they were in the original array.
+ * @signature
+ *    P.partition(predicate)(data)
+ * @example
+ *    P.pipe(
+ *      ['one', 'two', 'forty two'],
+ *      P.partition(x => x.length === 3),
+ *    ); // => [['one', 'two'], ['forty two']]
+ * @dataLast
+ * @category Array
+ */
+declare function partition<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => [Array<S>, Array<Exclude<T, S>>];
+declare function partition<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => [Array<T>, Array<T>];
+//#endregion
+export { partition };
+//# sourceMappingURL=partition-CIBacxWc.d.ts.map

package/dist/partition-CIBacxWc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition-CIBacxWc.d.ts","names":[],"sources":["../src/partition.ts"],"sourcesContent":[],"mappings":";;AAwBA;;;;;;;;;;;;;;;;AAIA;;;;;AAE2D,iBAN3C,SAM2C,CAAA,CAAA,EAAA,UANpB,CAMoB,CAAA,CAAA,IAAA,EALnD,aAKmD,CALrC,CAKqC,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAJtC,CAIsC,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAJd,aAIc,CAJA,CAIA,CAAA,EAAA,GAAA,KAAA,IAJgB,CAIhB,CAAA,EAAA,CAHvD,KAGuD,CAHjD,CAGiD,CAAA,EAH7C,KAG6C,CAHvC,OAGuC,CAH/B,CAG+B,EAH5B,CAG4B,CAAA,CAAA,CAAA;AAAd,iBAF7B,SAE6B,CAAA,CAAA,CAAA,CAAA,IAAA,EADrC,aACqC,CADvB,CACuB,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAAxB,CAAwB,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAAA,aAAA,CAAc,CAAd,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CACzC,KADyC,CACnC,CADmC,CAAA,EAC/B,KAD+B,CACzB,CADyB,CAAA,CAAA;;;;;;AAwB7C;;;;;;;;;;;;;;;;AAGgB,iBAHA,SAGS,CAAA,CAAA,EAAA,UAHc,CAGd,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAFJ,CAEI,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAFoB,aAEpB,CAFkC,CAElC,CAAA,EAAA,GAAA,KAAA,IAFkD,CAElD,CAAA,EAAA,CAAA,IAAA,EADf,aACe,CADD,CACC,CAAA,EAAA,GAAA,CADO,KACP,CADa,CACb,CAAA,EADiB,KACjB,CADuB,OACvB,CAD+B,CAC/B,EADkC,CAClC,CAAA,CAAA,CAAA;AAAA,iBAAT,SAAS,CAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EACJ,CADI,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EACoB,aADpB,CACkC,CADlC,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,IAAA,EAEf,aAFe,CAED,CAFC,CAAA,EAAA,GAAA,CAEO,KAFP,CAEa,CAFb,CAAA,EAEiB,KAFjB,CAEuB,CAFvB,CAAA,CAAA"}

package/dist/partition-CP0fPbGt.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t){let n=[[],[]];for(let[r,i]of e.entries())n[t(i,r,e)?0:1].push(i);return n}Object.defineProperty(exports,`partition`,{enumerable:!0,get:function(){return t}});

package/dist/partition-LBHIQgBS.d.cts

@@ -0,0 +1,51 @@
+//#region src/partition.d.ts
+/**
+ * Splits a collection into two groups, the first of which contains elements the
+ * `predicate` type guard passes, and the second one containing the rest.
+ *
+ * @param data - The items to split.
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to add the element to the first partition, and and
+ * `false` to add the element to the other partition. A type-predicate can also
+ * be used to narrow the result.
+ * @returns A 2-tuple of arrays where the first array contains the elements that
+ * passed the predicate, and the second array contains the elements that did
+ * not. The items are in the same order as they were in the original array.
+ * @signature
+ *    P.partition(data, predicate)
+ * @example
+ *    P.partition(
+ *      ['one', 'two', 'forty two'],
+ *      x => x.length === 3,
+ *    ); // => [['one', 'two'], ['forty two']]
+ * @dataFirst
+ * @category Array
+ */
+declare function partition<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): [Array<S>, Array<Exclude<T, S>>];
+declare function partition<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): [Array<T>, Array<T>];
+/**
+ * Splits a collection into two groups, the first of which contains elements the
+ * `predicate` type guard passes, and the second one containing the rest.
+ *
+ * @param predicate - A function to execute for each element in the array. It
+ * should return `true` to add the element to the first partition, and and
+ * `false` to add the element to the other partition. A type-predicate can also
+ * be used to narrow the result.
+ * @returns A 2-tuple of arrays where the first array contains the elements that
+ * passed the predicate, and the second array contains the elements that did
+ * not. The items are in the same order as they were in the original array.
+ * @signature
+ *    P.partition(predicate)(data)
+ * @example
+ *    P.pipe(
+ *      ['one', 'two', 'forty two'],
+ *      P.partition(x => x.length === 3),
+ *    ); // => [['one', 'two'], ['forty two']]
+ * @dataLast
+ * @category Array
+ */
+declare function partition<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => [Array<S>, Array<Exclude<T, S>>];
+declare function partition<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => [Array<T>, Array<T>];
+//#endregion
+export { partition };
+//# sourceMappingURL=partition-LBHIQgBS.d.cts.map

package/dist/partition-LBHIQgBS.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition-LBHIQgBS.d.cts","names":[],"sources":["../src/partition.ts"],"sourcesContent":[],"mappings":";;AAwBA;;;;;;;;;;;;;;;;AAIA;;;;;AAE2D,iBAN3C,SAM2C,CAAA,CAAA,EAAA,UANpB,CAMoB,CAAA,CAAA,IAAA,EALnD,aAKmD,CALrC,CAKqC,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAJtC,CAIsC,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAJd,aAIc,CAJA,CAIA,CAAA,EAAA,GAAA,KAAA,IAJgB,CAIhB,CAAA,EAAA,CAHvD,KAGuD,CAHjD,CAGiD,CAAA,EAH7C,KAG6C,CAHvC,OAGuC,CAH/B,CAG+B,EAH5B,CAG4B,CAAA,CAAA,CAAA;AAAd,iBAF7B,SAE6B,CAAA,CAAA,CAAA,CAAA,IAAA,EADrC,aACqC,CADvB,CACuB,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EAAxB,CAAwB,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAAA,aAAA,CAAc,CAAd,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CACzC,KADyC,CACnC,CADmC,CAAA,EAC/B,KAD+B,CACzB,CADyB,CAAA,CAAA;;;;;;AAwB7C;;;;;;;;;;;;;;;;AAGgB,iBAHA,SAGS,CAAA,CAAA,EAAA,UAHc,CAGd,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAFJ,CAEI,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAFoB,aAEpB,CAFkC,CAElC,CAAA,EAAA,GAAA,KAAA,IAFkD,CAElD,CAAA,EAAA,CAAA,IAAA,EADf,aACe,CADD,CACC,CAAA,EAAA,GAAA,CADO,KACP,CADa,CACb,CAAA,EADiB,KACjB,CADuB,OACvB,CAD+B,CAC/B,EADkC,CAClC,CAAA,CAAA,CAAA;AAAA,iBAAT,SAAS,CAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EACJ,CADI,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EACoB,aADpB,CACkC,CADlC,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,IAAA,EAEf,aAFe,CAED,CAFC,CAAA,EAAA,GAAA,CAEO,KAFP,CAEa,CAFb,CAAA,EAEiB,KAFjB,CAEuB,CAFvB,CAAA,CAAA"}

package/dist/partition-e274M9T9.js

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

package/dist/partition-e274M9T9.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition-e274M9T9.js","names":["ret: [Array<T>, Array<T>]"],"sources":["../src/partition.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Splits a collection into two groups, the first of which contains elements the\n * `predicate` type guard passes, and the second one containing the rest.\n *\n * @param data - The items to split.\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to add the element to the first partition, and and\n * `false` to add the element to the other partition. A type-predicate can also\n * be used to narrow the result.\n * @returns A 2-tuple of arrays where the first array contains the elements that\n * passed the predicate, and the second array contains the elements that did\n * not. The items are in the same order as they were in the original array.\n * @signature\n *    P.partition(data, predicate)\n * @example\n *    P.partition(\n *      ['one', 'two', 'forty two'],\n *      x => x.length === 3,\n *    ); // => [['one', 'two'], ['forty two']]\n * @dataFirst\n * @category Array\n */\nexport function partition<T, S extends T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): [Array<S>, Array<Exclude<T, S>>];\nexport function partition<T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): [Array<T>, Array<T>];\n\n/**\n * Splits a collection into two groups, the first of which contains elements the\n * `predicate` type guard passes, and the second one containing the rest.\n *\n * @param predicate - A function to execute for each element in the array. It\n * should return `true` to add the element to the first partition, and and\n * `false` to add the element to the other partition. A type-predicate can also\n * be used to narrow the result.\n * @returns A 2-tuple of arrays where the first array contains the elements that\n * passed the predicate, and the second array contains the elements that did\n * not. The items are in the same order as they were in the original array.\n * @signature\n *    P.partition(predicate)(data)\n * @example\n *    P.pipe(\n *      ['one', 'two', 'forty two'],\n *      P.partition(x => x.length === 3),\n *    ); // => [['one', 'two'], ['forty two']]\n * @dataLast\n * @category Array\n */\nexport function partition<T, S extends T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): (data: ReadonlyArray<T>) => [Array<S>, Array<Exclude<T, S>>];\nexport function partition<T>(\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean,\n): (data: ReadonlyArray<T>) => [Array<T>, Array<T>];\n\nexport function partition(...args: ReadonlyArray<unknown>): unknown {\n  return curry(partitionImplementation, args);\n}\n\nfunction partitionImplementation<T, S extends T>(\n  data: ReadonlyArray<T>,\n  predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S,\n): [Array<T>, Array<T>] {\n  const ret: [Array<T>, Array<T>] = [[], []];\n  for (const [index, item] of data.entries()) {\n    const matches = predicate(item, index, data);\n    ret[matches ? 0 : 1].push(item);\n  }\n  return ret;\n};\n"],"mappings":"4CA6DA,SAAgB,EAAU,GAAG,EAAuC,CAClE,OAAO,EAAM,EAAyB,EAAK,CAG7C,SAAS,EACP,EACA,EACsB,CACtB,IAAMA,EAA4B,CAAC,EAAE,CAAE,EAAE,CAAC,CAC1C,IAAK,GAAM,CAAC,EAAO,KAAS,EAAK,SAAS,CAExC,EADgB,EAAU,EAAM,EAAO,EAAK,CAC9B,EAAI,GAAG,KAAK,EAAK,CAEjC,OAAO"}

package/dist/partition.cjs

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

package/dist/partition.d.cts

@@ -1,49 +1,2 @@
-/**
- * Splits a collection into two groups, the first of which contains elements the
- * `predicate` type guard passes, and the second one containing the rest.
- *
- * @param data - The items to split.
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to add the element to the first partition, and and
- * `false` to add the element to the other partition. A type-predicate can also
- * be used to narrow the result.
- * @returns A 2-tuple of arrays where the first array contains the elements that
- * passed the predicate, and the second array contains the elements that did
- * not. The items are in the same order as they were in the original array.
- * @signature
- *    P.partition(data, predicate)
- * @example
- *    P.partition(
- *      ['one', 'two', 'forty two'],
- *      x => x.length === 3,
- *    ); // => [['one', 'two'], ['forty two']]
- * @dataFirst
- * @category Array
- */
-declare function partition<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): [Array<S>, Array<Exclude<T, S>>];
-declare function partition<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): [Array<T>, Array<T>];
-/**
- * Splits a collection into two groups, the first of which contains elements the
- * `predicate` type guard passes, and the second one containing the rest.
- *
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to add the element to the first partition, and and
- * `false` to add the element to the other partition. A type-predicate can also
- * be used to narrow the result.
- * @returns A 2-tuple of arrays where the first array contains the elements that
- * passed the predicate, and the second array contains the elements that did
- * not. The items are in the same order as they were in the original array.
- * @signature
- *    P.partition(predicate)(data)
- * @example
- *    P.pipe(
- *      ['one', 'two', 'forty two'],
- *      P.partition(x => x.length === 3),
- *    ); // => [['one', 'two'], ['forty two']]
- * @dataLast
- * @category Array
- */
-declare function partition<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => [Array<S>, Array<Exclude<T, S>>];
-declare function partition<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => [Array<T>, Array<T>];
-
-export { partition };
+import { partition } from "./partition-LBHIQgBS.cjs";
+export { partition };

package/dist/partition.d.ts

@@ -1,49 +1,2 @@
-/**
- * Splits a collection into two groups, the first of which contains elements the
- * `predicate` type guard passes, and the second one containing the rest.
- *
- * @param data - The items to split.
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to add the element to the first partition, and and
- * `false` to add the element to the other partition. A type-predicate can also
- * be used to narrow the result.
- * @returns A 2-tuple of arrays where the first array contains the elements that
- * passed the predicate, and the second array contains the elements that did
- * not. The items are in the same order as they were in the original array.
- * @signature
- *    P.partition(data, predicate)
- * @example
- *    P.partition(
- *      ['one', 'two', 'forty two'],
- *      x => x.length === 3,
- *    ); // => [['one', 'two'], ['forty two']]
- * @dataFirst
- * @category Array
- */
-declare function partition<T, S extends T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): [Array<S>, Array<Exclude<T, S>>];
-declare function partition<T>(data: ReadonlyArray<T>, predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): [Array<T>, Array<T>];
-/**
- * Splits a collection into two groups, the first of which contains elements the
- * `predicate` type guard passes, and the second one containing the rest.
- *
- * @param predicate - A function to execute for each element in the array. It
- * should return `true` to add the element to the first partition, and and
- * `false` to add the element to the other partition. A type-predicate can also
- * be used to narrow the result.
- * @returns A 2-tuple of arrays where the first array contains the elements that
- * passed the predicate, and the second array contains the elements that did
- * not. The items are in the same order as they were in the original array.
- * @signature
- *    P.partition(predicate)(data)
- * @example
- *    P.pipe(
- *      ['one', 'two', 'forty two'],
- *      P.partition(x => x.length === 3),
- *    ); // => [['one', 'two'], ['forty two']]
- * @dataLast
- * @category Array
- */
-declare function partition<T, S extends T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => value is S): (data: ReadonlyArray<T>) => [Array<S>, Array<Exclude<T, S>>];
-declare function partition<T>(predicate: (value: T, index: number, data: ReadonlyArray<T>) => boolean): (data: ReadonlyArray<T>) => [Array<T>, Array<T>];
-
-export { partition };
+import { partition } from "./partition-CIBacxWc.js";
+export { partition };

package/dist/partition.js

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

package/dist/path-or-D-RyTkoO.cjs

@@ -0,0 +1 @@
+const e=require(`./curry-BPVIsvo3.cjs`);function t(...t){return e.curry(n,t)}function n(e,t,n){let r=e;for(let e of t){if(r==null)break;r=r[e]}return r??n}Object.defineProperty(exports,`pathOr`,{enumerable:!0,get:function(){return t}});

package/dist/path-or-D2Gn-2iU.js

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

package/dist/path-or-D2Gn-2iU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-or-D2Gn-2iU.js","names":[],"sources":["../src/path-or.ts"],"sourcesContent":["import { curry } from './curry';\n\n/**\n * Given a union of indexable types `T`, we derive an indexable type\n * containing all of the keys of each variant of `T`. If a key is\n * present in multiple variants of `T`, then the corresponding type in\n * `Pathable<T>` will be the intersection of all types for that key.\n *\n * @example\n *    type T1 = Pathable<{a: number} | {a: string; b: boolean}>\n *    // {a: number | string; b: boolean}\n *\n *    type T2 = Pathable<{a?: {b: string}}\n *    // {a: {b: string} | undefined}\n *\n *    type T3 = Pathable<{a: string} | number>\n *    // {a: string}\n *\n *    type T4 = Pathable<{a: number} | {a: string} | {b: boolean}>\n *    // {a: number | string; b: boolean}\n *\n * This type lets us answer the questions:\n * - Given some object of type `T`, what keys might this object have?\n * - If this object did happen to have a particular key, what values\n *   might that key have?\n */\ntype Pathable<T> = { [K in AllKeys<T>]: TypesForKey<T, K> };\n\ntype AllKeys<T> = T extends infer I ? keyof I : never;\ntype TypesForKey<T, K extends PropertyKey> = T extends infer I\n  ? K extends keyof I\n    ? I[K]\n    : never\n  : never;\n\n// Like Required<T>, but also removes explicit null and undefined typings */\ntype StrictlyRequired<T> = { [K in keyof T]-?: NonNullable<T[K]> };\n\n/**\n * Given some `A` which is a key of at least one variant of `T`, derive\n * `T[A]` for the cases where `A` is present in `T`, and `T[A]` is not\n * null or undefined.\n */\ntype PathValue1<T, A extends keyof Pathable<T>> = StrictlyRequired<\n  Pathable<T>\n>[A];\n/** All possible options after successfully reaching `T[A]`. */\ntype Pathable1<T, A extends keyof Pathable<T>> = Pathable<PathValue1<T, A>>;\n\n/** As `PathValue1`, but for `T[A][B]`. */\ntype PathValue2<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n> = StrictlyRequired<Pathable1<T, A>>[B];\n/** As `Pathable1`, but for `T[A][B]`. */\ntype Pathable2<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n> = Pathable<PathValue2<T, A, B>>;\n\n/** As `PathValue1`, but for `T[A][B][C]`. */\ntype PathValue3<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n  C extends keyof Pathable2<T, A, B>,\n> = StrictlyRequired<Pathable2<T, A, B>>[C];\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is `null` or `undefined`, the `defaultValue` is returned in its place.\n *\n * Prefer `prop` over this function as it provides better typing and is more\n * flexible when building solutions. To provide a default value using `prop`\n * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)\n * after the call.\n *\n * @param object - The target object.\n * @param path - The path of the property to get.\n * @param defaultValue - The default value.\n * @signature P.pathOr(object, array, defaultValue)\n * @example\n *    P.pathOr({x: 10}, ['y'], 2) // 2\n *    P.pathOr({y: 10}, ['y'], 2) // 10\n * @dataFirst\n * @category Object\n */\nexport function pathOr<T, A extends keyof Pathable<T>>(\n  object: T,\n  path: readonly [A],\n  defaultValue: PathValue1<T, A>,\n): PathValue1<T, A>;\n\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n>(\n  object: T,\n  path: readonly [A, B],\n  defaultValue: PathValue2<T, A, B>,\n): PathValue2<T, A, B>;\n\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n  C extends keyof Pathable2<T, A, B>,\n>(\n  object: T,\n  path: readonly [A, B, C],\n  defaultValue: PathValue3<T, A, B, C>,\n): PathValue3<T, A, B, C>;\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place.\n *\n * Prefer `prop` over this function as it provides better typing and is more\n * flexible when building solutions. To provide a default value using `prop`\n * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)\n * after the call.\n *\n * @param path - The path of the property to get.\n * @param defaultValue - The default value.\n * @signature P.pathOr(array, defaultValue)(object)\n * @example\n *    P.pipe({x: 10}, P.pathOr(['y'], 2)) // 2\n *    P.pipe({y: 10}, P.pathOr(['y'], 2)) // 10\n * @dataLast\n * @category Object\n */\nexport function pathOr<T, A extends keyof Pathable<T>>(\n  path: readonly [A],\n  defaultValue: PathValue1<T, A>,\n): (object: T) => PathValue1<T, A>;\n\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n>(\n  path: readonly [A, B],\n  defaultValue: PathValue2<T, A, B>,\n): (object: T) => PathValue2<T, A, B>;\n\nexport function pathOr<\n  T,\n  A extends keyof Pathable<T>,\n  B extends keyof Pathable1<T, A>,\n  C extends keyof Pathable2<T, A, B>,\n>(\n  path: readonly [A, B, C],\n  defaultValue: PathValue3<T, A, B, C>,\n): (object: T) => PathValue3<T, A, B, C>;\n\nexport function pathOr(...args: ReadonlyArray<unknown>): unknown {\n  return curry(pathOrImplementation, args);\n}\n\nfunction pathOrImplementation(\n  data: unknown,\n  path: ReadonlyArray<PropertyKey>,\n  defaultValue: unknown,\n): unknown {\n  let current = data;\n  for (const prop of path) {\n    if (current === null || current === undefined) {\n      break;\n    }\n    current = (current as Record<PropertyKey, unknown>)[prop];\n  }\n\n  return current ?? defaultValue;\n}\n"],"mappings":"4CA4JA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAM,EAAsB,EAAK,CAG1C,SAAS,EACP,EACA,EACA,EACS,CACT,IAAI,EAAU,EACd,IAAK,IAAM,KAAQ,EAAM,CACvB,GAAI,GAAY,KACd,MAEF,EAAW,EAAyC,GAGtD,OAAO,GAAW"}

package/dist/path-or-DvWnAQUG.d.cts

@@ -0,0 +1,87 @@
+//#region src/path-or.d.ts
+/**
+ * Given a union of indexable types `T`, we derive an indexable type
+ * containing all of the keys of each variant of `T`. If a key is
+ * present in multiple variants of `T`, then the corresponding type in
+ * `Pathable<T>` will be the intersection of all types for that key.
+ *
+ * @example
+ *    type T1 = Pathable<{a: number} | {a: string; b: boolean}>
+ *    // {a: number | string; b: boolean}
+ *
+ *    type T2 = Pathable<{a?: {b: string}}
+ *    // {a: {b: string} | undefined}
+ *
+ *    type T3 = Pathable<{a: string} | number>
+ *    // {a: string}
+ *
+ *    type T4 = Pathable<{a: number} | {a: string} | {b: boolean}>
+ *    // {a: number | string; b: boolean}
+ *
+ * This type lets us answer the questions:
+ * - Given some object of type `T`, what keys might this object have?
+ * - If this object did happen to have a particular key, what values
+ *   might that key have?
+ */
+type Pathable<T> = { [K in AllKeys<T>]: TypesForKey<T, K> };
+type AllKeys<T> = T extends infer I ? keyof I : never;
+type TypesForKey<T, K extends PropertyKey> = T extends infer I ? K extends keyof I ? I[K] : never : never;
+type StrictlyRequired<T> = { [K in keyof T]-?: NonNullable<T[K]> };
+/**
+ * Given some `A` which is a key of at least one variant of `T`, derive
+ * `T[A]` for the cases where `A` is present in `T`, and `T[A]` is not
+ * null or undefined.
+ */
+type PathValue1<T, A extends keyof Pathable<T>> = StrictlyRequired<Pathable<T>>[A];
+/** All possible options after successfully reaching `T[A]`. */
+type Pathable1<T, A extends keyof Pathable<T>> = Pathable<PathValue1<T, A>>;
+/** As `PathValue1`, but for `T[A][B]`. */
+type PathValue2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = StrictlyRequired<Pathable1<T, A>>[B];
+/** As `Pathable1`, but for `T[A][B]`. */
+type Pathable2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = Pathable<PathValue2<T, A, B>>;
+/** As `PathValue1`, but for `T[A][B][C]`. */
+type PathValue3<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>> = StrictlyRequired<Pathable2<T, A, B>>[C];
+/**
+ * Gets the value at `path` of `object`. If the resolved value is `null` or `undefined`, the `defaultValue` is returned in its place.
+ *
+ * Prefer `prop` over this function as it provides better typing and is more
+ * flexible when building solutions. To provide a default value using `prop`
+ * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
+ * after the call.
+ *
+ * @param object - The target object.
+ * @param path - The path of the property to get.
+ * @param defaultValue - The default value.
+ * @signature P.pathOr(object, array, defaultValue)
+ * @example
+ *    P.pathOr({x: 10}, ['y'], 2) // 2
+ *    P.pathOr({y: 10}, ['y'], 2) // 10
+ * @dataFirst
+ * @category Object
+ */
+declare function pathOr<T, A extends keyof Pathable<T>>(object: T, path: readonly [A], defaultValue: PathValue1<T, A>): PathValue1<T, A>;
+declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(object: T, path: readonly [A, B], defaultValue: PathValue2<T, A, B>): PathValue2<T, A, B>;
+declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(object: T, path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): PathValue3<T, A, B, C>;
+/**
+ * Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place.
+ *
+ * Prefer `prop` over this function as it provides better typing and is more
+ * flexible when building solutions. To provide a default value using `prop`
+ * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
+ * after the call.
+ *
+ * @param path - The path of the property to get.
+ * @param defaultValue - The default value.
+ * @signature P.pathOr(array, defaultValue)(object)
+ * @example
+ *    P.pipe({x: 10}, P.pathOr(['y'], 2)) // 2
+ *    P.pipe({y: 10}, P.pathOr(['y'], 2)) // 10
+ * @dataLast
+ * @category Object
+ */
+declare function pathOr<T, A extends keyof Pathable<T>>(path: readonly [A], defaultValue: PathValue1<T, A>): (object: T) => PathValue1<T, A>;
+declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(path: readonly [A, B], defaultValue: PathValue2<T, A, B>): (object: T) => PathValue2<T, A, B>;
+declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): (object: T) => PathValue3<T, A, B, C>;
+//#endregion
+export { pathOr };
+//# sourceMappingURL=path-or-DvWnAQUG.d.cts.map

package/dist/path-or-DvWnAQUG.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-or-DvWnAQUG.d.cts","names":[],"sources":["../src/path-or.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/path-or-ld_fRiaZ.d.ts

@@ -0,0 +1,87 @@
+//#region src/path-or.d.ts
+/**
+ * Given a union of indexable types `T`, we derive an indexable type
+ * containing all of the keys of each variant of `T`. If a key is
+ * present in multiple variants of `T`, then the corresponding type in
+ * `Pathable<T>` will be the intersection of all types for that key.
+ *
+ * @example
+ *    type T1 = Pathable<{a: number} | {a: string; b: boolean}>
+ *    // {a: number | string; b: boolean}
+ *
+ *    type T2 = Pathable<{a?: {b: string}}
+ *    // {a: {b: string} | undefined}
+ *
+ *    type T3 = Pathable<{a: string} | number>
+ *    // {a: string}
+ *
+ *    type T4 = Pathable<{a: number} | {a: string} | {b: boolean}>
+ *    // {a: number | string; b: boolean}
+ *
+ * This type lets us answer the questions:
+ * - Given some object of type `T`, what keys might this object have?
+ * - If this object did happen to have a particular key, what values
+ *   might that key have?
+ */
+type Pathable<T> = { [K in AllKeys<T>]: TypesForKey<T, K> };
+type AllKeys<T> = T extends infer I ? keyof I : never;
+type TypesForKey<T, K extends PropertyKey> = T extends infer I ? K extends keyof I ? I[K] : never : never;
+type StrictlyRequired<T> = { [K in keyof T]-?: NonNullable<T[K]> };
+/**
+ * Given some `A` which is a key of at least one variant of `T`, derive
+ * `T[A]` for the cases where `A` is present in `T`, and `T[A]` is not
+ * null or undefined.
+ */
+type PathValue1<T, A extends keyof Pathable<T>> = StrictlyRequired<Pathable<T>>[A];
+/** All possible options after successfully reaching `T[A]`. */
+type Pathable1<T, A extends keyof Pathable<T>> = Pathable<PathValue1<T, A>>;
+/** As `PathValue1`, but for `T[A][B]`. */
+type PathValue2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = StrictlyRequired<Pathable1<T, A>>[B];
+/** As `Pathable1`, but for `T[A][B]`. */
+type Pathable2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = Pathable<PathValue2<T, A, B>>;
+/** As `PathValue1`, but for `T[A][B][C]`. */
+type PathValue3<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>> = StrictlyRequired<Pathable2<T, A, B>>[C];
+/**
+ * Gets the value at `path` of `object`. If the resolved value is `null` or `undefined`, the `defaultValue` is returned in its place.
+ *
+ * Prefer `prop` over this function as it provides better typing and is more
+ * flexible when building solutions. To provide a default value using `prop`
+ * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
+ * after the call.
+ *
+ * @param object - The target object.
+ * @param path - The path of the property to get.
+ * @param defaultValue - The default value.
+ * @signature P.pathOr(object, array, defaultValue)
+ * @example
+ *    P.pathOr({x: 10}, ['y'], 2) // 2
+ *    P.pathOr({y: 10}, ['y'], 2) // 10
+ * @dataFirst
+ * @category Object
+ */
+declare function pathOr<T, A extends keyof Pathable<T>>(object: T, path: readonly [A], defaultValue: PathValue1<T, A>): PathValue1<T, A>;
+declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(object: T, path: readonly [A, B], defaultValue: PathValue2<T, A, B>): PathValue2<T, A, B>;
+declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(object: T, path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): PathValue3<T, A, B, C>;
+/**
+ * Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place.
+ *
+ * Prefer `prop` over this function as it provides better typing and is more
+ * flexible when building solutions. To provide a default value using `prop`
+ * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
+ * after the call.
+ *
+ * @param path - The path of the property to get.
+ * @param defaultValue - The default value.
+ * @signature P.pathOr(array, defaultValue)(object)
+ * @example
+ *    P.pipe({x: 10}, P.pathOr(['y'], 2)) // 2
+ *    P.pipe({y: 10}, P.pathOr(['y'], 2)) // 10
+ * @dataLast
+ * @category Object
+ */
+declare function pathOr<T, A extends keyof Pathable<T>>(path: readonly [A], defaultValue: PathValue1<T, A>): (object: T) => PathValue1<T, A>;
+declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(path: readonly [A, B], defaultValue: PathValue2<T, A, B>): (object: T) => PathValue2<T, A, B>;
+declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): (object: T) => PathValue3<T, A, B, C>;
+//#endregion
+export { pathOr };
+//# sourceMappingURL=path-or-ld_fRiaZ.d.ts.map

package/dist/path-or-ld_fRiaZ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-or-ld_fRiaZ.d.ts","names":[],"sources":["../src/path-or.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/path-or.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk25CFIH7Lcjs = require('./chunk-25CFIH7L.cjs');require('./chunk-XR72I63W.cjs');require('./chunk-GZJMERDJ.cjs');require('./chunk-MBGSSEZN.cjs');exports.pathOr = _chunk25CFIH7Lcjs.a;
+require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./path-or-D-RyTkoO.cjs`);exports.pathOr=e.pathOr;

package/dist/path-or.d.cts

@@ -1,89 +1,2 @@
-/**
- * Given a union of indexable types `T`, we derive an indexable type
- * containing all of the keys of each variant of `T`. If a key is
- * present in multiple variants of `T`, then the corresponding type in
- * `Pathable<T>` will be the intersection of all types for that key.
- *
- * @example
- *    type T1 = Pathable<{a: number} | {a: string; b: boolean}>
- *    // {a: number | string; b: boolean}
- *
- *    type T2 = Pathable<{a?: {b: string}}
- *    // {a: {b: string} | undefined}
- *
- *    type T3 = Pathable<{a: string} | number>
- *    // {a: string}
- *
- *    type T4 = Pathable<{a: number} | {a: string} | {b: boolean}>
- *    // {a: number | string; b: boolean}
- *
- * This type lets us answer the questions:
- * - Given some object of type `T`, what keys might this object have?
- * - If this object did happen to have a particular key, what values
- *   might that key have?
- */
-type Pathable<T> = {
-    [K in AllKeys<T>]: TypesForKey<T, K>;
-};
-type AllKeys<T> = T extends infer I ? keyof I : never;
-type TypesForKey<T, K extends PropertyKey> = T extends infer I ? K extends keyof I ? I[K] : never : never;
-type StrictlyRequired<T> = {
-    [K in keyof T]-?: NonNullable<T[K]>;
-};
-/**
- * Given some `A` which is a key of at least one variant of `T`, derive
- * `T[A]` for the cases where `A` is present in `T`, and `T[A]` is not
- * null or undefined.
- */
-type PathValue1<T, A extends keyof Pathable<T>> = StrictlyRequired<Pathable<T>>[A];
-/** All possible options after successfully reaching `T[A]`. */
-type Pathable1<T, A extends keyof Pathable<T>> = Pathable<PathValue1<T, A>>;
-/** As `PathValue1`, but for `T[A][B]`. */
-type PathValue2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = StrictlyRequired<Pathable1<T, A>>[B];
-/** As `Pathable1`, but for `T[A][B]`. */
-type Pathable2<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>> = Pathable<PathValue2<T, A, B>>;
-/** As `PathValue1`, but for `T[A][B][C]`. */
-type PathValue3<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>> = StrictlyRequired<Pathable2<T, A, B>>[C];
-/**
- * Gets the value at `path` of `object`. If the resolved value is `null` or `undefined`, the `defaultValue` is returned in its place.
- *
- * Prefer `prop` over this function as it provides better typing and is more
- * flexible when building solutions. To provide a default value using `prop`
- * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
- * after the call.
- *
- * @param object - The target object.
- * @param path - The path of the property to get.
- * @param defaultValue - The default value.
- * @signature P.pathOr(object, array, defaultValue)
- * @example
- *    P.pathOr({x: 10}, ['y'], 2) // 2
- *    P.pathOr({y: 10}, ['y'], 2) // 10
- * @dataFirst
- * @category Object
- */
-declare function pathOr<T, A extends keyof Pathable<T>>(object: T, path: readonly [A], defaultValue: PathValue1<T, A>): PathValue1<T, A>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(object: T, path: readonly [A, B], defaultValue: PathValue2<T, A, B>): PathValue2<T, A, B>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(object: T, path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): PathValue3<T, A, B, C>;
-/**
- * Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place.
- *
- * Prefer `prop` over this function as it provides better typing and is more
- * flexible when building solutions. To provide a default value using `prop`
- * use a [Nullish coalescing operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing)
- * after the call.
- *
- * @param path - The path of the property to get.
- * @param defaultValue - The default value.
- * @signature P.pathOr(array, defaultValue)(object)
- * @example
- *    P.pipe({x: 10}, P.pathOr(['y'], 2)) // 2
- *    P.pipe({y: 10}, P.pathOr(['y'], 2)) // 10
- * @dataLast
- * @category Object
- */
-declare function pathOr<T, A extends keyof Pathable<T>>(path: readonly [A], defaultValue: PathValue1<T, A>): (object: T) => PathValue1<T, A>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>>(path: readonly [A, B], defaultValue: PathValue2<T, A, B>): (object: T) => PathValue2<T, A, B>;
-declare function pathOr<T, A extends keyof Pathable<T>, B extends keyof Pathable1<T, A>, C extends keyof Pathable2<T, A, B>>(path: readonly [A, B, C], defaultValue: PathValue3<T, A, B, C>): (object: T) => PathValue3<T, A, B, C>;
-
-export { pathOr };
+import { pathOr } from "./path-or-DvWnAQUG.cjs";
+export { pathOr };