@augment-vir/core 32.1.0 → 32.2.0

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

@@ -0,0 +1,290 @@
+import { type BuiltIns } from './built-in-type.js';
+import { type If } from './conditional-type.js';
+import { type LiteralUnion } from './literal-union.js';
+import { type IsAny, type IsEqual, type IsNever } from './type-checks.js';
+import { type UnknownArray } from './unknown-array.js';
+type IfNotAnyOrNever<T, IfNotAny, IfAny = any, IfNever = never> = If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAny>>;
+type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown) | Promise<unknown>;
+type MapsSetsOrArrays = ReadonlyMap<unknown, unknown> | WeakMap<WeakKey, unknown> | ReadonlySet<unknown> | WeakSet<WeakKey> | UnknownArray;
+type DigitCharacter = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+type PositiveInfinity = 1e999;
+type NegativeInfinity = -1e999;
+type Zero = 0 | 0n;
+type Negative<T extends number | bigint> = T extends Zero ? never : `${T}` extends `-${string}` ? T : never;
+type IsNegative<T extends number | bigint> = 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 StringToArray<S extends string, Result extends string[] = []> = string extends S ? never : S extends `${infer First}${infer Rest}` ? StringToArray<Rest, [
+    ...Result,
+    First
+]> : 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 _Middle}${infer _Rest}` ? 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 Lengths extends [
+    readonly unknown[],
+    readonly unknown[]
+] ? Lengths[0] extends [
+    ...Lengths[1],
+    ...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.
+ */
+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}. */
+type Or<A extends boolean, B extends boolean> = A extends true ? true : B extends true ? true : false;
+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 Signs extends [
+    boolean,
+    boolean
+] ? [
+    true,
+    false
+] extends Signs ? false : [
+    false,
+    true
+] extends Signs ? true : [
+    false,
+    false
+] extends Signs ? 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 _TupleOf<Length extends number, Fill> = number extends Length ? Fill[] : BuildTupleDigitByDigit<`${Length}`, Fill>;
+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 RepeatTupleTenTimes<Tuple extends UnknownArray> = [
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple
+];
+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 TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length, _TupleOf<If<IsNegative<Length>, 0, Length>, Fill>, Fill[], [
+]>;
+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;
+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 StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> = T extends unknown ? number extends T['length'] ? T extends readonly [
+    infer U,
+    ...infer V
+] ? StaticPartOfArray<V, [
+    ...Result,
+    U
+]> : Result : T : never;
+type VariablePartOfArray<T extends UnknownArray> = T extends unknown ? T extends readonly [
+    ...StaticPartOfArray<T>,
+    ...infer U
+] ? U : [] : never;
+type SetArrayAccess<T extends UnknownArray, IsReadonly extends boolean> = T extends readonly [
+    ...infer U
+] ? IsReadonly extends true ? readonly [...U] : [...U] : T;
+type IsArrayReadonly<T extends UnknownArray> = If<IsNever<T>, false, T extends unknown[] ? false : true>;
+type SplitFixedArrayByIndex<T extends UnknownArray, SplitIndex extends number> = SplitIndex extends 0 ? [
+    [
+    ],
+    T
+] : T extends readonly [
+    ...TupleOf<SplitIndex>,
+    ...infer V
+] ? T extends readonly [
+    ...infer U,
+    ...V
+] ? [
+    U,
+    V
+] : [
+    never,
+    never
+] : [
+    never,
+    never
+];
+type SplitVariableArrayByIndex<T extends UnknownArray, SplitIndex extends number, T1 = Subtract<SplitIndex, StaticPartOfArray<T>['length']>, T2 = T1 extends number ? TupleOf<GreaterThanOrEqual<T1, 0> extends true ? T1 : number, VariablePartOfArray<T>[number]> : []> = SplitIndex extends 0 ? [
+    [
+    ],
+    T
+] : GreaterThanOrEqual<StaticPartOfArray<T>['length'], SplitIndex> extends true ? [
+    SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[0],
+    [
+        ...SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[1],
+        ...VariablePartOfArray<T>
+    ]
+] : [
+    [
+        ...StaticPartOfArray<T>,
+        ...(T2 extends UnknownArray ? T2 : [])
+    ],
+    VariablePartOfArray<T>
+];
+type SplitArrayByIndex<T extends UnknownArray, SplitIndex extends number> = SplitIndex extends 0 ? [
+    [
+    ],
+    T
+] : number extends T['length'] ? SplitVariableArrayByIndex<T, SplitIndex> : SplitFixedArrayByIndex<T, SplitIndex>;
+type ArraySplice<T extends UnknownArray, Start extends number, DeleteCount extends number, Items extends UnknownArray = []> = SplitArrayByIndex<T, Start> extends [
+    infer U extends UnknownArray,
+    infer V extends UnknownArray
+] ? SplitArrayByIndex<V, DeleteCount> extends [
+    infer _Deleted extends UnknownArray,
+    infer X extends UnknownArray
+] ? [
+    ...U,
+    ...Items,
+    ...X
+] : never : never;
+type ToString<T> = T extends string | number ? `${T}` : never;
+type ExactKey<T extends object, Key extends PropertyKey> = Key extends keyof T ? Key : ToString<Key> extends keyof T ? ToString<Key> : Key extends `${infer NumberKey extends number}` ? NumberKey extends keyof T ? NumberKey : never : never;
+type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection & Union : never;
+type UnionMember<T> = IsNever<T> extends true ? never : UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
+type _ExcludeExactly<Union, Delete> = IfNotAnyOrNever<Delete, Union extends unknown ? [
+    Delete extends unknown ? If<IsEqual<Union, Delete>, true, never> : never
+] extends [never] ? Union : never : never, Union, Union>;
+type ExcludeExactly<Union, Delete> = IfNotAnyOrNever<Union, _ExcludeExactly<Union, Delete>, If<IsAny<Delete>, never, Union>, If<IsNever<Delete>, never, Union>>;
+type _UnionToTuple<Union, Accumulator extends UnknownArray = [], Member = UnionMember<Union>> = IsNever<Union> extends true ? Accumulator : _UnionToTuple<ExcludeExactly<Union, Member>, [
+    Member,
+    ...Accumulator
+]>;
+type UnionToTuple<Union> = _UnionToTuple<Union> extends infer Result extends UnknownArray ? Result : never;
+type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType ? Type : Type extends IncludeType ? {
+    [TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType>;
+} : Type;
+type SimplifyDeep<Type, ExcludeType = never> = ConditionalSimplifyDeep<Type, ExcludeType | NonRecursiveType | Exclude<MapsSetsOrArrays, UnknownArray>, object>;
+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;
+type OmitDeepObjectWithOnePath<ObjectT extends object, P extends string | number> = P extends `${infer RecordKeyInPath}.${infer SubPath}` ? {
+    [Key in keyof ObjectT]: IsEqual<RecordKeyInPath, ToString<Key>> extends true ? ExactKey<ObjectT, Key> extends infer RealKey ? RealKey extends keyof ObjectT ? OmitDeepWithOnePath<ObjectT[RealKey], SubPath> : ObjectT[Key] : ObjectT[Key] : ObjectT[Key];
+} : ExactKey<ObjectT, P> extends infer Key ? IsNever<Key> extends true ? ObjectT : Key extends PropertyKey ? Omit<ObjectT, Key> : ObjectT : ObjectT;
+type OmitDeepWithOnePath<T, Path extends string | number> = T extends NonRecursiveType ? T : T extends UnknownArray ? SetArrayAccess<OmitDeepArrayWithOnePath<T, Path>, IsArrayReadonly<T>> : T extends object ? OmitDeepObjectWithOnePath<T, Path> : T;
+type OmitDeepHelper<T, PathTuple extends UnknownArray> = PathTuple extends [
+    infer Path,
+    ...infer RestPaths
+] ? OmitDeepHelper<OmitDeepWithOnePath<T, Path & (string | number)>, RestPaths> : T;
+/**
+ * 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.
+ *
+ * @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 {};

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * Omit any index signatures from the given object type, leaving only explicitly defined properties.
+ * This is the counterpart of `PickIndexSignature`.
+ *
+ * Copied from the `OmitIndexSignature` 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 OmitIndexSignature<ObjectType> = {
+    [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType];
+};

package/dist/augments/type/omit-index-signature.js

@@ -0,0 +1,2 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type -- faithful copy of type-fest, which intentionally uses the `{}` identity type. */
+export {};

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

@@ -0,0 +1,25 @@
+import { type IsAny } from './type-checks.js';
+/**
+ * Returns a boolean for whether the given key is an optional key of the given type.
+ *
+ * Copied from the `IsOptionalKeyOf` 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 IsOptionalKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends keyof Type ? Type extends Record<Key, Type[Key]> ? false : true : false;
+/**
+ * Extract all optional keys from the given type.
+ *
+ * Copied from the `OptionalKeysOf` 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 OptionalKeysOf<Type extends object> = Type extends unknown ? keyof {
+    [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never;
+} & keyof Type : never;

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

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

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

@@ -0,0 +1,176 @@
+import { type JsonObject, type JsonValue } from '../json/json-value.js';
+import { type LiteralUnion } from './literal-union.js';
+type Person = string | {
+    name: string;
+    url?: string;
+    email?: string;
+};
+type BugsLocation = string | {
+    url?: string;
+    email?: string;
+};
+type DirectoryLocations = {
+    [directoryType: string]: JsonValue | undefined;
+    bin?: string;
+    doc?: string;
+    example?: string;
+    lib?: string;
+    man?: string;
+    test?: string;
+};
+type Scripts = {
+    prepublish?: string;
+    prepare?: string;
+    prepublishOnly?: string;
+    prepack?: string;
+    postpack?: string;
+    publish?: string;
+    postpublish?: string;
+    preinstall?: string;
+    install?: string;
+    postinstall?: string;
+    preuninstall?: string;
+    uninstall?: string;
+    postuninstall?: string;
+    preversion?: string;
+    version?: string;
+    postversion?: string;
+    pretest?: string;
+    test?: string;
+    posttest?: string;
+    prestop?: string;
+    stop?: string;
+    poststop?: string;
+    prestart?: string;
+    start?: string;
+    poststart?: string;
+    prerestart?: string;
+    restart?: string;
+    postrestart?: string;
+} & Partial<Record<string, string>>;
+type Dependency = Partial<Record<string, string>>;
+type DependencyOverrides = {
+    [packageName in string]: string | undefined | DependencyOverrides;
+};
+type DevEngineDependency = {
+    name: string;
+    version?: string;
+    onFail?: 'ignore' | 'warn' | 'error' | 'download';
+};
+type ExportConditions = {
+    [condition: string]: Exports;
+};
+type Exports = null | string | Array<string | ExportConditions> | ExportConditions;
+type Imports = {
+    [key: `#${string}`]: Exports;
+};
+type NonStandardEntryPoints = {
+    module?: string;
+    esnext?: string | {
+        [moduleName: string]: string | undefined;
+        main?: string;
+        browser?: string;
+    };
+    browser?: string | Partial<Record<string, string | false>>;
+    sideEffects?: boolean | string[];
+};
+type TypeScriptConfiguration = {
+    types?: string;
+    typesVersions?: Partial<Record<string, Partial<Record<string, string[]>>>>;
+    typings?: string;
+};
+type WorkspaceConfig = {
+    packages?: string[];
+    nohoist?: string[];
+};
+type YarnConfiguration = {
+    flat?: boolean;
+    resolutions?: Dependency;
+};
+type JSPMConfiguration = {
+    jspm?: PackageJson;
+};
+type PublishConfig = {
+    [additionalProperties: string]: JsonValue | undefined;
+    access?: 'public' | 'restricted';
+    registry?: string;
+    tag?: string;
+};
+type NodeJsStandard = {
+    packageManager?: string;
+};
+type PackageJsonStandard = {
+    name?: string;
+    version?: string;
+    description?: string;
+    keywords?: string[];
+    homepage?: LiteralUnion<'.', string>;
+    bugs?: BugsLocation;
+    license?: string;
+    licenses?: Array<{
+        type?: string;
+        url?: string;
+    }>;
+    author?: Person;
+    contributors?: Person[];
+    maintainers?: Person[];
+    files?: string[];
+    type?: 'module' | 'commonjs';
+    main?: string;
+    exports?: Exports;
+    imports?: Imports;
+    bin?: string | Partial<Record<string, string>>;
+    man?: string | string[];
+    directories?: DirectoryLocations;
+    repository?: string | {
+        type: string;
+        url: string;
+        directory?: string;
+    };
+    scripts?: Scripts;
+    config?: JsonObject;
+    dependencies?: Dependency;
+    devDependencies?: Dependency;
+    optionalDependencies?: Dependency;
+    peerDependencies?: Dependency;
+    peerDependenciesMeta?: Partial<Record<string, {
+        optional: true;
+    }>>;
+    bundledDependencies?: string[];
+    bundleDependencies?: string[];
+    overrides?: DependencyOverrides;
+    engines?: {
+        [EngineName in LiteralUnion<'npm' | 'node', string>]?: string;
+    };
+    engineStrict?: boolean;
+    os?: Array<LiteralUnion<'aix' | 'darwin' | 'freebsd' | 'linux' | 'openbsd' | 'sunos' | 'win32' | '!aix' | '!darwin' | '!freebsd' | '!linux' | '!openbsd' | '!sunos' | '!win32', string>>;
+    cpu?: Array<LiteralUnion<'arm' | 'arm64' | 'ia32' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 's390' | 's390x' | 'x32' | 'x64' | '!arm' | '!arm64' | '!ia32' | '!mips' | '!mipsel' | '!ppc' | '!ppc64' | '!s390' | '!s390x' | '!x32' | '!x64', string>>;
+    devEngines?: {
+        os?: DevEngineDependency | DevEngineDependency[];
+        cpu?: DevEngineDependency | DevEngineDependency[];
+        libc?: DevEngineDependency | DevEngineDependency[];
+        runtime?: DevEngineDependency | DevEngineDependency[];
+        packageManager?: DevEngineDependency | DevEngineDependency[];
+    };
+    preferGlobal?: boolean;
+    private?: boolean;
+    publishConfig?: PublishConfig;
+    funding?: string | {
+        type?: LiteralUnion<'github' | 'opencollective' | 'patreon' | 'individual' | 'foundation' | 'corporation', string>;
+        url: string;
+    };
+    workspaces?: string[] | WorkspaceConfig;
+};
+/**
+ * Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-json-file). Also
+ * includes types for fields used by other popular projects, like TypeScript and Yarn.
+ *
+ * Copied from the `PackageJson` 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 File
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type PackageJson = JsonObject & NodeJsStandard & PackageJsonStandard & NonStandardEntryPoints & TypeScriptConfiguration & YarnConfiguration & JSPMConfiguration;
+export {};

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

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

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

@@ -0,0 +1,52 @@
+import { type BuiltIns, type HasMultipleCallSignatures } from './built-in-type.js';
+import { type IsNever } from './type-checks.js';
+/**
+ * Options for {@link PartialDeep}.
+ *
+ * Copied from the `PartialDeepOptions` 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 PartialDeepOptions = {
+    /**
+     * Whether to affect the individual elements of arrays and tuples.
+     *
+     * @default false
+     */
+    readonly recurseIntoArrays?: boolean;
+    /**
+     * Allows `undefined` values in non-tuple arrays.
+     *
+     * @default false
+     */
+    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>;
+};
+/**
+ * Create a deeply optional version of another type. Use `Partial<T>` if you only need one level
+ * deep.
+ *
+ * Copied from the `PartialDeep` 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 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 {};

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

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

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

@@ -0,0 +1,11 @@
+/**
+ * Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+ *
+ * Copied from the `Primitive` 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 Primitive = null | undefined | string | number | boolean | symbol | bigint;

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

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

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

@@ -0,0 +1,11 @@
+/**
+ * Create a type that represents either the value or the value wrapped in `PromiseLike`.
+ *
+ * Copied from the `Promisable` 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 Async
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Promisable<T> = T | PromiseLike<T>;

package/dist/augments/type/promisable.js

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

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

@@ -0,0 +1,30 @@
+import { type BuiltIns, type HasMultipleCallSignatures } from './built-in-type.js';
+type ReadonlyMapDeep<KeyType, ValueType> = {} & Readonly<ReadonlyMap<ReadonlyDeep<KeyType>, ReadonlyDeep<ValueType>>>;
+type ReadonlySetDeep<ItemType> = {} & Readonly<ReadonlySet<ReadonlyDeep<ItemType>>>;
+type ReadonlyObjectDeep<ObjectType extends object> = {
+    readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]>;
+};
+/**
+ * Create a deeply immutable version of another type.
+ *
+ * Copied from the `ReadonlyDeep` 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 ReadonlyDeep<T> = T extends BuiltIns ? T : T extends new (...arguments_: any[]) => unknown ? T : T extends (...arguments_: any[]) => unknown ? {} extends ReadonlyObjectDeep<T> ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T> : T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>> ? ReadonlyMapDeep<KeyType, ValueType> : T extends Readonly<ReadonlySet<infer ItemType>> ? ReadonlySetDeep<ItemType> : T extends readonly [] | readonly [...never[]] ? readonly [] : T extends readonly [
+    infer U,
+    ...infer V
+] ? readonly [
+    ReadonlyDeep<U>,
+    ...ReadonlyDeep<V>
+] : T extends readonly [
+    ...infer U,
+    infer V
+] ? readonly [
+    ...ReadonlyDeep<U>,
+    ReadonlyDeep<V>
+] : T extends ReadonlyArray<infer ItemType> ? ReadonlyArray<ReadonlyDeep<ItemType>> : T extends object ? ReadonlyObjectDeep<T> : unknown;
+export {};

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

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

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

@@ -0,0 +1,20 @@
+import { type IsAny, type IsEqual } from './type-checks.js';
+type IsReadonlyKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends unknown ? Type extends unknown ? IsEqual<{
+    [K in Key]: Type[Key];
+}, {
+    readonly [K in Key]: Type[Key];
+}> : never : never;
+/**
+ * Extract all readonly keys from the given type.
+ *
+ * Copied from the `ReadonlyKeysOf` 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 ReadonlyKeysOf<Type extends object> = Type extends unknown ? keyof {
+    [Key in keyof Type as IsReadonlyKeyOf<Type, Key> extends false ? never : Key]: never;
+} & keyof Type : never;
+export {};

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

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