@stryke/types 0.10.23 → 0.10.24

package/dist/async-eKWh-_sF.d.cts

@@ -1,111 +0,0 @@
-import { K as IsUnknown, j as FunctionLike } from "./base-EF17pdAI.cjs";
-
-//#region src/async.d.ts
-
-/**
- * Get the type of the value that a promise resolves to.
- *
- * @example
- * ```
- * import type {Awaited} from 'type-fest';
- *
- * const value: Awaited<Promise<string>> = 'foo';
- * ```
- */
-type Awaitable<T> = T | PromiseLike<T>;
-/**
- * A type that can be either a value or a function that returns a value.
- *
- * @example
- * ```
- * import type {Resolvable} from 'type-fest';
- *
- * const foo: Resolvable<string> = 'bar';
- * const bar: Resolvable<string> = () => 'baz';
- * ```
- */
-type Resolvable<T> = Awaitable<T> | (() => Awaitable<T>);
-/**
- * Create a function type with a return type of your choice and the same parameters as the given function type.
- *
- * Use-case: You want to define a wrapped function that returns something different while receiving the same parameters. For example, you might want to wrap a function that can throw an error into one that will return `undefined` instead.
- *
- * @example
- * ```
- * import type {SetReturnType} from 'type-fest';
- *
- * type MyFunctionThatCanThrow = (foo: SomeType, bar: unknown) => SomeOtherType;
- *
- * type MyWrappedFunction = SetReturnType<MyFunctionThatCanThrow, SomeOtherType | undefined>;
- * //=> type MyWrappedFunction = (foo: SomeType, bar: unknown) => SomeOtherType | undefined;
- * ```
- */
-type SetReturnType<TFunct extends (...arguments_: any[]) => any, TypeToReturn> = TFunct extends ((this: infer ThisArgument, ...arguments_: infer Arguments) => any) ? IsUnknown<ThisArgument> extends true ? (...arguments_: Arguments) => TypeToReturn : (this: ThisArgument, ...arguments_: Arguments) => TypeToReturn : (...arguments_: Parameters<TFunct>) => TypeToReturn;
-type AsyncFunction = (...arguments_: any[]) => Promise<unknown>;
-/**
- * Unwrap the return type of a function that returns a `Promise`.
- *
- * There has been [discussion](https://github.com/microsoft/TypeScript/pull/35998) about implementing this type in TypeScript.
- *
- * @example
- * ```ts
- * import type {AsyncReturnType} from 'type-fest';
- * import {asyncFunction} from 'api';
- *
- * // This type resolves to the unwrapped return type of `asyncFunction`.
- * type Value = AsyncReturnType<typeof asyncFunction>;
- *
- * async function doSomething(value: Value) {}
- *
- * asyncFunction().then(value => doSomething(value));
- * ```
- */
-type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<Target>>;
-/**
- * Create an async version of the given function type, by boxing the return type in `Promise` while keeping the same parameter types.
- *
- * Use-case: You have two functions, one synchronous and one asynchronous that do the same thing. Instead of having to duplicate the type definition, you can use `Asyncify` to reuse the synchronous type.
- *
- * @example
- * ```
- * import type {Asyncify} from 'type-fest';
- *
- * // Synchronous function.
- * function getFooSync(someArg: SomeType): Foo {
- *   // …
- * }
- *
- * type AsyncifiedFooGetter = Asyncify<typeof getFooSync>;
- * //=> type AsyncifiedFooGetter = (someArg: SomeType) => Promise<Foo>;
- *
- * // Same as `getFooSync` but asynchronous.
- * const getFooAsync: AsyncifiedFooGetter = (someArg) => {
- *   // TypeScript now knows that `someArg` is `SomeType` automatically.
- *   // It also knows that this function must return `Promise<Foo>`.
- *   // If you have `@typescript-eslint/promise-function-async` linter rule enabled, it will even report that "Functions that return promises must be async.".
- *
- *   // …
- * }
- * ```
- */
-type Asyncify<TFunct extends FunctionLike> = SetReturnType<TFunct, Promise<Awaited<ReturnType<TFunct>>>>;
-/**
- * Get the result type of a `Promise`
- *
- * @example
- * ```ts
- * import { Await } from '@stryke/types'
- *
- * const promise = new Promise<string>((res, rej) => res('x'))
- *
- * type test0 = C.Await<typeof promise>  // string
- * type test1 = C.Await<Promise<number>> // number
- * ```
- *
- * @param P - A promise
- * @returns [[Any]]
- */
-type Await<P> = P extends Promise<infer A> ? A : P;
-//#endregion
-export { Awaitable as a, Await as i, AsyncReturnType as n, Resolvable as o, Asyncify as r, SetReturnType as s, AsyncFunction as t };
-//# sourceMappingURL=async-eKWh-_sF.d.cts.map

package/dist/async-eKWh-_sF.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"async-eKWh-_sF.d.cts","names":[],"sources":["../src/async.ts"],"sourcesContent":[],"mappings":";;;;;;AA8BA;;;;;AAaA;;;AAA4D,KAbhD,SAagD,CAAA,CAAA,CAAA,GAbjC,CAaiC,GAb7B,WAa6B,CAbjB,CAaiB,CAAA;;;AAiB5D;;;;;;;;;AAeiC,KAhCrB,UAgCqB,CAAA,CAAA,CAAA,GAhCL,SAgCK,CAhCK,CAgCL,CAAA,GAAA,CAAA,GAAA,GAhCiB,SAgCjB,CAhC2B,CAgC3B,CAAA,CAAA;;;;AAEjC;AAoBA;;;;;;AA+BA;;;;;AAEU,KAtEE,aAsEF,CAAA,eAAA,CAAA,GAAA,UAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA,EAAA,YAAA,CAAA,GAjER,MAiEQ,UAAA,CAAA,IAAA,EAAA,KAAA,aAAA,EAAA,GAAA,UAAA,EAAA,KAAA,UAAA,EAAA,GAAA,GAAA,IA3DJ,SA2DI,CA3DM,YA2DN,CAAA,SAAA,IAAA,GAAA,CAAA,GAAA,UAAA,EA1Dc,SA0Dd,EAAA,GA1D4B,YA0D5B,GAAA,CAAA,IAAA,EAzDK,YAyDL,EAAA,GAAA,UAAA,EAzDkC,SAyDlC,EAAA,GAzDgD,YAyDhD,GAAA,CAAA,GAAA,UAAA,EAvDY,UAuDZ,CAvDuB,MAuDvB,CAAA,EAAA,GAvDmC,YAuDnC;AAAR,KArDU,aAAA,GAqDV,CAAA,GAAA,UAAA,EAAA,GAAA,EAAA,EAAA,GArDoD,OAqDpD,CAAA,OAAA,CAAA;;;AAmBF;;;;;;;;;;;;;;;;KApDY,+BAA+B,iBAAiB,QAC1D,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BD,wBAAwB,gBAAgB,cAClD,QACA,QAAQ,QAAQ,WAAW;;;;;;;;;;;;;;;;;KAmBjB,WAAW,UAAU,uBAAuB"}

