@vinicunca/perkakas 1.9.0 → 1.12.0

package/dist/tuple-parts-BJQEORxn.d.cts

@@ -0,0 +1,89 @@
+import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+import { t as PerkakasTypeError } from "./perkakas-type-error-BERl_sWR.cjs";
+import { Or, Simplify } from "type-fest";
+
+//#region src/internal/types/tuple-parts.d.ts
+
+/**
+ * Takes a tuple and returns the types that make up its parts. These parts
+ * follow TypeScript's only supported format for arrays/tuples:
+ * [<required>, <optional>, ...<rest>[], <suffix>].
+ *
+ * There are some limitations to what shapes TypeScript supports:
+ * tuples can only have a suffix if they also have a non-never rest element,
+ * **and** tuples cannot have both an optional part and a suffix; this means
+ * there are only 10 possible shapes for tuples:
+ *   1.  Empty Tuples: `[]`.
+ *   2.  Fixed Tuples: `[string, number]`.
+ *   3.  Optional Tuples: `[string?, number?]`.
+ *   4.  Mixed Tuples: `[string, number?]`.
+ *   5.  Arrays: `Array<string>`.
+ *   6.  Fixed-Prefix Arrays: `[string, ...Array<string>]`.
+ *   7.  Optional-Prefix Arrays: `[number?, ...Array<boolean>]`.
+ *   8.  Mixed-Prefix Arrays: `[string, number?, ...Array<boolean>]`.
+ *   9.  Fixed-Suffix Arrays: `[...Array<string>, string]`.
+ *   10. Fixed-Elements Arrays: `[string, ...Array<string>, string]`.
+ *
+ * @example [
+ *   ...TupleParts<T>["required"],
+ *   ...Partial<TupleParts<T>["optional"]>,
+ *   ...CoercedArray<TupleParts<T>["item"]>,
+ *   ...TupleParts<T>["suffix"],
+ * ].
+ */
+type TupleParts<T extends IterableContainer, Prefix extends Array<unknown> = []> = T extends readonly [infer Head, ...infer Tail] ? TupleParts<Tail, [...Prefix, Head]> : Simplify<{
+  /**
+   * A fixed tuple that defines the part of the tuple where all its
+   * elements are required. This will always be the first part of the
+   * tuple and will never contain any optional or rest elements. When the
+   * array doesn't have a required part this will be an empty tuple
+   * (`[]`).
+   */
+  required: Prefix;
+} & TuplePartsWithoutRequired<T>>;
+type TuplePartsWithoutRequired<T extends IterableContainer, Suffix extends Array<unknown> = []> = T extends readonly [...infer Head, infer Tail] ? TuplePartsWithoutRequired<Head, [Tail, ...Suffix]> : (Suffix extends readonly [] ? TuplePartsWithoutFixed<T> : {
+  optional: [];
+} & TuplePartsRest<T>) & {
+  /**
+   * A *fixed* tuple that defines the part of a tuple **after** a non-never
+   * rest parameter. These could never be optional elements, and could
+   * never contain another rest element. When the array doesn't have a
+   * required part this will be an empty tuple (`[]`).
+   */
+  suffix: Suffix;
+};
+type TuplePartsWithoutFixed<T extends IterableContainer, Optional extends Array<unknown> = []> = T extends readonly [(infer Head)?, ...infer Tail] ? Or<T extends readonly [] ? true : false, Array<T[number]> extends Tail ? true : false> extends true ? {
+  /**
+   * A *fixed* tuple that defines the part of a tuple where all its
+   * elements are suffixed with the optional operator (`?`); but with
+   * the optional operator removed (e.g. `[string?]` would be
+   * represented as `[string]`). These elements can only follow the
+   * `required` part (which could be empty).
+   * To add optional operator back wrap the result with the built-in
+   * `Partial` type.
+   * When the array doesn't have a required part this will be an empty
+   * tuple (`[]`).
+   *
+   * @example Partial<TupleParts<T>["optional"]>
+   */
+  optional: Optional;
+} & TuplePartsRest<T> : TuplePartsWithoutFixed<Tail, [...Optional, Head | undefined]> : PerkakasTypeError<'TupleParts', 'Unexpected tuple shape', {
+  type: never;
+  metadata: T;
+}>;
+interface TuplePartsRest<T extends IterableContainer> {
+  /**
+   * The type for the rest parameter of the tuple, if any. Unlike the
+   * other parts of the tuple, this is a single type and not
+   * represented as an array/tuple. When a tuple doesn't have a rest
+   * element, this will be `never`. To convert this to a matching array
+   * type that could be spread into a new type use the `CoercedArray`
+   * type which handles the `never` case correctly.
+   *
+   * @example CoercedArray<TupleParts<T>["item"]>
+   */
+  item: T extends readonly [] ? never : T[number];
+}
+//#endregion
+export { TupleParts as t };
+//# sourceMappingURL=tuple-parts-BJQEORxn.d.cts.map

