@augment-vir/core 32.2.0 → 32.2.1

package/dist/augments/type/apply-default-options.d.ts

@@ -0,0 +1,24 @@
+import { type RequiredKeysOf } from '../object/required-keys.js';
+import { type If } from './conditional-type.js';
+import { type Merge } from './merge.js';
+import { type OptionalKeysOf } from './optional-keys-of.js';
+import { type Simplify } from './simplify.js';
+import { type IsAny, type IsNever } from './type-checks.js';
+/**
+ * Fill in the unspecified properties of an options object with their defaults.
+ *
+ * Copied from the `ApplyDefaultOptions` type in the `type-fest` package so that this package's
+ * public types do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Simplify<Merge<Defaults, {
+    [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key]: SpecifiedOptions[Key];
+}> & 
+/**
+ * `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is
+ * always assignable to `Required<SomeOption>`.
+ */
+Required<Options>>>>;

package/dist/augments/type/apply-default-options.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/conditional-type.d.ts

@@ -1,4 +1,4 @@
-import { type IsNever } from './type-checks.js';
+import { type IsAny, type IsNever } from './type-checks.js';
 /**
  * An if-else-like type that resolves depending on whether the given `boolean` type is `true` or
  * `false`. Returns the else branch when the given type is `never`.
@@ -11,3 +11,15 @@ import { type IsNever } from './type-checks.js';
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
 export type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
+/**
+ * Resolves to `IfNotAnyOrNeverBranch` unless the given type is `any` or `never`, in which case the
+ * respective `IfAny` or `IfNever` branch is used.
+ *
+ * Copied from the `IfNotAnyOrNever` type in the `type-fest` package so that this package's public
+ * types do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Type
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type IfNotAnyOrNever<Type, IfNotAnyOrNeverBranch, IfAny = any, IfNever = never> = If<IsAny<Type>, IfAny, If<IsNever<Type>, IfNever, IfNotAnyOrNeverBranch>>;

package/dist/augments/type/except.d.ts

@@ -1,3 +1,4 @@
+import { type ApplyDefaultOptions } from './apply-default-options.js';
 import { type IsEqual } from './type-checks.js';
 type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : KeyType extends ExcludeType ? never : KeyType;
 /**
@@ -18,6 +19,12 @@ export type ExceptOptions = {
      */
     requireExactProps?: boolean;
 };