package/dist/base-CiIyKS-b.d.mts

@@ -1,331 +0,0 @@
-import { l as TypedArray } from "./array-DVtfX_TI.mjs";
-
-//#region src/base.d.ts
-type SerializablePrimitive = null | undefined | string | number | boolean | bigint;
-type Primitive = SerializablePrimitive | symbol;
-/**
- * Matches any primitive, `void`, `Date`, or `RegExp` value.
- */
-type BuiltIns = Primitive | void | Date | RegExp;
-/**
- * Matches any non-primitive object
- */
-type AtomicObject = Function | Promise<any> | Date | RegExp;
-/** Determines if the passed value is of a specific type */
-type TypeTester = (value: any) => boolean;
-/**
- * The interface for a type mapping (key =\> function) to use for {@link getType}.
- * export * The key represents the name of the type. The function represents the {@link TypeTester | test method}.
- * The map should be ordered by testing preference, with more specific tests first.
- * If a test returns true, it is selected, and the key is returned as the type.
- */
-type TypeMap = Record<string, TypeTester>;
-declare const emptyObjectSymbol: unique symbol;
-type FunctionOrValue<Value> = Value extends (() => infer X) ? X : Value;
-/**
- * A [[List]]
- *
- * @example
- * ```ts
- * type list0 = [1, 2, 3]
- * type list1 = number[]
- * ```
- *
- * @param A - its type
- * @returns [[List]]
- */
-type List<A = any> = ReadonlyArray<A>;
-/**
- * Alias to create a [[Function]]
- *
- * @example
- * ```ts
- * import { FunctionLike } from '@stryke/types'
- *
- * type test0 = FunctionLike<[string, number], boolean>
- * /// (args_0: string, args_1: number) => boolean
- * ```
- *
- * @param P - parameters
- * @param R - return type
- * @returns [[Function]]
- */
-type FunctionLike<P extends List = any, R$1 = any> = (...args: P) => R$1;
-type AnyFunction = FunctionLike<any, any>;
-type Nullish = undefined | null;
-type Nullishable<T> = T | Nullish;
-type NonNullishObject = object;
-type NativeClass = abstract new (...args: any) => any;
-type AnyNumber = number | number;
-type AnyString = string | string;
-type AnyBoolean = boolean | boolean;
-type AnyArray = any[];
-type PlainObject = Record<any, object>;
-type AnyMap = Map<any, any>;
-type AnyWeakMap = WeakMap<WeakKey, any>;
-type EmptyArray = [];
-interface EmptyObject {
-  [emptyObjectSymbol]?: never;
-}
-type Any = boolean | number | bigint | string | null | undefined | void | symbol | object | PlainObject | AnyArray | AnyMap | AnyWeakMap;
-/**
- * The valid types of the index for an `Indexable` type object
- */
-type IndexType = string | number | symbol;
-/**
- * The declaration of a ***dictionary-type*** object with a specific type
- *
- * @see {@link Indexable}
- * @see {@link IndexType}
- * @see {@link Dictionary}
- */
-type TypedIndexable<T> = Record<IndexType, T>;
-/**
- * The declaration of a ***dictionary-type*** object
- *
- * @see {@link TypedIndexable}
- * @see {@link IndexType}
- * @see {@link Dictionary}
- */
-type Indexable = TypedIndexable<any>;
-/**
- * The declaration of a ***dictionary-type*** object with a specific type
- *
- * @see {@link Indexable}
- * @see {@link IndexType}
- * @see {@link TypedIndexable}
- */
-type Dictionary<T> = Record<string, T>;
-declare const EMPTY_STRING = "";
-declare const NEWLINE_STRING = "\r\n";
-declare const EMPTY_OBJECT: {};
-type AnyCase<T extends IndexType> = string extends T ? string : T extends `${infer F1}${infer F2}${infer R}` ? `${Uppercase<F1> | Lowercase<F1>}${Uppercase<F2> | Lowercase<F2>}${AnyCase<R>}` : T extends `${infer F}${infer R}` ? `${Uppercase<F> | Lowercase<F>}${AnyCase<R>}` : typeof EMPTY_STRING;
-type Newable<T> = new (..._args: never[]) => T;
-interface Abstract<T> {
-  prototype: T;
-}
-interface Clonable<T> {
-  clone: () => T;
-}
-type MaybePromise<T> = T | Promise<T>;
-type ReducerFunction<TState, TAction> = (state: TState, action: TAction) => TState;
-declare const TYPE_ARGUMENTS = "Arguments";
-declare const TYPE_ARRAY = "Array";
-declare const TYPE_OBJECT = "Object";
-declare const TYPE_MAP = "Map";
-declare const TYPE_SET = "Set";
-type Collection = IArguments | unknown[] | Map<unknown, unknown> | Record<string | number | symbol, unknown> | Set<unknown>;
-type NonUndefined<T> = T extends undefined ? never : T;
-type BrowserNativeObject = Date | File;
-type DeepPartial<T> = T extends BrowserNativeObject | NestedValue ? T : { [K in keyof T]?: DeepPartial<T[K]> };
-type Rollback = Record<string, (initialValue: any, currentValue: any) => any>;
-/**
- * Extract all required keys from the given type.
- *
- * @remarks
- * This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
- */
-type RequiredKeysOf<BaseType extends object> = Exclude<{ [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never }[keyof BaseType], undefined>;
-/**
- * Returns a boolean for whether the two given types are equal.
- *
- * @remarks
- * Use-cases: If you want to make a conditional branch based on the result of a comparison of two types.
- *
- * @see https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
- * @see https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
- */
-type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends (<G>() => G extends B ? 1 : 2) ? true : false;
-type Filter<KeyType$1, ExcludeType> = IsEqual<KeyType$1, ExcludeType> extends true ? never : KeyType$1 extends ExcludeType ? never : KeyType$1;
-interface ExceptOptions {
-  /**
-    Disallow assigning non-specified properties.
-       Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
-       @defaultValue  false
-   */
-  requireExactProps?: boolean;
-}
-/**
- * Create a type from an object type without certain keys.
- *
- * @remarks
- * We recommend setting the `requireExactProps` option to `true`.
- *
- * This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
- *
- * This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
- */
-type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {
-  requireExactProps: false;
-}> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options["requireExactProps"] extends true ? Partial<Record<KeysType, never>> : Record<string, never>);
-/**
- * Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
- *
- * @remarks
- * Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
- *
- * If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
- *
- * @see https://github.com/microsoft/TypeScript/issues/15300
- */
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
-/**
- * Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
- *
- * @remarks
- * Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
- */
-type SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends unknown ? Simplify<Except<BaseType, Keys> & Required<Pick<BaseType, Keys>>> : never;
-declare const $NestedValue: unique symbol;
-type NestedValue<TValue extends object = object> = {
-  [$NestedValue]: never;
-} & TValue;
-interface RefObject<T> {
-  current: T;
-}
-interface Identity<T = string> {
-  id: T;
-}
-interface Versioned {
-  version: number;
-}
-interface Sequenced {
-  /**
-   * The sequence number (version, or event counter, etc.) of the record
-   */
-  sequence: number;
-}
-interface Typed {
-  /**
-   * The type of the record
-   */
-  __type: string;
-}
-interface ClassTypeCheckable<T> extends Typed {
-  /**
-   * Run type check on the given value
-   * @param value - The value to check
-   * @returns True if the value is of the type of the class
-   */
-  isTypeOf: (value: unknown) => value is T;
-}
-/**
- * Matches non-recursive types.
- */
-type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
-type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
-type IsNever<T> = [T] extends [never] ? true : false;
-type IsAny<T> = 0 extends 1 & T ? true : false;
-type IsNull<T> = [T] extends [null] ? true : false;
-type IsUndefined<T> = T extends undefined ? true : false;
-type IsUnknown<T> = unknown extends T ? IsNull<T> extends false ? true : false : false;
-type IsNullish<T> = IsNull<T> & IsUndefined<T>;
-type IsFunction<T> = T extends AnyFunction ? true : false;
-/**
- * Declare locally scoped properties on `globalThis`.
- *
- * When defining a global variable in a declaration file is inappropriate, it can be helpful to define a `type` or `interface` (say `ExtraGlobals`) with the global variable and then cast `globalThis` via code like `globalThis as unknown as ExtraGlobals`.
- *
- * Instead of casting through `unknown`, you can update your `type` or `interface` to extend `GlobalThis` and then directly cast `globalThis`.
- *
- * @example
- * ```
- * import type { GlobalThis } from '@stryke/types';
- *
- * type ExtraGlobals = GlobalThis & {
- *   readonly GLOBAL_TOKEN: string;
- * };
- *
- * (globalThis as ExtraGlobals).GLOBAL_TOKEN;
- * ```
- */
-type GlobalThis = typeof globalThis;
-/**
- * Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
- */
-interface Class<T, Arguments extends unknown[] = any[]> {
-  prototype: Pick<T, keyof T>;
-  new (...arguments_: Arguments): T;
-}
-/**
- * Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
- */
-type Constructor<T, Arguments extends unknown[] = any[]> = new (...arguments_: Arguments) => T;
-/**
- * Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/classes.html#abstract-classes).
- *
- * @privateRemarks
- * We cannot use a `type` here because TypeScript throws: 'abstract' modifier cannot appear on a type member. (1070)
- */
-interface AbstractClass<T, Arguments extends unknown[] = any[]> extends AbstractConstructor<T, Arguments> {
-  prototype: Pick<T, keyof T>;
-}
-/**
- * Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html#abstract-construct-signatures) constructor.
- */
-type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstract new (...arguments_: Arguments) => T;
-/**
- * Create a tuple type of the given length `<L>` and fill it with the given type `<Fill>`.
- *
- * If `<Fill>` is not provided, it will default to `unknown`.
- *
- * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
- */
-type BuildTuple<L extends number, Fill = unknown, T extends readonly unknown[] = []> = T["length"] extends L ? T : BuildTuple<L, Fill, [...T, Fill]>;
-/**
- * Test if the given function has multiple call signatures.
- *
- * Needed to handle the case of a single call signature with properties.
- *
- * Multiple call signatures cannot currently be supported due to a TypeScript limitation.
- * @see https://github.com/microsoft/TypeScript/issues/29732
- */
-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;
-type StructuredCloneablePrimitive = string | number | bigint | boolean | null | undefined | boolean | number | string;
-type StructuredCloneableData = ArrayBuffer | DataView | Date | Error | RegExp | TypedArray | Blob | File;
-type StructuredCloneableCollection = readonly StructuredCloneable[] | {
-  readonly [key: string]: StructuredCloneable;
-  readonly [key: number]: StructuredCloneable;
-} | ReadonlyMap<StructuredCloneable, StructuredCloneable> | ReadonlySet<StructuredCloneable>;
-/**
- * Matches a value that can be losslessly cloned using `structuredClone`.
- *
- * Note:
- * - Custom error types will be cloned as the base `Error` type
- * - This type doesn't include types exclusive to the TypeScript DOM library (e.g. `DOMRect` and `VideoFrame`)
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
- *
- * @example
- * ```
- * import type { StructuredCloneable } from '@stryke/types';
- *
- * class CustomClass {}
- *
- * // @ts-expect-error
- * const error: StructuredCloneable = {
- *     custom: new CustomClass(),
- * };
- *
- * structuredClone(error);
- * //=> {custom: {}}
- *
- * const good: StructuredCloneable = {
- *     number: 3,
- *     date: new Date(),
- *     map: new Map<string, number>(),
- * }
- *
- * good.map.set('key', 1);
- *
- * structuredClone(good);
- * //=> {number: 3, date: Date(2022-10-17 22:22:35.920), map: Map {'key' -> 1}}
- * ```
- */
-type StructuredCloneable = StructuredCloneablePrimitive | StructuredCloneableData | StructuredCloneableCollection;
-//#endregion
-export { NonNullishObject as $, Filter as A, IsFunction as B, DeepPartial as C, TypedIndexable as Ct, EmptyArray as D, EMPTY_STRING as E, Identity as F, IsUndefined as G, IsNull as H, IndexType as I, MaybePromise as J, IsUnknown as K, Indexable as L, FunctionOrValue as M, GlobalThis as N, EmptyObject as O, HasMultipleCallSignatures as P, Newable as Q, IsAny as R, Constructor as S, Typed as St, EMPTY_OBJECT as T, IsNullish as U, IsNever as V, IsPrimitive as W, NativeClass as X, NEWLINE_STRING as Y, NestedValue as Z, BuiltIns as _, TYPE_MAP as _t, Any as a, Primitive as at, Clonable as b, TypeMap as bt, AnyCase as c, RequiredKeysOf as ct, AnyNumber as d, SerializablePrimitive as dt, NonRecursiveType as et, AnyString as f, SetRequired as ft, BuildTuple as g, TYPE_ARRAY as gt, BrowserNativeObject as h, TYPE_ARGUMENTS as ht, AbstractConstructor as i, PlainObject as it, FunctionLike as j, Except as k, AnyFunction as l, Rollback as lt, AtomicObject as m, StructuredCloneable as mt, Abstract as n, Nullish as nt, AnyArray as o, ReducerFunction as ot, AnyWeakMap as p, Simplify as pt, List as q, AbstractClass as r, Nullishable as rt, AnyBoolean as s, RefObject as st, $NestedValue as t, NonUndefined as tt, AnyMap as u, Sequenced as ut, Class as v, TYPE_OBJECT as vt, Dictionary as w, Versioned as wt, Collection as x, TypeTester as xt, ClassTypeCheckable as y, TYPE_SET as yt, IsEqual as z };
-//# sourceMappingURL=base-CiIyKS-b.d.mts.map

