@augment-vir/common 13.2.1 → 13.2.3

package/dist/cjs/augments/promise.d.ts

@@ -1,28 +0,0 @@
-export declare function wait(delayMs: number): Promise<void>;
-export declare function waitValue<ResolutionValue>(delayMs: number, returnValue: ResolutionValue): Promise<ResolutionValue>;
-export declare function isPromiseLike<T>(input: T | unknown): input is T extends PromiseLike<infer ValueType> ? PromiseLike<ValueType> : PromiseLike<unknown>;
-export type UnPromise<T> = T extends PromiseLike<infer PromiseType> ? Awaited<PromiseType> : T;
-export type MaybePromise<T> = Promise<UnPromise<T>> | UnPromise<T>;
-export declare class PromiseTimeoutError extends Error {
-    readonly durationMs: number;
-    readonly message: string;
-    readonly name = "PromiseTimeoutError";
-    constructor(durationMs: number, message?: string);
-}
-export declare function wrapPromiseInTimeout<PromiseValueType>(durationMs: number, originalPromise: PromiseLike<PromiseValueType>): Promise<PromiseValueType>;
-/** A promise which can be resolved or rejected by external code. */
-export type DeferredPromiseWrapper<T> = {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: any) => void;
-    isSettled: () => boolean;
-};
-export declare function createDeferredPromiseWrapper<T = void>(): DeferredPromiseWrapper<T>;
-export type WaitForConditionInputs = {
-    conditionCallback: () => boolean | Promise<boolean>;
-    timeoutMs?: number;
-    intervalMs?: number;
-    timeoutMessage?: string;
-};
-export declare function waitForCondition({ conditionCallback, timeoutMs, intervalMs, timeoutMessage, }: WaitForConditionInputs): Promise<void>;
-//# sourceMappingURL=promise.d.ts.map

package/dist/cjs/augments/regexp.d.ts

@@ -1,4 +0,0 @@
-export declare function deDupeRegExFlags(flags: string): string;
-export declare function addRegExpFlags(originalRegExp: RegExp, flags: string): RegExp;
-export declare function safeMatch(input: string, regExp: RegExp): string[];
-//# sourceMappingURL=regexp.d.ts.map

package/dist/cjs/augments/runtime-type-of.d.ts

@@ -1,20 +0,0 @@
-import { AnyFunction } from './function';
-declare function rawGetTypeOf(x: any): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-type RawTypeOf = ReturnType<typeof rawGetTypeOf>;
-export type RuntimeTypeOf = RawTypeOf | 'array';
-export type RuntimeTypeOfMapping = {
-    array: any[] | ReadonlyArray<any>;
-    bigint: bigint;
-    boolean: boolean;
-    function: AnyFunction | Readonly<AnyFunction>;
-    number: number;
-    object: Record<PropertyKey, unknown> | Readonly<Record<PropertyKey, unknown>>;
-    string: string;
-    symbol: symbol;
-    undefined: undefined;
-};
-export declare function getRuntimeTypeOf(input: unknown): RuntimeTypeOf;
-export declare function isRuntimeTypeOf<T extends RuntimeTypeOf>(input: unknown, testType: T): input is RuntimeTypeOfMapping[T];
-export declare function assertRuntimeTypeOf<T extends RuntimeTypeOf>(input: unknown, testType: T, inputName: string): asserts input is RuntimeTypeOfMapping[T];
-export {};
-//# sourceMappingURL=runtime-type-of.d.ts.map

package/dist/cjs/augments/string/url.d.ts

@@ -1,8 +0,0 @@
-/**
- * Joins all given arguments together as if they were parts of a URL. Preserves trailing slashes and
- * removes consecutive slashes in the path. This also encodes each URL part.
- *
- * @example: joinToUrl('https://example.com', 'path1', 'path2/', '/path3/') === 'https://example.com/path1/path2/path3/'
- */
-export declare function joinUrlParts(...urlParts: ReadonlyArray<string>): string;
-//# sourceMappingURL=url.d.ts.map

package/dist/cjs/augments/string/uuid.d.ts

@@ -1,2 +0,0 @@
-export declare function isUuid(maybeUuid: string): boolean;
-//# sourceMappingURL=uuid.d.ts.map

package/dist/cjs/augments/truncate-number.d.ts

@@ -1,20 +0,0 @@
-/**
- * This truncates a number such that is will at a max have 6 characters including suffix, decimal
- * point, or comma.
- *
- * Default suffixes are:
- *
- *     'k', // thousand
- *     'M', // million
- *     'B', // billion
- *     'T', // trillion
- *     'P', // peta-, quadrillion
- *     'E', // exa- quintillion
- *     'Z', // zetta- sextillion
- *     'Y', // yotta- septillion
- */
-export declare function truncateNumber(originalValue: Readonly<unknown>, { customSuffixes, maxLength, }?: Partial<{
-    customSuffixes: ReadonlyArray<string> | undefined;
-    maxLength: number | undefined;
-}>): string;
-//# sourceMappingURL=truncate-number.d.ts.map