package/dist/tuple-parts-BJQEORxn.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple-parts-BJQEORxn.d.cts","names":[],"sources":["../src/internal/types/tuple-parts.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA+BA;;;;;;;;;;;;;AAoBI;;;;;;;;;;;;AAgBqB,KApCb,UAoCa,CAAA,UAnCb,iBAmCa,EAAA,eAlCR,KAkCQ,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAjCrB,CAiCqB,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GA9BrB,UA8BqB,CA9BV,IA8BU,EAAA,CAAA,GA9BA,MA8BA,EA9BQ,IA8BR,CAAA,CAAA,GA3BrB,QA2BqB,CAAA;EAOX;;AAAM;;;;;EAmBV,QAAA,EA5CM,MA4CN;CAAN,GA3CI,yBA2CJ,CA3C8B,CA2C9B,CAAA,CAAA;KAvCC,yBAiCD,CAAA,UAhCQ,iBAgCR,EAAA,eA/Ba,KA+Bb,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GA9BA,CA8BA,SAAA,SAAA,CAAA,GAAA,KAAA,KAAA,EAAA,KAAA,KAAA,CAAA,GA3BA,yBA2BA,CA3B0B,IA2B1B,EAAA,CA3BiC,IA2BjC,EAAA,GA3B0C,MA2B1C,CAAA,CAAA,GAAA,CA1BC,MA0BD,SAAA,SAAA,EAAA,GAvBE,sBAuBF,CAvByB,CAuBzB,CAAA,GAAA;EAqBU,QAAA,EAAA,EAAA;CACO,GA1CI,cA0CJ,CA1CmB,CA0CnB,CAAA,CAAA,GAAA;EAAf;;;;;;EAEF,MAAA,EArCU,MAqCV;CAAiB;AAAA,KAhChB,sBA4CmB,CAAA,UA3CZ,iBA2CY,EAAA,iBA1CL,KA0CK,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAzCpB,CAyCoB,SAAA,SAAA,CAAA,CAAA,KAAA,KAAA,CAAA,CAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GApCpB,EAoCoB,CAjCpB,CAiCoB,SAAA,SAAA,EAAA,GAAA,IAAA,GAAA,KAAA,EA9BpB,KA8BoB,CA9Bd,CA8Bc,CAAA,MAAA,CAAA,CAAA,SAAA,IAAA,GAAA,IAAA,GAAA,KAAA,CAAA,SAAA,IAAA,GAAA;EAAW;;;;;;;;;;;;;YAfrB;IACR,eAAe,KACf,uBAAuB,UAAU,UAAU,qBAC7C;;YAKY;;UAON,yBAAyB;;;;;;;;;;;QAW3B,gCAAgC"}

package/dist/tuple-parts-Bhbm4jiu.d.ts

@@ -0,0 +1,89 @@
+import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+import { t as PerkakasTypeError } from "./perkakas-type-error-DmmsEmEF.js";
+import { Or, Simplify } from "type-fest";
+
+//#region src/internal/types/tuple-parts.d.ts
+
+/**
+ * Takes a tuple and returns the types that make up its parts. These parts
+ * follow TypeScript's only supported format for arrays/tuples:
+ * [<required>, <optional>, ...<rest>[], <suffix>].
+ *
+ * There are some limitations to what shapes TypeScript supports:
+ * tuples can only have a suffix if they also have a non-never rest element,
+ * **and** tuples cannot have both an optional part and a suffix; this means
+ * there are only 10 possible shapes for tuples:
+ *   1.  Empty Tuples: `[]`.
+ *   2.  Fixed Tuples: `[string, number]`.
+ *   3.  Optional Tuples: `[string?, number?]`.
+ *   4.  Mixed Tuples: `[string, number?]`.
+ *   5.  Arrays: `Array<string>`.
+ *   6.  Fixed-Prefix Arrays: `[string, ...Array<string>]`.
+ *   7.  Optional-Prefix Arrays: `[number?, ...Array<boolean>]`.
+ *   8.  Mixed-Prefix Arrays: `[string, number?, ...Array<boolean>]`.
+ *   9.  Fixed-Suffix Arrays: `[...Array<string>, string]`.
+ *   10. Fixed-Elements Arrays: `[string, ...Array<string>, string]`.
+ *
+ * @example [
+ *   ...TupleParts<T>["required"],
+ *   ...Partial<TupleParts<T>["optional"]>,
+ *   ...CoercedArray<TupleParts<T>["item"]>,
+ *   ...TupleParts<T>["suffix"],
+ * ].
+ */
+type TupleParts<T extends IterableContainer, Prefix extends Array<unknown> = []> = T extends readonly [infer Head, ...infer Tail] ? TupleParts<Tail, [...Prefix, Head]> : Simplify<{
+  /**
+   * A fixed tuple that defines the part of the tuple where all its
+   * elements are required. This will always be the first part of the
+   * tuple and will never contain any optional or rest elements. When the
+   * array doesn't have a required part this will be an empty tuple
+   * (`[]`).
+   */
+  required: Prefix;
+} & TuplePartsWithoutRequired<T>>;
+type TuplePartsWithoutRequired<T extends IterableContainer, Suffix extends Array<unknown> = []> = T extends readonly [...infer Head, infer Tail] ? TuplePartsWithoutRequired<Head, [Tail, ...Suffix]> : (Suffix extends readonly [] ? TuplePartsWithoutFixed<T> : {
+  optional: [];
+} & TuplePartsRest<T>) & {
+  /**
+   * A *fixed* tuple that defines the part of a tuple **after** a non-never
+   * rest parameter. These could never be optional elements, and could
+   * never contain another rest element. When the array doesn't have a
+   * required part this will be an empty tuple (`[]`).
+   */
+  suffix: Suffix;
+};
+type TuplePartsWithoutFixed<T extends IterableContainer, Optional extends Array<unknown> = []> = T extends readonly [(infer Head)?, ...infer Tail] ? Or<T extends readonly [] ? true : false, Array<T[number]> extends Tail ? true : false> extends true ? {
+  /**
+   * A *fixed* tuple that defines the part of a tuple where all its
+   * elements are suffixed with the optional operator (`?`); but with
+   * the optional operator removed (e.g. `[string?]` would be
+   * represented as `[string]`). These elements can only follow the
+   * `required` part (which could be empty).
+   * To add optional operator back wrap the result with the built-in
+   * `Partial` type.
+   * When the array doesn't have a required part this will be an empty
+   * tuple (`[]`).
+   *
+   * @example Partial<TupleParts<T>["optional"]>
+   */
+  optional: Optional;
+} & TuplePartsRest<T> : TuplePartsWithoutFixed<Tail, [...Optional, Head | undefined]> : PerkakasTypeError<'TupleParts', 'Unexpected tuple shape', {
+  type: never;
+  metadata: T;
+}>;
+interface TuplePartsRest<T extends IterableContainer> {
+  /**
+   * The type for the rest parameter of the tuple, if any. Unlike the
+   * other parts of the tuple, this is a single type and not
+   * represented as an array/tuple. When a tuple doesn't have a rest
+   * element, this will be `never`. To convert this to a matching array
+   * type that could be spread into a new type use the `CoercedArray`
+   * type which handles the `never` case correctly.
+   *
+   * @example CoercedArray<TupleParts<T>["item"]>
+   */
+  item: T extends readonly [] ? never : T[number];
+}
+//#endregion
+export { TupleParts as t };
+//# sourceMappingURL=tuple-parts-Bhbm4jiu.d.ts.map

