@vinicunca/perkakas 1.9.0 → 1.13.0

package/dist/omit-by.js.map

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

package/dist/omit.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`),require(`./has-at-least-D-ahiJB6.cjs`);const e=require(`./omit-Ljg-nRSD.cjs`);exports.omit=e.omit;
+const e=require(`./curry-BsY0Z8jH.cjs`),t=require(`./has-at-least-BXwOPLQK.cjs`);function n(...t){return e.t(r,t)}function r(e,n){if(!t.t(n,1))return{...e};if(!t.t(n,2)){let{[n[0]]:t,...r}=e;return r}let r={...e};for(let e of n)delete r[e];return r}exports.omit=n;

package/dist/omit.d.cts

@@ -1,2 +1,2 @@
-import { omit } from "./omit-DJ4Q7wfp.cjs";
+import { t as omit } from "./omit-DQiCiWAg.cjs";
 export { omit };

package/dist/omit.d.ts

@@ -1,2 +1,2 @@
-import { omit } from "./omit-DY21j6I-.js";
+import { t as omit } from "./omit-DI8DRDHj.js";
 export { omit };

package/dist/omit.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import"./has-at-least-6iRvhsST.js";import{omit as e}from"./omit-CbVbZe6B.js";export{e as omit};
+import{t as e}from"./curry-NmniqyJ0.js";import{t}from"./has-at-least-Coy9sM-B.js";function n(...t){return e(r,t)}function r(e,n){if(!t(n,1))return{...e};if(!t(n,2)){let{[n[0]]:t,...r}=e;return r}let r={...e};for(let e of n)delete r[e];return r}export{n as omit};
+//# sourceMappingURL=omit.js.map

package/dist/omit.js.map

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

package/dist/once.cjs

@@ -1 +1 @@
-const e=require(`./once-BrpjaAJS.cjs`);exports.once=e.once;
+function e(e){let t=!1,n;return()=>(t||=(n=e(),!0),n)}exports.once=e;

package/dist/once.d.cts

@@ -1,2 +1,17 @@
-import { once } from "./once-Cr_DJNbf.cjs";
-export { once };
+//#region src/once.d.ts
+/**
+ * Creates a function that is restricted to invoking `func` once. Repeat calls to the function return the value of the first invocation.
+ *
+ * @param fn - The function to wrap.
+ * @signature P.once(fn)
+ * @example
+ * const initialize = P.once(createApplication);
+ * initialize();
+ * initialize();
+ * // => `createApplication` is invoked once
+ * @category Function
+ */
+declare function once<T>(fn: () => T): () => T;
+//#endregion
+export { once };
+//# sourceMappingURL=once.d.cts.map

package/dist/once.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"once.d.cts","names":[],"sources":["../src/once.ts"],"sourcesContent":[],"mappings":";;AAYA;;;;;;;;;;;iBAAgB,kBAAkB,UAAU"}

package/dist/once.d.ts

@@ -1,2 +1,17 @@
-import { once } from "./once-YBm4xrPC.js";
-export { once };
+//#region src/once.d.ts
+/**
+ * Creates a function that is restricted to invoking `func` once. Repeat calls to the function return the value of the first invocation.
+ *
+ * @param fn - The function to wrap.
+ * @signature P.once(fn)
+ * @example
+ * const initialize = P.once(createApplication);
+ * initialize();
+ * initialize();
+ * // => `createApplication` is invoked once
+ * @category Function
+ */
+declare function once<T>(fn: () => T): () => T;
+//#endregion
+export { once };
+//# sourceMappingURL=once.d.ts.map

package/dist/once.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"once.d.ts","names":[],"sources":["../src/once.ts"],"sourcesContent":[],"mappings":";;AAYA;;;;;;;;;;;iBAAgB,kBAAkB,UAAU"}

package/dist/once.js

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

package/dist/once.js.map

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

package/dist/only.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./only-DltQiNme.cjs`);exports.only=e.only;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e){return e.length===1?e[0]:void 0}exports.only=t;

package/dist/only.d.cts