package/dist/cjs/augments/tuple.d.ts

@@ -1,9 +0,0 @@
-export type Tuple<ArrayElementGeneric, LengthGeneric extends number> = LengthGeneric extends LengthGeneric ? number extends LengthGeneric ? ArrayElementGeneric[] : _TupleOf<ArrayElementGeneric, LengthGeneric, []> : never;
-type _TupleOf<ArrayElementGeneric, LengthGeneric extends number, FullArrayGeneric extends unknown[]> = FullArrayGeneric['length'] extends LengthGeneric ? FullArrayGeneric : _TupleOf<ArrayElementGeneric, LengthGeneric, [ArrayElementGeneric, ...FullArrayGeneric]>;
-export type AtLeastTuple<ArrayElementGeneric, LengthGeneric extends number> = readonly [
-    ...Tuple<ArrayElementGeneric, LengthGeneric>,
-    ...(ArrayElementGeneric | undefined)[]
-];
-export declare function isLengthAtLeast<ArrayElementGeneric, LengthGeneric extends number>(array: ReadonlyArray<ArrayElementGeneric | undefined>, length: LengthGeneric): array is AtLeastTuple<ArrayElementGeneric, LengthGeneric>;
-export {};
-//# sourceMappingURL=tuple.d.ts.map

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

@@ -1,60 +0,0 @@
-import { Except, Simplify } from 'type-fest';
-/** Makes all properties in an object writable. This is the opposite of Readonly<> */
-export type Writeable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-/** Makes all property values in an object also readonly. Can cause issues on primitive. */
-export type DeepWriteable<T> = {
-    -readonly [P in keyof T]: DeepWriteable<T[P]>;
-};
-/** Replace properties in T with properties in U. */
-export type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
-/** Extract the element type out of an array type. */
-export type ArrayElement<ArrayType extends ReadonlyArray<any>> = ArrayType[number];
-/**
- * Same as the Required<> built-in type helper but this requires that each property be present and
- * be not null.
- */
-export type RequiredAndNotNull<T> = {
-    [P in keyof T]-?: NonNullable<T[P]>;
-};
-export type SetOptionalAndNullable<OriginalObjectGeneric, OptionalKeysGeneric extends keyof OriginalObjectGeneric> = Simplify<Except<OriginalObjectGeneric, OptionalKeysGeneric> & {
-    [PropKey in OptionalKeysGeneric]?: OriginalObjectGeneric[PropKey] | null | undefined;
-}>;
-/** Require only a subset of object properties. */
-export type RequiredBy<T, K extends keyof T> = Overwrite<T, Required<Pick<T, K>>>;
-export declare function makeWritable<T>(input: T): Writeable<T>;
-export declare function makeReadonly<T>(input: T): Readonly<T>;
-/**
- * Require only a subset of object properties and require that they be not null. This is
- * particularly useful in conjunction with the "exactOptionalPropertyTypes" tsconfig flag.
- */
-export type RequiredAndNotNullBy<T, K extends keyof T> = Omit<T, K> & Required<{
-    [PropertyName in K]: NonNullable<T[PropertyName]>;
-}>;
-/** If type T = type U, then type Y. Else type N. */
-export type IfEquals<T, U, Y = unknown, N = never> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? Y : N;
-/**
- * This function returns another function that simply returns whatever input it's given. However, it
- * also checks that the input matches the original wrapNarrowTypeWithTypeCheck's generic, while
- * maintaining strict "const" like typing.
- *
- * Use like this: wrapNarrowTypeWithTypeCheck<EnforcedTypeHere>()(valueToEnforceTypeOn as const)
- *
- * Sometimes "as const" isn't required, usually it is for any object or array though.
- */
-export declare function wrapNarrowTypeWithTypeCheck<P>(): <T extends P>(input: T) => Readonly<T>;
-/**
- * This type helper is useful for forcing function generics to be explicitly provided, rather than
- * inferring them from the given inputs. See the test file for examples.
- */
-export type NoInfer<T> = [T][T extends any ? 0 : never];
-/**
- * This is a type helper that ensures the given input matches the given generic type. The generic is
- * setup in such a way that if it is omitted (which is typically allowed in TypeScript, resulting in
- * the generic being inferred from the inputs), there will actually be a type error. This forces
- * each usage of this function to explicitly specify the generic, thus giving us type safety for the
- * input.
- */
-export declare function ensureType<ExpectedType = never>(input: NoInfer<ExpectedType>): NoInfer<ExpectedType>;
-//# sourceMappingURL=type.d.ts.map

package/dist/cjs/index.d.ts