package/dist/tuple-parts-Bhbm4jiu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple-parts-Bhbm4jiu.d.ts","names":[],"sources":["../src/internal/types/tuple-parts.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA+BA;;;;;;;;;;;;;AAoBI;;;;;;;;;;;;AAgBqB,KApCb,UAoCa,CAAA,UAnCb,iBAmCa,EAAA,eAlCR,KAkCQ,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAjCrB,CAiCqB,SAAA,SAAA,CAAA,KAAA,KAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GA9BrB,UA8BqB,CA9BV,IA8BU,EAAA,CAAA,GA9BA,MA8BA,EA9BQ,IA8BR,CAAA,CAAA,GA3BrB,QA2BqB,CAAA;EAOX;;AAAM;;;;;EAmBV,QAAA,EA5CM,MA4CN;CAAN,GA3CI,yBA2CJ,CA3C8B,CA2C9B,CAAA,CAAA;KAvCC,yBAiCD,CAAA,UAhCQ,iBAgCR,EAAA,eA/Ba,KA+Bb,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GA9BA,CA8BA,SAAA,SAAA,CAAA,GAAA,KAAA,KAAA,EAAA,KAAA,KAAA,CAAA,GA3BA,yBA2BA,CA3B0B,IA2B1B,EAAA,CA3BiC,IA2BjC,EAAA,GA3B0C,MA2B1C,CAAA,CAAA,GAAA,CA1BC,MA0BD,SAAA,SAAA,EAAA,GAvBE,sBAuBF,CAvByB,CAuBzB,CAAA,GAAA;EAqBU,QAAA,EAAA,EAAA;CACO,GA1CI,cA0CJ,CA1CmB,CA0CnB,CAAA,CAAA,GAAA;EAAf;;;;;;EAEF,MAAA,EArCU,MAqCV;CAAiB;AAAA,KAhChB,sBA4CmB,CAAA,UA3CZ,iBA2CY,EAAA,iBA1CL,KA0CK,CAAA,OAAA,CAAA,GAAA,EAAA,CAAA,GAzCpB,CAyCoB,SAAA,SAAA,CAAA,CAAA,KAAA,KAAA,CAAA,CAAA,EAAA,GAAA,KAAA,KAAA,CAAA,GApCpB,EAoCoB,CAjCpB,CAiCoB,SAAA,SAAA,EAAA,GAAA,IAAA,GAAA,KAAA,EA9BpB,KA8BoB,CA9Bd,CA8Bc,CAAA,MAAA,CAAA,CAAA,SAAA,IAAA,GAAA,IAAA,GAAA,KAAA,CAAA,SAAA,IAAA,GAAA;EAAW;;;;;;;;;;;;;YAfrB;IACR,eAAe,KACf,uBAAuB,UAAU,UAAU,qBAC7C;;YAKY;;UAON,yBAAyB;;;;;;;;;;;QAW3B,gCAAgC"}

package/dist/type.helpers.cjs

@@ -1 +0,0 @@
-require(`./type.helpers-DRN0iRW5.cjs`);

package/dist/type.helpers.d.cts

@@ -1,2 +1,5 @@
-import { DeepPartial } from "./type.helpers-Dmf6ppyq.cjs";
-export { DeepPartial };
+//#region src/type.helpers.d.ts
+type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
+//#endregion
+export { DeepPartial };
+//# sourceMappingURL=type.helpers.d.cts.map

package/dist/type.helpers.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.helpers.d.cts","names":[],"sources":["../src/type.helpers.ts"],"sourcesContent":[],"mappings":";KAAY,iBAAiB,2BAAjB,MAEM,CAFN,IAEW,WAFA,CAEY,CAFZ,CAEc,CAFd,CAAA,CAAA,EAAM,GAIzB,CAJyB"}

package/dist/type.helpers.d.ts

@@ -1,2 +1,5 @@
-import { DeepPartial } from "./type.helpers-1V2lXyqJ.js";
-export { DeepPartial };
+//#region src/type.helpers.d.ts
+type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
+//#endregion
+export { DeepPartial };
+//# sourceMappingURL=type.helpers.d.ts.map

package/dist/type.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.helpers.d.ts","names":[],"sources":["../src/type.helpers.ts"],"sourcesContent":[],"mappings":";KAAY,iBAAiB,2BAAjB,MAEM,CAFN,IAEW,WAFA,CAEY,CAFZ,CAEc,CAFd,CAAA,CAAA,EAAM,GAIzB,CAJyB"}

package/dist/type.helpers.js

@@ -1 +0,0 @@
-import"./type.helpers-eVB6l9f9.js";

package/dist/unique-by.cjs

