@stryke/types 0.10.12 → 0.10.19

package/dist/{base.d.ts → base-CiIyKS-b.d.mts}

@@ -1,25 +1,27 @@
-import type { TypedArray } from "./array";
-export type SerializablePrimitive = null | undefined | string | number | boolean | bigint;
-export type Primitive = SerializablePrimitive | symbol;
+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.
  */
-export type BuiltIns = Primitive | void | Date | RegExp;
+type BuiltIns = Primitive | void | Date | RegExp;
 /**
  * Matches any non-primitive object
  */
-export type AtomicObject = Function | Promise<any> | Date | RegExp;
+type AtomicObject = Function | Promise<any> | Date | RegExp;
 /** Determines if the passed value is of a specific type */
-export type TypeTester = (value: any) => boolean;
+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.
  */
-export type TypeMap = Record<string, TypeTester>;
+type TypeMap = Record<string, TypeTester>;
 declare const emptyObjectSymbol: unique symbol;
-export type FunctionOrValue<Value> = Value extends () => infer X ? X : Value;
+type FunctionOrValue<Value> = Value extends (() => infer X) ? X : Value;
 /**
  * A [[List]]
  *
@@ -32,7 +34,7 @@ export type FunctionOrValue<Value> = Value extends () => infer X ? X : Value;
  * @param A - its type
  * @returns [[List]]
  */
-export type List<A = any> = ReadonlyArray<A>;
+type List<A = any> = ReadonlyArray<A>;
 /**
  * Alias to create a [[Function]]
  *
@@ -48,28 +50,28 @@ export type List<A = any> = ReadonlyArray<A>;
  * @param R - return type
  * @returns [[Function]]
  */
-export type FunctionLike<P extends List = any, R = any> = (...args: P) => R;
-export type AnyFunction = FunctionLike<any, any>;
-export type Nullish = undefined | null;
-export type Nullishable<T> = T | Nullish;
-export type NonNullishObject = object;
-export type NativeClass = abstract new (...args: any) => any;
-export type AnyNumber = number | number;
-export type AnyString = string | string;
-export type AnyBoolean = boolean | boolean;
-export type AnyArray = any[];
-export type PlainObject = Record<any, object>;
-export type AnyMap = Map<any, any>;
-export type AnyWeakMap = WeakMap<WeakKey, any>;
-export type EmptyArray = [];
-export interface EmptyObject {
-    [emptyObjectSymbol]?: never;
+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;
 }
-export type Any = boolean | number | bigint | string | null | undefined | void | symbol | object | PlainObject | AnyArray | AnyMap | AnyWeakMap;
+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
  */
-export type IndexType = string | number | symbol;
+type IndexType = string | number | symbol;
 /**
  * The declaration of a ***dictionary-type*** object with a specific type
  *
@@ -77,7 +79,7 @@ export type IndexType = string | number | symbol;
  * @see {@link IndexType}
  * @see {@link Dictionary}
  */
-export type TypedIndexable<T> = Record<IndexType, T>;
+type TypedIndexable<T> = Record<IndexType, T>;
 /**
  * The declaration of a ***dictionary-type*** object
  *
@@ -85,7 +87,7 @@ export type TypedIndexable<T> = Record<IndexType, T>;
  * @see {@link IndexType}
  * @see {@link Dictionary}
  */
-export type Indexable = TypedIndexable<any>;
+type Indexable = TypedIndexable<any>;
 /**
  * The declaration of a ***dictionary-type*** object with a specific type
  *
@@ -93,41 +95,37 @@ export type Indexable = TypedIndexable<any>;
  * @see {@link IndexType}
  * @see {@link TypedIndexable}
  */
-export type Dictionary<T> = Record<string, T>;
-export declare const EMPTY_STRING = "";
-export declare const NEWLINE_STRING = "\r\n";
-export declare const EMPTY_OBJECT: {};
-export 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;
-export type Newable<T> = new (..._args: never[]) => T;
-export interface Abstract<T> {
-    prototype: T;
+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;
 }
