@vinicunca/perkakas 0.5.4 → 1.0.0

package/dist/to-pascal-case.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkI7I54DAZcjs = require('./chunk-I7I54DAZ.cjs');require('./chunk-WPGWO7LA.cjs');exports.toPascalCase = _chunkI7I54DAZcjs.a;

package/dist/to-pascal-case.d.cts

@@ -0,0 +1,29 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.cjs';
+
+/**
+ * Convert a string to pascal case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, an underscore will be injected before the numbers.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toPascalCase(str)
+ * @example
+ *   toPascalCase('test'); // => 'Test'
+ *   toPascalCase('test string'); // => 'TestString'
+ *   toPascalCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toPascalCase('testV2', { separateNumbers: true }); // => 'TestV_2'
+ *   toPascalCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toPascalCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ *   toPascalCase('version 1.2.10', { mergeAmbiguousCharacters: true }); // => 'Version1210'
+ * @category String
+ */
+declare function toPascalCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toPascalCase };

package/dist/to-pascal-case.d.ts

@@ -0,0 +1,29 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.js';
+
+/**
+ * Convert a string to pascal case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, an underscore will be injected before the numbers.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toPascalCase(str)
+ * @example
+ *   toPascalCase('test'); // => 'Test'
+ *   toPascalCase('test string'); // => 'TestString'
+ *   toPascalCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toPascalCase('testV2', { separateNumbers: true }); // => 'TestV_2'
+ *   toPascalCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toPascalCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ *   toPascalCase('version 1.2.10', { mergeAmbiguousCharacters: true }); // => 'Version1210'
+ * @category String
+ */
+declare function toPascalCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toPascalCase };

package/dist/to-pascal-case.js

@@ -0,0 +1 @@
+import{a}from"./chunk-JL33LZPL.js";import"./chunk-YD2H56BT.js";export{a as toPascalCase};

package/dist/to-pascal-snake-case.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkG6SFG3W4cjs = require('./chunk-G6SFG3W4.cjs');require('./chunk-MQGR4WQQ.cjs');require('./chunk-WPGWO7LA.cjs');exports.toPascalSnakeCase = _chunkG6SFG3W4cjs.a;

package/dist/to-pascal-snake-case.d.cts

@@ -0,0 +1,28 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.cjs';
+
+/**
+ * Convert a string to kebab case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toPascalSnakeCase(str)
+ * @example
+ *   toPascalSnakeCase('test'); // => 'Test'
+ *   toPascalSnakeCase('test string'); // => 'Test_String'
+ *   toPascalSnakeCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toPascalSnakeCase('testV2', { separateNumbers: true }); // => 'Test_V_2'
+ *   toPascalSnakeCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toPascalSnakeCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ * @category String
+ */
+declare function toPascalSnakeCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toPascalSnakeCase };

package/dist/to-pascal-snake-case.d.ts

@@ -0,0 +1,28 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.js';
+
+/**
+ * Convert a string to kebab case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toPascalSnakeCase(str)
+ * @example
+ *   toPascalSnakeCase('test'); // => 'Test'
+ *   toPascalSnakeCase('test string'); // => 'Test_String'
+ *   toPascalSnakeCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toPascalSnakeCase('testV2', { separateNumbers: true }); // => 'Test_V_2'
+ *   toPascalSnakeCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toPascalSnakeCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ * @category String
+ */
+declare function toPascalSnakeCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toPascalSnakeCase };

package/dist/to-pascal-snake-case.js

@@ -0,0 +1 @@
+import{a}from"./chunk-MA4ZCOG3.js";import"./chunk-R5K7KY5K.js";import"./chunk-YD2H56BT.js";export{a as toPascalSnakeCase};

package/dist/to-sentence-case.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkJWNYA3DDcjs = require('./chunk-JWNYA3DD.cjs');require('./chunk-WPGWO7LA.cjs');exports.toSentenceCase = _chunkJWNYA3DDcjs.a;

package/dist/to-sentence-case.d.cts

@@ -0,0 +1,28 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.cjs';
+
+/**
+ * Convert a string to sentence case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toSentenceCase(str)
+ * @example
+ *   toSentenceCase('test'); // => 'Test'
+ *   toSentenceCase('test string'); // => 'Test string'
+ *   toSentenceCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toSentenceCase('testV2', { separateNumbers: true }); // => 'Test v 2'
+ *   toSentenceCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toSentenceCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ * @category String
+ */
+declare function toSentenceCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toSentenceCase };