@@ -1 +1 @@
-require(`./utility-evaluators-DqJcWENu.cjs`),require(`./pipe-DlFjc4Wf.cjs`),require(`./curry-from-lazy-BDH06qZ-.cjs`);const e=require(`./unique-by-Ds6Uwfxl.cjs`);exports.uniqueBy=e.uniqueBy;
+const e=require(`./utility-evaluators-CAbODbuk.cjs`),t=require(`./curry-from-lazy-BCGvmhyS.cjs`);function n(...e){return t.t(r,e)}function r(t){let n=new Set;return(r,i,a)=>{let o=t(r,i,a);return n.has(o)?e.t:(n.add(o),{done:!1,hasNext:!0,next:r})}}exports.uniqueBy=n;

package/dist/unique-by.d.cts

@@ -1,5 +1,44 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import "./non-empty-array-D3ZRHApS.cjs";
-import "./deduped-CAglY8bF.cjs";
-import { uniqueBy } from "./unique-by-BPYs6c1v.cjs";
-export { uniqueBy };
+import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+import { t as Deduped } from "./deduped-CXeQa-0F.cjs";
+
+//#region src/unique-by.d.ts
+
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list transformed by a function. Elements are compared by reference using Set.
+ *
+ * @param data - The array to filter.
+ * @param keyFunction - Extracts a value that would be used to compare elements.
+ * @signature
+ *    P.uniqueBy(data, keyFunction)
+ * @example
+ *    P.uniqueBy(
+ *     [{ n: 1 }, { n: 2 }, { n: 2 }, { n: 5 }, { n: 1 }, { n: 6 }, { n: 7 }],
+ *     (obj) => obj.n,
+ *    ) // => [{n: 1}, {n: 2}, {n: 5}, {n: 6}, {n: 7}]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function uniqueBy<T extends IterableContainer, K>(data: T, keyFunction: (item: T[number], index: number, data: T) => K): Deduped<T>;
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list transformed by a function. Elements are compared by reference using Set.
+ *
+ * @param keyFunction - Extracts a value that would be used to compare elements.
+ * @signature
+ *    P.uniqueBy(keyFunction)(data)
+ * @example
+ *    P.pipe(
+ *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations
+ *      P.uniqueBy(obj => obj.n),
+ *      P.take(3)
+ *    ) // => [{n: 1}, {n: 2}, {n: 5}]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function uniqueBy<T extends IterableContainer, K>(keyFunction: (item: T[number], index: number, data: T) => K): (data: T) => Deduped<T>;
+//#endregion
+export { uniqueBy };
+//# sourceMappingURL=unique-by.d.cts.map

package/dist/unique-by.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique-by.d.cts","names":[],"sources":["../src/unique-by.ts"],"sourcesContent":[],"mappings":";;;;;;;AAwBA;;;;;;;;;AAsBA;;;;;;AAEwB,iBAxBR,QAwBQ,CAAA,UAxBW,iBAwBX,EAAA,CAAA,CAAA,CAAA,IAAA,EAvBhB,CAuBgB,EAAA,WAAA,EAAA,CAAA,IAAA,EAtBF,CAsBE,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAtB8B,CAsB9B,EAAA,GAtBoC,CAsBpC,CAAA,EArBrB,OAqBqB,CArBb,CAqBa,CAAA;;;;;;;;;;;;;;;;;;iBAFR,mBAAmB,0CACb,gCAAgC,MAAM,WAClD,MAAM,QAAQ"}

package/dist/unique-by.d.ts

@@ -1,5 +1,44 @@
-import "./iterable-container-F9CDF7ym.js";
-import "./non-empty-array-BfTfvDYg.js";
-import "./deduped-Dru_XVLX.js";
-import { uniqueBy } from "./unique-by-B06g2psm.js";
-export { uniqueBy };
+import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+import { t as Deduped } from "./deduped-CL5-bmYU.js";
+
+//#region src/unique-by.d.ts
+
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list transformed by a function. Elements are compared by reference using Set.
+ *
+ * @param data - The array to filter.
+ * @param keyFunction - Extracts a value that would be used to compare elements.
+ * @signature
+ *    P.uniqueBy(data, keyFunction)
+ * @example
+ *    P.uniqueBy(
+ *     [{ n: 1 }, { n: 2 }, { n: 2 }, { n: 5 }, { n: 1 }, { n: 6 }, { n: 7 }],
+ *     (obj) => obj.n,
+ *    ) // => [{n: 1}, {n: 2}, {n: 5}, {n: 6}, {n: 7}]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function uniqueBy<T extends IterableContainer, K>(data: T, keyFunction: (item: T[number], index: number, data: T) => K): Deduped<T>;
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list transformed by a function. Elements are compared by reference using Set.
+ *
+ * @param keyFunction - Extracts a value that would be used to compare elements.
+ * @signature
+ *    P.uniqueBy(keyFunction)(data)
+ * @example
+ *    P.pipe(
+ *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations
+ *      P.uniqueBy(obj => obj.n),
+ *      P.take(3)
+ *    ) // => [{n: 1}, {n: 2}, {n: 5}]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function uniqueBy<T extends IterableContainer, K>(keyFunction: (item: T[number], index: number, data: T) => K): (data: T) => Deduped<T>;
+//#endregion
+export { uniqueBy };
+//# sourceMappingURL=unique-by.d.ts.map

package/dist/unique-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique-by.d.ts","names":[],"sources":["../src/unique-by.ts"],"sourcesContent":[],"mappings":";;;;;;;AAwBA;;;;;;;;;AAsBA;;;;;;AAEwB,iBAxBR,QAwBQ,CAAA,UAxBW,iBAwBX,EAAA,CAAA,CAAA,CAAA,IAAA,EAvBhB,CAuBgB,EAAA,WAAA,EAAA,CAAA,IAAA,EAtBF,CAsBE,CAAA,MAAA,CAAA,EAAA,KAAA,EAAA,MAAA,EAAA,IAAA,EAtB8B,CAsB9B,EAAA,GAtBoC,CAsBpC,CAAA,EArBrB,OAqBqB,CArBb,CAqBa,CAAA;;;;;;;;;;;;;;;;;;iBAFR,mBAAmB,0CACb,gCAAgC,MAAM,WAClD,MAAM,QAAQ"}