-export interface Clonable<T> {
-    clone: () => T;
+interface Clonable<T> {
+  clone: () => T;
 }
-export type MaybePromise<T> = T | Promise<T>;
-export type ReducerFunction<TState, TAction> = (state: TState, action: TAction) => TState;
-export declare const TYPE_ARGUMENTS = "Arguments";
-export declare const TYPE_ARRAY = "Array";
-export declare const TYPE_OBJECT = "Object";
-export declare const TYPE_MAP = "Map";
-export declare const TYPE_SET = "Set";
-export type Collection = IArguments | unknown[] | Map<unknown, unknown> | Record<string | number | symbol, unknown> | Set<unknown>;
-export type NonUndefined<T> = T extends undefined ? never : T;
-export type BrowserNativeObject = Date | File;
-export type DeepPartial<T> = T extends BrowserNativeObject | NestedValue ? T : {
-    [K in keyof T]?: DeepPartial<T[K]>;
-};
-export type Rollback = Record<string, (initialValue: any, currentValue: any) => any>;
+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...
  */
-export type RequiredKeysOf<BaseType extends object> = Exclude<{
-    [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never;
-}[keyof BaseType], undefined>;
+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.
  *
@@ -137,17 +135,15 @@ export type RequiredKeysOf<BaseType extends object> = Exclude<{
  * @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
  */
-export type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends <G>() => G extends B ? 1 : 2 ? true : false;
-export type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : KeyType extends ExcludeType ? never : KeyType;
+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;
+  /**
+    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.
@@ -159,11 +155,9 @@ interface ExceptOptions {
  *
  * 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)).
  */
-export 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>);
+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.
  *
@@ -174,61 +168,59 @@ export type Except<ObjectType, KeysType extends keyof ObjectType, Options extend
  *
  * @see https://github.com/microsoft/TypeScript/issues/15300
  */
-export type Simplify<T> = {
-    [KeyType in keyof T]: T[KeyType];
-} & {};
+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.
  */
-export type SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends unknown ? Simplify<Except<BaseType, Keys> & Required<Pick<BaseType, Keys>>> : never;
-export declare const $NestedValue: unique symbol;
-export type NestedValue<TValue extends object = object> = {
-    [$NestedValue]: never;
+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;
-export interface RefObject<T> {
-    current: T;
+interface RefObject<T> {
+  current: T;
 }
-export interface Identity<T = string> {
-    id: T;
+interface Identity<T = string> {
+  id: T;
 }
-export interface Versioned {
-    version: number;
+interface Versioned {
+  version: number;
 }
-export interface Sequenced {
-    /**
-     * The sequence number (version, or event counter, etc.) of the record
-     */
-    sequence: number;
+interface Sequenced {
+  /**
+   * The sequence number (version, or event counter, etc.) of the record
+   */
+  sequence: number;
 }
-export interface Typed {
-    /**
-     * The type of the record
-     */
-    __type: string;
+interface Typed {
+  /**
+   * The type of the record
+   */
+  __type: string;
 }
-export 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;
+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.
  */
-export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
-export type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
-export type IsNever<T> = [T] extends [never] ? true : false;
-export type IsAny<T> = 0 extends 1 & T ? true : false;
-export type IsNull<T> = [T] extends [null] ? true : false;
-export type IsUndefined<T> = T extends undefined ? true : false;
-export type IsUnknown<T> = unknown extends T ? IsNull<T> extends false ? true : false : false;
-export type IsNullish<T> = IsNull<T> & IsUndefined<T>;
-export type IsFunction<T> = T extends AnyFunction ? true : false;
+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`.
  *
@@ -247,31 +239,31 @@ export type IsFunction<T> = T extends AnyFunction ? true : false;
  * (globalThis as ExtraGlobals).GLOBAL_TOKEN;
  * ```
  */
-export type GlobalThis = typeof globalThis;
+type GlobalThis = typeof globalThis;
 /**
  * Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
  */
-export interface Class<T, Arguments extends unknown[] = any[]> {
-    prototype: Pick<T, keyof T>;
-    new (...arguments_: Arguments): T;
+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).
  */
-export type Constructor<T, Arguments extends unknown[] = any[]> = new (...arguments_: Arguments) => T;
+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)
  */
-export interface AbstractClass<T, Arguments extends unknown[] = any[]> extends AbstractConstructor<T, Arguments> {
-    prototype: Pick<T, keyof T>;
+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.
  */
-export type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstract new (...arguments_: Arguments) => T;
+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>`.
  *
@@ -279,7 +271,7 @@ export type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstra
  *
  * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
  */
-export type BuildTuple<L extends number, Fill = unknown, T extends readonly unknown[] = []> = T["length"] extends L ? T : BuildTuple<L, Fill, [...T, Fill]>;
+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.
  *
@@ -288,15 +280,15 @@ export type BuildTuple<L extends number, Fill = unknown, T extends readonly unkn
  * Multiple call signatures cannot currently be supported due to a TypeScript limitation.
  * @see https://github.com/microsoft/TypeScript/issues/29732
  */
-export type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
-    (...arguments_: infer A): unknown;
-    (...arguments_: infer B): unknown;
+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;
+  readonly [key: string]: StructuredCloneable;
+  readonly [key: number]: StructuredCloneable;
 } | ReadonlyMap<StructuredCloneable, StructuredCloneable> | ReadonlySet<StructuredCloneable>;
 /**
  * Matches a value that can be losslessly cloned using `structuredClone`.
@@ -333,5 +325,7 @@ type StructuredCloneableCollection = readonly StructuredCloneable[] | {
  * //=> {number: 3, date: Date(2022-10-17 22:22:35.920), map: Map {'key' -> 1}}
  * ```
  */
-export type StructuredCloneable = StructuredCloneablePrimitive | StructuredCloneableData | StructuredCloneableCollection;
-export {};
+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

@@ -0,0 +1 @@
+{"version":3,"file":"base-CiIyKS-b.d.mts","names":[],"sources":["../src/base.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/base-Cpeh4C5c.cjs

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1 @@
+{"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"}