package/dist/to-sentence-case.d.ts

@@ -0,0 +1,28 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.js';
+
+/**
+ * Convert a string to sentence case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toSentenceCase(str)
+ * @example
+ *   toSentenceCase('test'); // => 'Test'
+ *   toSentenceCase('test string'); // => 'Test string'
+ *   toSentenceCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toSentenceCase('testV2', { separateNumbers: true }); // => 'Test v 2'
+ *   toSentenceCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toSentenceCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ * @category String
+ */
+declare function toSentenceCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toSentenceCase };

package/dist/to-sentence-case.js

@@ -0,0 +1 @@
+import{a}from"./chunk-6GVFMZ2X.js";import"./chunk-YD2H56BT.js";export{a as toSentenceCase};

package/dist/to-snake-case.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunk2ETHJVG3cjs = require('./chunk-2ETHJVG3.cjs');require('./chunk-7QAJO3GY.cjs');require('./chunk-WPGWO7LA.cjs');exports.toSnakeCase = _chunk2ETHJVG3cjs.a;

package/dist/to-snake-case.d.cts

@@ -0,0 +1,28 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.cjs';
+
+/**
+ * Convert a string to sentence case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toSnakeCase(str)
+ * @example
+ *   toSnakeCase('test'); // => 'test'
+ *   toSnakeCase('test string'); // => 'test_string'
+ *   toSnakeCase('test string', { delimiter: '$' }); // => 'test$string'
+ *   toSnakeCase('testV2', { separateNumbers: true }); // => 'test_v_2'
+ *   toSnakeCase('__typename', { prefixCharacters: '_' }); // => '__typename'
+ *   toSnakeCase('type__', { suffixCharacters: '_' }); // => 'type__'
+ * @category String
+ */
+declare function toSnakeCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toSnakeCase };

package/dist/to-snake-case.d.ts

@@ -0,0 +1,28 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.js';
+
+/**
+ * Convert a string to sentence case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toSnakeCase(str)
+ * @example
+ *   toSnakeCase('test'); // => 'test'
+ *   toSnakeCase('test string'); // => 'test_string'
+ *   toSnakeCase('test string', { delimiter: '$' }); // => 'test$string'
+ *   toSnakeCase('testV2', { separateNumbers: true }); // => 'test_v_2'
+ *   toSnakeCase('__typename', { prefixCharacters: '_' }); // => '__typename'
+ *   toSnakeCase('type__', { suffixCharacters: '_' }); // => 'type__'
+ * @category String
+ */
+declare function toSnakeCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toSnakeCase };

package/dist/to-snake-case.js

@@ -0,0 +1 @@
+import{a}from"./chunk-IKXLQXFZ.js";import"./chunk-CUJA7FM4.js";import"./chunk-YD2H56BT.js";export{a as toSnakeCase};

package/dist/to-train-case.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkON6MMTUNcjs = require('./chunk-ON6MMTUN.cjs');require('./chunk-MQGR4WQQ.cjs');require('./chunk-WPGWO7LA.cjs');exports.toTrainCase = _chunkON6MMTUNcjs.a;

package/dist/to-train-case.d.cts

@@ -0,0 +1,28 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.cjs';
+
+/**
+ * Convert a string to sentence case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toTrainCase(str)
+ * @example
+ *   toTrainCase('test'); // => 'Test'
+ *   toTrainCase('test string'); // => 'Test-String'
+ *   toTrainCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toTrainCase('testV2', { separateNumbers: true }); // => 'Test-V-2'
+ *   toTrainCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toTrainCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ * @category String
+ */
+declare function toTrainCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toTrainCase };

package/dist/to-train-case.d.ts

@@ -0,0 +1,28 @@
+import { C as ChangeCaseOptions } from './case.types-C6kHRY4f.js';
+
+/**
+ * Convert a string to sentence case.
+ *
+ * @param input the string to convert
+ * @param options - Optional configuration for the conversion.
+ * @param options.delimiter - The delimiter to use between words.
+ * @param options.separateNumbers - If true, numbers will be separated.
+ * @param options.prefixCharacters - The prefix characters that we want to ignore.
+ * @param options.suffixCharacters - The suffix characters that we want to ignore.
+ * @param options.splitFn - A custom split function to separated the words.
+ * @param options.mergeAmbiguousCharacters - If true, merges ambiguous characters.
+ *
+ * @signature
+ *   toTrainCase(str)
+ * @example
+ *   toTrainCase('test'); // => 'Test'
+ *   toTrainCase('test string'); // => 'Test-String'
+ *   toTrainCase('test string', { delimiter: '$' }); // => 'Test$String'
+ *   toTrainCase('testV2', { separateNumbers: true }); // => 'Test-V-2'
+ *   toTrainCase('__typename', { prefixCharacters: '_' }); // => '__Typename'
+ *   toTrainCase('type__', { suffixCharacters: '_' }); // => 'Type__'
+ * @category String
+ */
+declare function toTrainCase(input: string, options?: ChangeCaseOptions): string;
+
+export { toTrainCase };