package/dist/unique-by.js

@@ -1 +1,2 @@
-import"./utility-evaluators-CnQVdcZv.js";import"./pipe-CtsfTnqv.js";import"./curry-from-lazy-BR-hoRDR.js";import{uniqueBy as e}from"./unique-by-Dh4QjQ3_.js";export{e as uniqueBy};
+import{t as e}from"./utility-evaluators-BwYLtB8b.js";import{t}from"./curry-from-lazy-CYtJvyas.js";function n(...e){return t(r,e)}function r(t){let n=new Set;return(r,i,a)=>{let o=t(r,i,a);return n.has(o)?e:(n.add(o),{done:!1,hasNext:!0,next:r})}}export{n as uniqueBy};
+//# sourceMappingURL=unique-by.js.map

package/dist/unique-by.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique-by.js","names":[],"sources":["../src/unique-by.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\n\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    P.uniqueBy(data, keyFunction)\n * @example\n *    P.uniqueBy(\n *     [{ n: 1 }, { n: 2 }, { n: 2 }, { n: 5 }, { n: 1 }, { n: 6 }, { n: 7 }],\n *     (obj) => obj.n,\n *    ) // => [{n: 1}, {n: 2}, {n: 5}, {n: 6}, {n: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer, K>(\n  data: T,\n  keyFunction: (item: T[number], index: number, data: T) => K,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list transformed by a function. Elements are compared by reference using Set.\n *\n * @param keyFunction - Extracts a value that would be used to compare elements.\n * @signature\n *    P.uniqueBy(keyFunction)(data)\n * @example\n *    P.pipe(\n *      [{n: 1}, {n: 2}, {n: 2}, {n: 5}, {n: 1}, {n: 6}, {n: 7}], // only 4 iterations\n *      P.uniqueBy(obj => obj.n),\n *      P.take(3)\n *    ) // => [{n: 1}, {n: 2}, {n: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueBy<T extends IterableContainer, K>(\n  keyFunction: (item: T[number], index: number, data: T) => K,\n): (data: T) => Deduped<T>;\n\nexport function uniqueBy(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T, K>(\n  keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => K,\n): LazyEvaluator<T> {\n  const set = new Set<K>();\n  return (value, index, data) => {\n    const key = keyFunction(value, index, data);\n    if (set.has(key)) {\n      return SKIP_ITEM;\n    }\n\n    set.add(key);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kGAkDA,SAAgB,EAAS,GAAG,EAAuC,CACjE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EACP,EACkB,CAClB,IAAM,EAAM,IAAI,IAChB,OAAQ,EAAO,EAAO,IAAS,CAC7B,IAAM,EAAM,EAAY,EAAO,EAAO,EAAK,CAM3C,OALI,EAAI,IAAI,EAAI,CACP,GAGT,EAAI,IAAI,EAAI,CACL,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}

package/dist/unique-with.cjs

@@ -1 +1 @@
-require(`./utility-evaluators-DqJcWENu.cjs`),require(`./pipe-DlFjc4Wf.cjs`),require(`./curry-from-lazy-BDH06qZ-.cjs`);const e=require(`./unique-with-DMT11QX0.cjs`);exports.uniqueWith=e.uniqueWith;
+const e=require(`./utility-evaluators-CAbODbuk.cjs`),t=require(`./curry-from-lazy-BCGvmhyS.cjs`);function n(...e){return t.t(r,e)}function r(t){return(n,r,i)=>i.findIndex((e,i)=>r===i||t(n,e))===r?{done:!1,hasNext:!0,next:n}:e.t}exports.uniqueWith=n;

package/dist/unique-with.d.cts

@@ -1,5 +1,46 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import "./non-empty-array-D3ZRHApS.cjs";
-import "./deduped-CAglY8bF.cjs";
-import { uniqueWith } from "./unique-with-CLhkmrmv.cjs";
-export { uniqueWith };
+import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+import { t as Deduped } from "./deduped-CXeQa-0F.cjs";
+
+//#region src/unique-with.d.ts
+type IsEquals<T> = (a: T, b: T) => boolean;
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list. Elements are compared by custom comparator isEquals.
+ *
+ * @param data - The array to filter.
+ * @param isEquals - The comparator.
+ * @signature
+ *    P.uniqueWith(array, isEquals)
+ * @example
+ *    P.uniqueWith(
+ *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],
+ *      P.equals,
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function uniqueWith<T extends IterableContainer>(data: T, isEquals: IsEquals<T[number]>): Deduped<T>;
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list. Elements are compared by custom comparator isEquals.
+ *
+ * @param isEquals - The comparator.
+ * @signature P.uniqueWith(isEquals)(array)
+ * @example
+ *    P.uniqueWith(P.equals)(
+ *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]
+ *    P.pipe(
+ *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}], // only 4 iterations
+ *      P.uniqueWith(P.equals),
+ *      P.take(3)
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function uniqueWith<T extends IterableContainer>(isEquals: IsEquals<T[number]>): (data: T) => Deduped<T>;
+//#endregion
+export { uniqueWith };
+//# sourceMappingURL=unique-with.d.cts.map