@@ -1,3 +1,34 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import { only } from "./only-oROrZ51q.cjs";
-export { only };
+import { t as IterableContainer } from "./iterable-container-1TN3AJ3s.cjs";
+
+//#region src/only.d.ts
+type Only<T extends IterableContainer> = T extends readonly [...Array<unknown>, unknown, unknown] | readonly [] | readonly [unknown, ...Array<unknown>, unknown] | readonly [unknown, unknown, ...Array<unknown>] ? undefined : T extends readonly [unknown] ? T[number] : T[number] | undefined;
+/**
+ * Returns the first and only element of `array`, or undefined otherwise.
+ *
+ * @param array - The target array.
+ * @signature
+ *    P.only(array)
+ * @example
+ *    P.only([]) // => undefined
+ *    P.only([1]) // => 1
+ *    P.only([1, 2]) // => undefined
+ * @dataFirst
+ * @category Array
+ */
+declare function only<T extends IterableContainer>(array: Readonly<T>): Only<T>;
+/**
+ * Returns the first and only element of `array`, or undefined otherwise.
+ *
+ * @signature
+ *    P.only()(array)
+ * @example
+ *    P.pipe([], P.only()); // => undefined
+ *    P.pipe([1], P.only()); // => 1
+ *    P.pipe([1, 2], P.only()); // => undefined
+ * @dataLast
+ * @category Array
+ */
+declare function only<T extends IterableContainer>(): (array: Readonly<T>) => Only<T>;
+//#endregion
+export { only };
+//# sourceMappingURL=only.d.cts.map

package/dist/only.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"only.d.cts","names":[],"sources":["../src/only.ts"],"sourcesContent":[],"mappings":";;;KAIK,eAAe,qBAAqB,uBACxB,wEAES,0DACS,8BAE/B,+BACE,YACA;;AAZuE;;;;;;;;;;AA2B7E;;AAAkE,iBAAlD,IAAkD,CAAA,UAAnC,iBAAmC,CAAA,CAAA,KAAA,EAAT,QAAS,CAAA,CAAA,CAAA,CAAA,EAAK,IAAL,CAAU,CAAV,CAAA;;;;;AAclE;;;;;;;;iBAAgB,eAAe,8BACtB,SAAS,OACb,KAAK"}

package/dist/only.d.ts

@@ -1,3 +1,34 @@
-import "./iterable-container-F9CDF7ym.js";
-import { only } from "./only-D2B9O0Kn.js";
-export { only };
+import { t as IterableContainer } from "./iterable-container-Dv5vSKht.js";
+
+//#region src/only.d.ts
+type Only<T extends IterableContainer> = T extends readonly [...Array<unknown>, unknown, unknown] | readonly [] | readonly [unknown, ...Array<unknown>, unknown] | readonly [unknown, unknown, ...Array<unknown>] ? undefined : T extends readonly [unknown] ? T[number] : T[number] | undefined;
+/**
+ * Returns the first and only element of `array`, or undefined otherwise.
+ *
+ * @param array - The target array.
+ * @signature
+ *    P.only(array)
+ * @example
+ *    P.only([]) // => undefined
+ *    P.only([1]) // => 1
+ *    P.only([1, 2]) // => undefined
+ * @dataFirst
+ * @category Array
+ */
+declare function only<T extends IterableContainer>(array: Readonly<T>): Only<T>;
+/**
+ * Returns the first and only element of `array`, or undefined otherwise.
+ *
+ * @signature
+ *    P.only()(array)
+ * @example
+ *    P.pipe([], P.only()); // => undefined
+ *    P.pipe([1], P.only()); // => 1
+ *    P.pipe([1, 2], P.only()); // => undefined
+ * @dataLast
+ * @category Array
+ */
+declare function only<T extends IterableContainer>(): (array: Readonly<T>) => Only<T>;
+//#endregion
+export { only };
+//# sourceMappingURL=only.d.ts.map