package/dist/to-train-case.js

@@ -0,0 +1 @@
+import{a}from"./chunk-N4VSV73E.js";import"./chunk-R5K7KY5K.js";import"./chunk-YD2H56BT.js";export{a as toTrainCase};

package/dist/types-DCY4LHuA.d.cts

@@ -0,0 +1,102 @@
+import { IsAny, Simplify, IsLiteral, IsNever } from 'type-fest';
+
+declare const __brand: unique symbol;
+type Branded<T, Brand extends symbol> = T & {
+    [__brand]: Brand;
+};
+type NonEmptyArray<T> = [T, ...Array<T>];
+type Mapped<T extends IterableContainer, K> = {
+    -readonly [P in keyof T]: K;
+};
+/**
+ * This should only be used for defining generics which extend any kind of JS
+ * array under the hood, this includes arrays *AND* tuples (of the form [x, y],
+ * and of the form [x, ...y[]], etc...), and their readonly equivalent. This
+ * allows us to be more inclusive to what functions can process.
+ *
+ * @example map<T extends ArrayLike>(items: T) { ... }
+ *
+ * We would've named this `ArrayLike`, but that's already used by typescript...
+ * @see This was inspired by the type-definition of Promise.all (https://github.com/microsoft/TypeScript/blob/1df5717b120cddd325deab8b0f2b2c3eecaf2b01/src/lib/es2015.promise.d.ts#L21)
+ */
+type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
+/**
+ * Define a Simple record as one that doesn't define it's properties beyond
+ * their general type. This is the case for string and number keys (and their
+ * combination). Another way of thinking about simple records is that the number
+ * of properties are unbound (they can be empty, or they can have 1000 props).
+ */
+type IfSimpleRecord<T, TypeIfSimpleRecord = true, TypeIfNotSimpleRecord = false> = string extends keyof T ? TypeIfSimpleRecord : number extends keyof T ? TypeIfSimpleRecord : number | string extends keyof T ? TypeIfSimpleRecord : TypeIfNotSimpleRecord;
+/**
+ * A union of all keys of T which are not symbols, and where number keys are
+ * converted to strings, following the definition of `Object.keys` and
+ * `Object.entries`.
+ *
+ * Inspired and largely copied from [`sindresorhus/ts-extras`](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-keys.ts).
+ *
+ * @see EnumerableStringKeyedValueOf
+ */
+type EnumerableStringKeyOf<T> = `${Exclude<keyof T, symbol>}`;
+/**
+ * A union of all values of properties in T which are not keyed by a symbol,
+ * following the definition of `Object.values` and `Object.entries`.
+ */
+type EnumerableStringKeyedValueOf<T> = {
+    [K in keyof T]-?: K extends symbol ? never : T[K];
+}[keyof T];
+/**
+ * This is the type you'd get from doing:
+ * `Object.fromEntries(Object.entries(x))`.
+ */
+type ReconstructedRecord<T> = Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>;
+/**
+ * An extension of Extract for type predicates which falls back to the base
+ * in order to narrow the `unknown` case.
+ *
+ * @example
+ *   function isMyType<T>(data: T | MyType): data is NarrowedTo<T, MyType> { ... }
+ */
+type NarrowedTo<T, Base> = Extract<T, Base> extends never ? Base : IsAny<T> extends true ? Base : Extract<T, Base>;
+/**
+ * Records keyed with generic `string` and `number`
+ * have different semantics to those with a a union of literal values
+ * (e.g. 'cat' | 'dog') when using 'noUncheckedIndexedAccess',
+ * the former being implicitly `Partial` whereas the latter are implicitly `Required`.
+ */
+type ExactRecord<Key extends PropertyKey, Value> = IfSimpleRecord<Record<Key, Value>, 
+/**
+ * If either string or number extend Key it means that Key is at least as wide as them,
+ * so we don't need to wrap the returned record with Partial.
+ */
+Record<Key, Value>, 
+/**
+ * If the key is specific, e.g. 'cat' | 'dog', the result is partial
+ * because we can't statically know what values the mapper would return on
+ * a specific input.
+ */
+Partial<Record<Key, Value>>>;
+type ReorderedArray<T extends IterableContainer> = {
+    -readonly [P in keyof T]: T[number];
+};
+type UpsertProp<T, K extends PropertyKey, V> = Simplify<Omit<T, K> & (IsSingleLiteral<K> extends true ? {
+    -readonly [P in K]-?: V;
+} : // The key is either a broad type (`string`) or union of literals
+{
+    -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;
+})>;
+/**
+ * This type attempts to detect when a type is a single literal value
+ * (e.g. "cat"), and not anything else (e.g. "cat" | "dog", string, etc...)
+ */
+type IsSingleLiteral<K> = IsLiteral<K> extends true ? (IsUnion<K> extends true ? false : true) : false;
+/**
+ * This is copied from type-fest because currently
+ * it isn't exported.
+ * TODO: Check whenever this type is exported.
+ */
+type IsUnion<T> = InternalIsUnion<T>;
+type InternalIsUnion<T, U = T> = (IsNever<T> extends true ? false : T extends any ? [U] extends [T] ? false : true : never) extends infer Result ? boolean extends Result ? true : Result : never;
+
+export type { Branded as B, EnumerableStringKeyedValueOf as E, IterableContainer as I, Mapped as M, NonEmptyArray as N, ReconstructedRecord as R, UpsertProp as U, EnumerableStringKeyOf as a, ExactRecord as b, NarrowedTo as c, IsUnion as d, IfSimpleRecord as e, ReorderedArray as f };