+type DefaultExceptOptions = {
+    requireExactProps: false;
+};
+type ExceptHelper<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = {
+    [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
+} & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
 /**
  * Create a type from an object type without certain keys. This is a stricter version of the
  * built-in `Omit` type: it restricts the omitted keys to keys present on the given type.
@@ -29,9 +36,5 @@ export type ExceptOptions = {
  * @category Package : @augment-vir/common
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
-export type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = {
-    [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType];
-} & (Options extends {
-    requireExactProps: true;
-} ? Partial<Record<KeysType, never>> : {});
+export type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = ExceptHelper<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
 export {};

package/dist/augments/type/exclude-exactly.d.ts

@@ -0,0 +1,27 @@
+import { type If, type IfNotAnyOrNever } from './conditional-type.js';
+import { type IsAny, type IsEqual, type IsNever } from './type-checks.js';
+type ExcludeExactlyMember<Union, Delete> = IfNotAnyOrNever<Delete, Union extends unknown ? [
+    Delete extends unknown ? If<IsEqual<Union, Delete>, true, never> : never
+] extends [never] ? Union : never : never, 
+/**
+ * When `Delete` is `any` or `never`, return `Union`, because `Union` cannot be `any` or `never`
+ * here.
+ */
+Union, Union>;
+/**
+ * Exclude exactly the given type from a union, instead of excluding every member assignable to it
+ * the way the built-in `Exclude` does.
+ *
+ * Copied from the `ExcludeExactly` type in the `type-fest` package so that this package's public
+ * types do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Type
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type ExcludeExactly<Union, Delete> = IfNotAnyOrNever<Union, ExcludeExactlyMember<Union, Delete>, 
+/** When `Union` is `any`: if `Delete` is `any` return `never`, otherwise return `Union`. */
+If<IsAny<Delete>, never, Union>, 
+/** When `Union` is `never`: if `Delete` is `never` return `never`, otherwise return `Union`. */
+If<IsNever<Delete>, never, Union>>;
+export {};

package/dist/augments/type/exclude-exactly.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/merge.d.ts

@@ -0,0 +1,20 @@
+import { type If } from './conditional-type.js';
+import { type OmitIndexSignature, type PickIndexSignature } from './omit-index-signature.js';
+import { type Simplify } from './simplify.js';
+import { type IsEqual } from './type-checks.js';
+type SimpleMerge<Destination, Source> = Simplify<{
+    [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
+} & Source>;
+type MergeNonEqual<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
+/**
+ * Merge two types into a new type. Keys of the second type override keys of the first type.
+ *
+ * Copied from the `Merge` type in the `type-fest` package so that this package's public types do
+ * not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Merge<Destination, Source> = Destination extends unknown ? Source extends unknown ? If<IsEqual<Destination, Source>, Destination, MergeNonEqual<Destination, Source>> : never : never;
+export {};

package/dist/augments/type/merge.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/omit-deep.d.ts

@@ -1,3 +1,4 @@
+import { type ApplyDefaultOptions } from './apply-default-options.js';
 import { type BuiltIns } from './built-in-type.js';
 import { type If } from './conditional-type.js';
 import { type LiteralUnion } from './literal-union.js';
@@ -34,9 +35,9 @@ type PositiveNumericStringGt<A extends string, B extends string> = A extends B ?
     ...infer Remaining extends readonly unknown[]
 ] ? 0 extends Remaining['length'] ? SameLengthPositiveNumericStringGt<A, B> : true : false : never;
 /**
- * Simplified 2-input logical `and`. `type-fest` routes `And` through `AndAll`/`AllExtend`, but the
- * only consumer here (`GreaterThan`) always passes concrete `true`/`false` values, for which this
- * definition is behaviorally identical.
+ * Simplified 2-input logical `and`. `type-fest` routes `And` through `AndAll`/`AllExtend`, but
+ * every consumer here (`GreaterThan` and `InternalPaths`) always passes concrete `true`/`false`
+ * values, for which this definition is behaviorally identical.
  */
 type And<A extends boolean, B extends boolean> = A extends true ? B extends true ? true : false : false;
 /** Simplified 2-input logical `or`. See the note on {@link And}. */
@@ -174,6 +175,29 @@ type SubtractPostChecks<A extends number, B extends number, AreNegative = [
     ...TupleOf<Absolute<B>>
 ] extends infer R extends unknown[] ? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length'] : never;
 type Subtract<A extends number, B extends number> = number extends A | B ? number : A extends B & (PositiveInfinity | NegativeInfinity) ? number : A extends NegativeInfinity ? NegativeInfinity : B extends PositiveInfinity ? NegativeInfinity : A extends PositiveInfinity ? PositiveInfinity : B extends NegativeInfinity ? PositiveInfinity : A extends B ? 0 : A extends 0 ? ReverseSign<B> : B extends 0 ? A : SubtractPostChecks<A, B>;
+type TupleMax<A extends number[], Result extends number = NegativeInfinity> = number extends A[number] ? never : A extends [
+    infer First extends number,
+    ...infer Rest extends number[]
+] ? GreaterThan<First, Result> extends true ? TupleMax<Rest, First> : TupleMax<Rest, Result> : Result;
+type SumPositives<A extends number, B extends number> = [
+    ...TupleOf<A>,
+    ...TupleOf<B>
+]['length'] extends infer Result extends number ? Result : never;
+type SumPostChecks<A extends number, B extends number, AreNegative = [
+    IsNegative<A>,
+    IsNegative<B>
+]> = AreNegative extends [
+    false,
+    false
+] ? SumPositives<A, B> : AreNegative extends [
+    true,
+    true
+] ? ReverseSign<SumPositives<Absolute<A>, Absolute<B>>> : Absolute<Subtract<Absolute<A>, Absolute<B>>> extends infer Result extends number ? TupleMax<[
+    Absolute<A>,
+    Absolute<B>
+]> extends infer LargestMagnitude extends number ? LargestMagnitude extends A | B ? Result : ReverseSign<Result> : never : never;
+type Sum<A extends number, B extends number> = number extends A | B ? number : A extends B & (PositiveInfinity | NegativeInfinity) ? A : A | B extends PositiveInfinity | NegativeInfinity ? number : A extends PositiveInfinity | NegativeInfinity ? A : B extends PositiveInfinity | NegativeInfinity ? B : A extends 0 ? B : B extends 0 ? A : A extends ReverseSign<B> ? 0 : SumPostChecks<A, B>;
+type IsNumberLike<N> = IfNotAnyOrNever<N, N extends number | `${number}` ? true : false, boolean, false>;
 type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> = T extends unknown ? number extends T['length'] ? T extends readonly [
     infer U,
     ...infer V
@@ -259,6 +283,70 @@ type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> =
     [TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType>;
 } : Type;
 type SimplifyDeep<Type, ExcludeType = never> = ConditionalSimplifyDeep<Type, ExcludeType | NonRecursiveType | Exclude<MapsSetsOrArrays, UnknownArray>, object>;
+/**
+ * Options for {@link Paths}.
+ *
+ * Copied from the `PathsOptions` type in `type-fest` v5.6 so that this package's public types do
+ * not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type PathsOptions = {
+    /**
+     * The maximum depth to recurse when searching for paths. Range: 0 ~ 10.
+     *
+     * @default 5
+     */
+    maxRecursionDepth?: number;
+    /**
+     * Use bracket notation for array indices and numeric object keys.
+     *
+     * @default false
+     */
+    bracketNotation?: boolean;
+    /**
+     * Only include leaf paths in the output.
+     *
+     * @default false
+     */
+    leavesOnly?: boolean;
+    /**
+     * Only include paths at the specified depth. By default all paths up to
+     * {@link PathsOptions.maxRecursionDepth} are included. Depth starts at `0` for root properties.
+     *
+     * @default number
+     */
+    depth?: number;
+};
+type DefaultPathsOptions = {
+    maxRecursionDepth: 5;
+    bracketNotation: false;
+    leavesOnly: false;
+    depth: number;
+};
+type InternalPaths<T, Options extends Required<PathsOptions>, CurrentDepth extends number> = {
+    [Key in keyof T]: Key extends string | number ? (And<Options['bracketNotation'], IsNumberLike<Key>> extends true ? `[${Key}]` : CurrentDepth extends 0 ? /**
+       * Return both `Key` and `ToString<Key>` because for number keys, like `1`, both `1` and `'1'` are
+       * valid keys.
+       */ Key | ToString<Key> : `.${Key | ToString<Key>}`) extends infer TransformedKey extends string | number ? ((Options['leavesOnly'] extends true ? Options['maxRecursionDepth'] extends CurrentDepth ? TransformedKey : IsNever<T[Key]> extends true ? TransformedKey : T[Key] extends infer Value ? Value extends readonly [] | NonRecursiveType | Exclude<MapsSetsOrArrays, UnknownArray> ? TransformedKey : IsNever<keyof Value> extends true ? TransformedKey : never : never : TransformedKey) extends infer LeafFilteredKey ? CurrentDepth extends Options['depth'] ? LeafFilteredKey : never : never)
+    /** Recursively generate paths for the current key. */
+     | (GreaterThan<Options['maxRecursionDepth'], CurrentDepth> extends true ? `${TransformedKey}${PathsHelper<T[Key], Options, Sum<CurrentDepth, 1>> & (string | number)}` : never) : never : never;
+}[keyof T & (T extends UnknownArray ? number : unknown)];
+type PathsHelper<T, Options extends Required<PathsOptions>, CurrentDepth extends number = 0> = T extends NonRecursiveType | Exclude<MapsSetsOrArrays, UnknownArray> ? never : IsAny<T> extends true ? never : T extends object ? InternalPaths<Required<T>, Options, CurrentDepth> : never;
+/**
+ * Generate a union of all possible paths to properties in the given object. Also works with arrays.
+ *
+ * Copied from the `Paths` type in `type-fest` v5.6 so that this package's public types do not
+ * depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Array
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Paths<T, Options extends PathsOptions = {}> = PathsHelper<T, ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, Options>>;
 type OmitDeepArrayWithOnePath<ArrayType extends UnknownArray, P extends string | number> = P extends `${infer ArrayIndex extends number}.${infer SubPath}` ? number extends ArrayIndex ? Array<OmitDeepWithOnePath<NonNullable<ArrayType[number]>, SubPath>> : ArraySplice<ArrayType, ArrayIndex, 1, [
     OmitDeepWithOnePath<NonNullable<ArrayType[ArrayIndex]>, SubPath>
 ]> : P extends `${infer ArrayIndex extends number}` ? number extends ArrayIndex ? [] : ArraySplice<ArrayType, ArrayIndex, 1, [unknown]> : ArrayType;
@@ -274,17 +362,12 @@ type OmitDeepHelper<T, PathTuple extends UnknownArray> = PathTuple extends [
  * Omit properties from a deeply-nested object, supporting recursion into arrays (each removed array
  * item is replaced with `unknown` at its index).
  *
- * Copied from the `OmitDeep` type in the `type-fest` package so that this package's public types do
- * not depend on `type-fest` (see the note in `type-checks.ts`).
- *
- * Note: `type-fest` constrains `PathUnion` to `LiteralUnion<Paths<T>, string>`. That `Paths<T>`
- * portion is only an autocomplete/validation aid on the path argument and is not used by the
- * omission logic, so it is relaxed here to `LiteralUnion<string, string>` (effectively `string`) to
- * avoid vendoring type-fest's enormous `Paths` type.
+ * Copied from the `OmitDeep` type in `type-fest` v5.6 so that this package's public types do not
+ * depend on `type-fest` (see the note in `type-checks.ts`).
  *
  * @category Object
  * @category Package : @augment-vir/common
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
-export type OmitDeep<T, PathUnion extends LiteralUnion<string, string>> = SimplifyDeep<OmitDeepHelper<T, UnionToTuple<PathUnion>>, UnknownArray>;
+export type OmitDeep<T, PathUnion extends LiteralUnion<Paths<T>, string>> = SimplifyDeep<OmitDeepHelper<T, UnionToTuple<PathUnion>>, UnknownArray>;
 export {};

package/dist/augments/type/omit-index-signature.d.ts

@@ -12,3 +12,17 @@
 export type OmitIndexSignature<ObjectType> = {
     [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType];
 };
+/**
+ * Pick only index signatures from the given object type, leaving out all explicitly defined
+ * properties. This is the counterpart of {@link OmitIndexSignature}.
+ *
+ * Copied from the `PickIndexSignature` type in the `type-fest` package so that this package's
+ * public types do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type PickIndexSignature<ObjectType> = {
+    [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType];
+};

package/dist/augments/type/package-json.d.ts

@@ -80,6 +80,7 @@ type TypeScriptConfiguration = {
     typings?: string;
 };
 type WorkspaceConfig = {
+    /** Glob patterns relative to the `package.json` that defines them, such as `packages/*`. */
     packages?: string[];
     nohoist?: string[];
 };

package/dist/augments/type/partial-deep.d.ts

@@ -1,3 +1,4 @@
+import { type ApplyDefaultOptions } from './apply-default-options.js';
 import { type BuiltIns, type HasMultipleCallSignatures } from './built-in-type.js';
 import { type IsNever } from './type-checks.js';
 /**
@@ -24,12 +25,16 @@ export type PartialDeepOptions = {
      */
     readonly allowUndefinedInNonTupleArrays?: boolean;
 };