@@ -1,32 +0,0 @@
-export * from './augments/ansi';
-export * from './augments/array';
-export * from './augments/async';
-export * from './augments/common-number';
-export * from './augments/common-string';
-export * from './augments/date/date';
-export * from './augments/date/relative-date';
-export * from './augments/environment';
-export * from './augments/error';
-export * from './augments/function';
-export * from './augments/json';
-export * from './augments/json-compatible';
-export * from './augments/object/enum';
-export * from './augments/object/filter-object';
-export * from './augments/object/has-key';
-export * from './augments/object/jsonify';
-export * from './augments/object/map-object';
-export * from './augments/object/matches-object-shape';
-export * from './augments/object/nested-keys';
-export * from './augments/object/object';
-export * from './augments/object/object-entries';
-export * from './augments/object/pick-deep';
-export * from './augments/object/typed-has-property';
-export * from './augments/promise';
-export * from './augments/regexp';
-export * from './augments/runtime-type-of';
-export * from './augments/string/url';
-export * from './augments/string/uuid';
-export * from './augments/truncate-number';
-export * from './augments/tuple';
-export * from './augments/type';
-//# sourceMappingURL=index.d.ts.map

package/dist/esm/augments/ansi.d.ts

@@ -1,2 +0,0 @@
-export declare const ansiRegex: RegExp;
-//# sourceMappingURL=ansi.d.ts.map

package/dist/esm/augments/array.d.ts

@@ -1,14 +0,0 @@
-import { AtLeastTuple } from './tuple';
-import { ArrayElement } from './type';
-export declare function filterOutIndexes<T>(array: ReadonlyArray<T>, indexes: ReadonlyArray<number>): T[];
-export declare function flatten2dArray<T>(array2d: ReadonlyArray<ReadonlyArray<T>>): T[];
-export type AtLeastOneEntryArray<ArrayGeneric extends ReadonlyArray<any>> = AtLeastTuple<ArrayElement<ArrayGeneric>, 1>;
-export declare function trimArrayStrings(input: ReadonlyArray<string>): string[];
-export declare function typedArrayIncludes<T>(array: ReadonlyArray<T>, input: unknown): input is T;
-type MapCallbackType<ArrayType extends ReadonlyArray<any>, OutputType> = (value: ArrayElement<ArrayType>, index: number, array: ArrayType) => OutputType;
-/** Preserves tuple types. */
-export declare function typedMap<InputArrayGeneric extends ReadonlyArray<any>, OutputType>(arrayToMap: InputArrayGeneric, mapCallback: MapCallbackType<InputArrayGeneric, OutputType>): {
-    [Index in keyof InputArrayGeneric]: OutputType;
-};
-export {};
-//# sourceMappingURL=array.d.ts.map

package/dist/esm/augments/async.d.ts

@@ -1,15 +0,0 @@
-/**
- * Acts like calling Array.prototype.forEach in that all elements are executed upon in order, and
- * each execution is blocking. Meaning, the callback won't be called on element 2 until the callback
- * has finished its call on element 1.
- */
-export declare function awaitedForEach<OriginalGeneric>(input: ReadonlyArray<OriginalGeneric>, callback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => void | PromiseLike<void>): Promise<void>;
-export declare function awaitedBlockingMap<OriginalGeneric, MappedGeneric>(input: ReadonlyArray<OriginalGeneric>, callback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => MappedGeneric | PromiseLike<MappedGeneric>): Promise<Awaited<MappedGeneric>[]>;
-export declare function awaitedFilter<OriginalGeneric>(arrayInput: ReadonlyArray<OriginalGeneric>, filterCallback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => Promise<unknown>, options?: {
-    /**
-     * Each call to the filter callback is blocking, meaning the next one won't start until the
-     * current one finishes. By default this is false.
-     */
-    blocking?: boolean | undefined;
-}): Promise<OriginalGeneric[]>;
-//# sourceMappingURL=async.d.ts.map

package/dist/esm/augments/common-number.d.ts

@@ -1,26 +0,0 @@
-export declare const NaNString: string;
-export declare function addCommasToNumber(input: number | string): string;
-export declare function clamp(
-/**
- * This uses a destructured object so that consumers cannot get confused as to which input is
- * which (which would be easy to do since they're all of the same type).
- */
-{ value, min, max, }: {
-    value: number;
-    min: number;
-    max: number;
-}): number;
-export declare function convertIntoNumber(input: unknown): number;
-export declare function doesRequireScientificNotation(input: number): boolean;
-/**
- * Given a min and max, ensures that they are in correct order. Meaning, min is less than max. If
- * that is not the case, the returned value is the given min and max values swapped.
- */
-export declare function ensureMinAndMax({ min, max }: {
-    min: number;
-    max: number;
-}): {
-    min: number;
-    max: number;
-};
-//# sourceMappingURL=common-number.d.ts.map

package/dist/esm/augments/common-string.d.ts