package/dist/only.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"only.d.ts","names":[],"sources":["../src/only.ts"],"sourcesContent":[],"mappings":";;;KAIK,eAAe,qBAAqB,uBACxB,wEAES,0DACS,8BAE/B,+BACE,YACA;;AAZuE;;;;;;;;;;AA2B7E;;AAAkE,iBAAlD,IAAkD,CAAA,UAAnC,iBAAmC,CAAA,CAAA,KAAA,EAAT,QAAS,CAAA,CAAA,CAAA,CAAA,EAAK,IAAL,CAAU,CAAV,CAAA;;;;;AAclE;;;;;;;;iBAAgB,eAAe,8BACtB,SAAS,OACb,KAAK"}

package/dist/only.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{only as e}from"./only-aG2aEsjs.js";export{e as only};
+import{t as e}from"./curry-NmniqyJ0.js";function t(...t){return e(n,t)}function n(e){return e.length===1?e[0]:void 0}export{t as only};
+//# sourceMappingURL=only.js.map

package/dist/only.js.map

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

package/dist/optional-options-with-defaults-BFaBSKkF.d.ts

@@ -0,0 +1,12 @@
+import { Merge } from "type-fest";
+
+//#region src/internal/types/optional-options-with-defaults.d.ts
+
+/**
+ * A simplified version of type-fest's `ApplyDefaultOptions` which isn't
+ * exported. It allows us to provide a default fallback for an optional option.
+ */
+type OptionalOptionsWithDefaults<T, Provided extends T, Defaults extends T> = Merge<Defaults, { [Key in keyof Provided as Extract<Provided[Key], undefined> extends never ? Key : never]: Provided[Key] }> & Required<T>;
+//#endregion
+export { OptionalOptionsWithDefaults as t };
+//# sourceMappingURL=optional-options-with-defaults-BFaBSKkF.d.ts.map

package/dist/optional-options-with-defaults-BFaBSKkF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional-options-with-defaults-BFaBSKkF.d.ts","names":[],"sources":["../src/internal/types/optional-options-with-defaults.ts"],"sourcesContent":[],"mappings":";;;;;;AAMA;;AAGmB,KAHP,2BAGO,CAAA,CAAA,EAAA,iBADA,CACA,EAAA,iBAAA,CAAA,CAAA,GACf,KADe,CAEjB,QAFiB,EAAA,UAEjB,MAKgB,QALhB,IAK4B,OAL5B,CAKoC,QALpC,CAK6C,GAL7C,CAAA,EAAA,SAAA,CAAA,SAAA,KAAA,GAMM,GANN,GAAA,KAAA,GAOc,QAPd,CAOuB,GAPvB,CAAA,EAKgB,CAAA,GAQhB,QARgB,CAQP,CARO,CAAA"}

package/dist/optional-options-with-defaults-BZVW8GfC.d.cts

@@ -0,0 +1,12 @@
+import { Merge } from "type-fest";
+
+//#region src/internal/types/optional-options-with-defaults.d.ts
+
+/**
+ * A simplified version of type-fest's `ApplyDefaultOptions` which isn't
+ * exported. It allows us to provide a default fallback for an optional option.
+ */
+type OptionalOptionsWithDefaults<T, Provided extends T, Defaults extends T> = Merge<Defaults, { [Key in keyof Provided as Extract<Provided[Key], undefined> extends never ? Key : never]: Provided[Key] }> & Required<T>;
+//#endregion
+export { OptionalOptionsWithDefaults as t };
+//# sourceMappingURL=optional-options-with-defaults-BZVW8GfC.d.cts.map

package/dist/optional-options-with-defaults-BZVW8GfC.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional-options-with-defaults-BZVW8GfC.d.cts","names":[],"sources":["../src/internal/types/optional-options-with-defaults.ts"],"sourcesContent":[],"mappings":";;;;;;AAMA;;AAGmB,KAHP,2BAGO,CAAA,CAAA,EAAA,iBADA,CACA,EAAA,iBAAA,CAAA,CAAA,GACf,KADe,CAEjB,QAFiB,EAAA,UAEjB,MAKgB,QALhB,IAK4B,OAL5B,CAKoC,QALpC,CAK6C,GAL7C,CAAA,EAAA,SAAA,CAAA,SAAA,KAAA,GAMM,GANN,GAAA,KAAA,GAOc,QAPd,CAOuB,GAPvB,CAAA,EAKgB,CAAA,GAQhB,QARgB,CAQP,CARO,CAAA"}

