@augment-vir/core 32.1.0 → 32.2.0

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

@@ -0,0 +1,43 @@
+import { type RequiredKeysOf } from '../object/required-keys.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`).
+ *
+ * @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;
+/**
+ * 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`.
+ *
+ * @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>;
+/**
+ * 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`.
+ *
+ * @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>;

package/dist/augments/type/require-keys.js

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

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

@@ -0,0 +1,16 @@
+import { type RequireExactlyOne } from './require-keys.js';
+type RequireNone<KeysType extends PropertyKey> = Partial<Record<KeysType, never>>;
+/**
+ * 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`.
+ *
+ * @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 {};

package/dist/augments/type/require-one-or-none.js

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

package/dist/augments/type/set-optional.d.ts

@@ -0,0 +1,19 @@
+import { type Except } from './except.js';
+import { type KeysOfUnion } from './keys-of-union.js';
+import { type Simplify } from './simplify.js';
+type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = {
+    [P in keyof T as Extract<P, Keys>]: T[P];
+};
+type _SetOptional<BaseType, Keys extends keyof BaseType> = BaseType extends unknown ? Simplify<Except<BaseType, Keys> & Partial<HomomorphicPick<BaseType, Keys>>> : never;
+/**
+ * Create a type that makes the given keys optional, while keeping the remaining keys as is.
+ *
+ * Copied from the `SetOptional` 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 SetOptional<BaseType, Keys extends keyof BaseType> = (BaseType extends (...arguments_: never) => any ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetOptional<BaseType, Keys>;
+export {};

package/dist/augments/type/set-optional.js

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

package/dist/augments/type/set-required.d.ts

@@ -0,0 +1,47 @@
+import { type If } from './conditional-type.js';
+import { type Except } from './except.js';
+import { type KeysOfUnion } from './keys-of-union.js';
+import { type OptionalKeysOf } from './optional-keys-of.js';
+import { type Simplify } from './simplify.js';
+import { type IsNever } from './type-checks.js';
+import { type UnknownArray } from './unknown-array.js';
+type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = {
+    [P in keyof T as Extract<P, Keys>]: T[P];
+};
+type IsArrayReadonly<T extends UnknownArray> = If<IsNever<T>, false, T extends unknown[] ? false : true>;
+/** Remove the optional modifier from the specified keys in an array. */
+type SetArrayRequired<TArray extends UnknownArray, Keys, Counter extends any[] = [], Accumulator extends UnknownArray = []> = TArray extends unknown ? keyof TArray & `${number}` extends never ? [
+    ...Accumulator,
+    ...TArray
+] : TArray extends readonly [
+    (infer First)?,
+    ...infer Rest
+] ? '0' extends OptionalKeysOf<TArray> ? `${Counter['length']}` extends `${Keys & (string | number)}` ? SetArrayRequired<Rest, Keys, [
+    ...Counter,
+    any
+], [
+    ...Accumulator,
+    First
+]> : [
+    ...Accumulator,
+    ...TArray
+] : SetArrayRequired<Rest, Keys, [
+    ...Counter,
+    any
+], [
+    ...Accumulator,
+    TArray[0]
+]> : never : never;
+type _SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? If<IsArrayReadonly<BaseType>, Readonly<ResultantArray>, ResultantArray> : never : Simplify<Except<BaseType, Keys> & Required<HomomorphicPick<BaseType, Keys>>>;
+/**
+ * Create a type that makes the given keys required, while keeping the remaining keys as is.
+ *
+ * Copied from the `SetRequired` 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 SetRequired<BaseType, Keys extends keyof BaseType> = (BaseType extends (...arguments_: never) => any ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetRequired<BaseType, Keys>;
+export {};

package/dist/augments/type/set-required.js

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

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

@@ -0,0 +1,14 @@
+/**
+ * Flattens the type output to improve type hints shown in editors. Also transforms an interface
+ * into a type to aid with assignability.
+ *
+ * Copied from the `Simplify` 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 Simplify<T> = {
+    [KeyType in keyof T]: T[KeyType];
+} & {};

package/dist/augments/type/simplify.js

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

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

@@ -0,0 +1,177 @@
+import { type NegativeInfinity, type PositiveInfinity } from '../number/infinity.js';
+import { type If } from './conditional-type.js';
+import { type IsAny, type IsEqual, type IsNever } from './type-checks.js';
+import { type UnknownArray } from './unknown-array.js';
+type Numeric = number | bigint;
+type Zero = 0 | 0n;
+type Negative<T extends Numeric> = T extends Zero ? never : `${T}` extends `-${string}` ? T : never;
+type IsNegative<T extends Numeric> = T extends Negative<T> ? true : false;
+type ReverseSign<N extends number> = N extends 0 ? 0 : N extends PositiveInfinity ? NegativeInfinity : N extends NegativeInfinity ? PositiveInfinity : `${N}` extends `-${infer P extends number}` ? P : `-${N}` extends `${infer R extends number}` ? R : never;
+type StringToNumber<S extends string> = S extends `${infer N extends number}` ? N : S extends 'Infinity' ? PositiveInfinity : S extends '-Infinity' ? NegativeInfinity : never;
+type Absolute<N extends number | bigint> = N extends bigint ? `${N}` extends `-${infer Magnitude extends bigint}` ? Magnitude : N : `${N}` extends `-${infer Magnitude}` ? StringToNumber<Magnitude> : N;
+type IfNotAnyOrNever<T, IfNotAny, IfAny = any, IfNever = never> = If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAny>>;
+type DigitCharacter = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+type DigitTupleOf<Digit extends DigitCharacter, Fill> = [
+    [
+    ],
+    [
+        Fill
+    ],
+    [
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill
+    ]
+][Digit];
+type RepeatTupleTenTimes<Tuple extends UnknownArray> = [
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple
+];
+type BuildTupleDigitByDigit<Length extends string, Fill, Accumulator extends UnknownArray = []> = Length extends `${infer First extends DigitCharacter}${infer Rest}` ? BuildTupleDigitByDigit<Rest, Fill, [
+    ...RepeatTupleTenTimes<Accumulator>,
+    ...DigitTupleOf<First, Fill>
+]> : Accumulator;
+type BuildTuple<Length extends number, Fill> = number extends Length ? Fill[] : BuildTupleDigitByDigit<`${Length}`, Fill>;
+type TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length, BuildTuple<If<IsNegative<Length>, 0, Length>, Fill>, Fill[], [
+]>;
+type And<A extends boolean, B extends boolean> = A extends true ? B extends true ? true : false : false;
+type Or<A extends boolean, B extends boolean> = A extends true ? true : B extends true ? true : false;
+type StringToArray<S extends string, Result extends string[] = []> = string extends S ? never : S extends `${infer F}${infer R}` ? StringToArray<R, [
+    ...Result,
+    F
+]> : Result;
+type StringLength<S extends string> = string extends S ? never : StringToArray<S>['length'];
+type NumericString = '0123456789';
+type PositiveNumericCharacterGt<A extends string, B extends string> = NumericString extends `${infer HeadA}${A}${infer TailA}` ? NumericString extends `${infer HeadB}${B}${infer TailB}` ? HeadA extends `${HeadB}${infer _}${infer __}` ? true : false : never : never;
+type SameLengthPositiveNumericStringGt<A extends string, B extends string> = A extends `${infer FirstA}${infer RestA}` ? B extends `${infer FirstB}${infer RestB}` ? FirstA extends FirstB ? SameLengthPositiveNumericStringGt<RestA, RestB> : PositiveNumericCharacterGt<FirstA, FirstB> : never : false;
+type PositiveNumericStringGt<A extends string, B extends string> = A extends B ? false : [
+    TupleOf<StringLength<A>, 0>,
+    TupleOf<StringLength<B>, 0>
+] extends infer R extends [
+    readonly unknown[],
+    readonly unknown[]
+] ? R[0] extends [
+    ...R[1],
+    ...infer Remain extends readonly unknown[]
+] ? 0 extends Remain['length'] ? SameLengthPositiveNumericStringGt<A, B> : true : false : never;
+type GreaterThan<A extends number, B extends number> = A extends number ? B extends number ? number extends A | B ? boolean : [
+    IsEqual<A, PositiveInfinity>,
+    IsEqual<A, NegativeInfinity>,
+    IsEqual<B, PositiveInfinity>,
+    IsEqual<B, NegativeInfinity>
+] extends infer R extends [
+    boolean,
+    boolean,
+    boolean,
+    boolean
+] ? Or<And<IsEqual<R[0], true>, IsEqual<R[2], false>>, And<IsEqual<R[3], true>, IsEqual<R[1], false>>> extends true ? true : Or<And<IsEqual<R[1], true>, IsEqual<R[3], false>>, And<IsEqual<R[2], true>, IsEqual<R[0], false>>> extends true ? false : true extends R[number] ? false : [
+    IsNegative<A>,
+    IsNegative<B>
+] extends infer R extends [
+    boolean,
+    boolean
+] ? [
+    true,
+    false
+] extends R ? false : [
+    false,
+    true
+] extends R ? true : [
+    false,
+    false
+] extends R ? PositiveNumericStringGt<`${A}`, `${B}`> : PositiveNumericStringGt<`${Absolute<B>}`, `${Absolute<A>}`> : never : never : never : never;
+type GreaterThanOrEqual<A extends number, B extends number> = number extends A | B ? boolean : A extends number ? B extends number ? A extends B ? true : GreaterThan<A, B> : never : never;
+type LessThan<A extends number, B extends number> = GreaterThanOrEqual<A, B> extends infer Result ? (Result extends true ? false : true) : never;
+type SubtractIfAGreaterThanB<A extends number, B extends number> = TupleOf<A> extends [
+    ...TupleOf<B>,
+    ...infer R
+] ? R['length'] : never;
+type SubtractPositives<A extends number, B extends number> = LessThan<A, B> extends true ? ReverseSign<SubtractIfAGreaterThanB<B, A>> : SubtractIfAGreaterThanB<A, B>;
+type SubtractPostChecks<A extends number, B extends number, AreNegative = [
+    IsNegative<A>,
+    IsNegative<B>
+]> = AreNegative extends [
+    false,
+    false
+] ? SubtractPositives<A, B> : AreNegative extends [
+    true,
+    true
+] ? ReverseSign<SubtractPositives<Absolute<A>, Absolute<B>>> : [
+    ...TupleOf<Absolute<A>>,
+    ...TupleOf<Absolute<B>>
+] extends infer R extends unknown[] ? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length'] : never;
+/**
+ * Returns the difference between two numbers. `A` or `B` can only support `-999` ~ `999`.
+ *
+ * Copied from the `Subtract` 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 Number
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export 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>;
+export {};

package/dist/augments/type/subtract.js

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

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

@@ -0,0 +1,30 @@
+declare const tag: unique symbol;
+/**
+ * The container object that holds a {@link Tagged} type's tags.
+ *
+ * Copied from the `TagContainer` 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 TagContainer<Token> = {
+    readonly [tag]: Token;
+};
+type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{
+    [K in Token]: TagMetadata;
+}>;
+/**
+ * Create a tagged type that can support multiple tags and per-tag metadata. Useful for creating
+ * distinct types that are not assignable to one another even though they share an underlying type.
+ *
+ * Copied from the `Tagged` 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 Tagged<Type, TagName extends PropertyKey, TagMetadata = never> = Type & Tag<TagName, TagMetadata>;
+export {};

package/dist/augments/type/tagged.js

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

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

@@ -0,0 +1,32 @@
+/**
+ * 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`.
+ */
+/**
+ * Returns `true` if the two given types are exactly equal, otherwise `false`.
+ *
+ * @category Type
+ * @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;
+/**
+ * Returns `true` if the given type is `never`, otherwise `false`.
+ *
+ * @category Type
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Returns `true` if the given type is `any`, otherwise `false`.
+ *
+ * @category Type
+ * @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;

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

@@ -0,0 +1,9 @@
+/**
+ * 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`.
+ */
+export {};