@@ -1,45 +0,0 @@
-import { AtLeastTuple } from './tuple';
-/**
- * Join elements into a string with commas separating each value. Add a conjunction before the final
- * item in the list. If the array has a length < 2, the conjunction is not added. If the list is
- * only of length 2, then no commas are added.
- *
- * @param list Array of items to be converted into strings. Works best if these are simply strings
- *   to begin with.
- * @param conjunction Defaults to 'and'. The conjunction to be used before the final element.
- */
-export declare function joinWithFinalConjunction(list: ReadonlyArray<any>, conjunction?: string): string;
-export declare function removeAnsiEscapeCodes(input: string): string;
-export declare const removeColor: typeof removeAnsiEscapeCodes;
-export declare function removeCommasFromNumberString(numberString: string): string;
-/** Collapse all consecutive white space into just one space and trim surrounding whitespace. */
-export declare function collapseWhiteSpace(input: string): string;
-/** Same as String.prototype.split but includes the delimiter to split by in the output array. */
-export declare function splitIncludeSplit(original: string, splitterInput: string | RegExp, caseSensitive: boolean): readonly string[];
-export type CasingOptions = {
-    capitalizeFirstLetter: boolean;
-};
-export declare function capitalizeFirstLetter<InputGeneric extends string>(input: InputGeneric): Capitalize<InputGeneric>;
-export declare function kebabCaseToCamelCase(rawKebabCase: string, casingOptions?: Partial<CasingOptions> | undefined): string;
-export declare function camelCaseToKebabCase(rawCamelCase: string): string;
-export declare function replaceStringAtIndex(originalString: string, start: number, newString: string, length?: number): string;
-/**
- * Escapes characters from the given string so that it can be used within a RegExp without being
- * parsed as RegExp syntax.
- */
-export declare function escapeStringForRegExp(input: string): string;
-export declare function getAllIndexesOf<IncludeLength extends boolean | undefined>({ searchIn, searchFor, caseSensitive, includeLength, }: {
-    searchIn: string;
-    searchFor: string | RegExp;
-    /**
-     * CaseSensitive only applies when the input is a string. Otherwise, the RegExp's "i" flag is
-     * used to determine case sensitivity.
-     */
-    caseSensitive: boolean;
-    includeLength?: IncludeLength;
-}): IncludeLength extends true ? {
-    index: number;
-    length: number;
-}[] : number[];
-export declare function typedSplit(input: string, splitString: string): AtLeastTuple<string, 1>;
-//# sourceMappingURL=common-string.d.ts.map

package/dist/esm/augments/date/date.d.ts

@@ -1,27 +0,0 @@
-export declare const englishFullMonthNames: readonly ["january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"];
-export declare const englishShortMonthNames: string[];
-export declare class InvalidDateError extends Error {
-    readonly name = "InvalidDateError";
-}
-/**
- * @param slashFormatString String that should be of format "MM/DD/YY", "MM/DD/YYYY". When the year
- *   portion only contains 2 numbers ("MM/DD/YY") the century must be provided in the form of the
- *   yearPrefix input.
- * @param yearPrefix String or number that is used to prefix slash format strings that only contain
- *   2 digits ("MM/DD/YY"). If the year is entirely missing form the given slash format string, the
- *   year will default to year 00 of the given century. See test file for examples.
- */
-export declare function createDateFromSlashFormat(slashFormatString: string, yearPrefix?: number | string): Date;
-/**
- * @param commaFormatString Should be at string of the form "monthName dayNumber, fullYear" Example:
- *   "May 19, 2005"
- * @param ignoreInvalidMonth Set to true to ignore invalid months and just use the current UTC month
- */
-export declare function createDateFromNamedCommaFormat(commaFormatString: string, ignoreInvalidMonth?: boolean): Date;
-/**
- * Converts an iso-formatted string to a UTC date object. The time is nulled out to all zeros.
- *
- * @param isoFormatString Should be a date in the format YYYY-MM-DD.
- */
-export declare function createDateFromUtcIsoFormat(isoFormatString: string): Date;
-//# sourceMappingURL=date.d.ts.map

package/dist/esm/augments/date/relative-date.d.ts

@@ -1,12 +0,0 @@
-import { PartialAndUndefined } from '../..';
-export type RelativeDateCalculation = PartialAndUndefined<{
-    milliseconds: number;
-    seconds: number;
-    minutes: number;
-    hours: number;
-    days: number;
-    months: number;
-    years: number;
-}>;
-export declare function calculateRelativeDate(startingDate: Date | number | string, calculations: RelativeDateCalculation): Date;
-//# sourceMappingURL=relative-date.d.ts.map

package/dist/esm/augments/environment.d.ts

@@ -1,2 +0,0 @@
-export declare function isBrowser(): boolean;
-//# sourceMappingURL=environment.d.ts.map

package/dist/esm/augments/error.d.ts