package/dist/base-CiIyKS-b.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base-CiIyKS-b.d.mts","names":[],"sources":["../src/base.ts"],"sourcesContent":[],"mappings":";;;KAoBY,qBAAA;KAOA,SAAA,GAAY;AAPxB;AAOA;AAKA;AAAuB,KAAX,QAAA,GAAW,SAAA,GAAA,IAAA,GAAmB,IAAnB,GAA0B,MAA1B;;;;AAMX,KAAA,YAAA,GAAe,QAAH,GAAc,OAAd,CAAA,GAAA,CAAA,GAA6B,IAA7B,GAAoC,MAApC;;AAAc,KAG1B,UAAA,GAH0B,CAAA,KAAA,EAAA,GAAA,EAAA,GAAA,OAAA;;;;AAGtC;AAQA;AAAiD;AAIrC,KAJA,OAAA,GAAU,MAIK,CAAA,MAAA,EAJU,UAIkC,CAAA;AAcvE,cAhBc,iBAgBc,EAAA,OAAa,MAAA;AAiB7B,KA/BA,eA+BY,CAAA,KAAA,CAAA,GA/Ba,KA+Bb,UAAA,GAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GA/B+C,KA+B/C;;;;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,KA3BA,IA2BQ,CAAA,IAAA,GAAA,CAAA,GA3BQ,aA2BR,CA3BsB,CA2BtB,CAAA;AACpB;AACA;AACA;AACA;AACA;AAIA;;;;;;AAkBA;AASA;;;AAAgC,KA9CpB,YA8CoB,CAAA,UA9CG,IA8CH,GAAA,GAAA,EAAA,MAAA,GAAA,CAAA,GAAA,CAAA,GAAA,IAAA,EA9CoC,CA8CpC,EAAA,GA9C0C,GA8C1C;AAAM,KA5C1B,WAAA,GAAc,YA4CY,CAAA,GAAA,EAAA,GAAA,CAAA;AAS1B,KApDA,OAAA,GAoDS,SAAG,GAAA,IAAA;AASZ,KA5DA,WA4DU,CAAA,CAAA,CAAA,GA5DO,CA4Dc,GA5DV,OA4DC;AAErB,KA7DD,gBAAA,GA6Da,MAAA;AACZ,KA7DD,WAAA,GA6De,cAAA,GAAA,IAAA,EAAA,GAAA,EAAA,GAAA,GAAA;AACd,KA7DD,SAAA,GA6DkB,MAAA,GAAA,MAAA;AAElB,KA9DA,SAAA,GA8DO,MAAA,GAAA,MAAA;AAAW,KA7DlB,UAAA,GA6DkB,OAAA,GAAA,OAAA;AAA4B,KA5D9C,QAAA,GA4D8C,GAAA,EAAA;AAEtD,KA7DQ,WAAA,GAAc,MA6DtB,CAAA,GAAA,EAAA,MAAA,CAAA;AACe,KA7DP,MAAA,GAAS,GA6DF,CAAA,GAAA,EAAA,GAAA,CAAA;AAAV,KA5DG,UAAA,GAAa,OA4DhB,CA5DwB,OA4DxB,EAAA,GAAA,CAAA;AAA0B,KA3DvB,UAAA,GA2DuB,EAAA;AAAV,UA1DR,WAAA,CA0DQ;EAA0B,CAzDhD,iBAAA,EAyDgD,EAAA,KAAA;;AAAgB,KAtDvD,GAAA,GAsDuD,OAAA,GAAA,MAAA,GAAA,MAAA,GAAA,MAAA,GAAA,IAAA,GAAA,SAAA,GAAA,IAAA,GAAA,MAAA,GAAA,MAAA,GA5C/D,WA4C+D,GA3C/D,QA2C+D,GA1C/D,MA0C+D,GAzC/D,UAyC+D;;;;AAC7D,KArCM,SAAA,GAqCN,MAAA,GAAA,MAAA,GAAA,MAAA;;;;;;;;AAEqB,KA9Bf,cA8Be,CAAA,CAAA,CAAA,GA9BK,MA8BL,CA9BY,SA8BZ,EA9BuB,CA8BvB,CAAA;AAE3B;AAEA;AAIA;AAIA;;;;AAAyC,KAjC7B,SAAA,GAAY,cAiCiB,CAAA,GAAA,CAAA;AAEzC;;;;;AAMA;AACA;AACa,KAlCD,UAkCY,CAAA,CAAA,CAAA,GAlCI,MAkCJ,CAAA,MAAA,EAlCmB,CAkCnB,CAAA;AACX,cAjCA,YAAA,GAiCQ,EAAA;AACR,cAjCA,cAAA,GAiCQ,MAAA;AAET,cAlCC,YAkCS,EAAA,CAAA,CAAA;AAClB,KAjCQ,OAiCR,CAAA,UAjC0B,SAiC1B,CAAA,GAAA,MAAA,SAjCsD,CAiCtD,GAAA,MAAA,GA/BA,CA+BA,SAAA,GAAA,KAAA,GAAA,GAAA,KAAA,GAAA,GAAA,KAAA,EAAA,EAAA,GAAA,GA9BK,SA8BL,CA9Be,EA8Bf,CAAA,GA9BqB,SA8BrB,CA9B+B,EA8B/B,CAAA,GA9BqC,SA8BrC,CA9B+C,EA8B/C,CAAA,GA9BqD,SA8BrD,CA9B+D,EA8B/D,CAAA,GA9BqE,OA8BrE,CA9B6E,CA8B7E,CAAA,EAAA,GA7BE,CA6BF,SAAA,GAAA,KAAA,EAAA,GAAA,KAAA,EAAA,EAAA,GAAA,GA5BO,SA4BP,CA5BiB,CA4BjB,CAAA,GA5BsB,SA4BtB,CA5BgC,CA4BhC,CAAA,GA5BqC,OA4BrC,CA5B6C,CA4B7C,CAAA,EAAA,GAAA,OA3BW,YA2BX;AAEA,KA3BQ,OA2BR,CAAA,CAAA,CAAA,GAAA,KAAA,GAAA,KAAA,EAAA,KAAA,EAAA,EAAA,GA3BgD,CA2BhD;AACA,UA1Ba,QA0Bb,CAAA,CAAA,CAAA,CAAA;EACA,SAAA,EA1BS,CA0BT;;AAEQ,UAzBK,QAyBO,CAAA,CAAA,CAAA,CAAA;EAEZ,KAAA,EAAA,GAAA,GA1BG,CA0BH;AAEZ;AAA6B,KAzBjB,YAyBiB,CAAA,CAAA,CAAA,GAzBC,CAyBD,GAzBK,OAyBL,CAzBa,CAyBb,CAAA;AAAU,KAvB3B,eAuB2B,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,KAAA,EAtB9B,MAsB8B,EAAA,MAAA,EArB7B,OAqB6B,EAAA,GApBlC,MAoBkC;AAAsB,cAjBhD,cAAA,GAiBgD,WAAA;AACzD,cAjBS,UAAA,GAiBT,OAAA;AAEc,cAlBL,WAAA,GAkBK,QAAA;AAAiB,cAjBtB,QAAA,GAiBsB,KAAA;AAAE,cAhBxB,QAAA,GAgBwB,KAAA;AAAd,KAdX,UAAA,GACR,UAamB,GAAA,OAAA,EAAA,GAXnB,GAWmB,CAAA,OAAA,EAAA,OAAA,CAAA,GAVnB,MAUmB,CAAA,MAAA,GAAA,MAAA,GAAA,MAAA,EAAA,OAAA,CAAA,GATnB,GASmB,CAAA,OAAA,CAAA;AAAW,KAPtB,YAOsB,CAAA,CAAA,CAAA,GAPJ,CAOI,SAAA,SAAA,GAAA,KAAA,GAP0B,CAO1B;AAGtB,KARA,mBAAA,GAAsB,IAQL,GARY,IAQZ;AAWjB,KAjBA,WAiBc,CAAA,CAAA,CAAA,GAjBG,CAiBH,SAjBa,mBAiBb,GAjBmC,WAiBnC,GAhBtB,CAgBsB,GAAA,QAER,MAhBA,CAgBA,IAhBK,WAgBL,CAhBiB,CAgBjB,CAhBmB,CAgBnB,CAAA,CAAA,EAAW;AAAwB,KAbzC,QAAA,GAAW,MAa8B,CAAA,MAAA,EAAA,CAAA,YAAA,EAAA,GAAA,EAAA,YAAA,EAAA,GAAA,EAAA,GAAA,GAAA,CAAA;;;;;;;AAFQ,KAAjD,cAAiD,CAAA,iBAAA,MAAA,CAAA,GAAP,OAAO,CAAA,UAkBjD,MAhBM,QAgBC,GAhBU,QAgBV,SAhB2B,MAgB3B,CAhBkC,GAgBlC,EAhBuC,QAgBvC,CAhBgD,GAgBhD,CAAA,CAAA,GAfX,GAeW,GAAA,KAAA,EACP,CAAA,MAdF,QAcE,CAAA,EAAA,SAAA,CAAA;;;;;AAIZ;;;;;AAGsB,KARV,OAQU,CAAA,CAAA,EAAA,CAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA,GAAA,GAPV,CAOU,SAPA,CAOA,GAAA,CAAA,GAAA,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,GAAA,GAP4B,CAO5B,SAPsC,CAOtC,GAAA,CAAA,GAAA,CAAA,IAAA,IAAA,GAAA,KAAA;AAEd,KALI,MAKJ,CAAA,SAAA,EAAA,WAAA,CAAA,GAJN,OAIM,CAJE,SAIF,EAJW,WAIX,CAAA,SAAA,IAAA,GAAA,KAAA,GAFF,SAEE,SAFc,WAEd,GAAA,KAAA,GAAA,SAAA;UAEE,aAAA,CAFK;EAEL;AAqBV;;;;EAKkC,iBAAA,CAAA,EAAA,OAAA;;;;;;;;;AAkBlC;;;AAAoD,KAvBxC,MAuBwC,CAAA,UAAA,EAAA,iBAAA,MArB3B,UAqB2B,EAAA,gBApBlC,aAoBkC,GAAA;EAAO,iBAAA,EAAA,KAAA;AAQ3D,CAAA,CAAA,GAAY,cAES,MA5BD,UA4BC,IA5Ba,MA4Bb,CA3BjB,OA2BiB,EA1BjB,QA0BiB,CAAA,GAzBf,UAyBe,CAzBJ,OAyBI,CAAA,EACjB,GAAA,CAzBC,OAyBD,CAAA,mBAAA,CAAA,SAAA,IAAA,GAxBA,OAwBA,CAxBQ,MAwBR,CAxBe,QAwBf,EAAA,KAAA,CAAA,CAAA,GAvBA,MAuBA,CAAA,MAAA,EAAA,KAAA,CAAA,CAAA;;;;;;;;;;AASJ;AAEY,KAtBA,QAsBW,CAAA,CAAA,CAAA,GAAA,cAIG,MA1BoB,CA0BpB,GA1BwB,CA0BxB,CA1B0B,OA2BxC,CAAA,EAGZ,GAAiB,CAAA,CAAA;AAIjB;AAIA;AAOA;AAOA;AAYA;AAMA;AACY,KA/DA,WA+DO,CAAA,QAAQ,EAAA,aAAA,MA7DN,QA6DM,CAAA,GA5DvB,QA4DuB,SAAA,OAAA,GA3DvB,QA2DuB,CAzDrB,MAyDqB,CAzDd,QAyDc,EAzDJ,IAyDI,CAAA,GAvDnB,QAuDmB,CAvDV,IAuDU,CAvDL,QAuDK,EAvDK,IAuDL,CAAA,CAAA,CAAA,GAAA,KAAA;AACf,cApDC,YAoDyB,EAAA,OAAA,MAAA;AAC1B,KAnDA,WAmDM,CAAA,eAAQ,MAAA,GAAA,MAAA,CAAA,GAAA;EACd,CAnDT,YAAA,CAmDoB,EAAA,KAAA;AACvB,CAAA,GAnDI,MAmDQ;AAA+B,UAjD1B,SAiD0B,CAAA,CAAA,CAAA,CAAA;EAChC,OAAA,EAjDA,CAiDA;;AAAD,UA9CO,QA8CP,CAAA,IAAA,MAAA,CAAA,CAAA;EAIE,EAAA,EAjDN,CAiDM;;AAAe,UA9CV,SAAA,CA8CU;EAAwB,OAAA,EAAA,MAAA;;AAAD,UA1CjC,SAAA,CA0CiC;EACtC;AAoBZ;AAKA;EACkB,QAAA,EAAA,MAAA;;AAAL,UA9DI,KAAA,CA8DJ;EACS;;;EAMV,MAAA,EAAA,MAAW;AAWvB;AAG8B,UA5Eb,kBA4Ea,CAAA,CAAA,CAAA,SA5EiB,KA4EjB,CAAA;EAAG;;;;;EAAJ,QAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,KAAA,IAtEY,CAsEZ;AAO7B;AAYA;;;AAI4B,KAvFhB,gBAAA,GACR,QAsFwB,GApFxB,QAoFwB,GAAA,CAAA,KAAA,GAAA,UAAA,EAAA,GAAA,EAAA,EAAA,GAAA,OAAA,CAAA;AAAe,KAjF/B,WAiF+B,CAAA,CAAA,CAAA,GAAA,CAjFb,CAiFa,CAAA,SAAA,CAjFD,SAiFC,CAAA,GAAA,IAAA,GAAA,KAAA;AAAG,KAhFlC,OAgFkC,CAAA,CAAA,CAAA,GAAA,CAhFpB,CAgFoB,CAAA,SAAA,CAAA,KAAA,CAAA,GAAA,IAAA,GAAA,KAAA;AAAU,KA/E5C,KA+E4C,CAAA,CAAA,CAAA,GAAA,CAAA,SAAA,CAAA,GA/EnB,CA+EmB,GAAA,IAAA,GAAA,KAAA;AAAG,KA9E/C,MA8E+C,CAAA,CAAA,CAAA,GAAA,CA9ElC,CA8EkC,CAAA,SAAA,CAAA,IAAA,CAAA,GAAA,IAAA,GAAA,KAAA;AAA3B,KA7EpB,WA6EoB,CAAA,CAAA,CAAA,GA7EH,CA6EG,SAAA,SAAA,GAAA,IAAA,GAAA,KAAA;AAAU,KA5E9B,SA4E8B,CAAA,CAAA,CAAA,GAAA,OAAA,SA5EC,CA4ED,GA3EtC,MA2EsC,CA3E/B,CA2E+B,CAAA,SAAA,KAAA,GAAA,IAAA,GAAA,KAAA,GAAA,KAAA;AAU9B,KAjFA,SAiFA,CAAA,CAAA,CAAA,GAjFe,MAiFU,CAjFH,CAiFG,CAAA,GAjFE,WAmFlC,CAnF8C,CAmF9C,CAAA;AAWA,KA7FO,UA6FP,CAAA,CAAA,CAAA,GA7FuB,CA6FvB,SA7FiC,WA6FL,GAAA,IAAA,GAAA,KAAA;AAAA;;;;;;;;;;AAmBzB;;;;;;;;AAgCJ,KA5HQ,UAAA,GA4HR,OA5H4B,UA4H5B;;AAqCJ;;AAEI,UA9Ja,KA8Jb,CAAA,CAAA,EAAA,kBAAA,OAAA,EAAA,GAAA,GAAA,EAAA,CAAA,CAAA;EACA,SAAA,EA9JS,IA8JT,CA9Jc,CA8Jd,EAAA,MA9JuB,CA8JvB,CAAA;EAA6B,KAAA,GAAA,UAAA,EA7JX,SA6JW,CAAA,EA7JC,CA6JD;;;;;KAvJrB,0EACK,cACZ;;;;;;;UASY,8DAGP,oBAAoB,GAAG;aACpB,KAAK,SAAS;;;;;KAMf,2FAGqB,cAAc;;;;;;;;KASnC,kFAIR,oBAAoB,IAAI,IAAI,WAAW,GAAG,UAAU,GAAG;;;;;;;;;KAU/C,yEAER;;;;KAWC,4BAAA;KAWA,uBAAA,GACD,cACA,WACA,OACA,QACA,SACA,aACA,OACA;KAyBC,6BAAA,YACQ;0BAEiB;0BACA;IAE1B,YAAY,qBAAqB,uBACjC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqCJ,mBAAA,GACR,+BACA,0BACA"}