package/dist/types-DCY4LHuA.d.ts

@@ -0,0 +1,102 @@
+import { IsAny, Simplify, IsLiteral, IsNever } from 'type-fest';
+
+declare const __brand: unique symbol;
+type Branded<T, Brand extends symbol> = T & {
+    [__brand]: Brand;
+};
+type NonEmptyArray<T> = [T, ...Array<T>];
+type Mapped<T extends IterableContainer, K> = {
+    -readonly [P in keyof T]: K;
+};
+/**
+ * This should only be used for defining generics which extend any kind of JS
+ * array under the hood, this includes arrays *AND* tuples (of the form [x, y],
+ * and of the form [x, ...y[]], etc...), and their readonly equivalent. This
+ * allows us to be more inclusive to what functions can process.
+ *
+ * @example map<T extends ArrayLike>(items: T) { ... }
+ *
+ * We would've named this `ArrayLike`, but that's already used by typescript...
+ * @see This was inspired by the type-definition of Promise.all (https://github.com/microsoft/TypeScript/blob/1df5717b120cddd325deab8b0f2b2c3eecaf2b01/src/lib/es2015.promise.d.ts#L21)
+ */
+type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
+/**
+ * Define a Simple record as one that doesn't define it's properties beyond
+ * their general type. This is the case for string and number keys (and their
+ * combination). Another way of thinking about simple records is that the number
+ * of properties are unbound (they can be empty, or they can have 1000 props).
+ */
+type IfSimpleRecord<T, TypeIfSimpleRecord = true, TypeIfNotSimpleRecord = false> = string extends keyof T ? TypeIfSimpleRecord : number extends keyof T ? TypeIfSimpleRecord : number | string extends keyof T ? TypeIfSimpleRecord : TypeIfNotSimpleRecord;
+/**
+ * A union of all keys of T which are not symbols, and where number keys are
+ * converted to strings, following the definition of `Object.keys` and
+ * `Object.entries`.
+ *
+ * Inspired and largely copied from [`sindresorhus/ts-extras`](https://github.com/sindresorhus/ts-extras/blob/44f57392c5f027268330771996c4fdf9260b22d6/source/object-keys.ts).
+ *
+ * @see EnumerableStringKeyedValueOf
+ */
+type EnumerableStringKeyOf<T> = `${Exclude<keyof T, symbol>}`;
+/**
+ * A union of all values of properties in T which are not keyed by a symbol,
+ * following the definition of `Object.values` and `Object.entries`.
+ */
+type EnumerableStringKeyedValueOf<T> = {
+    [K in keyof T]-?: K extends symbol ? never : T[K];
+}[keyof T];
+/**
+ * This is the type you'd get from doing:
+ * `Object.fromEntries(Object.entries(x))`.
+ */
+type ReconstructedRecord<T> = Record<EnumerableStringKeyOf<T>, EnumerableStringKeyedValueOf<T>>;
+/**
+ * An extension of Extract for type predicates which falls back to the base
+ * in order to narrow the `unknown` case.
+ *
+ * @example
+ *   function isMyType<T>(data: T | MyType): data is NarrowedTo<T, MyType> { ... }
+ */
+type NarrowedTo<T, Base> = Extract<T, Base> extends never ? Base : IsAny<T> extends true ? Base : Extract<T, Base>;
+/**
+ * Records keyed with generic `string` and `number`
+ * have different semantics to those with a a union of literal values
+ * (e.g. 'cat' | 'dog') when using 'noUncheckedIndexedAccess',
+ * the former being implicitly `Partial` whereas the latter are implicitly `Required`.
+ */
+type ExactRecord<Key extends PropertyKey, Value> = IfSimpleRecord<Record<Key, Value>, 
+/**
+ * If either string or number extend Key it means that Key is at least as wide as them,
+ * so we don't need to wrap the returned record with Partial.
+ */
+Record<Key, Value>, 
+/**
+ * If the key is specific, e.g. 'cat' | 'dog', the result is partial
+ * because we can't statically know what values the mapper would return on
+ * a specific input.
+ */
+Partial<Record<Key, Value>>>;
+type ReorderedArray<T extends IterableContainer> = {
+    -readonly [P in keyof T]: T[number];
+};
+type UpsertProp<T, K extends PropertyKey, V> = Simplify<Omit<T, K> & (IsSingleLiteral<K> extends true ? {
+    -readonly [P in K]-?: V;
+} : // The key is either a broad type (`string`) or union of literals
+{
+    -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;
+})>;
+/**
+ * This type attempts to detect when a type is a single literal value
+ * (e.g. "cat"), and not anything else (e.g. "cat" | "dog", string, etc...)
+ */
+type IsSingleLiteral<K> = IsLiteral<K> extends true ? (IsUnion<K> extends true ? false : true) : false;
+/**
+ * This is copied from type-fest because currently
+ * it isn't exported.
+ * TODO: Check whenever this type is exported.
+ */
+type IsUnion<T> = InternalIsUnion<T>;
+type InternalIsUnion<T, U = T> = (IsNever<T> extends true ? false : T extends any ? [U] extends [T] ? false : true : never) extends infer Result ? boolean extends Result ? true : Result : never;
+
+export type { Branded as B, EnumerableStringKeyedValueOf as E, IterableContainer as I, Mapped as M, NonEmptyArray as N, ReconstructedRecord as R, UpsertProp as U, EnumerableStringKeyOf as a, ExactRecord as b, NarrowedTo as c, IsUnion as d, IfSimpleRecord as e, ReorderedArray as f };