@@ -1,11 +0,0 @@
-import { AtLeastTuple, NoInputsFunction, UnPromise } from '..';
-export declare function combineErrors(errors: AtLeastTuple<Error, 1>): Error;
-export declare function combineErrors(errors: ReadonlyArray<never>): undefined;
-export declare function combineErrors(errors: ReadonlyArray<Error>): Error | undefined;
-export declare function combineErrors(errors?: undefined): undefined;
-export declare function combineErrorMessages(errors?: ReadonlyArray<Error | string | undefined> | undefined): string;
-export declare function extractErrorMessage(error: unknown): string;
-export declare function ensureError(input: unknown): Error;
-export declare function executeAndReturnError<CallbackGeneric extends NoInputsFunction<PromiseLike<any>>>(callback: CallbackGeneric): Promise<Error | UnPromise<ReturnType<CallbackGeneric>>>;
-export declare function executeAndReturnError<CallbackGeneric extends NoInputsFunction>(callback: CallbackGeneric): Error | ReturnType<CallbackGeneric>;
-//# sourceMappingURL=error.d.ts.map

package/dist/esm/augments/function.d.ts

@@ -1,27 +0,0 @@
-import { ArrayElement } from './type';
-export type AnyFunction<ReturnGeneric = any> = (...args: any[]) => ReturnGeneric;
-export type NoInputsFunction<ReturnGeneric = any> = () => ReturnGeneric;
-/**
- * Accepts an "Arguments" and "Return" generic to quickly make a function type. If "Arguments" is an
- * array, it is spread into the full function's Parameters list. If any argument should be an array,
- * instead of a rest parameter, put it inside of a tuple. If no arguments should be possible, pass
- * void to "Arguments". If you need an optional argument, pass it inside of a tuple.
- *
- * @example
- *     TypedFunction<string, number>; // (input: string) => number
- *
- * @example
- *     TypedFunction<string[], number>; // (...inputs: string[]) => number
- *
- * @example
- *     TypedFunction<[string[]], number>; // (input: string[]) => number
- *
- * @example
- *     TypedFunction<[string, number], number>; // (input1: string, input2: number) => number
- *
- * @example
- *     TypedFunction<[string | undefined], number>; // (input1: string|undefined) => number
- */
-export type TypedFunction<Arguments, Return> = Arguments extends readonly any[] ? number extends Arguments['length'] ? (...args: ArrayElement<Arguments>[]) => Return : (...args: Arguments) => Return : void extends Arguments ? () => Return : (arg: Arguments) => Return;
-export declare function isTruthy<T>(input: T): input is NonNullable<T>;
-//# sourceMappingURL=function.d.ts.map

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

@@ -1,23 +0,0 @@
-import { Jsonify, Primitive } from 'type-fest';
-/**
- * These are similar in purpose, name, and structure to type-fest's JsonValue types but these are
- * permissive. The goal here is to allow any types that do not get serialized into just empty
- * objects. (For example, JSON.stringify(new Map()) returns "{}", so we don't want to allow that
- * type.)
- */
-export type JsonCompatiblePrimitiveValue = Jsonify<Primitive> | undefined;
-export type JsonCompatibleObject = Partial<{
-    readonly [key: string | number]: JsonCompatibleValue | Readonly<JsonCompatibleValue>;
-}> | Partial<{
-    [key: string | number]: JsonCompatibleValue | Readonly<JsonCompatibleValue>;
-}>;
-export type JsonCompatibleArray = JsonCompatibleValue[]
-/**
- * This weird readonly with object syntax for an array type is so that TypeScript doesn't
- * complain about JsonCompatibleArray circularly referencing itself
- */
- | ({
-    readonly [P in number]: JsonCompatibleValue;
-} & ReadonlyArray<any>);
-export type JsonCompatibleValue = JsonCompatiblePrimitiveValue | JsonCompatibleObject | JsonCompatibleArray;
-//# sourceMappingURL=json-compatible.d.ts.map

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

@@ -1,6 +0,0 @@
-export declare function parseJson<ParsedJsonGeneric>({ jsonString, errorHandler, shapeMatcher, }: {
-    jsonString: string;
-    errorHandler?: (error: unknown) => never | ParsedJsonGeneric;
-    shapeMatcher?: ParsedJsonGeneric;
-}): ParsedJsonGeneric;
-//# sourceMappingURL=json.d.ts.map

package/dist/esm/augments/object/enum.d.ts

@@ -1,5 +0,0 @@
-export declare function getEnumTypedKeys<T extends object>(input: T): (keyof T)[];
-export declare function getEnumTypedValues<T extends object>(input: T): T[keyof T][];
-export declare function isEnumValue<T extends object>(input: unknown, checkEnum: T): input is T[keyof T];
-export declare function filterToEnumValues<T extends object>(inputs: ReadonlyArray<unknown>, checkEnum: T, caseInsensitive?: boolean): T[keyof T][];
-//# sourceMappingURL=enum.d.ts.map

package/dist/esm/augments/object/filter-object.d.ts

