@augment-vir/core 32.1.0 → 32.2.1

package/dist/augments/error/ensure-error.d.ts

@@ -1,4 +1,4 @@
-import { type Constructor } from 'type-fest';
+import { type Constructor } from '../type/constructor-type.js';
 /**
  * Either returns the input if it's already an Error instance or converts it into an Error instance.
  *

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

@@ -1,4 +1,5 @@
-import { type Jsonify, type Primitive } from 'type-fest';
+import { type Primitive } from '../type/primitive-type.js';
+import { type Jsonify } from './jsonify.js';
 /**
  * These are similar in purpose, name, and structure to type-fest's JsonValue types but these are
  * more permissive. The goal here is to allow any types that do not get serialized into just empty

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

@@ -0,0 +1,46 @@
+/**
+ * Matches a JSON object.
+ *
+ * Copied from the `JsonObject` 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 JSON
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type JsonObject = {
+    [Key in string]: JsonValue;
+};
+/**
+ * Matches a JSON array.
+ *
+ * Copied from the `JsonArray` 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 JSON
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type JsonArray = JsonValue[] | readonly JsonValue[];
+/**
+ * Matches any valid JSON primitive value.
+ *
+ * Copied from the `JsonPrimitive` 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 JSON
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type JsonPrimitive = string | number | boolean | null;
+/**
+ * Matches any valid JSON value.
+ *
+ * Copied from the `JsonValue` 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 JSON
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;

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

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

package/dist/augments/json/jsonify.d.ts

@@ -0,0 +1,41 @@
+import { type NegativeInfinity, type PositiveInfinity } from '../number/infinity.js';
+import { type EmptyObject } from '../type/empty-object.js';
+import { type IsUnknown } from '../type/is-unknown.js';
+import { type IsAny, type IsNever } from '../type/type-checks.js';
+import { type TypedArray } from '../type/typed-array.js';
+import { type UndefinedToOptional } from '../type/undefined-to-optional.js';
+import { type UnknownArray } from '../type/unknown-array.js';
+import { type JsonPrimitive, type JsonValue } from './json-value.js';
+type NotJsonable = ((...arguments_: any[]) => any) | undefined | symbol;
+type NeverToNull<T> = IsNever<T> extends true ? null : T;
+type UndefinedToNull<T> = T extends undefined ? null : T;
+type JsonifyList<T extends UnknownArray> = T extends readonly [] ? [] : T extends readonly [
+    infer F,
+    ...infer R
+] ? [
+    F,
+    ...R
+] extends T ? [
+    NeverToNull<Jsonify<F>>,
+    ...JsonifyList<R>
+] : [NeverToNull<Jsonify<F>>] : IsUnknown<T[number]> extends true ? JsonValue[] : Array<T[number] extends NotJsonable ? null : Jsonify<UndefinedToNull<T[number]>>>;
+type FilterJsonableKeys<T extends object> = {
+    [Key in keyof T]: T[Key] extends NotJsonable ? never : Key;
+}[keyof T];
+type JsonifyObject<T extends object> = {
+    [Key in keyof Pick<T, FilterJsonableKeys<T>>]: Jsonify<T[Key]>;
+};
+/**
+ * Transform a type to one that is assignable to the `JsonValue` type.
+ *
+ * Copied from the `Jsonify` 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 JSON
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Jsonify<T> = IsAny<T> extends true ? any : T extends PositiveInfinity | NegativeInfinity ? null : T extends JsonPrimitive ? T : T extends {
+    toJSON(): infer J;
+} ? (() => J) extends () => JsonValue ? J : Jsonify<J> : T extends Number ? number : T extends String ? string : T extends Boolean ? boolean : T extends Map<any, any> | Set<any> ? EmptyObject : T extends TypedArray ? Record<string, number> : T extends NotJsonable ? never : T extends UnknownArray ? JsonifyList<T> : T extends object ? JsonifyObject<UndefinedToOptional<T>> : IsUnknown<T> extends true ? JsonValue : never;
+export {};

package/dist/augments/json/jsonify.js

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

package/dist/augments/number/infinity.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Matches the hidden `Infinity` type.
+ *
+ * Copied from the `PositiveInfinity` 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 PositiveInfinity = 1e999;
+/**
+ * Matches the hidden `-Infinity` type.
+ *
+ * Copied from the `NegativeInfinity` 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 NegativeInfinity = -1e999;

package/dist/augments/number/infinity.js

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

package/dist/augments/object/object-keys.d.ts

@@ -1,4 +1,4 @@
-import { type IsNever } from 'type-fest';
+import { type IsNever } from '../type/type-checks.js';
 /**
  * Gets all keys of an object. This is similar to
  * [`Object.keys`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/keys)

package/dist/augments/object/required-keys.d.ts

@@ -1,5 +1,5 @@
-import { type Except, type Simplify } from 'type-fest';
-export type { SetRequired } from 'type-fest';
+import { type Except } from '../type/except.js';
+import { type Simplify } from '../type/simplify.js';
 /**
  * Same as the Required<> built-in type helper but this requires that each property be present and
  * be not null.
@@ -50,9 +50,9 @@ export type SetOptionalWithUndefined<OriginalObjectGeneric, OptionalKeysGeneric
  * @category Package : @augment-vir/common
  * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
-export type RequiredKeysOf<BaseType> = Exclude<{
-    [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never;
-}[keyof BaseType], undefined>;
+export type RequiredKeysOf<BaseType> = keyof {
+    [Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? Key : never]: never;
+} & keyof BaseType;
 /**
  * Requires every part of an object, even the indexed keys. This is needed because
  * `Required<Partial<T>>` doesn't fully remove `| undefined` from indexed keys when the

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/built-in-type.d.ts

@@ -0,0 +1,28 @@
+import { type Primitive } from './primitive-type.js';
+/**
+ * Matches any primitive, `void`, `Date`, or `RegExp` value.
+ *
+ * Copied from the internal `BuiltIns` 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 BuiltIns = Primitive | void | Date | RegExp;
+/**
+ * Tests if the given function has multiple call signatures. Needed to handle the case of a single
+ * call signature with properties, as multiple call signatures cannot currently be supported due to
+ * a TypeScript limitation.
+ *
+ * Copied from the internal `HasMultipleCallSignatures` 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 HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
+    (...arguments_: infer A): unknown;
+    (...arguments_: infer B): unknown;
+} ? B extends A ? A extends B ? false : true : true : false;

package/dist/augments/type/built-in-type.js

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

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

@@ -0,0 +1,25 @@
+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`.
+ *
+ * Copied from the `If` 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 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/conditional-type.js

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

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

@@ -0,0 +1,51 @@
+/**
+ * Matches a class constructor.
+ *
+ * Copied from the `Constructor` 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 Function
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Constructor<T, Arguments extends unknown[] = any[]> = new (...constructorArguments: Arguments) => T;
+/**
+ * Matches a class constructor with an abstract signature.
+ *
+ * Copied from the `AbstractConstructor` 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 Function
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstract new (...constructorArguments: Arguments) => T;
+/**
+ * Matches a
+ * [`class`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/class).
+ *
+ * Copied from the `Class` 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 Function
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Class<T, Arguments extends unknown[] = any[]> = {
+    prototype: Pick<T, keyof T>;
+    new (...constructorArguments: Arguments): T;
+};
+/**
+ * Matches an [`abstract
+ * class`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Classes#abstract_classes).
+ *
+ * Copied from the `AbstractClass` 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 Function
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type AbstractClass<T, Arguments extends unknown[] = any[]> = AbstractConstructor<T, Arguments> & {
+    prototype: Pick<T, keyof T>;
+};

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

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

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

@@ -0,0 +1,13 @@
+import { type KeysOfUnion } from './keys-of-union.js';
+/**
+ * Omits keys from a type, distributing the operation over a union. Unlike the built-in `Omit`, this
+ * retains member-specific properties of each union member.
+ *
+ * Copied from the `DistributedOmit` 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 DistributedOmit<ObjectType, KeyType extends KeysOfUnion<ObjectType>> = ObjectType extends unknown ? Omit<ObjectType, KeyType> : never;

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

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

package/dist/augments/type/empty-object.d.ts

@@ -0,0 +1,27 @@
+declare const emptyObjectSymbol: unique symbol;
+/**
+ * Represents a strictly empty plain object, the `{}` value.
+ *
+ * Copied from the `EmptyObject` 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 EmptyObject = {
+    [emptyObjectSymbol]?: never;
+};
+/**
+ * Returns a boolean for whether the type is strictly equal to an empty plain object, the `{}`
+ * value.
+ *
+ * Copied from the `IsEmptyObject` 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 IsEmptyObject<T> = T extends EmptyObject ? true : false;
+export {};

package/dist/augments/type/empty-object.js

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

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

@@ -0,0 +1,23 @@
+import { type IsUnknown } from './is-unknown.js';
+import { type KeysOfUnion } from './keys-of-union.js';
+import { type Primitive } from './primitive-type.js';
+import { type IsEqual } from './type-checks.js';
+type ToString<T> = T extends string | number ? `${T}` : never;
+type ArrayElementOf<T> = T extends readonly (infer ElementType)[] ? ElementType : never;
+type ObjectValue<T, K> = K extends keyof T ? T[K] : ToString<K> extends keyof T ? T[ToString<K>] : K extends `${infer NumberK extends number}` ? NumberK extends keyof T ? T[NumberK] : never : never;
+type ExactObject<ParameterType, InputType> = {
+    [Key in keyof ParameterType]: Exact<ParameterType[Key], ObjectValue<InputType, Key>>;
+} & Record<Exclude<keyof InputType, KeysOfUnion<ParameterType>>, never>;
+/**
+ * Create a type that does not allow extra properties, meaning it only allows properties that are
+ * explicitly declared.
+ *
+ * Copied from the `Exact` 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 Exact<ParameterType, InputType> = IsEqual<ParameterType, InputType> extends true ? ParameterType : ParameterType extends Primitive ? ParameterType : IsUnknown<ParameterType> extends true ? unknown : ParameterType extends Function ? ParameterType : ParameterType extends unknown[] ? Array<Exact<ArrayElementOf<ParameterType>, ArrayElementOf<InputType>>> : ParameterType extends readonly unknown[] ? ReadonlyArray<Exact<ArrayElementOf<ParameterType>, ArrayElementOf<InputType>>> : ExactObject<ParameterType, InputType>;
+export {};

package/dist/augments/type/exact.js

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

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

@@ -0,0 +1,40 @@
+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;
+/**
+ * Options for {@link Except}.
+ *
+ * Copied from the `ExceptOptions` 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 ExceptOptions = {
+    /**
+     * Disallow assigning non-specified properties.
+     *
+     * @default false
+     */
+    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.
+ *
+ * Copied from the `Except` 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 Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = ExceptHelper<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
+export {};

