@vinicunca/perkakas 1.14.0 → 1.16.0

package/dist/index.d.ts

@@ -1395,65 +1395,6 @@ type K = IsLiteral<boolean>;
 */
 type IsLiteral<T> = IsPrimitive<T> extends true ? IsNotFalse<IsLiteralUnion<T>> : false;
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/is-null.d.ts
-/**
-Returns a boolean for whether the given type is `null`.
-
-@example
-```
-import type {IsNull} from 'type-fest';
-
-type NonNullFallback<T, Fallback> = IsNull<T> extends true ? Fallback : T;
-
-type Example1 = NonNullFallback<null, string>;
-//=> string
-
-type Example2 = NonNullFallback<number, string>;
-//=> number
-```
-
-@category Type Guard
-@category Utilities
-*/
-type IsNull<T> = [T] extends [null] ? true : false;
-//#endregion
-//#region node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/is-unknown.d.ts
-/**
-Returns a boolean for whether the given type is `unknown`.
-
-@link https://github.com/dsherret/conditional-type-checks/pull/16
-
-Useful in type utilities, such as when dealing with unknown data from API calls.
-
-@example
-```
-import type {IsUnknown} from 'type-fest';
-
-type A = IsUnknown<unknown>;
-//=> true
-
-type B = IsUnknown<any>;
-//=> false
-
-type C = IsUnknown<never>;
-//=> false
-
-type D = IsUnknown<unknown[]>;
-//=> false
-
-type E = IsUnknown<object>;
-//=> false
-
-type F = IsUnknown<string>;
-//=> false
-```
-
-@category Utilities
-*/
-type IsUnknown<T> = (unknown extends T // `T` can be `unknown` or `any`
-? IsNull<T> extends false // `any` can be `null`, but `unknown` can't be
-? true : false : false);
-//#endregion
 //#region node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/tuple-of.d.ts
 /**
 Create a tuple type of the specified length with elements of the specified type.
@@ -4166,100 +4107,6 @@ type ArraySliceHelper<Array_ extends readonly unknown[], Start extends number =
 ? 0 : GreaterThan<AddResult, 0> extends true ? AddResult : 0 : never : Start), PositiveE extends number = (IsNegative<End> extends true ? Sum$1<ArrayLength, End> : End)> = true extends [IsNegative<PositiveS>, LessThanOrEqual<PositiveE, PositiveS>, GreaterThanOrEqual<PositiveS, ArrayLength>][number] ? [] : ArraySliceByPositiveIndex<Array_, TupleMin<[PositiveS, ArrayLength]>, TupleMin<[PositiveE, ArrayLength]>>;
 type ArraySliceByPositiveIndex<Array_ extends readonly unknown[], Start extends number, End extends number, Result extends Array<Array_[number]> = []> = Start extends End ? Result : ArraySliceByPositiveIndex<Array_, Sum$1<Start, 1>, End, [...Result, Array_[Start]]>;
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/fixed-length-array.d.ts
-/**
-Methods to exclude.
-*/
-type ArrayLengthMutationKeys = 'splice' | 'push' | 'pop' | 'shift' | 'unshift';
-/**
-Create a type that represents an array of the given type and length. The `Array` prototype methods that manipulate its length are excluded from the resulting type.
-
-The problem with the built-in tuple type is that it allows mutating methods like `push`, `pop` etc, which can cause issues, like in the following example:
-
-@example
-```
-const color: [number, number, number] = [255, 128, 64];
-
-function toHex([r, g, b]: readonly [number, number, number]) {
-	return `#${r.toString(16)}${g.toString(16)}${b.toString(16)}`;
-}
-
-color.pop(); // Allowed
-
-console.log(toHex(color)); // Compiles fine, but fails at runtime since index `2` no longer contains a `number`.
-```
-
-`ArrayLengthMutationKeys` solves this problem by excluding methods like `push`, `pop` etc from the resulting type.
-
-@example
-```
-import type {FixedLengthArray} from 'type-fest';
-
-const color: FixedLengthArray<number, 3> = [255, 128, 64];
-
-// @ts-expect-error
-color.pop();
-// Error: Property 'pop' does not exist on type 'FixedLengthArray<number, 3>'.
-```
-
-Use-cases:
-- Declaring fixed-length tuples or arrays with a large number of items.
-- Creating an array of coordinates with a static length, for example, length of 3 for a 3D vector.
-
-@example
-```
-import type {FixedLengthArray} from 'type-fest';
-
-let color: FixedLengthArray<number, 3> = [255, 128, 64];
-
-const red = color[0];
-//=> number
-const green = color[1];
-//=> number
-const blue = color[2];
-//=> number
-
-// @ts-expect-error
-const alpha = color[3];
-// Error: Property '3' does not exist on type 'FixedLengthArray<number, 3>'.
-
-// You can write to valid indices.
-color[0] = 128;
-color[1] = 64;
-color[2] = 32;
-
-// But you cannot write to out-of-bounds indices.
-// @ts-expect-error
-color[3] = 0.5;
-// Error: Property '3' does not exist on type 'FixedLengthArray<number, 3>'.
-
-// @ts-expect-error
-color.push(0.5);
-// Error: Property 'push' does not exist on type 'FixedLengthArray<number, 3>'.
-
-// @ts-expect-error
-color = [0, 128, 255, 0.5];
-// Error: Type '[number, number, number, number]' is not assignable to type 'FixedLengthArray<number, 3>'. Types of property 'length' are incompatible.
-
-// @ts-expect-error
-color.length = 4;
-// Error: Cannot assign to 'length' because it is a read-only property.
-
-function toHex([r, g, b]: readonly [number, number, number]) {
-	return `#${r.toString(16)}${g.toString(16)}${b.toString(16)}`;
-}
-
-console.log(toHex(color)); // `FixedLengthArray<number, 3>` is assignable to `readonly [number, number, number]`.
-```
-
-@category Array
-*/
-type FixedLengthArray<Element, Length extends number> = Except<TupleOf<Length, Element>, ArrayLengthMutationKeys | number | 'length'> & {
-  readonly length: Length;
-} & (number extends Length ? {
-  [n: number]: Element;
-} : {});
-//#endregion
 //#region node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/int-range.d.ts
 /**
 Generate a union of numbers between a specified start (inclusive) and end (exclusive), with an optional step.
@@ -5117,7 +4964,7 @@ type TuplePartsWithoutRequired<T extends IterableContainer, Suffix extends Array
    */
   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 ? {
+type TuplePartsWithoutFixed<T extends IterableContainer, Optional extends Array<unknown> = []> = T extends readonly [(infer Head)?, ...infer Tail] ? (T extends readonly [] ? true : 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
@@ -5521,7 +5368,7 @@ declare function constant<const T>(value: T): <Args extends ReadonlyArray<unknow
  *
  * [For an interactive deeper dive and explanation see the following playground](https://www.typescriptlang.org/play/?noUncheckedIndexedAccess=true#code/PTAEBUAsEsGdQE4FMDGB7BATUdQCIAjNAVwDtMlM8AaHAF1EgEN4nQAzaU6OpUWJAzTtQAayQBPWADpQASQZMANrDSIkAR2LRk8HgHJYAKBCg0BAFaoGdNcwBufZUrMi6kJAFtpRuhIAOfABCJOSUoAC8oABKqBiYADwABv7InAAeAPoAJADeeB5KSmh4oAA++ADuGEpUAL5JtHiqnoIwpADmeAB8ANxGJmBQuMjoWDjweGREZBRUtDyMLKBMpDiknNy8-IKuoP5osLDQBEp84lKyCoaDZpbWoOjEtY9opHRMXKCkb3zCoO4vAC0GgfH5AqAAKqkGZhbBRWJjRIpNLQLJ5WB0BBcDoNJotNo4nr9W4AMQwK1IEggAC4IKAkOleOR4AAFJgIOjQZQJcDdUAEakUTZct60AjEGwedaOBACCbfNCKJSVJhSW5Y4hIWQAdQ8a0WuE1fEqfBQq34aoBzAY4AV0E8-iU0BQPCU1P8HK5ylAAApDcZTJptPZlEh3sDQOzOdylLzugBKXwBPhyWByR3O110d3R71xvmRKNe2PxhlM8OYeB2gD8+AkpTpeFIeBJpj14ZWKBQSCOOJW+wQaH8e0BAtCczuVhQtpTAGUUNj-AxzWtw7BiMhrUwGKlh7dGXA6Ho1mPzNPFOQGaQN1uePBwdqjBQUEoOWa3pjQEEAPKQgByAAiACigF0iEsyUP06A3gwsKTlEv4ASBgEANp4KkSAZJkhTFHgAC6-SmKAJEAHo1gM7b6l2PZ9p0A57iO-xjtME7hOe1i0JU1H6D80IoB4KDiJgchhOklAAILdr2sBJLcuDhkwpzhOA86LtAy6PBabzutet4mjaAIpvQoAAFSeNAHSQHQpkCkg4qSisKhoLcMHHBQCDWmaLAGUgd4MJgaC9qQ+gMIeX5fGe9wzrQqgmU8LzKHFBBILcSSQZslBJD4L5vlubkMABSFAaBdLQvBUFGAVoCsZB8JQv+xUoehmHYbhJSEbcJGgORlFDDAegPggWocBSpmmasEjjYOw57EVf4lYBvSgNxLqQKArSrA+hnODN-jwMItzzchoErFueDDqKpDKDQK0wAJCqMkwM66dxO6gEkealo+-zHYt3RyaYm03jsnirFy5pFBIy1xaa+jYIygQztaRpqMgdCbms+gSPoDkMIs6OY-AvH6AAhMmEJpuVbEiZmLpuhIX0+lEaYZk69M5ozJY8tTdV9F1PUUbcervbt7i4MDg3bvjaxg1SWkCLAtC9kjsa6e4hx8O4726MwEKrLcHHI6aG2WdZ3xIOEthLOQZzjnVlLYLVcLqEi8ACJ6CA7u6tCrJgrmrKF6i6W8OB09mrx+a6n7K44azcZ2gLUmD4g7De2rSD4QA).
  */
-type IsBounded<T> = (T extends unknown ? Or<IsBoundedString<T>, Or<IsNumericLiteral<T>, IsSymbolLiteral<T>>> : never) extends true ? true : false;
+type IsBounded<T> = (T extends unknown ? IsBoundedString<T> extends true ? true : IsNumericLiteral<T> extends true ? true : IsSymbolLiteral<T> extends true ? true : false : never) extends true ? true : false;
 /**
  * Literal strings can be unbounded when they are a template literal which
  * contains non-literal components (e.g. `prefix_${string}`), this is because
@@ -5986,6 +5833,11 @@ type DropFixedTuple<T, N, IncludePrefixes = false, Dropped extends Array<unknown
 /**
  * Removes first `n` elements from the `array`.
  *
+ * Related operations:
+ * - `dropLast` - same, but from the end of the array.
+ * - `splice` - to remove or insert at an arbitrary index.
+ * - `take` - to keep the first `n` instead.
+ *
  * @param array - The target array.
  * @param n - The number of elements to skip.
  * @signature
@@ -6000,6 +5852,11 @@ declare function drop<T extends IterableContainer, N extends number>(array: T, n
 /**
  * Removes first `n` elements from the `array`.
  *
+ * Related operations:
+ * - `dropLast` - same, but from the end of the array.
+ * - `splice` - to remove or insert at an arbitrary index.
+ * - `take` - to keep the first `n` instead.
+ *
  * @param n - The number of elements to skip.
  * @signature
  *    drop(n)(array)
@@ -6096,6 +5953,11 @@ declare function dropFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<Orde
 /**
  * Removes last `n` elements from the `array`.
  *
+ * Related operations:
+ * - `drop` - same, but from the start of the array.
+ * - `splice` - to remove or insert at an arbitrary index.
+ * - `takeLast` - to keep the last `n` instead.
+ *
  * @param array - The target array.
  * @param n - The number of elements to skip.
  * @signature
@@ -6109,6 +5971,11 @@ declare function dropLast<T extends IterableContainer>(array: T, n: number): Arr
 /**
  * Removes last `n` elements from the `array`.
  *
+ * Related operations:
+ * - `drop` - same, but from the start of the array.
+ * - `splice` - to remove or insert at an arbitrary index.
+ * - `takeLast` - to keep the last `n` instead.
+ *
  * @param n - The number of elements to skip.
  * @signature
  *    dropLast(n)(array)
@@ -6385,6 +6252,9 @@ type NonRefinedFilteredArray<T extends IterableContainer, IsItemIncluded extends
  * the elements from the given array that pass the test implemented by the
  * provided function. Equivalent to `Array.prototype.filter`.
  *
+ * Related operations:
+ * - `splice` - to shape the array by *position* rather than by *value*.
+ *
  * @param data - The array to filter.
  * @param predicate - A function to execute for each element in the array. It
  * should return `true` to keep the element in the resulting array, and `false`
@@ -6406,6 +6276,9 @@ declare function filter<T extends IterableContainer, IsItemIncluded extends bool
  * the elements from the given array that pass the test implemented by the
  * provided function. Equivalent to `Array.prototype.filter`.
  *
+ * Related operations:
+ * - `splice` - to shape the array by *position* rather than by *value*.
+ *
  * @param predicate - A function to execute for each element in the array. It
  * should return `true` to keep the element in the resulting array, and `false`
  * otherwise.
@@ -6976,7 +6849,7 @@ type FromEntriesTuple<E, Rest> = E extends Entry ? FromEntries<Rest> & Record<E[
 type FromEntriesArray<Entries extends IterableContainer<Entry>> = string extends AllKeys$1<Entries> ? Record<string, Entries[number][1]> : number extends AllKeys$1<Entries> ? Record<number, Entries[number][1]> : symbol extends AllKeys$1<Entries> ? Record<symbol, Entries[number][1]> : FromEntriesArrayWithLiteralKeys<Entries>;
 type FromEntriesArrayWithLiteralKeys<Entries extends IterableContainer<Entry>> = { [P in AllKeys$1<Entries>]?: ValueForKey<Entries, P> };
 type AllKeys$1<Entries extends IterableContainer<Entry>> = Extract<Entries[number], Entry>[0];
-type ValueForKey<Entries extends IterableContainer<Entry>, K extends PropertyKey> = (Extract<Entries[number], Entry<K>> extends never ? Entries[number] : Extract<Entries[number], Entry<K>>)[1];
+type ValueForKey<Entries extends IterableContainer<Entry>, K extends PropertyKey> = (IsNever<Extract<Entries[number], Entry<K>>> extends true ? Entries[number] : Extract<Entries[number], Entry<K>>)[1];
 /**
  * Creates a new object from an array of tuples by pairing up first and second elements as {[key]: value}.
  * If a tuple is not supplied for any element in the array, the element will be ignored
@@ -7290,10 +7163,10 @@ declare function groupBy<T, Key extends PropertyKey = PropertyKey>(data: Readonl
 declare function groupBy<T, Key extends PropertyKey = PropertyKey>(callbackfn: (value: T, index: number, data: ReadonlyArray<T>) => Key | undefined): (items: ReadonlyArray<T>) => BoundedPartial<Record<Key, NonEmptyArray<T>>>;
 //#endregion
 //#region src/internal/types/array-required-prefix.d.ts
-type ArrayRequiredPrefix<T extends IterableContainer, N extends number> = IsLiteral<N> extends true ? T extends unknown ? ClampedIntegerSubtract<N, [...TupleParts<T>['required'], ...TupleParts<T>['suffix']]['length']> extends infer Remainder extends number ? Remainder extends 0 ? T : And<GreaterThan<Remainder, TupleParts<T>['optional']['length']>, IsNever<TupleParts<T>['item']>> extends true ? PerkakasTypeError<'ArrayRequiredPrefix', 'The input tuple cannot satisfy the minimum', {
+type ArrayRequiredPrefix<T extends IterableContainer, N extends number> = IsLiteral<N> extends true ? T extends unknown ? ClampedIntegerSubtract<N, [...TupleParts<T>['required'], ...TupleParts<T>['suffix']]['length']> extends infer Remainder extends number ? Remainder extends 0 ? T : GreaterThan<Remainder, TupleParts<T>['optional']['length']> extends true ? IsNever<TupleParts<T>['item']> extends true ? PerkakasTypeError<'ArrayRequiredPrefix', 'The input tuple cannot satisfy the minimum', {
   type: never;
   metadata: [T, N];
-}> : WithSameReadonly<T, [...TupleParts<T>['required'], ...OptionalTupleRequiredPrefix<TupleParts<T>['optional'], Remainder>, ...TupleOf<ClampedIntegerSubtract<Remainder, TupleParts<T>['optional']['length']>, TupleParts<T>['item']>, ...CoercedArray<TupleParts<T>['item']>, ...TupleParts<T>['suffix']]> : PerkakasTypeError<'ArrayRequiredPrefix', 'Remainder didn\'t compute to a number?!', {
+}> : ExpandedRequiredPrefix<T, Remainder> : ExpandedRequiredPrefix<T, Remainder> : PerkakasTypeError<'ArrayRequiredPrefix', 'Remainder didn\'t compute to a number?!', {
   type: never;
   metadata: [T, N];
 }> : PerkakasTypeError<'ArrayRequiredPrefix', 'Failed to distribute union?!', {
@@ -7303,6 +7176,7 @@ type ArrayRequiredPrefix<T extends IterableContainer, N extends number> = IsLite
   type: never;
   metadata: N;
 }>;
+type ExpandedRequiredPrefix<T extends IterableContainer, Remainder extends number> = WithSameReadonly<T, [...TupleParts<T>['required'], ...OptionalTupleRequiredPrefix<TupleParts<T>['optional'], Remainder>, ...NTuple<TupleParts<T>['item'], ClampedIntegerSubtract<Remainder, TupleParts<T>['optional']['length']>>, ...CoercedArray<TupleParts<T>['item']>, ...TupleParts<T>['suffix']]>;
 type WithSameReadonly<Source, Destination> = IsEqual$1<Source, Readonly<Source>> extends true ? Readonly<Destination> : Destination;
 type OptionalTupleRequiredPrefix<T extends Array<unknown>, N, Prefix extends Array<unknown> = []> = Prefix['length'] extends N ? [...Prefix, ...Partial<T>] : T extends readonly [infer Head, ...infer Rest] ? OptionalTupleRequiredPrefix<Rest, N, [...Prefix, Head]> : Prefix;
 //#endregion
@@ -7315,7 +7189,7 @@ type ItemsSuperObject<T extends IterableContainer> = AllUnionFields<Exclude<T[nu
 type FixEmptyObject<T> = IsNever<keyof T> extends true ? EmptyObject : T;
 type EnsureValuesAreNonEmpty<T extends Record<PropertyKey, IterableContainer>> = Simplify<Omit<T, PossiblyEmptyArrayKeys<T>> & BoundedPartial<CoercedNonEmptyValues<Pick<T, PossiblyEmptyArrayKeys<T>>>>>;
 type PossiblyEmptyArrayKeys<T extends Record<PropertyKey, IterableContainer>> = keyof T extends infer Key extends unknown ? Key extends keyof T ? IsNonEmptyArray<T[Key]> extends true ? never : Key : never : never;
-type IsNonEmptyArray<T extends IterableContainer> = Or<IsNonEmptyFixedTuple<TupleParts<T>['required']>, IsNonEmptyFixedTuple<TupleParts<T>['suffix']>>;
+type IsNonEmptyArray<T extends IterableContainer> = IsNonEmptyFixedTuple<TupleParts<T>['required']> extends true ? true : IsNonEmptyFixedTuple<TupleParts<T>['suffix']> extends true ? true : false;
 type IsNonEmptyFixedTuple<T> = IsNever<Extract<T, readonly []>>;
 type CoercedNonEmptyValues<T extends Record<PropertyKey, IterableContainer>> = { [P in keyof T]: ArrayRequiredPrefix<T[P], 1> };
 /**
@@ -7438,12 +7312,56 @@ declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
 declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArrayRequiredPrefix<T, N>;
 declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
 //#endregion
+//#region src/has-prop.d.ts
+type NonArray<T> = T extends ReadonlyArray<unknown> ? never : T;
+type HasProp<T, Key extends PropertyKey> = T extends ReadonlyArray<unknown> ? never : T extends unknown ? Key extends keyof T ? Simplify<T & Required<Pick<T, Key>>> : never : never;
+/**
+ * Checks if `data` has a prop `key`.
+ *
+ * Uses [`Object.hasOwn`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn)
+ * which only checks own properties, skipping properties inherited through the
+ * prototype chain.
+ *
+ * - Use `prop` to read the value.
+ *
+ * @param data - The object to test.
+ * @param key - The key to look up.
+ * @signature
+ *   hasProp(data, key)
+ * @example
+ *   hasProp({ a: 1 }, "a"); //=> true
+ * @dataFirst
+ * @category Guard
+ */
+declare function hasProp<T extends object, Key extends KeysOfUnion<T>>(data: NonArray<T>, key: IsBounded<Key> extends true ? Key : never): data is HasProp<T, Key>;
+declare function hasProp<T extends object>(data: T, key: KeysOfUnion<T>): boolean;
+/**
+ * Checks if `data` has a prop `key`.
+ *
+ * Uses [`Object.hasOwn`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn)
+ * which only checks own properties, skipping properties inherited through the
+ * prototype chain.
+ *
+ * - Use `prop` to read the value.
+ *
+ * @param key - The key to look up.
+ * @signature
+ *   hasProp(key)(data)
+ * @example
+ *   pipe({ a: 1 }, hasProp("a")); //=> true
+ *   filter([] as { a?: number }[], hasProp("a")); //=> typed as { a: number }[]
+ * @dataLast
+ * @category Guard
+ */
+declare function hasProp<T extends object, Key extends KeysOfUnion<T>>(key: IsBounded<Key> extends true ? Key : never): (data: NonArray<T>) => data is HasProp<T, Key>;
+declare function hasProp<T extends object>(key: KeysOfUnion<T>): (data: T) => boolean;
+//#endregion
 //#region src/has-sub-object.d.ts
 declare const HAS_SUB_OBJECT_BRAND: unique symbol;
 type HasSubObjectGuard<T, S> = Simplify<Tagged<S & T, typeof HAS_SUB_OBJECT_BRAND>>;
-type HasSubObjectObjectValue<A, B> = Partial<{ [Key in keyof A & keyof B]: A[Key] & B[Key] extends never ? B[Key] : A[Key] | B[Key] extends object ? HasSubObjectObjectValue<A[Key], B[Key]> : A[Key] & B[Key] extends object ? B[Key] : A[Key] }> & { [Key in Exclude<keyof A, keyof B> | Exclude<keyof B, keyof A>]: Key extends keyof B ? B[Key] : never };
-type HasSubObjectData<Data, SubObject, RData = Required<Data>, RSubObject = Required<SubObject>> = Partial<{ [Key in keyof RData & keyof RSubObject]: RData[Key] & RSubObject[Key] extends never ? RSubObject[Key] : RData[Key] | RSubObject[Key] extends object ? HasSubObjectObjectValue<RData[Key], RSubObject[Key]> : RData[Key] & RSubObject[Key] extends object ? RSubObject[Key] : RData[Key] }> & { [Key in Exclude<keyof SubObject, keyof Data>]: SubObject[Key] };
-type HasSubObjectSubObject<SubObject, Data, RSubObject = Required<SubObject>, RData = Required<Data>> = Partial<{ [Key in keyof RData & keyof RSubObject]: RData[Key] & RSubObject[Key] extends never ? RData[Key] : RData[Key] | RSubObject[Key] extends object ? HasSubObjectObjectValue<RSubObject[Key], RData[Key]> : RData[Key] & RSubObject[Key] extends object ? RData[Key] : RSubObject[Key] }> & Record<Exclude<keyof SubObject, keyof Data>, never>;
+type HasSubObjectObjectValue<A, B> = Partial<{ [Key in keyof A & keyof B]: IsNever<A[Key] & B[Key]> extends true ? B[Key] : A[Key] | B[Key] extends object ? HasSubObjectObjectValue<A[Key], B[Key]> : A[Key] & B[Key] extends object ? B[Key] : A[Key] }> & { [Key in Exclude<keyof A, keyof B> | Exclude<keyof B, keyof A>]: Key extends keyof B ? B[Key] : never };
+type HasSubObjectData<Data, SubObject, RData = Required<Data>, RSubObject = Required<SubObject>> = Partial<{ [Key in keyof RData & keyof RSubObject]: IsNever<RData[Key] & RSubObject[Key]> extends true ? RSubObject[Key] : RData[Key] | RSubObject[Key] extends object ? HasSubObjectObjectValue<RData[Key], RSubObject[Key]> : RData[Key] & RSubObject[Key] extends object ? RSubObject[Key] : RData[Key] }> & { [Key in Exclude<keyof SubObject, keyof Data>]: SubObject[Key] };
+type HasSubObjectSubObject<SubObject, Data, RSubObject = Required<SubObject>, RData = Required<Data>> = Partial<{ [Key in keyof RData & keyof RSubObject]: IsNever<RData[Key] & RSubObject[Key]> extends true ? RData[Key] : RData[Key] | RSubObject[Key] extends object ? HasSubObjectObjectValue<RSubObject[Key], RData[Key]> : RData[Key] & RSubObject[Key] extends object ? RData[Key] : RSubObject[Key] }> & Record<Exclude<keyof SubObject, keyof Data>, never>;
 /**
  * Checks if `subObject` is a sub-object of `object`, which means for every
  * property and value in `subObject`, there's the same property in `object`
@@ -7683,7 +7601,7 @@ declare function invert<T extends object>(): (object: T) => Inverted<T>;
  * @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>;
+type NarrowedTo<T, Base> = IsNever<Extract<T, Base>> extends true ? Base : IsAny<T> extends true ? Base : Extract<T, Base>;
 //#endregion
 //#region src/is-array.d.ts
 /**
@@ -7757,11 +7675,11 @@ declare function isDate(data: unknown): data is Date;
  * for objects all props will be compared recursively.
  *
  * The built-in Date and RegExp are special-cased and will be compared by their
- * values.
+ * values. Objects with a `null` prototype are comparable to plain objects by
+ * their enumerable properties.
  *
  * !IMPORTANT: TypedArrays and symbol properties of objects are not supported
- * right now and might result in unexpected behavior. Please open an issue in
- * the Perkakas github project if you need support for these types.
+ * right now and might result in unexpected behavior.
  *
  * The result would be narrowed to the second value so that the function can be
  * used as a type guard.
@@ -7792,11 +7710,11 @@ declare function isDeepEqual<T>(data: T, other: T): boolean;
  * for objects all props will be compared recursively.
  *
  * The built-in Date and RegExp are special-cased and will be compared by their
- * values.
+ * values. Objects with a `null` prototype are comparable to plain objects by
+ * their enumerable properties.
  *
  * !IMPORTANT: TypedArrays and symbol properties of objects are not supported
- * right now and might result in unexpected behavior. Please open an issue in
- * the Perkakas github project if you need support for these types.
+ * right now and might result in unexpected behavior.
  *
  * The result would be narrowed to the second value so that the function can be
  * used as a type guard.
@@ -7883,14 +7801,14 @@ declare const EMPTYISH_BRAND: unique symbol;
 type Empty<T> = Tagged<T, typeof EMPTYISH_BRAND>;
 type Emptyish<T> = (T extends string ? '' : never) | (T extends object ? EmptyishObjectLike<T> : never) | (T extends null ? null : never) | (T extends undefined ? undefined : never);
 type EmptyishObjectLike<T extends object> = T extends ReadonlyArray<unknown> ? EmptyishArray<T> : T extends ReadonlyMap<infer Key, unknown> ? T extends Map<unknown, unknown> ? Empty<T> : ReadonlyMap<Key, never> : T extends ReadonlySet<unknown> ? T extends Set<unknown> ? Empty<T> : ReadonlySet<never> : EmptyishObject<T>;
-type EmptyishArray<T extends ReadonlyArray<unknown>> = T extends readonly [] ? T : And<IsEqual$1<TupleParts<T>['required'], []>, IsEqual$1<TupleParts<T>['suffix'], []>> extends true ? T extends Array<unknown> ? Empty<T> : readonly [] : never;
+type EmptyishArray<T extends ReadonlyArray<unknown>> = T extends readonly [] ? T : TupleParts<T>['required'] extends readonly [] ? TupleParts<T>['suffix'] extends readonly [] ? T extends Array<unknown> ? Empty<T> : readonly [] : never : never;
 type EmptyishObject<T extends object> = T extends {
   length: infer Length extends number;
 } ? T extends string ? never : EmptyishArbitrary<T, Length> : T extends {
   size: infer Size extends number;
 } ? EmptyishArbitrary<T, Size> : IsNever<ValueOf<T>> extends true ? T : HasRequiredKeys<OmitIndexSignature<T>> extends true ? never : HasWritableKeys<T> extends true ? Empty<T> : { readonly [P in keyof T]: never };
 type EmptyishArbitrary<T, N> = IsNumericLiteral<N> extends true ? [0] extends [N] ? [N] extends [0] ? T : Empty<T> : never : Empty<T>;
-type ShouldNotNarrow<T> = Or<Or<IsAny<T>, IsUnknown<T>>, IsEqual$1<T, {}>>;
+type ShouldNotNarrow<T> = unknown extends T ? true : IsAny<T> extends true ? true : IsEqual$1<T, {}> extends true ? true : false;
 /**
  * A function that checks if the input is empty. Empty is defined as anything
  * exposing a numerical `length`, or `size` property that is equal to `0`. This
@@ -7944,7 +7862,7 @@ declare function isEmptyish<T>(data: ShouldNotNarrow<T> extends true ? never : T
 declare function isEmptyish(data: unknown): boolean;
 //#endregion
 //#region src/is-error.d.ts
-type DefinitelyError<T> = Extract<T, Error> extends never ? Error : Extract<T, Error>;
+type DefinitelyError<T> = IsNever<Extract<T, Error>> extends true ? Error : Extract<T, Error>;
 /**
  * A function that checks if the passed parameter is an Error and narrows its type accordingly.
  *
@@ -8499,8 +8417,8 @@ declare const KEY_CODES: {
 //#region src/keys.d.ts
 type Keys<T> = T extends IterableContainer ? ArrayKeys<T> : ObjectKeys<T>;
 type ArrayKeys<T extends IterableContainer> = { -readonly [Index in keyof T]: Index extends number | string ? ToString<IsIndexAfterSpread<T, Index> extends true ? number : Index> : never };
-type IsIndexAfterSpread<T extends IterableContainer, Index extends number | string> = IndicesAfterSpread<T> extends never ? false : Index extends `${IndicesAfterSpread<T>}` ? true : false;
-type IndicesAfterSpread<T extends ReadonlyArray<unknown> | [], Iterations extends ReadonlyArray<unknown> = []> = T[number] extends never ? never : T extends readonly [unknown, ...infer Tail] ? IndicesAfterSpread<Tail, [unknown, ...Iterations]> : T extends readonly [...infer Head, unknown] ? IndicesAfterSpread<Head, [unknown, ...Iterations]> | Iterations['length'] : Iterations['length'];
+type IsIndexAfterSpread<T extends IterableContainer, Index extends number | string> = IsNever<IndicesAfterSpread<T>> extends true ? false : Index extends `${IndicesAfterSpread<T>}` ? true : false;
+type IndicesAfterSpread<T extends ReadonlyArray<unknown> | [], Iterations extends ReadonlyArray<unknown> = []> = IsNever<T[number]> extends true ? never : T extends readonly [unknown, ...infer Tail] ? IndicesAfterSpread<Tail, [unknown, ...Iterations]> : T extends readonly [...infer Head, unknown] ? IndicesAfterSpread<Head, [unknown, ...Iterations]> | Iterations['length'] : Iterations['length'];
 type ObjectKeys<T> = T extends Record<PropertyKey, never> ? [] : Array<EnumerableStringKeyOf<T>>;
 /**
  * Returns a new array containing the keys of the array or object.
@@ -8638,7 +8556,7 @@ type MappedKeys<T, Key extends PropertyKey> = MaybePartial<T, Key, Record<Key, E
  *
  * @see BoundedPartial
  */
-type MaybePartial<T, Key extends PropertyKey, Output> = And<IsBounded<Key>, Or<IsUnion<Key>, CouldBeEmpty<T>>> extends true ? Partial<Output> : Output;
+type MaybePartial<T, Key extends PropertyKey, Output> = IsBounded<Key> extends true ? IsUnion<Key> extends true ? Partial<Output> : CouldBeEmpty<T> extends true ? Partial<Output> : Output : Output;
 /**
  * Types that are extendable by `{}` are also satisfied by an empty object and
  * thus _could be empty_.
@@ -9236,7 +9154,7 @@ type PartialEnumerableKeysNarrowed<T extends object, S> = Simplify<ExactProps$1<
 type ExactProps$1<T, S> = { -readonly [P in keyof T as IsExactProp$1<T, P, S> extends true ? P : never]: Exclude<T[P], S> };
 type PartialProps$1<T, S> = { -readonly [P in keyof T as IsPartialProp$1<T, P, S> extends true ? P : never]?: Exclude<T[P], S> };
 type IsExactProp$1<T, P extends keyof T, S> = P extends symbol ? false : T[P] extends Exclude<T[P], S> ? S extends T[P] ? false : true : false;
-type IsPartialProp$1<T, P extends keyof T, S> = P extends symbol ? false : Or<IsExactProp$1<T, P, S>, IsNever<Exclude<Required<T>[P], S>>> extends true ? false : true;
+type IsPartialProp$1<T, P extends keyof T, S> = P extends symbol ? false : IsExactProp$1<T, P, S> extends true ? false : IsNever<Exclude<Required<T>[P], S>> extends true ? false : true;
 /**
  * Creates a shallow copy of the data, and then removes any keys that the
  * predicate rejects. Symbol keys are not passed to the predicate and would be
@@ -9292,11 +9210,11 @@ declare function once<T>(fn: () => T): () => T;
 //#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.
+ * Returns the first and only element of `data`, or undefined otherwise.
  *
- * @param array - The target array.
+ * @param data - The target array.
  * @signature
- *    only(array)
+ *    only(data)
  * @example
  *    only([]) // => undefined
  *    only([1]) // => 1
@@ -9304,12 +9222,12 @@ type Only<T extends IterableContainer> = T extends readonly [...Array<unknown>,
  * @dataFirst
  * @category Array
  */
-declare function only<T extends IterableContainer>(array: Readonly<T>): Only<T>;
+declare function only<T extends IterableContainer>(data: T): Only<T>;
 /**
- * Returns the first and only element of `array`, or undefined otherwise.
+ * Returns the first and only element of `data`, or undefined otherwise.
  *
  * @signature
- *    only()(array)
+ *    only()(data)
  * @example
  *    pipe([], only()); // => undefined
  *    pipe([1], only()); // => 1
@@ -9317,7 +9235,7 @@ declare function only<T extends IterableContainer>(array: Readonly<T>): Only<T>;
  * @dataLast
  * @category Array
  */
-declare function only<T extends IterableContainer>(): (array: Readonly<T>) => Only<T>;
+declare function only<T extends IterableContainer>(): (data: T) => Only<T>;
 //#endregion
 //#region src/internal/types/tuple-splits.d.ts
 /**
@@ -9913,6 +9831,8 @@ type NonPropertyKey = object | null | undefined;
  * validated against the object type to provide stronger type safety, better
  * compile-time errors, and to enable autocompletion in IDEs.
  *
+ * To check whether a key exists on the object, use `hasProp`.
+ *
  * @param data - The object or array to access.
  * @param key - The key(s) for the property to extract.
  * @signature
@@ -9943,6 +9863,8 @@ declare function prop<T extends NonPropertyKey, Key0 extends KeysDeep<T, []>, Ke
  * validated against the object type to provide stronger type safety, better
  * compile-time errors, and to enable autocompletion in IDEs.
  *
+ * To check whether a key exists on the object, use `hasProp`.
+ *
  * @param key - The key(s) for the property to extract.
  * @signature
  *   prop(...keys)(data);
@@ -10052,7 +9974,7 @@ declare function randomBigInt(from: bigint, to: bigint): bigint;
 //#endregion
 //#region src/random-integer.d.ts
 type MaxLiteral = 1000;
-type RandomInteger<From extends number, To extends number> = Or<IsNever<NonNegativeInteger<From>>, IsNever<NonNegativeInteger<To>>> extends true ? number : IsEqual$1<From, To> extends true ? From : GreaterThan<From, To> extends true ? never : GreaterThanOrEqual<To, MaxLiteral> extends true ? number : IntRangeInclusive<From, To>;
+type RandomInteger<From extends number, To extends number> = IsNever<NonNegativeInteger<From>> extends true ? number : IsNever<NonNegativeInteger<To>> extends true ? number : IsEqual$1<From, To> extends true ? From : GreaterThan<From, To> extends true ? never : GreaterThanOrEqual<To, MaxLiteral> extends true ? number : IntRangeInclusive<From, To>;
 /**
  * Generate a random integer between `from` and `to` (inclusive).
  *
@@ -10307,7 +10229,7 @@ declare function round(value: number, precision: number): number;
 declare function round(precision: number): (value: number) => number;
 //#endregion
 //#region src/sample.d.ts
-type Sampled<T extends IterableContainer, N extends number> = Or<IsEqual$1<N, 0>, IsEqual$1<T['length'], 0>> extends true ? [] : IsNever<NonNegativeInteger<N>> extends true ? SampledPrimitive<T> : IsLongerThan$1<T, N> extends true ? SampledLiteral<T, N> : Writable$1<T>;
+type Sampled<T extends IterableContainer, N extends number> = [N] extends [0] ? [] : [T['length']] extends [0] ? [] : IsNever<NonNegativeInteger<N>> extends true ? SampledPrimitive<T> : IsLongerThan$1<T, N> extends true ? SampledLiteral<T, N> : Writable$1<T>;
 /**
  * When N is not a non-negative integer **literal** we can't use it in our
  * reconstructing logic so we fallback to a simpler definition of the output of
@@ -10318,11 +10240,15 @@ type SampledPrimitive<T extends IterableContainer> = [...FixedSubTuples<TuplePar
  * Knowing N is a non-negative literal integer we can construct all sub-tuples
  * of T that are exactly N elements long.
  */
-type SampledLiteral<T extends IterableContainer, N extends number> = Extract<FixedSubTuples<[...TupleParts<T>['required'], ...(IsNever<TupleParts<T>['item']> extends true ? [] : NTuple<TupleParts<T>['item'], N>), ...TupleParts<T>['suffix']]>, FixedLengthArray<unknown, N>> | SubSampled<TupleParts<T>['required'], TupleParts<T>['item'], TupleParts<T>['suffix'], N>;
+type SampledLiteral<T extends IterableContainer, N extends number> = Combinations<[...TupleParts<T>['required'], ...(IsNever<TupleParts<T>['item']> extends true ? [] : NTuple<TupleParts<T>['item'], N>), ...TupleParts<T>['suffix']], N> | SubSampled<TupleParts<T>['required'], TupleParts<T>['item'], TupleParts<T>['suffix'], N>;
 type SubSampled<Prefix extends ReadonlyArray<unknown>, Item, Suffix extends ReadonlyArray<unknown>, N extends number> = IsLongerThan$1<[...Prefix, ...Suffix], N> extends true ? never : [...Prefix, ...Suffix]['length'] extends N ? never : [...Prefix, ...Suffix] | SubSampled<[...Prefix, Item], Item, Suffix, N>;
-type IsLongerThan$1<T extends ReadonlyArray<unknown>, N extends number> = IsEqual$1<T[N], undefined> extends true ? false : true;
+type IsLongerThan$1<T extends ReadonlyArray<unknown>, N extends number> = [T[N]] extends [undefined] ? false : true;
 type FixedSubTuples<T> = T extends readonly [infer Head, ...infer Rest] ? // For each element we either take it or skip it, and recurse over the rest.
 FixedSubTuples<Rest> | [Head, ...FixedSubTuples<Rest>] : [];
+/**
+ * Compute all combinations (sub-tuples) of T of exactly length N.
+ */
+type Combinations<T extends IterableContainer, N extends number, Counter extends ReadonlyArray<unknown> = []> = N extends unknown ? Counter['length'] extends N ? [] : T extends readonly [infer Head, ...infer Rest] ? [Head, ...Combinations<Rest, N, [unknown, ...Counter]>] | Combinations<Rest, N, Counter> : never : never;
 /**
  * Returns a random subset of size `sampleSize` from `array`.
  *
@@ -10951,36 +10877,56 @@ declare function sortedLastIndexBy<T>(item: T, valueFunction: (item: T, index: n
 //#endregion
 //#region src/splice.d.ts
 /**
- * Removes elements from an array and, inserts new elements in their place.
+ * Removes elements from an array and, optionally, inserts new elements in
+ * their place.
  *
- * @param items - The array to splice.
+ * Related operations:
+ * - `drop` - to skip past the first `n` elements.
+ * - `dropLast` - to skip past the last `n` elements.
+ * - `filter` - to shape the array by *value* rather than by *position*.
+ * - `swapIndices` - to swap two elements by their indices.
+ * - `take` - to keep only the first `n` elements.
+ * - `takeLast` - to keep only the last `n` elements.
+ *
+ * @param data - The array to splice.
  * @param start - The index from which to start removing elements.
  * @param deleteCount - The number of elements to remove.
- * @param replacement - The elements to insert into the array in place of the deleted elements.
+ * @param replacement - Elements to insert at the cutoff point.
  * @signature
- *    splice(items, start, deleteCount, replacement)
+ *    splice(data, start, deleteCount);
+ *    splice(data, start, deleteCount, replacement);
  * @example
- *    splice([1,2,3,4,5,6,7,8], 2, 3, []); //=> [1,2,6,7,8]
+ *    splice([1,2,3,4,5,6,7,8], 2, 3); //=> [1,2,6,7,8]
  *    splice([1,2,3,4,5,6,7,8], 2, 3, [9, 10]); //=> [1,2,9,10,6,7,8]
  * @dataFirst
  * @category Array
  */
-declare function splice<T>(items: ReadonlyArray<T>, start: number, deleteCount: number, replacement: ReadonlyArray<T>): Array<T>;
+declare function splice<T extends IterableContainer>(data: T, start: number, deleteCount: number, replacement?: ReadonlyArray<T[number]>): Array<T[number]>;
 /**
- * Removes elements from an array and, inserts new elements in their place.
+ * Removes elements from an array and, optionally, inserts new elements in
+ * their place.
+ *
+ * Related operations:
+ * - `drop` - to skip past the first `n` elements.
+ * - `dropLast` - to skip past the last `n` elements.
+ * - `filter` - to shape the array by *value* rather than by *position*.
+ * - `swapIndices` - to swap two elements by their indices.
+ * - `take` - to keep only the first `n` elements.
+ * - `takeLast` - to keep only the last `n` elements.
  *
  * @param start - The index from which to start removing elements.
  * @param deleteCount - The number of elements to remove.
- * @param replacement - The elements to insert into the array in place of the deleted elements.
+ * @param replacement - Elements to insert at the cutoff point.
  * @signature
- *    splice(start, deleteCount, replacement)(items)
+ *    splice(start, deleteCount)(data);
+ *    splice(start, deleteCount, replacement)(data);
  * @example
- *    pipe([1,2,3,4,5,6,7,8], splice(2, 3, [])) // => [1,2,6,7,8]
+ *    pipe([1,2,3,4,5,6,7,8], splice(2, 3)) // => [1,2,6,7,8]
  *    pipe([1,2,3,4,5,6,7,8], splice(2, 3, [9, 10])) // => [1,2,9,10,6,7,8]
  * @dataLast
  * @category Array
  */
-declare function splice<T>(start: number, deleteCount: number, replacement: ReadonlyArray<T>): (items: ReadonlyArray<T>) => Array<T>;
+declare function splice<T extends IterableContainer>(start: number, deleteCount: number, replacement?: ReadonlyArray<T[number]>): (data: T) => Array<T[number]>;
 //#endregion
 //#region src/split.d.ts
 type BuiltInReturnType = ReturnType<typeof String.prototype.split>;
@@ -11323,7 +11269,7 @@ type IsNonNegative<T extends number> = number extends T ? false : `${T}` extends
 type CharactersTuple<T extends string> = string extends T ? Array<string> : T extends `${infer C}${infer R}` ? [C, ...CharactersTuple<R>] : [];
 type SwapArrayInternal<T extends IterableContainer, Index1 extends number, Index2 extends number, Position extends ReadonlyArray<unknown> = [], Original extends IterableContainer = T> = T extends readonly [infer AtPosition, ...infer Rest] ? [Position['length'] extends Index1 ? Original[Index2] : Position['length'] extends Index2 ? Original[Index1] : AtPosition, ...SwapArrayInternal<Rest, Index1, Index2, [unknown, ...Position], Original>] : T;
 type SwapString<T extends string, K1 extends number, K2 extends number> = Join<SwapArray<CharactersTuple<T>, K1, K2>, ''>;
-type SwapArray<T extends IterableContainer, K1 extends number, K2 extends number> = And<IsNonNegative<K1>, IsNonNegative<K2>> extends true ? And<isLessThan<K1, T['length']>, isLessThan<K2, T['length']>> extends true ? SwapArrayInternal<T, K1, K2> : T : Array<T[number]>;
+type SwapArray<T extends IterableContainer, K1 extends number, K2 extends number> = IsNonNegative<K1> extends true ? IsNonNegative<K2> extends true ? isLessThan<K1, T['length']> extends true ? isLessThan<K2, T['length']> extends true ? SwapArrayInternal<T, K1, K2> : T : T : Array<T[number]> : Array<T[number]>;
 type SwappedIndices<T extends IterableContainer | string, K1 extends number, K2 extends number> = T extends string ? SwapString<T, K1, K2> : T extends IterableContainer ? SwapArray<T, K1, K2> : never;
 /**
  * Swaps the positions of two elements in an array or string at the provided indices.
@@ -11332,6 +11278,9 @@ type SwappedIndices<T extends IterableContainer | string, K1 extends number, K2
  *
  * If either index is out of bounds the result would be a shallow copy of the input, as-is.
  *
+ * Related operations:
+ * - `splice` - for more general positional edits (remove a slice, insert at an index).
+ *
  * @param data - The item to be manipulated. This can be an array, or a string.
  * @param index1 - The first index.
  * @param index2 - The second index.
@@ -11353,6 +11302,9 @@ declare function swapIndices<T extends IterableContainer | string, K1 extends nu
  *
  * If either index is out of bounds the result would be a shallow copy of the input, as-is.
  *
+ * Related operations:
+ * - `splice` - for more general positional edits (remove a slice, insert at an index).
+ *
  * @param index1 - The first index.
  * @param index2 - The second index.
  * @returns Returns the manipulated array or string.
@@ -11402,6 +11354,11 @@ declare function swapProps<T extends object, K1 extends keyof T, K2 extends keyo
 /**
  * Returns the first `n` elements of `array`.
  *
+ * Related operations:
+ * - `drop` - to skip past the first `n` instead.
+ * - `splice` - to remove or insert at an arbitrary index.
+ * - `takeLast` - same, but from the end of the array.
+ *
  * @param array - The array.
  * @param n - The number of elements to take.
  * @signature
@@ -11416,6 +11373,11 @@ declare function take<T extends IterableContainer>(array: T, n: number): Array<T
 /**
  * Returns the first `n` elements of `array`.
  *
+ * Related operations:
+ * - `drop` - to skip past the first `n` instead.
+ * - `splice` - to remove or insert at an arbitrary index.
+ * - `takeLast` - same, but from the end of the array.
+ *
  * @param n - The number of elements to take.
  * @signature
  *    take(n)(array)
@@ -11466,6 +11428,11 @@ declare function takeFirstBy<T>(n: number, ...rules: Readonly<NonEmptyArray<Orde
 /**
  * Takes the last `n` elements from the `array`.
  *
+ * Related operations:
+ * - `dropLast` - to skip past the last `n` instead.
+ * - `splice` - to remove or insert at an arbitrary index.
+ * - `take` - same, but from the start of the array.
+ *
  * @param array - The target array.
  * @param n - The number of elements to take.
  * @signature
@@ -11479,6 +11446,11 @@ declare function takeLast<T extends IterableContainer>(array: T, n: number): Arr
 /**
  * Take the last `n` elements from the `array`.
  *
+ * Related operations:
+ * - `dropLast` - to skip past the last `n` instead.
+ * - `splice` - to remove or insert at an arbitrary index.
+ * - `take` - same, but from the start of the array.
+ *
  * @param n - The number of elements to take.
  * @signature
  *    takeLast(n)(array)
@@ -11636,7 +11608,7 @@ declare function times<T>(fn: (index: number) => T): <N extends number>(count: N
  * 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>;
+type OptionalOptionsWithDefaults<T, Provided extends T, Defaults extends T> = Merge<Defaults, { [Key in keyof Provided as IsNever<Extract<Provided[Key], undefined>> extends true ? Key : never]: Provided[Key] }> & Required<T>;
 //#endregion
 //#region src/to-camel-case.d.ts
 declare const DEFAULT_PRESERVE_CONSECUTIVE_UPPERCASE$1 = true;
@@ -12024,7 +11996,7 @@ interface TruncateOptions {
 }
 declare const DEFAULT_OMISSION = "...";
 type Truncate<S extends string, N extends number, Options extends TruncateOptions> = IsNever<NonNegativeInteger<N>> extends true ? string : IsStringLiteral<S> extends true ? TruncateWithOptions<S, N, Options extends Pick<Required<TruncateOptions>, 'omission'> ? Options['omission'] : typeof DEFAULT_OMISSION, Options extends Pick<Required<TruncateOptions>, 'separator'> ? Options['separator'] : undefined> : string;
-type TruncateWithOptions<S extends string, N extends number, Omission extends string, Separator extends string | RegExp | undefined> = N extends unknown ? IsEqual$1<N, 0> extends true ? '' : Omission extends unknown ? IsStringLiteral<Omission> extends true ? IsEqual$1<ClampedIntegerSubtract<N, StringLength<Omission>>, 0> extends true ? TruncateLiterals<Omission, N, ''> : And<IsStringLiteral<S>, IsEqual$1<Separator, undefined>> extends true ? TruncateLiterals<S, N, Omission> : string : string : never : never;
+type TruncateWithOptions<S extends string, N extends number, Omission extends string, Separator extends string | RegExp | undefined> = N extends unknown ? [N] extends [0] ? '' : Omission extends unknown ? IsStringLiteral<Omission> extends true ? [ClampedIntegerSubtract<N, StringLength<Omission>>] extends [0] ? TruncateLiterals<Omission, N, ''> : IsStringLiteral<S> extends true ? [Separator] extends [undefined] ? TruncateLiterals<S, N, Omission> : string : string : string : never : never;
 /**
  * This is the actual implementation of the truncation logic. It assumes all
  * its params are literals and valid.
@@ -12490,5 +12462,5 @@ declare function zipWith<T1 extends IterableContainer, T2 extends IterableContai
 //#region src/index.d.ts
 declare const isBrowser: boolean;
 //#endregion
-export { DeepPartial, KEY_CODES, add, addProp, allPass, anyPass, capitalize, ceil, chunk, clamp, clone, concat, conditional, constant, countBy, curry, debounce, defaultTo, difference, differenceWith, divide, doNothing, drop, dropFirstBy, dropLast, dropLastWhile, dropWhile, endsWith, entries, evolve, filter, find, findIndex, findLast, findLastIndex, first, firstBy, flat, flatMap, floor, forEach, forEachObj, fromEntries, fromKeys, funnel, groupBy, groupByProp, hasAtLeast, hasSubObject, humanReadableFileSize, identity, indexBy, intersection, intersectionWith, invert, isArray, isBigInt, isBoolean, isBrowser, isDate, isDeepEqual, isDefined, isEmpty, isEmptyish, isError, isFunction, isIncludedIn, isNonNull, isNonNullish, isNot, isNullish, isNumber, isObjectType, isPlainObject, isPromise, isShallowEqual, isStrictEqual, isString, isSymbol, isTruthy, join, keys, last, length, map, mapKeys, mapToObj, mapValues, mapWithFeedback, mean, meanBy, median, merge, mergeAll, mergeDeep, multiply, nthBy, objOf, omit, omitBy, once, only, partialBind, partialLastBind, partition, pathOr, pick, pickBy, pipe, piped, product, prop, pullObject, randomBigInt, randomInteger, randomString, range, rankBy, reduce, reverse, round, sample, set, setPath, shuffle, sleep, sliceString, slugify, sort, sortBy, sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy, splice, split, splitAt, splitWhen, startsWith, stringToPath, subtract, sum, sumBy, swapIndices, swapProps, take, takeFirstBy, takeLast, takeLastWhile, takeWhile, tap, times, toCamelCase, toKebabCase, toLowerCase, toSnakeCase, toTitleCase, toUpperCase, truncate, uncapitalize, unique, uniqueBy, uniqueWith, values, when, zip, zipWith, EMPTYISH_BRAND, HAS_SUB_OBJECT_BRAND, PerkakasErrorSymbol, emptyObjectSymbol, tag };
+export { DeepPartial, KEY_CODES, add, addProp, allPass, anyPass, capitalize, ceil, chunk, clamp, clone, concat, conditional, constant, countBy, curry, debounce, defaultTo, difference, differenceWith, divide, doNothing, drop, dropFirstBy, dropLast, dropLastWhile, dropWhile, endsWith, entries, evolve, filter, find, findIndex, findLast, findLastIndex, first, firstBy, flat, flatMap, floor, forEach, forEachObj, fromEntries, fromKeys, funnel, groupBy, groupByProp, hasAtLeast, hasProp, hasSubObject, humanReadableFileSize, identity, indexBy, intersection, intersectionWith, invert, isArray, isBigInt, isBoolean, isBrowser, isDate, isDeepEqual, isDefined, isEmpty, isEmptyish, isError, isFunction, isIncludedIn, isNonNull, isNonNullish, isNot, isNullish, isNumber, isObjectType, isPlainObject, isPromise, isShallowEqual, isStrictEqual, isString, isSymbol, isTruthy, join, keys, last, length, map, mapKeys, mapToObj, mapValues, mapWithFeedback, mean, meanBy, median, merge, mergeAll, mergeDeep, multiply, nthBy, objOf, omit, omitBy, once, only, partialBind, partialLastBind, partition, pathOr, pick, pickBy, pipe, piped, product, prop, pullObject, randomBigInt, randomInteger, randomString, range, rankBy, reduce, reverse, round, sample, set, setPath, shuffle, sleep, sliceString, slugify, sort, sortBy, sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy, splice, split, splitAt, splitWhen, startsWith, stringToPath, subtract, sum, sumBy, swapIndices, swapProps, take, takeFirstBy, takeLast, takeLastWhile, takeWhile, tap, times, toCamelCase, toKebabCase, toLowerCase, toSnakeCase, toTitleCase, toUpperCase, truncate, uncapitalize, unique, uniqueBy, uniqueWith, values, when, zip, zipWith, EMPTYISH_BRAND, HAS_SUB_OBJECT_BRAND, PerkakasErrorSymbol, emptyObjectSymbol, tag };
 //# sourceMappingURL=index.d.ts.map