package/dist/unique-by.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkDWPHE3F2cjs = require('./chunk-DWPHE3F2.cjs');require('./chunk-NLX7PGPI.cjs');require('./chunk-I6VXEY44.cjs');require('./chunk-3X6SAJDQ.cjs');exports.uniqueBy = _chunkDWPHE3F2cjs.a;

package/dist/unique-by.d.cts

@@ -0,0 +1,38 @@
+/**
+ * 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, K>(data: ReadonlyArray<T>, keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => K): Array<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, K>(keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => K): (data: ReadonlyArray<T>) => Array<T>;
+
+export { uniqueBy };

package/dist/unique-by.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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, K>(data: ReadonlyArray<T>, keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => K): Array<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, K>(keyFunction: (item: T, index: number, data: ReadonlyArray<T>) => K): (data: ReadonlyArray<T>) => Array<T>;
+
+export { uniqueBy };

package/dist/unique-by.js

@@ -0,0 +1 @@
+import{a}from"./chunk-DUKQ2ODK.js";import"./chunk-C6L5NLLB.js";import"./chunk-6ALZHU2N.js";import"./chunk-MYLYERXO.js";export{a as uniqueBy};

package/dist/unique-with.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkXQOKSJ5Rcjs = require('./chunk-XQOKSJ5R.cjs');require('./chunk-NLX7PGPI.cjs');require('./chunk-I6VXEY44.cjs');require('./chunk-3X6SAJDQ.cjs');exports.uniqueWith = _chunkXQOKSJ5Rcjs.a;