package/dist/base-Cpeh4C5c.cjs

@@ -1,3 +0,0 @@
-const e=``,t=`\r
-`,n={},r=`Arguments`,i=`Array`,a=`Object`,o=`Map`,s=`Set`,c=Symbol(`NestedValue`);Object.defineProperty(exports,`a`,{enumerable:!0,get:function(){return`Arguments`}}),Object.defineProperty(exports,`c`,{enumerable:!0,get:function(){return`Object`}}),Object.defineProperty(exports,`i`,{enumerable:!0,get:function(){return`\r
-`}}),Object.defineProperty(exports,`l`,{enumerable:!0,get:function(){return`Set`}}),Object.defineProperty(exports,`n`,{enumerable:!0,get:function(){return n}}),Object.defineProperty(exports,`o`,{enumerable:!0,get:function(){return`Array`}}),Object.defineProperty(exports,`r`,{enumerable:!0,get:function(){return``}}),Object.defineProperty(exports,`s`,{enumerable:!0,get:function(){return`Map`}}),Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return c}});

package/dist/base-DmFPRVSE.mjs

@@ -1,3 +0,0 @@
-const e=``,t=`\r
-`,n={},r=`Arguments`,i=`Array`,a=`Object`,o=`Map`,s=`Set`,c=Symbol(`NestedValue`);export{r as a,a as c,t as i,s as l,n,i as o,e as r,o as s,c as t};
-//# sourceMappingURL=base-DmFPRVSE.mjs.map