package/dist/augments/type/except.js

@@ -0,0 +1 @@
+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/is-unknown.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Returns a boolean for whether the given type is `null`.
+ *
+ * Copied from the `IsNull` 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 IsNull<T> = [T] extends [null] ? true : false;
+/**
+ * Returns a boolean for whether the given type is `unknown`.
+ *
+ * Copied from the `IsUnknown` 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 IsUnknown<T> = unknown extends T ? (IsNull<T> extends false ? true : false) : false;

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

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

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

@@ -0,0 +1,14 @@
+import { type UnionToIntersection } from './union-to-intersection.js';
+/**
+ * Create a union of all keys from a given type, even those exclusive to specific union members.
+ * Unlike the native `keyof` keyword, which returns keys present in _all_ union members, this type
+ * returns keys from _any_ member.
+ *
+ * Copied from the `KeysOfUnion` 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 KeysOfUnion<ObjectType> = keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;

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

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

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

@@ -0,0 +1,13 @@
+import { type Primitive } from './primitive-type.js';
+/**
+ * Create a union type by combining primitive types and literal types without sacrificing
+ * auto-completion in IDEs for the literal type part of the union.
+ *
+ * Copied from the `LiteralUnion` 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 LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);

package/dist/augments/type/literal-union.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/non-empty-string.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Blocks empty string literal types. Use this to constrain a string type parameter so that the
+ * empty string is rejected.
+ *
+ * @category Type
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type NonEmptyString<T> = T extends '' ? never : T;

package/dist/augments/type/non-empty-string.js

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