package/dist/augments/type/typed-array.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Matches any [typed
+ * array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/TypedArray),
+ * like `Uint8Array` or `Float64Array`.
+ *
+ * Copied from the `TypedArray` 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 Array
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;

package/dist/augments/type/typed-array.js

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

package/dist/augments/type/undefined-to-optional.d.ts

@@ -0,0 +1,27 @@
+import { type IsUnknown } from './is-unknown.js';
+import { type Simplify } from './simplify.js';
+import { type IsAny } from './type-checks.js';
+type BaseKeyFilter<Type, Key extends keyof Type> = Key extends symbol ? never : Type[Key] extends symbol ? never : Type[Key] extends Record<string, unknown> ? Key : [(...arguments_: any[]) => any] extends [Type[Key]] ? never : Key;
+type FilterDefinedKeys<T extends object> = Exclude<{
+    [Key in keyof T]: IsAny<T[Key]> extends true ? Key : IsUnknown<T[Key]> extends true ? Key : undefined extends T[Key] ? never : T[Key] extends undefined ? never : BaseKeyFilter<T, Key>;
+}[keyof T], undefined>;
+type FilterOptionalKeys<T extends object> = Exclude<{
+    [Key in keyof T]: IsAny<T[Key]> extends true ? never : undefined extends T[Key] ? T[Key] extends undefined ? never : BaseKeyFilter<T, Key> : never;
+}[keyof T], undefined>;
+/**
+ * For an object `T`, if it has any properties that are a union with `undefined`, make those into
+ * optional properties instead.
+ *
+ * Copied from the internal `UndefinedToOptional` 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 UndefinedToOptional<T extends object> = Simplify<{
+    [Key in keyof Pick<T, FilterDefinedKeys<T>>]: T[Key];
+} & {
+    [Key in keyof Pick<T, FilterOptionalKeys<T>>]?: Exclude<T[Key], undefined>;
+}>;
+export {};

package/dist/augments/type/undefined-to-optional.js

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

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

@@ -0,0 +1,11 @@
+/**
+ * Convert a union type to an intersection type.
+ *
+ * Copied from the `UnionToIntersection` 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 UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection & Union : never;

package/dist/augments/type/union-to-intersection.js

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

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

@@ -0,0 +1,18 @@
+import { type UnionToIntersection } from './union-to-intersection.js';
+type LastOfUnion<Union> = UnionToIntersection<Union extends unknown ? () => Union : never> extends () => infer Last ? Last : never;
+/**
+ * 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`).
+ *
+ * @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 {};

package/dist/augments/type/union-to-tuple.js

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

package/dist/augments/type/unknown-array.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Represents an array with `unknown` values. Any array can be assigned to this type.
+ *
+ * Copied from the `UnknownArray` 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 Array
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type UnknownArray = readonly unknown[];

package/dist/augments/type/unknown-array.js

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

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

@@ -0,0 +1,32 @@
+import { type BuiltIns, type HasMultipleCallSignatures } from './built-in-type.js';
+type WritableMapDeep<MapType extends ReadonlyMap<unknown, unknown>> = MapType extends ReadonlyMap<infer KeyType, infer ValueType> ? Map<WritableDeep<KeyType>, WritableDeep<ValueType>> : MapType;
+type WritableSetDeep<SetType extends ReadonlySet<unknown>> = SetType extends ReadonlySet<infer ItemType> ? Set<WritableDeep<ItemType>> : SetType;
+type WritableObjectDeep<ObjectType extends object> = {
+    -readonly [KeyType in keyof ObjectType]: WritableDeep<ObjectType[KeyType]>;
+};
+type WritableArrayDeep<ArrayType extends readonly unknown[]> = ArrayType extends readonly [] ? [] : ArrayType extends readonly [
+    ...infer U,
+    infer V
+] ? [
+    ...WritableArrayDeep<U>,
+    WritableDeep<V>
+] : ArrayType extends readonly [
+    infer U,
+    ...infer V
+] ? [
+    WritableDeep<U>,
+    ...WritableArrayDeep<V>
+] : ArrayType extends ReadonlyArray<infer U> ? Array<WritableDeep<U>> : ArrayType extends Array<infer U> ? Array<WritableDeep<U>> : ArrayType;
+/**
+ * Create a deeply mutable version of an `object`/`ReadonlyMap`/`ReadonlySet`/`ReadonlyArray` type.
+ * The inverse of `ReadonlyDeep<T>`.
+ *
+ * Copied from the `WritableDeep` 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 WritableDeep<T> = T extends BuiltIns ? T : T extends (...arguments_: any[]) => unknown ? {} extends WritableObjectDeep<T> ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & WritableObjectDeep<T> : T extends ReadonlyMap<unknown, unknown> ? WritableMapDeep<T> : T extends ReadonlySet<unknown> ? WritableSetDeep<T> : T extends readonly unknown[] ? WritableArrayDeep<T> : T extends object ? WritableObjectDeep<T> : unknown;
+export {};

package/dist/augments/type/writable-deep.js

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

package/dist/augments/type/writable-keys-of.d.ts

@@ -0,0 +1,12 @@
+import { type ReadonlyKeysOf } from './readonly-keys-of.js';
+/**
+ * Extract all writable keys from the given type.
+ *
+ * Copied from the `WritableKeysOf` 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 WritableKeysOf<Type extends object> = Type extends unknown ? Exclude<keyof Type, ReadonlyKeysOf<Type>> : never;

package/dist/augments/type/writable-keys-of.js

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

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

@@ -0,0 +1,29 @@
+import { type Except } from './except.js';
+import { type Simplify } from './simplify.js';
+type WritableArray<ArrayType extends readonly unknown[]> = ArrayType extends readonly [] ? [] : ArrayType extends readonly [
+    ...infer U,
+    infer V
+] ? [
+    ...U,
+    V
+] : ArrayType extends readonly [
+    infer U,
+    ...infer V
+] ? [
+    U,
+    ...V
+] : ArrayType extends ReadonlyArray<infer U> ? U[] : ArrayType;
+/**
+ * Create a type that strips `readonly` from the given type. Inverse of `Readonly<T>`.
+ *
+ * Copied from the `Writable` 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 Writable<BaseType, Keys extends keyof BaseType = keyof BaseType> = BaseType extends ReadonlyMap<infer KeyType, infer ValueType> ? Map<KeyType, ValueType> : BaseType extends ReadonlySet<infer ItemType> ? Set<ItemType> : BaseType extends readonly unknown[] ? WritableArray<BaseType> : Simplify<Except<BaseType, Keys> & {
+    -readonly [KeyType in keyof Pick<BaseType, Keys>]: Pick<BaseType, Keys>[KeyType];
+}>;
+export {};

package/dist/augments/type/writable.js

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