package/dist/base-DmFPRVSE.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"base-DmFPRVSE.mjs","names":["$NestedValue: unique symbol"],"sources":["../src/base.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type { TypedArray } from \"./array\";\n\nexport type SerializablePrimitive =\n  | null\n  | undefined\n  | string\n  | number\n  | boolean\n  | bigint;\nexport type Primitive = SerializablePrimitive | symbol;\n\n/**\n * Matches any primitive, `void`, `Date`, or `RegExp` value.\n */\nexport type BuiltIns = Primitive | void | Date | RegExp;\n\n/**\n * Matches any non-primitive object\n */\n// eslint-disable-next-line ts/no-unsafe-function-type\nexport type AtomicObject = Function | Promise<any> | Date | RegExp;\n\n/** Determines if the passed value is of a specific type */\nexport type TypeTester = (value: any) => boolean;\n\n/**\n * The interface for a type mapping (key =\\> function) to use for {@link getType}.\n * export * The key represents the name of the type. The function represents the {@link TypeTester | test method}.\n * The map should be ordered by testing preference, with more specific tests first.\n * If a test returns true, it is selected, and the key is returned as the type.\n */\nexport type TypeMap = Record<string, TypeTester>;\n\ndeclare const emptyObjectSymbol: unique symbol;\n\nexport type FunctionOrValue<Value> = Value extends () => infer X ? X : Value;\n\n/**\n * A [[List]]\n *\n * @example\n * ```ts\n * type list0 = [1, 2, 3]\n * type list1 = number[]\n * ```\n *\n * @param A - its type\n * @returns [[List]]\n */\nexport type List<A = any> = ReadonlyArray<A>;\n\n/**\n * Alias to create a [[Function]]\n *\n * @example\n * ```ts\n * import { FunctionLike } from '@stryke/types'\n *\n * type test0 = FunctionLike<[string, number], boolean>\n * /// (args_0: string, args_1: number) => boolean\n * ```\n *\n * @param P - parameters\n * @param R - return type\n * @returns [[Function]]\n */\nexport type FunctionLike<P extends List = any, R = any> = (...args: P) => R;\n\nexport type AnyFunction = FunctionLike<any, any>;\nexport type Nullish = undefined | null;\nexport type Nullishable<T> = T | Nullish;\nexport type NonNullishObject = object; // not null/undefined which are Object\nexport type NativeClass = abstract new (...args: any) => any;\nexport type AnyNumber = number | number;\nexport type AnyString = string | string;\nexport type AnyBoolean = boolean | boolean;\nexport type AnyArray = any[];\nexport type PlainObject = Record<any, object>; // https://stackoverflow.com/a/75052315/130638\nexport type AnyMap = Map<any, any>;\nexport type AnyWeakMap = WeakMap<WeakKey, any>;\nexport type EmptyArray = [];\nexport interface EmptyObject {\n  [emptyObjectSymbol]?: never;\n}\n\nexport type Any =\n  | boolean\n  | number\n  | bigint\n  | string\n  | null\n  | undefined\n  | void\n  | symbol\n  | object\n  | PlainObject\n  | AnyArray\n  | AnyMap\n  | AnyWeakMap;\n\n/**\n * The valid types of the index for an `Indexable` type object\n */\nexport type IndexType = string | number | symbol;\n\n/**\n * The declaration of a ***dictionary-type*** object with a specific type\n *\n * @see {@link Indexable}\n * @see {@link IndexType}\n * @see {@link Dictionary}\n */\nexport type TypedIndexable<T> = Record<IndexType, T>;\n\n/**\n * The declaration of a ***dictionary-type*** object\n *\n * @see {@link TypedIndexable}\n * @see {@link IndexType}\n * @see {@link Dictionary}\n */\nexport type Indexable = TypedIndexable<any>;\n\n/**\n * The declaration of a ***dictionary-type*** object with a specific type\n *\n * @see {@link Indexable}\n * @see {@link IndexType}\n * @see {@link TypedIndexable}\n */\nexport type Dictionary<T> = Record<string, T>;\n\nexport const EMPTY_STRING = \"\";\nexport const NEWLINE_STRING = \"\\r\\n\";\nexport const EMPTY_OBJECT = {};\n\nexport type AnyCase<T extends IndexType> = string extends T\n  ? string\n  : T extends `${infer F1}${infer F2}${infer R}`\n    ? `${Uppercase<F1> | Lowercase<F1>}${Uppercase<F2> | Lowercase<F2>}${AnyCase<R>}`\n    : T extends `${infer F}${infer R}`\n      ? `${Uppercase<F> | Lowercase<F>}${AnyCase<R>}`\n      : typeof EMPTY_STRING;\n\nexport type Newable<T> = new (..._args: never[]) => T;\n\nexport interface Abstract<T> {\n  prototype: T;\n}\n\nexport interface Clonable<T> {\n  clone: () => T;\n}\n\nexport type MaybePromise<T> = T | Promise<T>;\n\nexport type ReducerFunction<TState, TAction> = (\n  state: TState,\n  action: TAction\n) => TState;\n\n// NOTE: for the file size optimization\nexport const TYPE_ARGUMENTS = \"Arguments\";\nexport const TYPE_ARRAY = \"Array\";\nexport const TYPE_OBJECT = \"Object\";\nexport const TYPE_MAP = \"Map\";\nexport const TYPE_SET = \"Set\";\n\nexport type Collection =\n  | IArguments\n  | unknown[]\n  | Map<unknown, unknown>\n  | Record<string | number | symbol, unknown>\n  | Set<unknown>;\n\nexport type NonUndefined<T> = T extends undefined ? never : T;\n\nexport type BrowserNativeObject = Date | File;\n\nexport type DeepPartial<T> = T extends BrowserNativeObject | NestedValue\n  ? T\n  : {\n      [K in keyof T]?: DeepPartial<T[K]>;\n    };\n\nexport type Rollback = Record<\n  string,\n  (initialValue: any, currentValue: any) => any\n>;\n\n/**\n * Extract all required keys from the given type.\n *\n * @remarks\n * This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...\n */\nexport type RequiredKeysOf<BaseType extends object> = Exclude<\n  {\n    [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]>\n      ? Key\n      : never;\n  }[keyof BaseType],\n  undefined\n>;\n\n/**\n * Returns a boolean for whether the two given types are equal.\n *\n * @remarks\n * Use-cases: If you want to make a conditional branch based on the result of a comparison of two types.\n *\n * @see https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650\n * @see https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796\n */\nexport type IsEqual<A, B> =\n  (<G>() => G extends A ? 1 : 2) extends <G>() => G extends B ? 1 : 2\n    ? true\n    : false;\n\nexport type Filter<KeyType, ExcludeType> =\n  IsEqual<KeyType, ExcludeType> extends true\n    ? never\n    : KeyType extends ExcludeType\n      ? never\n      : KeyType;\n\ninterface ExceptOptions {\n  /**\n    Disallow assigning non-specified properties.\n\n    Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.\n\n    @defaultValue  false\n   */\n  requireExactProps?: boolean;\n}\n\n/**\n * Create a type from an object type without certain keys.\n *\n * @remarks\n * We recommend setting the `requireExactProps` option to `true`.\n *\n * This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.\n *\n * This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).\n */\nexport type Except<\n  ObjectType,\n  KeysType extends keyof ObjectType,\n  Options extends ExceptOptions = { requireExactProps: false }\n> = {\n  [KeyType in keyof ObjectType as Filter<\n    KeyType,\n    KeysType\n  >]: ObjectType[KeyType];\n} & (Options[\"requireExactProps\"] extends true\n  ? Partial<Record<KeysType, never>>\n  : Record<string, never>);\n\n/**\n * Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.\n *\n * @remarks\n * Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.\n *\n * If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.\n *\n * @see https://github.com/microsoft/TypeScript/issues/15300\n */\nexport type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};\n\n/**\n * Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.\n *\n * @remarks\n * Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.\n */\nexport type SetRequired<\n  BaseType,\n  Keys extends keyof BaseType\n> = BaseType extends unknown // type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types). // union into a [distributive conditional // `extends unknown` is always going to be the case and is used to convert any\n  ? Simplify<\n      // Pick just the keys that are optional from the base type.\n      Except<BaseType, Keys> &\n        // Pick the keys that should be required from the base type and make them required.\n        Required<Pick<BaseType, Keys>>\n    >\n  : never;\n\nexport const $NestedValue: unique symbol = Symbol(\"NestedValue\");\n\nexport type NestedValue<TValue extends object = object> = {\n  [$NestedValue]: never;\n} & TValue;\n\nexport interface RefObject<T> {\n  current: T;\n}\n\nexport interface Identity<T = string> {\n  id: T;\n}\n\nexport interface Versioned {\n  version: number;\n}\n\nexport interface Sequenced {\n  /**\n   * The sequence number (version, or event counter, etc.) of the record\n   */\n  sequence: number;\n}\n\nexport interface Typed {\n  /**\n   * The type of the record\n   */\n  __type: string;\n}\n\nexport interface ClassTypeCheckable<T> extends Typed {\n  /**\n   * Run type check on the given value\n   * @param value - The value to check\n   * @returns True if the value is of the type of the class\n   */\n  isTypeOf: (value: unknown) => value is T;\n}\n\n/**\n * Matches non-recursive types.\n */\nexport type NonRecursiveType =\n  | BuiltIns\n  // eslint-disable-next-line ts/no-unsafe-function-type\n  | Function\n  | (new (...arguments_: any[]) => unknown);\n\nexport type IsPrimitive<T> = [T] extends [Primitive] ? true : false;\nexport type IsNever<T> = [T] extends [never] ? true : false;\nexport type IsAny<T> = 0 extends 1 & T ? true : false;\nexport type IsNull<T> = [T] extends [null] ? true : false;\nexport type IsUndefined<T> = T extends undefined ? true : false;\nexport type IsUnknown<T> = unknown extends T // `T` can be `unknown` or `any`\n  ? IsNull<T> extends false // `any` can be `null`, but `unknown` can't be\n    ? true\n    : false\n  : false;\nexport type IsNullish<T> = IsNull<T> & IsUndefined<T>;\nexport type IsFunction<T> = T extends AnyFunction ? true : false;\n\n/**\n * Declare locally scoped properties on `globalThis`.\n *\n * When defining a global variable in a declaration file is inappropriate, it can be helpful to define a `type` or `interface` (say `ExtraGlobals`) with the global variable and then cast `globalThis` via code like `globalThis as unknown as ExtraGlobals`.\n *\n * Instead of casting through `unknown`, you can update your `type` or `interface` to extend `GlobalThis` and then directly cast `globalThis`.\n *\n * @example\n * ```\n * import type { GlobalThis } from '@stryke/types';\n *\n * type ExtraGlobals = GlobalThis & {\n *   readonly GLOBAL_TOKEN: string;\n * };\n *\n * (globalThis as ExtraGlobals).GLOBAL_TOKEN;\n * ```\n */\nexport type GlobalThis = typeof globalThis;\n\n/**\n * Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).\n */\nexport interface Class<T, Arguments extends unknown[] = any[]> {\n  prototype: Pick<T, keyof T>;\n  new (...arguments_: Arguments): T;\n}\n\n/**\n * Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).\n */\nexport type Constructor<T, Arguments extends unknown[] = any[]> = new (\n  ...arguments_: Arguments\n) => T;\n\n/**\n * Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/classes.html#abstract-classes).\n *\n * @privateRemarks\n * We cannot use a `type` here because TypeScript throws: 'abstract' modifier cannot appear on a type member. (1070)\n */\n\nexport interface AbstractClass<\n  T,\n  Arguments extends unknown[] = any[]\n> extends AbstractConstructor<T, Arguments> {\n  prototype: Pick<T, keyof T>;\n}\n\n/**\n * Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html#abstract-construct-signatures) constructor.\n */\nexport type AbstractConstructor<\n  T,\n  Arguments extends unknown[] = any[]\n> = abstract new (...arguments_: Arguments) => T;\n\n/**\n * Create a tuple type of the given length `<L>` and fill it with the given type `<Fill>`.\n *\n * If `<Fill>` is not provided, it will default to `unknown`.\n *\n * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f\n */\nexport type BuildTuple<\n  L extends number,\n  Fill = unknown,\n  T extends readonly unknown[] = []\n> = T[\"length\"] extends L ? T : BuildTuple<L, Fill, [...T, Fill]>;\n\n/**\n * Test if the given function has multiple call signatures.\n *\n * Needed to handle the case of a single call signature with properties.\n *\n * Multiple call signatures cannot currently be supported due to a TypeScript limitation.\n * @see https://github.com/microsoft/TypeScript/issues/29732\n */\nexport type HasMultipleCallSignatures<\n  T extends (...arguments_: any[]) => unknown\n> = T extends {\n  (...arguments_: infer A): unknown;\n  (...arguments_: infer B): unknown;\n}\n  ? B extends A\n    ? A extends B\n      ? false\n      : true\n    : true\n  : false;\n\ntype StructuredCloneablePrimitive =\n  | string\n  | number\n  | bigint\n  | boolean\n  | null\n  | undefined\n  | boolean\n  | number\n  | string;\n\ntype StructuredCloneableData =\n  | ArrayBuffer\n  | DataView\n  | Date\n  | Error\n  | RegExp\n  | TypedArray\n  | Blob\n  | File;\n\n// DOM exclusive types\n// | AudioData\n// | CropTarget\n// | CryptoKey\n// | DOMException\n// | DOMMatrix\n// | DOMMatrixReadOnly\n// | DOMPoint\n// | DOMPointReadOnly\n// | DOMQuad\n// | DOMRect\n// | DOMRectReadOnly\n// | FileList\n// | FileSystemDirectoryHandle\n// | FileSystemFileHandle\n// | FileSystemHandle\n// | GPUCompilationInfo\n// | GPUCompilationMessage\n// | ImageBitmap\n// | ImageData\n// | RTCCertificate\n// | VideoFrame\n\ntype StructuredCloneableCollection =\n  | readonly StructuredCloneable[]\n  | {\n      readonly [key: string]: StructuredCloneable;\n      readonly [key: number]: StructuredCloneable;\n    }\n  | ReadonlyMap<StructuredCloneable, StructuredCloneable>\n  | ReadonlySet<StructuredCloneable>;\n\n/**\n * Matches a value that can be losslessly cloned using `structuredClone`.\n *\n * Note:\n * - Custom error types will be cloned as the base `Error` type\n * - This type doesn't include types exclusive to the TypeScript DOM library (e.g. `DOMRect` and `VideoFrame`)\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\n *\n * @example\n * ```\n * import type { StructuredCloneable } from '@stryke/types';\n *\n * class CustomClass {}\n *\n * // @ts-expect-error\n * const error: StructuredCloneable = {\n *     custom: new CustomClass(),\n * };\n *\n * structuredClone(error);\n * //=> {custom: {}}\n *\n * const good: StructuredCloneable = {\n *     number: 3,\n *     date: new Date(),\n *     map: new Map<string, number>(),\n * }\n *\n * good.map.set('key', 1);\n *\n * structuredClone(good);\n * //=> {number: 3, date: Date(2022-10-17 22:22:35.920), map: Map {'key' -> 1}}\n * ```\n */\nexport type StructuredCloneable =\n  | StructuredCloneablePrimitive\n  | StructuredCloneableData\n  | StructuredCloneableCollection;\n"],"mappings":"AAsJA,MAAa,EAAe,GACf,EAAiB;EACjB,EAAe,EAAE,CA4BjB,EAAiB,YACjB,EAAa,QACb,EAAc,SACd,EAAW,MACX,EAAW,MA4HXA,EAA8B,OAAO,cAAc"}