package/dist/partial-array-CQF5oggb.d.cts

@@ -0,0 +1,12 @@
+//#region src/internal/types/partial-array.d.ts
+/**
+ * In versions of TypeScript prior to 5.4 there is an issue inferring an array
+ * type after passing it to Partial without additional testing. To allow simpler
+ * code we pulled this check into it's own utility.
+ *
+ * TODO: Remove this utility once the minimum TypeScript version is bumped.
+ */
+type PartialArray<T> = T extends ReadonlyArray<unknown> | [] ? Partial<T> : never;
+//#endregion
+export { PartialArray as t };
+//# sourceMappingURL=partial-array-CQF5oggb.d.cts.map

package/dist/partial-array-CQF5oggb.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partial-array-CQF5oggb.d.cts","names":[],"sources":["../src/internal/types/partial-array.ts"],"sourcesContent":[],"mappings":";;AAOA;;;;;;KAAY,kBAAkB,UAAU,8BACpC,QAAQ"}

package/dist/partial-array-DU-2Vkyx.d.ts

@@ -0,0 +1,12 @@
+//#region src/internal/types/partial-array.d.ts
+/**
+ * In versions of TypeScript prior to 5.4 there is an issue inferring an array
+ * type after passing it to Partial without additional testing. To allow simpler
+ * code we pulled this check into it's own utility.
+ *
+ * TODO: Remove this utility once the minimum TypeScript version is bumped.
+ */
+type PartialArray<T> = T extends ReadonlyArray<unknown> | [] ? Partial<T> : never;
+//#endregion
+export { PartialArray as t };
+//# sourceMappingURL=partial-array-DU-2Vkyx.d.ts.map

package/dist/partial-array-DU-2Vkyx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partial-array-DU-2Vkyx.d.ts","names":[],"sources":["../src/internal/types/partial-array.ts"],"sourcesContent":[],"mappings":";;AAOA;;;;;;KAAY,kBAAkB,UAAU,8BACpC,QAAQ"}

package/dist/partition-by-union-BztEpKVh.d.cts

@@ -0,0 +1,20 @@
+import { IsUnion } from "type-fest";
+
+//#region src/internal/types/partition-by-union.d.ts
+
+/**
+ * We split the fixed tuple item types into **singular** types (e.g., `"a"`),
+ * and unions of several types (e.g., `"a" | "b"`). This split allows building
+ * complex types based on if a specific value would always be present, or if
+ * it is *effectively* optional.
+ *
+ * We assume that T is a fixed tuple (no optional or rest elements), and that
+ * all elements in it are bounded (as defined by `IsBounded`).
+ */
+type PartitionByUnion<T, Singular = never, Union = never> = T extends readonly [infer Head, ...infer Rest] ? IsUnion<Head> extends true ? PartitionByUnion<Rest, Singular, Union | Head> : PartitionByUnion<Rest, Singular | Head, Union> : {
+  singular: Singular;
+  union: Union;
+};
+//#endregion
+export { PartitionByUnion as t };
+//# sourceMappingURL=partition-by-union-BztEpKVh.d.cts.map

package/dist/partition-by-union-BztEpKVh.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition-by-union-BztEpKVh.d.cts","names":[],"sources":["../src/internal/types/partition-by-union.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;AAM+C,KANnC,gBAMmC,CAAA,CAAA,EAAA,WAAA,KAAA,EAAA,QAAA,KAAA,CAAA,GAF3C,CAE2C,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAD3C,OAC2C,CADnC,IACmC,CAAA,SAAA,IAAA,GAAzC,gBAAyC,CAAxB,IAAwB,EAAlB,QAAkB,EAAR,KAAQ,GAAA,IAAA,CAAA,GACzC,gBADyC,CACxB,IADwB,EAClB,QADkB,GACP,IADO,EACD,KADC,CAAA,GAAA;EAAzC,QAAA,EAEU,QAFV;EACiB,KAAA,EACU,KADV;CAAM"}

package/dist/partition-by-union-DnfiiEMU.d.ts