-type PartialMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> = {} & Map<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>>;
-type PartialSetDeep<T, Options extends PartialDeepOptions> = {} & Set<PartialDeep<T, Options>>;
-type PartialReadonlyMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> = {} & ReadonlyMap<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>>;
-type PartialReadonlySetDeep<T, Options extends PartialDeepOptions> = {} & ReadonlySet<PartialDeep<T, Options>>;
-type PartialObjectDeep<ObjectType extends object, Options extends PartialDeepOptions> = {
-    [KeyType in keyof ObjectType]?: PartialDeep<ObjectType[KeyType], Options>;
+type DefaultPartialDeepOptions = {
+    recurseIntoArrays: false;
+    allowUndefinedInNonTupleArrays: false;
+};
+type PartialMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & Map<PartialDeepHelper<KeyType, Options>, PartialDeepHelper<ValueType, Options>>;
+type PartialSetDeep<T, Options extends Required<PartialDeepOptions>> = {} & Set<PartialDeepHelper<T, Options>>;
+type PartialReadonlyMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & ReadonlyMap<PartialDeepHelper<KeyType, Options>, PartialDeepHelper<ValueType, Options>>;
+type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<PartialDeepHelper<T, Options>>;
+type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = {
+    [KeyType in keyof ObjectType]?: PartialDeepHelper<ObjectType[KeyType], Options>;
 };
 /**
  * Create a deeply optional version of another type. Use `Partial<T>` if you only need one level
@@ -42,11 +47,6 @@ type PartialObjectDeep<ObjectType extends object, Options extends PartialDeepOpt
  * @category Package : @augment-vir/common
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
-export type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends BuiltIns | (new (...arguments_: any[]) => unknown) ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T extends (...arguments_: any[]) => unknown ? IsNever<keyof T> extends true ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & PartialObjectDeep<T, Options> : T extends object ? T extends ReadonlyArray<infer ItemType> ? Options extends {
-    recurseIntoArrays: true;
-} ? ItemType[] extends T ? readonly ItemType[] extends T ? ReadonlyArray<PartialDeep<Options extends {
-    allowUndefinedInNonTupleArrays: true;
-} ? ItemType | undefined : ItemType, Options>> : Array<PartialDeep<Options extends {
-    allowUndefinedInNonTupleArrays: true;
-} ? ItemType | undefined : ItemType, Options>> : PartialObjectDeep<T, Options> : T : PartialObjectDeep<T, Options> : unknown;
+export type PartialDeep<T, Options extends PartialDeepOptions = {}> = PartialDeepHelper<T, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
+type PartialDeepHelper<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | (new (...arguments_: any[]) => unknown) ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T extends (...arguments_: any[]) => unknown ? IsNever<keyof T> extends true ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & PartialObjectDeep<T, Options> : T extends object ? T extends ReadonlyArray<infer ItemType> ? Options['recurseIntoArrays'] extends true ? ItemType[] extends T ? readonly ItemType[] extends T ? ReadonlyArray<PartialDeepHelper<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : Array<PartialDeepHelper<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep<T, Options> : T : PartialObjectDeep<T, Options> : unknown;
 export {};

package/dist/augments/type/require-keys.d.ts

@@ -1,43 +1,47 @@
 import { type RequiredKeysOf } from '../object/required-keys.js';
+import { type If, type IfNotAnyOrNever } from './conditional-type.js';
+import { type Except } from './except.js';
+import { type IsAny, type IsNever } from './type-checks.js';
 /**
  * Returns `true` if the given object type has at least one required key, otherwise `false`.
  *
- * Copied from the `HasRequiredKeys` type in the `type-fest` package (built on
- * {@link RequiredKeysOf}) so that this package's public types do not depend on `type-fest` (see the
- * note in `type-checks.ts`).
+ * Copied from the `HasRequiredKeys` type in `type-fest` v5.6 (built on {@link RequiredKeysOf}) so
+ * that this package's public types do not depend on `type-fest` (see the note in
+ * `type-checks.ts`).
  *
  * @category Object
  * @category Package : @augment-vir/common
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
-export type HasRequiredKeys<BaseType> = [RequiredKeysOf<BaseType>] extends [never] ? false : true;
+export type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;
+type RequireExactlyOneHelper<ObjectType, KeysType extends keyof ObjectType> = {
+    [Key in KeysType]: Required<Pick<ObjectType, Key>> & Partial<Record<Exclude<KeysType, Key>, never>>;
+}[KeysType] & Omit<ObjectType, KeysType>;
 /**
  * Create a type that requires exactly one of the given keys and disallows the rest, while keeping
  * the remaining (non-listed) keys as is.
  *
- * Copied from the classic `RequireExactlyOne` implementation in the `type-fest` package (before
- * `type-fest` v5 wrapped it in an `IfNotAnyOrNever` conditional that breaks structural
- * assignability). See the note in `type-checks.ts`.
+ * Copied from the `RequireExactlyOne` type in `type-fest` v5.6 so that this package's public types
+ * do not depend on `type-fest` (see the note in `type-checks.ts`).
  *
  * @category Object
  * @category Package : @augment-vir/common
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
-export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = {
-    [Key in KeysType]: Required<Pick<ObjectType, Key>> & Partial<Record<Exclude<KeysType, Key>, never>>;
-}[KeysType] & Omit<ObjectType, KeysType>;
+export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If<IsNever<KeysType>, never, RequireExactlyOneHelper<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>>;
+type RequireAtLeastOneHelper<ObjectType, KeysType extends keyof ObjectType> = {
+    [Key in KeysType]-?: Required<Pick<ObjectType, Key>> & Partial<Pick<ObjectType, Exclude<KeysType, Key>>>;
+}[KeysType] & Except<ObjectType, KeysType>;
 /**
  * Create a type that requires at least one of the given keys, while keeping the remaining
  * (non-listed) keys as is.
  *
- * Copied from the classic `RequireAtLeastOne` implementation in the `type-fest` package (before
- * `type-fest` v5 wrapped it in an `IfNotAnyOrNever` conditional). See the note in
- * `type-checks.ts`.
+ * Copied from the `RequireAtLeastOne` type in `type-fest` v5.6 so that this package's public types
+ * do not depend on `type-fest` (see the note in `type-checks.ts`).
  *
  * @category Object
  * @category Package : @augment-vir/common
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
-export type RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = {
-    [Key in KeysType]-?: Required<Pick<ObjectType, Key>> & Partial<Pick<ObjectType, Exclude<KeysType, Key>>>;
-}[KeysType] & Omit<ObjectType, KeysType>;
+export type RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If<IsNever<KeysType>, never, RequireAtLeastOneHelper<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>>;
+export {};

package/dist/augments/type/require-one-or-none.d.ts

@@ -1,16 +1,18 @@
+import { type If, type IfNotAnyOrNever } from './conditional-type.js';
 import { type RequireExactlyOne } from './require-keys.js';
+import { type IsAny, type IsNever } from './type-checks.js';
 type RequireNone<KeysType extends PropertyKey> = Partial<Record<KeysType, never>>;
+type RequireOneOrNoneHelper<ObjectType, KeysType extends keyof ObjectType> = (RequireExactlyOne<ObjectType, KeysType> | RequireNone<KeysType>) & Omit<ObjectType, KeysType>;
 /**
  * Create a type that requires exactly one of the given keys or none of the given keys, while
  * keeping the remaining keys as is.
  *
- * Copied from the classic `RequireOneOrNone` implementation in the `type-fest` package (before
- * `type-fest` v5 wrapped it in an `IfNotAnyOrNever` conditional). See the note in
- * `type-checks.ts`.
+ * Copied from the `RequireOneOrNone` type in `type-fest` v5.6 so that this package's public types
+ * do not depend on `type-fest` (see the note in `type-checks.ts`).
  *
  * @category Object
  * @category Package : @augment-vir/common
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
-export type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = (RequireExactlyOne<ObjectType, KeysType> | RequireNone<KeysType>) & Omit<ObjectType, KeysType>;
+export type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If<IsNever<KeysType>, ObjectType, RequireOneOrNoneHelper<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>>;
 export {};

package/dist/augments/type/type-checks.d.ts

@@ -1,11 +1,11 @@
 /**
- * These type predicates are copied from the `type-fest` package rather than imported from it.
- * Owning them here keeps `@augment-vir` (and its consumers) decoupled from `type-fest`'s evolving
- * internals: `type-fest` v5 started wrapping several of its utility types in an `IfNotAnyOrNever`
- * conditional that breaks structural assignability and narrowing, and because those utilities leak
- * through the public `.d.ts` of downstream packages, a `type-fest` upgrade could silently break
- * consumers. These local copies use only built-in types so they never reference `type-fest`.
+ * These type predicates are copied from `type-fest` v5.6 rather than imported from it. Owning them
+ * here keeps `@augment-vir` (and its consumers) decoupled from `type-fest`'s evolving internals:
+ * these utilities leak through the public `.d.ts` of downstream packages, so a `type-fest` upgrade
+ * could otherwise silently break consumers. These local copies use only built-in types so they
+ * never reference `type-fest`.
  */
+type IsEqualHelper<A, B> = (<G>() => G extends (A & G) | G ? 1 : 2) extends <G>() => G extends (B & G) | G ? 1 : 2 ? true : false;
 /**
  * Returns `true` if the two given types are exactly equal, otherwise `false`.
  *
@@ -13,7 +13,7 @@
  * @category Package : @augment-vir/common
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
-export type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends <G>() => G extends B ? 1 : 2 ? true : false;
+export type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? IsEqualHelper<A, B> : false : false;
 /**
  * Returns `true` if the given type is `never`, otherwise `false`.
  *
@@ -29,4 +29,5 @@ export type IsNever<T> = [T] extends [never] ? true : false;
  * @category Package : @augment-vir/common
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
-export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+export {};

package/dist/augments/type/type-checks.js

@@ -1,9 +1,8 @@
 /**
- * These type predicates are copied from the `type-fest` package rather than imported from it.
- * Owning them here keeps `@augment-vir` (and its consumers) decoupled from `type-fest`'s evolving
- * internals: `type-fest` v5 started wrapping several of its utility types in an `IfNotAnyOrNever`
- * conditional that breaks structural assignability and narrowing, and because those utilities leak
- * through the public `.d.ts` of downstream packages, a `type-fest` upgrade could silently break
- * consumers. These local copies use only built-in types so they never reference `type-fest`.
+ * These type predicates are copied from `type-fest` v5.6 rather than imported from it. Owning them
+ * here keeps `@augment-vir` (and its consumers) decoupled from `type-fest`'s evolving internals:
+ * these utilities leak through the public `.d.ts` of downstream packages, so a `type-fest` upgrade
+ * could otherwise silently break consumers. These local copies use only built-in types so they
+ * never reference `type-fest`.
  */
 export {};

package/dist/augments/type/union-member.d.ts

@@ -0,0 +1,14 @@
+import { type IsNever } from './type-checks.js';
+import { type UnionToIntersection } from './union-to-intersection.js';
+/**
+ * Returns a single member of the given union. Which member is returned is not guaranteed, but it is
+ * deterministic for a given union.
+ *
+ * Copied from the `UnionMember` type in the `type-fest` package so that this package's public types
+ * do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Type
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type UnionMember<T> = IsNever<T> extends true ? never : UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;

package/dist/augments/type/union-member.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/union-to-tuple.d.ts

@@ -1,18 +1,21 @@
-import { type UnionToIntersection } from './union-to-intersection.js';
-type LastOfUnion<Union> = UnionToIntersection<Union extends unknown ? () => Union : never> extends () => infer Last ? Last : never;
+import { type ExcludeExactly } from './exclude-exactly.js';
+import { type IsNever } from './type-checks.js';
+import { type UnionMember } from './union-member.js';
+import { type UnknownArray } from './unknown-array.js';
+type UnionToTupleHelper<Union, Accumulator extends UnknownArray = [], Member = UnionMember<Union>> = IsNever<Union> extends true ? Accumulator : UnionToTupleHelper<ExcludeExactly<Union, Member>, [
+    Member,
+    ...Accumulator
+]>;
 /**
  * Convert a union type into an unordered tuple type of its elements. The order of the resulting
  * tuple is not guaranteed.
  *
- * Copied from the `UnionToTuple` type in the `type-fest` package so that this package's public
- * types do not depend on `type-fest` (see the note in `type-checks.ts`).
+ * Copied from the `UnionToTuple` type in `type-fest` v5.6 so that this package's public types do
+ * not depend on `type-fest` (see the note in `type-checks.ts`).
  *
  * @category Array
  * @category Package : @augment-vir/common
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
-export type UnionToTuple<Union, Accumulator extends unknown[] = []> = [Union] extends [never] ? Accumulator : UnionToTuple<Exclude<Union, LastOfUnion<Union>>, [
-    LastOfUnion<Union>,
-    ...Accumulator
-]>;
+export type UnionToTuple<Union> = UnionToTupleHelper<Union> extends infer Result extends UnknownArray ? Result : never;
 export {};

package/dist/index.d.ts

@@ -39,6 +39,7 @@ export * from './augments/string/match.js';
 export * from './augments/string/punctuation.js';
 export * from './augments/string/remove-duplicate-characters.js';
 export * from './augments/string/uuid.js';
+export * from './augments/type/apply-default-options.js';
 export * from './augments/type/branded-type.js';
 export * from './augments/type/built-in-type.js';
 export * from './augments/type/conditional-type.js';
@@ -47,9 +48,11 @@ export * from './augments/type/distributed-omit.js';
 export * from './augments/type/empty-object.js';
 export * from './augments/type/exact.js';
 export * from './augments/type/except.js';
+export * from './augments/type/exclude-exactly.js';
 export * from './augments/type/is-unknown.js';
 export * from './augments/type/keys-of-union.js';
 export * from './augments/type/literal-union.js';
+export * from './augments/type/merge.js';
 export * from './augments/type/non-empty-string.js';
 export * from './augments/type/omit-deep.js';
 export * from './augments/type/omit-index-signature.js';
@@ -70,6 +73,7 @@ export * from './augments/type/tagged.js';
 export * from './augments/type/type-checks.js';
 export * from './augments/type/typed-array.js';
 export * from './augments/type/undefined-to-optional.js';
+export * from './augments/type/union-member.js';
 export * from './augments/type/union-to-intersection.js';
 export * from './augments/type/union-to-tuple.js';
 export * from './augments/type/unknown-array.js';

package/dist/index.js

@@ -39,6 +39,7 @@ export * from './augments/string/match.js';
 export * from './augments/string/punctuation.js';
 export * from './augments/string/remove-duplicate-characters.js';
 export * from './augments/string/uuid.js';
+export * from './augments/type/apply-default-options.js';
 export * from './augments/type/branded-type.js';
 export * from './augments/type/built-in-type.js';
 export * from './augments/type/conditional-type.js';
@@ -47,9 +48,11 @@ export * from './augments/type/distributed-omit.js';
 export * from './augments/type/empty-object.js';
 export * from './augments/type/exact.js';
 export * from './augments/type/except.js';
+export * from './augments/type/exclude-exactly.js';
 export * from './augments/type/is-unknown.js';
 export * from './augments/type/keys-of-union.js';
 export * from './augments/type/literal-union.js';
+export * from './augments/type/merge.js';
 export * from './augments/type/non-empty-string.js';
 export * from './augments/type/omit-deep.js';
 export * from './augments/type/omit-index-signature.js';
@@ -70,6 +73,7 @@ export * from './augments/type/tagged.js';
 export * from './augments/type/type-checks.js';
 export * from './augments/type/typed-array.js';
 export * from './augments/type/undefined-to-optional.js';
+export * from './augments/type/union-member.js';
 export * from './augments/type/union-to-intersection.js';
 export * from './augments/type/union-to-tuple.js';
 export * from './augments/type/unknown-array.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/core",
-    "version": "32.2.0",
+    "version": "32.2.1",
     "description": "Core augment-vir augments. Use @augment-vir/common instead.",
     "homepage": "https://github.com/electrovir/augment-vir",
     "bugs": {