package/dist/unique-with.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique-with.d.cts","names":[],"sources":["../src/unique-with.ts"],"sourcesContent":[],"mappings":";;;;KAMK,kBAAkB,MAAM;;AALgD;AAwB7E;;;;;;;;AAwBA;;;;;;;AAEuB,iBA1BP,UA0BO,CAAA,UA1Bc,iBA0Bd,CAAA,CAAA,IAAA,EAzBf,CAyBe,EAAA,QAAA,EAxBX,QAwBW,CAxBF,CAwBE,CAAA,MAAA,CAAA,CAAA,CAAA,EAvBpB,OAuBoB,CAvBZ,CAuBY,CAAA;;;;;;;;;;;;;;;;;;;;iBAFP,qBAAqB,6BACzB,SAAS,oBACX,MAAM,QAAQ"}

package/dist/unique-with.d.ts

@@ -1,5 +1,46 @@
-import "./iterable-container-F9CDF7ym.js";
-import "./non-empty-array-BfTfvDYg.js";
-import "./deduped-Dru_XVLX.js";
-import { uniqueWith } from "./unique-with-nNna0tkx.js";
-export { uniqueWith };
+import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+import { t as Deduped } from "./deduped-CL5-bmYU.js";
+
+//#region src/unique-with.d.ts
+type IsEquals<T> = (a: T, b: T) => boolean;
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list. Elements are compared by custom comparator isEquals.
+ *
+ * @param data - The array to filter.
+ * @param isEquals - The comparator.
+ * @signature
+ *    P.uniqueWith(array, isEquals)
+ * @example
+ *    P.uniqueWith(
+ *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],
+ *      P.equals,
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function uniqueWith<T extends IterableContainer>(data: T, isEquals: IsEquals<T[number]>): Deduped<T>;
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list. Elements are compared by custom comparator isEquals.
+ *
+ * @param isEquals - The comparator.
+ * @signature P.uniqueWith(isEquals)(array)
+ * @example
+ *    P.uniqueWith(P.equals)(
+ *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]
+ *    P.pipe(
+ *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}], // only 4 iterations
+ *      P.uniqueWith(P.equals),
+ *      P.take(3)
+ *    ) // => [{a: 1}, {a: 2}, {a: 5}]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function uniqueWith<T extends IterableContainer>(isEquals: IsEquals<T[number]>): (data: T) => Deduped<T>;
+//#endregion
+export { uniqueWith };
+//# sourceMappingURL=unique-with.d.ts.map

package/dist/unique-with.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique-with.d.ts","names":[],"sources":["../src/unique-with.ts"],"sourcesContent":[],"mappings":";;;;KAMK,kBAAkB,MAAM;;AALgD;AAwB7E;;;;;;;;AAwBA;;;;;;;AAEuB,iBA1BP,UA0BO,CAAA,UA1Bc,iBA0Bd,CAAA,CAAA,IAAA,EAzBf,CAyBe,EAAA,QAAA,EAxBX,QAwBW,CAxBF,CAwBE,CAAA,MAAA,CAAA,CAAA,CAAA,EAvBpB,OAuBoB,CAvBZ,CAuBY,CAAA;;;;;;;;;;;;;;;;;;;;iBAFP,qBAAqB,6BACzB,SAAS,oBACX,MAAM,QAAQ"}

package/dist/unique-with.js

@@ -1 +1,2 @@
-import"./utility-evaluators-CnQVdcZv.js";import"./pipe-CtsfTnqv.js";import"./curry-from-lazy-BR-hoRDR.js";import{uniqueWith as e}from"./unique-with-hw-xxeGX.js";export{e as uniqueWith};
+import{t as e}from"./utility-evaluators-BwYLtB8b.js";import{t}from"./curry-from-lazy-CYtJvyas.js";function n(...e){return t(r,e)}function r(t){return(n,r,i)=>i.findIndex((e,i)=>r===i||t(n,e))===r?{done:!1,hasNext:!0,next:n}:e}export{n as uniqueWith};
+//# sourceMappingURL=unique-with.js.map

package/dist/unique-with.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique-with.js","names":[],"sources":["../src/unique-with.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\ntype IsEquals<T> = (a: T, b: T) => boolean;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param data - The array to filter.\n * @param isEquals - The comparator.\n * @signature\n *    P.uniqueWith(array, isEquals)\n * @example\n *    P.uniqueWith(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *      P.equals,\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  data: T,\n  isEquals: IsEquals<T[number]>,\n): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by custom comparator isEquals.\n *\n * @param isEquals - The comparator.\n * @signature P.uniqueWith(isEquals)(array)\n * @example\n *    P.uniqueWith(P.equals)(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}],\n *    ) // => [{a: 1}, {a: 2}, {a: 5}, {a: 6}, {a: 7}]\n *    P.pipe(\n *      [{a: 1}, {a: 2}, {a: 2}, {a: 5}, {a: 1}, {a: 6}, {a: 7}], // only 4 iterations\n *      P.uniqueWith(P.equals),\n *      P.take(3)\n *    ) // => [{a: 1}, {a: 2}, {a: 5}]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function uniqueWith<T extends IterableContainer>(\n  isEquals: IsEquals<T[number]>,\n): (data: T) => Deduped<T>;\n\nexport function uniqueWith(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(isEquals: IsEquals<T>): LazyEvaluator<T> {\n  return (value, index, data) => {\n    const firstEqualIndex = data.findIndex(\n      (otherValue, otherIndex) =>\n        index === otherIndex || isEquals(value, otherValue),\n    );\n\n    // skip items that aren't at the first equal index.\n    return firstEqualIndex === index\n      ? { done: false, hasNext: true, next: value }\n      : SKIP_ITEM;\n  };\n}\n"],"mappings":"kGAqDA,SAAgB,EAAW,GAAG,EAAuC,CACnE,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,EAAsB,EAAyC,CACtE,OAAQ,EAAO,EAAO,IACI,EAAK,WAC1B,EAAY,IACX,IAAU,GAAc,EAAS,EAAO,EAAW,CACtD,GAG0B,EACvB,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO,CAC3C"}

package/dist/unique.cjs