@@ -0,0 +1,20 @@
+import { IsUnion } from "type-fest";
+
+//#region src/internal/types/partition-by-union.d.ts
+
+/**
+ * We split the fixed tuple item types into **singular** types (e.g., `"a"`),
+ * and unions of several types (e.g., `"a" | "b"`). This split allows building
+ * complex types based on if a specific value would always be present, or if
+ * it is *effectively* optional.
+ *
+ * We assume that T is a fixed tuple (no optional or rest elements), and that
+ * all elements in it are bounded (as defined by `IsBounded`).
+ */
+type PartitionByUnion<T, Singular = never, Union = never> = T extends readonly [infer Head, ...infer Rest] ? IsUnion<Head> extends true ? PartitionByUnion<Rest, Singular, Union | Head> : PartitionByUnion<Rest, Singular | Head, Union> : {
+  singular: Singular;
+  union: Union;
+};
+//#endregion
+export { PartitionByUnion as t };
+//# sourceMappingURL=partition-by-union-DnfiiEMU.d.ts.map

package/dist/partition-by-union-DnfiiEMU.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition-by-union-DnfiiEMU.d.ts","names":[],"sources":["../src/internal/types/partition-by-union.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;;;;;;;AAM+C,KANnC,gBAMmC,CAAA,CAAA,EAAA,WAAA,KAAA,EAAA,QAAA,KAAA,CAAA,GAF3C,CAE2C,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GAD3C,OAC2C,CADnC,IACmC,CAAA,SAAA,IAAA,GAAzC,gBAAyC,CAAxB,IAAwB,EAAlB,QAAkB,EAAR,KAAQ,GAAA,IAAA,CAAA,GACzC,gBADyC,CACxB,IADwB,EAClB,QADkB,GACP,IADO,EACD,KADC,CAAA,GAAA;EAAzC,QAAA,EAEU,QAFV;EACiB,KAAA,EACU,KADV;CAAM"}