@@ -1,5 +0,0 @@
-import { PropertyValueType } from './object';
-export declare function filterObject<ObjectGeneric>(inputObject: ObjectGeneric, callback: (key: keyof ObjectGeneric, value: PropertyValueType<ObjectGeneric>, fullObject: ObjectGeneric) => boolean): Partial<ObjectGeneric>;
-export declare function omitObjectKeys<ObjectGeneric, KeyGeneric extends keyof ObjectGeneric>(inputObject: Readonly<ObjectGeneric>, omitTheseKeys: ReadonlyArray<KeyGeneric>): Omit<ObjectGeneric, KeyGeneric>;
-export declare function pickObjectKeys<ObjectGeneric, KeyGeneric extends keyof ObjectGeneric>(inputObject: Readonly<ObjectGeneric>, pickTheseKeys: ReadonlyArray<KeyGeneric>): Pick<ObjectGeneric, KeyGeneric>;
-//# sourceMappingURL=filter-object.d.ts.map

package/dist/esm/augments/object/has-key.d.ts

@@ -1,2 +0,0 @@
-export declare function hasKey<ParentType>(parent: ParentType, property: PropertyKey): property is keyof ParentType;
-//# sourceMappingURL=has-key.d.ts.map

package/dist/esm/augments/object/jsonify.d.ts

@@ -1,3 +0,0 @@
-import { Jsonify } from 'type-fest';
-export declare function jsonify<InputGeneric>(input: InputGeneric): Jsonify<InputGeneric>;
-//# sourceMappingURL=jsonify.d.ts.map

package/dist/esm/augments/object/map-object.d.ts

@@ -1,25 +0,0 @@
-import { PropertyValueType, UnPromise } from '../..';
-export type InnerMappedValues<EntireInputGeneric extends object, MappedValueGeneric> = {
-    [MappedProp in keyof EntireInputGeneric]: MappedValueGeneric;
-};
-export type MappedValues<EntireInputGeneric extends object, MappedValueGeneric> = MappedValueGeneric extends PromiseLike<unknown> ? Promise<InnerMappedValues<EntireInputGeneric, UnPromise<MappedValueGeneric>>> : InnerMappedValues<EntireInputGeneric, UnPromise<MappedValueGeneric>>;
-/**
- * Map an object's keys to new values synchronously. This is different from plain mapObjectValues in
- * that this will not wrap the return value in a promise if any of the new object values are
- * promises. This function also requires currying in order to get the types correct. This allows you
- * to explicitly state the return type.
- *
- * @example
- *     mapObjectValuesSync({objectToIterateOver: 'initial value'})<{objectToIterateOver: number}>(
- *         (key, value) => ({
- *             newValue: value.length,
- *         }),
- *     );
- */
-export declare function mapObjectValuesSync<EntireInputGeneric extends object>(inputObject: EntireInputGeneric): <OutputObjectGeneric extends object>(mapCallback: (inputKey: keyof EntireInputGeneric, keyValue: EntireInputGeneric[keyof EntireInputGeneric], fullObject: EntireInputGeneric) => never extends PropertyValueType<OutputObjectGeneric> ? any : PropertyValueType<OutputObjectGeneric>) => OutputObjectGeneric;
-/**
- * Creates a new object with the same properties as the input object, but with values set to the
- * result of mapCallback for each property.
- */
-export declare function mapObjectValues<EntireInputGeneric extends object, MappedValueGeneric>(inputObject: EntireInputGeneric, mapCallback: (inputKey: keyof EntireInputGeneric, keyValue: EntireInputGeneric[typeof inputKey], fullObject: EntireInputGeneric) => MappedValueGeneric): MappedValues<EntireInputGeneric, MappedValueGeneric>;
-//# sourceMappingURL=map-object.d.ts.map

package/dist/esm/augments/object/matches-object-shape.d.ts

@@ -1,37 +0,0 @@
-import { AtLeastOneEntryArray } from '../array';
-import { NoInfer } from '../type';
-/**
- * Checks that the first input, testThisOne, matches the object shape of the second input,
- * compareToThisOne. Does not compare exact values of properties, only types.
- *
- * To allow the test input, the first input, to have additional keys that the compare input, the
- * second input, does not have, pass in a third argument set to true.
- *
- * This function REQUIRES a generic to be assigned to it: it cannot infer it from the inputs.
- *
- * The compare input, the second input, is required to have at least one entry in every array value
- * that exists. If more array values are present, they will be considered other possible types for
- * entries in that array.
- */
-export declare function matchesObjectShape<MatchThisGeneric extends object>(testThisOne: unknown, compareToThisOne: NoInfer<ObjectWithAtLeastSingleEntryArrays<MatchThisGeneric>>, allowExtraProps?: boolean, shouldLogWhy?: boolean): testThisOne is MatchThisGeneric;
-export type ObjectWithAtLeastSingleEntryArrays<BaseObject extends object> = {
-    [Prop in keyof BaseObject]: BaseObject[Prop] extends ReadonlyArray<any> ? AtLeastOneEntryArray<BaseObject[Prop]> : BaseObject[Prop] extends object ? ObjectWithAtLeastSingleEntryArrays<BaseObject[Prop]> : BaseObject[Prop];
-};
-export type NestedBoolean<MatchObject extends object> = Partial<{
-    [Prop in keyof MatchObject]: MatchObject[Prop] extends object ? NestedBoolean<MatchObject[Prop]> | boolean : boolean;
-}>;
-/**
- * Asserts that the first input, testThisOne, matches the object shape of the second input,
- * compareToThisOne. Does not compare exact values of properties, only types.
- *
- * To allow the test input, the first input, to have additional keys that the compare input, the
- * second input, does not have, pass in a third argument set to true.
- *
- * This function REQUIRES a generic to be assigned to it: it cannot infer it from the inputs.
- *
- * The compare input, the second input, is required to have at least one entry in every array value
- * that exists. If more array values are present, they will be considered other possible types for
- * entries in that array.
- */
-export declare function assertMatchesObjectShape<MatchThisGeneric extends object = never>(testThisOne: unknown, compareToThisOne: NoInfer<ObjectWithAtLeastSingleEntryArrays<MatchThisGeneric>>, allowExtraProps?: boolean, noCheckInnerValueOfTheseKeys?: NestedBoolean<typeof compareToThisOne>): asserts testThisOne is MatchThisGeneric;
-//# sourceMappingURL=matches-object-shape.d.ts.map

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