@@ -1 +1 @@
-require(`./utility-evaluators-DqJcWENu.cjs`),require(`./pipe-DlFjc4Wf.cjs`),require(`./curry-from-lazy-BDH06qZ-.cjs`);const e=require(`./unique-BMVWEHgx.cjs`);exports.unique=e.unique;
+const e=require(`./utility-evaluators-CAbODbuk.cjs`),t=require(`./curry-from-lazy-BCGvmhyS.cjs`);function n(...e){return t.t(r,e)}function r(){let t=new Set;return n=>t.has(n)?e.t:(t.add(n),{done:!1,hasNext:!0,next:n})}exports.unique=n;

package/dist/unique.d.cts

@@ -1,5 +1,39 @@
-import "./iterable-container-V5sa0V_H.cjs";
-import "./non-empty-array-D3ZRHApS.cjs";
-import "./deduped-CAglY8bF.cjs";
-import { unique } from "./unique-Dlp6H7Md.cjs";
-export { unique };
+import { t as IterableContainer } from "./iterable-container-OFsaw8WL.cjs";
+import { t as Deduped } from "./deduped-CXeQa-0F.cjs";
+
+//#region src/unique.d.ts
+
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list. Elements are compared by reference using Set.
+ *
+ * @param data - The array to filter.
+ * @signature
+ *    P.unique(array)
+ * @example
+ *    P.unique([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function unique<T extends IterableContainer>(data: T): Deduped<T>;
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list. Elements are compared by reference using Set.
+ *
+ * @signature
+ *    P.unique()(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations
+ *      P.unique(),
+ *      P.take(3)
+ *    ) // => [1, 2, 5]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function unique(): <T extends IterableContainer>(data: T) => Deduped<T>;
+//#endregion
+export { unique };
+//# sourceMappingURL=unique.d.cts.map

package/dist/unique.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.d.cts","names":[],"sources":["../src/unique.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmBA;;;;;;AAkBA;;;;;AAA2E,iBAlB3D,MAkB2D,CAAA,UAlB1C,iBAkB0C,CAAA,CAAA,IAAA,EAlBjB,CAkBiB,CAAA,EAlBb,OAkBa,CAlBL,CAkBK,CAAA;;;;;;;;;;;;;;;;;iBAA3D,MAAA,CAAA,cAAqB,yBAAyB,MAAM,QAAQ"}

package/dist/unique.d.ts

@@ -1,5 +1,39 @@
-import "./iterable-container-F9CDF7ym.js";
-import "./non-empty-array-BfTfvDYg.js";
-import "./deduped-Dru_XVLX.js";
-import { unique } from "./unique-DQ6D857b.js";
-export { unique };
+import { t as IterableContainer } from "./iterable-container-BdjPuIjL.js";
+import { t as Deduped } from "./deduped-CL5-bmYU.js";
+
+//#region src/unique.d.ts
+
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list. Elements are compared by reference using Set.
+ *
+ * @param data - The array to filter.
+ * @signature
+ *    P.unique(array)
+ * @example
+ *    P.unique([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]
+ * @dataFirst
+ * @lazy
+ * @category Array
+ */
+declare function unique<T extends IterableContainer>(data: T): Deduped<T>;
+/**
+ * Returns a new array containing only one copy of each element in the original
+ * list. Elements are compared by reference using Set.
+ *
+ * @signature
+ *    P.unique()(array)
+ * @example
+ *    P.pipe(
+ *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations
+ *      P.unique(),
+ *      P.take(3)
+ *    ) // => [1, 2, 5]
+ * @dataLast
+ * @lazy
+ * @category Array
+ */
+declare function unique(): <T extends IterableContainer>(data: T) => Deduped<T>;
+//#endregion
+export { unique };
+//# sourceMappingURL=unique.d.ts.map

package/dist/unique.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.d.ts","names":[],"sources":["../src/unique.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmBA;;;;;;AAkBA;;;;;AAA2E,iBAlB3D,MAkB2D,CAAA,UAlB1C,iBAkB0C,CAAA,CAAA,IAAA,EAlBjB,CAkBiB,CAAA,EAlBb,OAkBa,CAlBL,CAkBK,CAAA;;;;;;;;;;;;;;;;;iBAA3D,MAAA,CAAA,cAAqB,yBAAyB,MAAM,QAAQ"}

package/dist/unique.js

@@ -1 +1,2 @@
-import"./utility-evaluators-CnQVdcZv.js";import"./pipe-CtsfTnqv.js";import"./curry-from-lazy-BR-hoRDR.js";import{unique as e}from"./unique-BiGTIN5e.js";export{e as unique};
+import{t as e}from"./utility-evaluators-BwYLtB8b.js";import{t}from"./curry-from-lazy-CYtJvyas.js";function n(...e){return t(r,e)}function r(){let t=new Set;return n=>t.has(n)?e:(t.add(n),{done:!1,hasNext:!0,next:n})}export{n as unique};
+//# sourceMappingURL=unique.js.map

package/dist/unique.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.js","names":[],"sources":["../src/unique.ts"],"sourcesContent":["import type { Deduped } from './internal/types/deduped';\nimport type { IterableContainer } from './internal/types/iterable-container';\nimport type { LazyEvaluator } from './internal/types/lazy-evaluator';\nimport { curryFromLazy } from './internal/curry-from-lazy';\nimport { SKIP_ITEM } from './internal/utility-evaluators';\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @param data - The array to filter.\n * @signature\n *    P.unique(array)\n * @example\n *    P.unique([1, 2, 2, 5, 1, 6, 7]) // => [1, 2, 5, 6, 7]\n * @dataFirst\n * @lazy\n * @category Array\n */\nexport function unique<T extends IterableContainer>(data: T): Deduped<T>;\n\n/**\n * Returns a new array containing only one copy of each element in the original\n * list. Elements are compared by reference using Set.\n *\n * @signature\n *    P.unique()(array)\n * @example\n *    P.pipe(\n *      [1, 2, 2, 5, 1, 6, 7], // only 4 iterations\n *      P.unique(),\n *      P.take(3)\n *    ) // => [1, 2, 5]\n * @dataLast\n * @lazy\n * @category Array\n */\nexport function unique(): <T extends IterableContainer>(data: T) => Deduped<T>;\n\nexport function unique(...args: ReadonlyArray<unknown>): unknown {\n  return curryFromLazy(lazyImplementation, args);\n}\n\nfunction lazyImplementation<T>(): LazyEvaluator<T> {\n  const set = new Set<T>();\n  return (value) => {\n    if (set.has(value)) {\n      return SKIP_ITEM;\n    }\n    set.add(value);\n    return { done: false, hasNext: true, next: value };\n  };\n}\n"],"mappings":"kGAuCA,SAAgB,EAAO,GAAG,EAAuC,CAC/D,OAAO,EAAc,EAAoB,EAAK,CAGhD,SAAS,GAA0C,CACjD,IAAM,EAAM,IAAI,IAChB,MAAQ,IACF,EAAI,IAAI,EAAM,CACT,GAET,EAAI,IAAI,EAAM,CACP,CAAE,KAAM,GAAO,QAAS,GAAM,KAAM,EAAO"}

package/dist/upsert-prop-P-aJDDII.d.cts

@@ -0,0 +1,9 @@
+import { t as IsUnion } from "./is-union-Dp9mCo1b.cjs";
+import { IsLiteral, Simplify, Writable } from "type-fest";
+
+//#region src/internal/types/upsert-prop.d.ts
+type UpsertProp<T, K extends PropertyKey, V> = Simplify<Omit<T, K> & (IsSingleLiteral<K> extends true ? Writable<Required<Record<K, V>>> : { -readonly [P in keyof T as P extends K ? P : never]: T[P] | V } & { -readonly [P in K as P extends keyof T ? never : P]?: V })>;
+type IsSingleLiteral<K> = IsLiteral<K> extends true ? (IsUnion<K> extends true ? false : true) : false;
+//#endregion
+export { UpsertProp as t };
+//# sourceMappingURL=upsert-prop-P-aJDDII.d.cts.map

package/dist/upsert-prop-P-aJDDII.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upsert-prop-P-aJDDII.d.cts","names":[],"sources":["../src/internal/types/upsert-prop.ts"],"sourcesContent":[],"mappings":";;;;KAGY,wBAAwB,kBAAkB,SAEpD,KAAK,GAAG,MAEL,gBAAgB,kBAEf,SAAS,SAAS,OAAO,GAAG,+BAKN,KAAK,UAAU,IAAI,YAAY,EAAE,KAAK,GAXlE,GAAY,kBAeU,CAfc,IAeT,CAfS,SAAA,MAeO,CAfP,GAAA,KAAA,GAemB,CAfnB,IAewB,CAfxB,EAE7B,CAAA,CAAA;KAmBF,eAnBK,CAAA,CAAA,CAAA,GAoBN,SApBM,CAoBI,CApBJ,CAAA,SAAA,IAAA,GAAA,CAoBuB,OApBvB,CAoB+B,CApB/B,CAAA,SAAA,IAAA,GAAA,KAAA,GAAA,IAAA,CAAA,GAAA,KAAA"}

package/dist/upsert-prop-__xTQQ07.d.ts

@@ -0,0 +1,9 @@
+import { t as IsUnion } from "./is-union-Bu19sEkP.js";
+import { IsLiteral, Simplify, Writable } from "type-fest";
+
+//#region src/internal/types/upsert-prop.d.ts
+type UpsertProp<T, K extends PropertyKey, V> = Simplify<Omit<T, K> & (IsSingleLiteral<K> extends true ? Writable<Required<Record<K, V>>> : { -readonly [P in keyof T as P extends K ? P : never]: T[P] | V } & { -readonly [P in K as P extends keyof T ? never : P]?: V })>;
+type IsSingleLiteral<K> = IsLiteral<K> extends true ? (IsUnion<K> extends true ? false : true) : false;
+//#endregion
+export { UpsertProp as t };
+//# sourceMappingURL=upsert-prop-__xTQQ07.d.ts.map

package/dist/upsert-prop-__xTQQ07.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upsert-prop-__xTQQ07.d.ts","names":[],"sources":["../src/internal/types/upsert-prop.ts"],"sourcesContent":[],"mappings":";;;;KAGY,wBAAwB,kBAAkB,SAEpD,KAAK,GAAG,MAEL,gBAAgB,kBAEf,SAAS,SAAS,OAAO,GAAG,+BAKN,KAAK,UAAU,IAAI,YAAY,EAAE,KAAK,GAXlE,GAAY,kBAeU,CAfc,IAeT,CAfS,SAAA,MAeO,CAfP,GAAA,KAAA,GAemB,CAfnB,IAewB,CAfxB,EAE7B,CAAA,CAAA;KAmBF,eAnBK,CAAA,CAAA,CAAA,GAoBN,SApBM,CAoBI,CApBJ,CAAA,SAAA,IAAA,GAAA,CAoBuB,OApBvB,CAoB+B,CApB/B,CAAA,SAAA,IAAA,GAAA,KAAA,GAAA,IAAA,CAAA,GAAA,KAAA"}

package/dist/utility-evaluators-BwYLtB8b.js

@@ -0,0 +1,2 @@
+const e={done:!0,hasNext:!1},t={done:!1,hasNext:!1};function n(){return e}function r(e){return{hasNext:!0,next:e,done:!1}}export{n,r,t};
+//# sourceMappingURL=utility-evaluators-BwYLtB8b.js.map