package/dist/partition.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./partition-CP0fPbGt.cjs`);exports.partition=e.partition;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(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}exports.partition=t;

package/dist/partition.d.cts

@@ -1,2 +1,51 @@
-import { partition } from "./partition-LBHIQgBS.cjs";
-export { partition };
+//#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.d.cts.map

package/dist/partition.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.d.cts","names":[],"sources":["../src/partition.ts"],"sourcesContent":[],"mappings":";;AAwBA;;;;;;;;;;;;;;;AAIA;;;;;;AAGU,iBAPM,SAON,CAAA,CAAA,EAAA,UAP6B,CAO7B,CAAA,CAAA,IAAA,EANF,aAME,CANY,CAMZ,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EALW,CAKX,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EALmC,aAKnC,CALiD,CAKjD,CAAA,EAAA,GAAA,KAAA,IALiE,CAKjE,CAAA,EAAA,CAJN,KAIM,CAJA,CAIA,CAAA,EAJI,KAIJ,CAJU,OAIV,CAJkB,CAIlB,EAJqB,CAIrB,CAAA,CAAA,CAAA;AAAN,iBAHY,SAGZ,CAAA,CAAA,CAAA,CAAA,IAAA,EAFI,aAEJ,CAFkB,CAElB,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EADiB,CACjB,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADyC,aACzC,CADuD,CACvD,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,KAAA,CAAM,CAAN,CAAA,EAAU,KAAV,CAAgB,CAAhB,CAAA,CAAA;;;;AAuBJ;;;;;;;;;;;;;;;AAGA;;;AAC6C,iBAJ7B,SAI6B,CAAA,CAAA,EAAA,UAJN,CAIM,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAHxB,CAGwB,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAHA,aAGA,CAHc,CAGd,CAAA,EAAA,GAAA,KAAA,IAH8B,CAG9B,CAAA,EAAA,CAAA,IAAA,EAFnC,aAEmC,CAFrB,CAEqB,CAAA,EAAA,GAAA,CAFb,KAEa,CAFP,CAEO,CAAA,EAFH,KAEG,CAFG,OAEH,CAFW,CAEX,EAFc,CAEd,CAAA,CAAA,CAAA;AACrB,iBAFR,SAEQ,CAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EADH,CACG,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADqB,aACrB,CADmC,CACnC,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,IAAA,EAAd,aAAc,CAAA,CAAA,CAAA,EAAA,GAAA,CAAQ,KAAR,CAAc,CAAd,CAAA,EAAkB,KAAlB,CAAwB,CAAxB,CAAA,CAAA"}

package/dist/partition.d.ts

@@ -1,2 +1,51 @@
-import { partition } from "./partition-CIBacxWc.js";
-export { partition };
+//#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.d.ts.map

package/dist/partition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.d.ts","names":[],"sources":["../src/partition.ts"],"sourcesContent":[],"mappings":";;AAwBA;;;;;;;;;;;;;;;AAIA;;;;;;AAGU,iBAPM,SAON,CAAA,CAAA,EAAA,UAP6B,CAO7B,CAAA,CAAA,IAAA,EANF,aAME,CANY,CAMZ,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EALW,CAKX,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EALmC,aAKnC,CALiD,CAKjD,CAAA,EAAA,GAAA,KAAA,IALiE,CAKjE,CAAA,EAAA,CAJN,KAIM,CAJA,CAIA,CAAA,EAJI,KAIJ,CAJU,OAIV,CAJkB,CAIlB,EAJqB,CAIrB,CAAA,CAAA,CAAA;AAAN,iBAHY,SAGZ,CAAA,CAAA,CAAA,CAAA,IAAA,EAFI,aAEJ,CAFkB,CAElB,CAAA,EAAA,SAAA,EAAA,CAAA,KAAA,EADiB,CACjB,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADyC,aACzC,CADuD,CACvD,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,KAAA,CAAM,CAAN,CAAA,EAAU,KAAV,CAAgB,CAAhB,CAAA,CAAA;;;;AAuBJ;;;;;;;;;;;;;;;AAGA;;;AAC6C,iBAJ7B,SAI6B,CAAA,CAAA,EAAA,UAJN,CAIM,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EAHxB,CAGwB,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAHA,aAGA,CAHc,CAGd,CAAA,EAAA,GAAA,KAAA,IAH8B,CAG9B,CAAA,EAAA,CAAA,IAAA,EAFnC,aAEmC,CAFrB,CAEqB,CAAA,EAAA,GAAA,CAFb,KAEa,CAFP,CAEO,CAAA,EAFH,KAEG,CAFG,OAEH,CAFW,CAEX,EAFc,CAEd,CAAA,CAAA,CAAA;AACrB,iBAFR,SAEQ,CAAA,CAAA,CAAA,CAAA,SAAA,EAAA,CAAA,KAAA,EADH,CACG,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EADqB,aACrB,CADmC,CACnC,CAAA,EAAA,GAAA,OAAA,CAAA,EAAA,CAAA,IAAA,EAAd,aAAc,CAAA,CAAA,CAAA,EAAA,GAAA,CAAQ,KAAR,CAAc,CAAd,CAAA,EAAkB,KAAlB,CAAwB,CAAxB,CAAA,CAAA"}

package/dist/partition.js

@@ -1 +1,2 @@
-import"./lazy-data-last-impl-7QfM1xXg.js";import"./curry-CzZjDrpv.js";import{partition as e}from"./partition-e274M9T9.js";export{e as partition};
+import{t as e}from"./curry-NmniqyJ0.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.js.map

package/dist/partition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.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":"wCA6DA,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/path-or.cjs

@@ -1 +1 @@
-require(`./lazy-data-last-impl-3PAFkslW.cjs`),require(`./curry-BPVIsvo3.cjs`);const e=require(`./path-or-D-RyTkoO.cjs`);exports.pathOr=e.pathOr;
+const e=require(`./curry-BsY0Z8jH.cjs`);function t(...t){return e.t(n,t)}function n(e,t,n){let r=e;for(let e of t){if(r==null)break;r=r[e]}return r??n}exports.pathOr=t;

package/dist/path-or.d.cts

@@ -1,2 +1,87 @@
-import { pathOr } from "./path-or-DvWnAQUG.cjs";
-export { pathOr };
+//#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$1 extends PropertyKey> = T extends infer I ? K$1 extends keyof I ? I[K$1] : 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.d.cts.map

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

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