@@ -1,12 +0,0 @@
-import { UnionToIntersection } from 'type-fest';
-import { PropertyValueType } from './object';
-export type NestedSequentialKeys<ObjectGeneric extends object> = PropertyValueType<{
-    [Prop in keyof ObjectGeneric]: NonNullable<ObjectGeneric[Prop]> extends object ? [Prop, ...(NestedSequentialKeys<NonNullable<ObjectGeneric[Prop]>> | [])] : [Prop];
-}>;
-export type NestedKeys<ObjectGeneric extends object> = UnionToIntersection<Extract<PropertyValueType<ObjectGeneric>, object>> extends object ? [
-    keyof ObjectGeneric,
-    ...(NestedKeys<UnionToIntersection<Extract<PropertyValueType<ObjectGeneric>, object>>> | [])
-] : [keyof ObjectGeneric];
-export type NestedValue<ObjectGeneric extends object, NestedKeysGeneric extends NestedSequentialKeys<ObjectGeneric>> = NestedKeysGeneric extends readonly [infer FirstEntry, ...infer FollowingEntries] ? FirstEntry extends keyof ObjectGeneric ? FollowingEntries extends never[] ? ObjectGeneric[FirstEntry] : ObjectGeneric[FirstEntry] extends object ? FollowingEntries extends NestedSequentialKeys<ObjectGeneric[FirstEntry]> ? NestedValue<ObjectGeneric[FirstEntry], FollowingEntries> : never : never : never : never;
-export declare function getValueFromNestedKeys<ObjectGeneric extends object, KeysGeneric extends NestedSequentialKeys<ObjectGeneric>>(inputObject: ObjectGeneric, nestedKeys: KeysGeneric): NestedValue<ObjectGeneric, KeysGeneric> | undefined;
-//# sourceMappingURL=nested-keys.d.ts.map

package/dist/esm/augments/object/object-entries.d.ts

@@ -1,6 +0,0 @@
-export declare function isKeyof<ObjectGeneric>(key: PropertyKey, object: ObjectGeneric): key is keyof ObjectGeneric;
-export declare function getObjectTypedKeys<ObjectGeneric extends unknown>(input: ObjectGeneric): Array<keyof ObjectGeneric>;
-export declare function getObjectTypedValues<ObjectGeneric extends unknown>(input: ObjectGeneric): ObjectGeneric[keyof ObjectGeneric][];
-export declare function getEntriesSortedByKey(input: object): [string, unknown][];
-export declare function typedObjectFromEntries<KeyType extends PropertyKey, ValueType>(entries: ReadonlyArray<Readonly<[KeyType, ValueType]>>): Record<KeyType, ValueType>;
-//# sourceMappingURL=object-entries.d.ts.map

package/dist/esm/augments/object/object.d.ts

@@ -1,13 +0,0 @@
-import { JsonCompatibleValue } from '../json-compatible';
-export type PartialAndNullable<T extends object> = {
-    [Prop in keyof T]?: T[Prop] | null | undefined;
-};
-export type PartialAndUndefined<T extends object> = {
-    [Prop in keyof T]?: T[Prop] | undefined;
-};
-export declare function isObject(input: any): input is NonNullable<object>;
-export declare function areJsonEqual(a: Readonly<JsonCompatibleValue | undefined>, b: Readonly<JsonCompatibleValue | undefined>): boolean;
-/** The input here must be serializable otherwise JSON parsing errors will be thrown */
-export declare function copyThroughJson<T>(input: T): T;
-export type PropertyValueType<T> = T[keyof T];
-//# sourceMappingURL=object.d.ts.map

package/dist/esm/augments/object/pick-deep.d.ts

@@ -1,8 +0,0 @@
-import { UnionToIntersection } from 'type-fest';
-import { NestedKeys } from './nested-keys';
-type InnerPickDeep<OriginalObjectGeneric extends object, DeepKeys extends any[]> = UnionToIntersection<DeepKeys extends [infer CurrentLevelPick, ...infer RemainingKeys] ? {
-    [CurrentProp in Extract<CurrentLevelPick, keyof OriginalObjectGeneric>]: OriginalObjectGeneric[CurrentProp] extends object ? InnerPickDeep<OriginalObjectGeneric[CurrentProp], RemainingKeys> : OriginalObjectGeneric[CurrentProp];
-} : DeepKeys extends [infer CurrentLevelPick] ? CurrentLevelPick extends keyof OriginalObjectGeneric ? Pick<OriginalObjectGeneric, CurrentLevelPick> : never : never>;
-export type PickDeep<OriginalObjectGeneric extends object, DeepKeys extends NestedKeys<OriginalObjectGeneric>> = InnerPickDeep<OriginalObjectGeneric, DeepKeys>;
-export {};
-//# sourceMappingURL=pick-deep.d.ts.map

package/dist/esm/augments/object/typed-has-property.d.ts

@@ -1,8 +0,0 @@
-import { RequiredBy } from '../type';
-type ExtractValue<KeyGeneric extends PropertyKey, ParentGeneric> = KeyGeneric extends keyof ParentGeneric ? RequiredBy<ParentGeneric, KeyGeneric>[KeyGeneric] : KeyGeneric extends keyof Extract<ParentGeneric, Record<KeyGeneric, any>> ? RequiredBy<Extract<ParentGeneric, Record<KeyGeneric, any>>, KeyGeneric>[KeyGeneric] : never;
-type CombinedParentValue<KeyGeneric extends PropertyKey, ParentGeneric> = ExtractValue<KeyGeneric, ParentGeneric> extends never ? unknown : ExtractValue<KeyGeneric, ParentGeneric>;
-type CombineTypeWithKey<KeyGeneric extends PropertyKey, ParentGeneric> = ParentGeneric & Record<KeyGeneric, CombinedParentValue<KeyGeneric, ParentGeneric>>;
-export declare function typedHasProperty<KeyGeneric extends PropertyKey, ParentGeneric>(inputObject: ParentGeneric, inputKey: KeyGeneric): inputObject is CombineTypeWithKey<KeyGeneric, ParentGeneric>;
-export declare function typedHasProperties<KeyGeneric extends PropertyKey, ParentGeneric>(inputObject: ParentGeneric, inputKeys: ReadonlyArray<KeyGeneric>): inputObject is CombineTypeWithKey<KeyGeneric, ParentGeneric>;
-export {};
-//# sourceMappingURL=typed-has-property.d.ts.map

package/dist/esm/augments/promise.d.ts

@@ -1,28 +0,0 @@
-export declare function wait(delayMs: number): Promise<void>;
-export declare function waitValue<ResolutionValue>(delayMs: number, returnValue: ResolutionValue): Promise<ResolutionValue>;
-export declare function isPromiseLike<T>(input: T | unknown): input is T extends PromiseLike<infer ValueType> ? PromiseLike<ValueType> : PromiseLike<unknown>;
-export type UnPromise<T> = T extends PromiseLike<infer PromiseType> ? Awaited<PromiseType> : T;
-export type MaybePromise<T> = Promise<UnPromise<T>> | UnPromise<T>;
-export declare class PromiseTimeoutError extends Error {
-    readonly durationMs: number;
-    readonly message: string;
-    readonly name = "PromiseTimeoutError";
-    constructor(durationMs: number, message?: string);
-}
-export declare function wrapPromiseInTimeout<PromiseValueType>(durationMs: number, originalPromise: PromiseLike<PromiseValueType>): Promise<PromiseValueType>;
-/** A promise which can be resolved or rejected by external code. */
-export type DeferredPromiseWrapper<T> = {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: any) => void;
-    isSettled: () => boolean;
-};
-export declare function createDeferredPromiseWrapper<T = void>(): DeferredPromiseWrapper<T>;
-export type WaitForConditionInputs = {
-    conditionCallback: () => boolean | Promise<boolean>;
-    timeoutMs?: number;
-    intervalMs?: number;
-    timeoutMessage?: string;
-};
-export declare function waitForCondition({ conditionCallback, timeoutMs, intervalMs, timeoutMessage, }: WaitForConditionInputs): Promise<void>;
-//# sourceMappingURL=promise.d.ts.map

package/dist/esm/augments/regexp.d.ts

@@ -1,4 +0,0 @@
-export declare function deDupeRegExFlags(flags: string): string;
-export declare function addRegExpFlags(originalRegExp: RegExp, flags: string): RegExp;
-export declare function safeMatch(input: string, regExp: RegExp): string[];
-//# sourceMappingURL=regexp.d.ts.map