@stryke/types 0.10.12 → 0.10.19

package/README.md

@@ -3,7 +3,13 @@
 <!-- markdownlint-disable -->
 
 
-<div align="center"><img src="https://public.storm-cdn.com/storm-banner.gif" width="100%" alt="Storm Software" /></div>
+<div align="center">
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://public.storm-cdn.com/storm-software/banner-1280x640-dark-optimized.gif">
+  <source media="(prefers-color-scheme: light)" srcset="https://public.storm-cdn.com/storm-software/banner-1280x640-light-optimized.gif">
+<img src="https://public.storm-cdn.com/storm-software/banner-1280x640-dark-optimized.gif" width="100%" alt="Storm Software" />
+</picture>
+</div>
 <br />
 
 <div align="center">
@@ -16,13 +22,13 @@
 </div>
 
 <br />
-This package is part of Storm Software's **🌩️ Stryke** monorepo. Stryke packages TypeScript utility packages with shared functionality common to many Storm Software applications.
+This package is part of Storm Software's **💥 Stryke** monorepo. Stryke packages TypeScript utility packages with shared functionality common to many Storm Software applications.
 
 <br />
 
 <h3 align="center">💻 Visit <a href="https://stormsoftware.com" target="_blank">stormsoftware.com</a> to stay up to date with this developer</h3><br />
 
-[![Version](https://img.shields.io/badge/version-0.8.4-1fb2a6.svg?style=for-the-badge&color=1fb2a6)](https://prettier.io/)&nbsp;[![Nx](https://img.shields.io/badge/Nx-17.0.2-lightgrey?style=for-the-badge&logo=nx&logoWidth=20&&color=1fb2a6)](http://nx.dev/)&nbsp;[![NextJs](https://img.shields.io/badge/Next.js-14.0.2-lightgrey?style=for-the-badge&logo=nextdotjs&logoWidth=20&color=1fb2a6)](https://nextjs.org/)&nbsp;[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg?style=for-the-badge&logo=commitlint&color=1fb2a6)](http://commitizen.github.io/cz-cli/)&nbsp;![Semantic-Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=for-the-badge&color=1fb2a6)&nbsp;[![documented with Fumadocs](https://img.shields.io/badge/documented_with-fumadocs-success.svg?style=for-the-badge&logo=readthedocs&color=1fb2a6)](https://fumadocs.vercel.app/)&nbsp;![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/storm-software/stryke/cr.yml?style=for-the-badge&logo=github-actions&color=1fb2a6)
+[![Version](https://img.shields.io/badge/version-0.10.16-1fb2a6.svg?style=for-the-badge&color=1fb2a6)](https://prettier.io/)&nbsp;[![Nx](https://img.shields.io/badge/Nx-17.0.2-lightgrey?style=for-the-badge&logo=nx&logoWidth=20&&color=1fb2a6)](http://nx.dev/)&nbsp;[![NextJs](https://img.shields.io/badge/Next.js-14.0.2-lightgrey?style=for-the-badge&logo=nextdotjs&logoWidth=20&color=1fb2a6)](https://nextjs.org/)&nbsp;[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg?style=for-the-badge&logo=commitlint&color=1fb2a6)](http://commitizen.github.io/cz-cli/)&nbsp;![Semantic-Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=for-the-badge&color=1fb2a6)&nbsp;[![documented with Fumadocs](https://img.shields.io/badge/documented_with-fumadocs-success.svg?style=for-the-badge&logo=readthedocs&color=1fb2a6)](https://fumadocs.vercel.app/)&nbsp;![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/storm-software/stryke/cr.yml?style=for-the-badge&logo=github-actions&color=1fb2a6)
 
 > [!IMPORTANT] Important
 > This repository, and the apps, libraries, and tools contained within, is still in it's initial development phase. As a result, bugs and  issues are expected with it's usage. When the main development phase completes, a proper release will be performed, the packages will be available through NPM (and other distributions), and this message will be removed. However, in the meantime, please feel free to report any issues you may come across.
@@ -46,7 +52,6 @@ across many projects.
 
 <!-- START doctoc -->
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
-
 ## Table of Contents
 
 - [Installing](#installing)
@@ -93,10 +98,10 @@ yarn add -D @stryke/types
 
 ## Reduced Package Size
 
-This project uses [tsup](https://tsup.egoist.dev/) to package the source code
-due to its ability to remove unused code and ship smaller javascript files
-thanks to code splitting. This helps to greatly reduce the size of the package
-and to make it easier to use in other projects.
+This project uses [tsdown](https://tsdown.dev) to package the source code due to
+its ability to remove unused code and ship smaller javascript files thanks to
+code splitting. This helps to greatly reduce the size of the package and to make
+it easier to use in other projects.
 
 ## Development
 
@@ -237,10 +242,13 @@ specification. Contributions of any kind welcome!
 <br />
 
 <hr />
-<br />
 
 <div align="center">
-<img src="https://public.storm-cdn.com/logo-banner.png" width="100%" alt="Storm Software" />
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://public.storm-cdn.com/storm-software/banner-1280x320-dark-optimized.webp">
+  <source media="(prefers-color-scheme: light)" srcset="https://public.storm-cdn.com/storm-software/banner-1280x320-light-optimized.webp">
+<img src="https://public.storm-cdn.com/storm-software/banner-1280x320-dark-optimized.webp" width="100%" alt="Storm Software" />
+</picture>
 </div>
 <br />
 

package/dist/{array.d.ts → array-DVtfX_TI.d.mts}

@@ -1,19 +1,20 @@
+//#region src/array.d.ts
 /**
  * Matches any array or array-like object.
  */
-export type Arrayable<T> = T | T[];
-export type UnknownArray = readonly unknown[];
+type Arrayable<T> = T | T[];
+type UnknownArray = readonly unknown[];
 /**
  * Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
  */
-export type TypedArray = BigInt64Array | BigUint64Array | Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
+type TypedArray = BigInt64Array | BigUint64Array | Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
 /**
  * Infer the length of the given array `<T>`.
  *
  * Check out {@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f | this article} for more information.
  */
-export type ArrayLength<T extends readonly unknown[]> = T extends {
-    readonly length: infer L;
+type ArrayLength<T extends readonly unknown[]> = T extends {
+  readonly length: infer L;
 } ? L : never;
 /**
  * Extract the element of an array that also works for array union.
@@ -22,7 +23,7 @@ export type ArrayLength<T extends readonly unknown[]> = T extends {
  *
  * It creates a type-safe way to access the element type of `unknown` type.
  */
-export type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
+type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
 /**
  * Provides all values for a constant array or tuple.
  *
@@ -42,7 +43,7 @@ export type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
  *
  * @see {@link ArrayIndices}
  */
-export type ArrayValues<T extends readonly unknown[]> = T[number];
+type ArrayValues<T extends readonly unknown[]> = T[number];
 /**
  * Provides valid indices for a constant array or tuple.
  *
@@ -62,15 +63,15 @@ export type ArrayValues<T extends readonly unknown[]> = T[number];
  *
  * @see {@link ArrayValues}
  */
-export type ArrayIndices<Element extends readonly unknown[]> = Exclude<Partial<Element>["length"], Element["length"]>;
+type ArrayIndices<Element extends readonly unknown[]> = Exclude<Partial<Element>["length"], Element["length"]>;
 /**
  * Matches any unknown array or tuple.
  */
-export type UnknownArrayOrTuple = readonly [...unknown[]];
+type UnknownArrayOrTuple = readonly [...unknown[]];
 /**
  * Extracts the type of the first element of an array or tuple.
  */
-export type FirstArrayElement<TArray extends UnknownArrayOrTuple> = TArray extends readonly [infer THead, ...unknown[]] ? THead : never;
+type FirstArrayElement<TArray extends UnknownArrayOrTuple> = TArray extends readonly [infer THead, ...unknown[]] ? THead : never;
 /**
  * Extracts the type of the last element of an array.
  *
@@ -93,7 +94,7 @@ export type FirstArrayElement<TArray extends UnknownArrayOrTuple> = TArray exten
  * //=> 2
  * ```
  */
-export type LastArrayElement<Elements extends readonly unknown[], ElementBeforeTailingSpreadElement = never> = Elements extends readonly [] ? ElementBeforeTailingSpreadElement : Elements extends readonly [...infer _U, infer V] ? V : Elements extends readonly [infer U, ...infer V] ? LastArrayElement<V, U> : Elements extends readonly (infer U)[] ? ElementBeforeTailingSpreadElement | U : never;
+type LastArrayElement<Elements extends readonly unknown[], ElementBeforeTailingSpreadElement = never> = Elements extends readonly [] ? ElementBeforeTailingSpreadElement : Elements extends readonly [...infer _U, infer V] ? V : Elements extends readonly [infer U, ...infer V] ? LastArrayElement<V, U> : Elements extends readonly (infer U)[] ? ElementBeforeTailingSpreadElement | U : never;
 /**
  * Returns the static, fixed-length portion of the given array, excluding variable-length parts.
  *
@@ -104,7 +105,7 @@ export type LastArrayElement<Elements extends readonly unknown[], ElementBeforeT
  * //=> [string, number, boolean]
  * ```
  */
-export type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> = T extends unknown ? number extends T["length"] ? T extends readonly [infer U, ...infer V] ? StaticPartOfArray<V, [...Result, U]> : Result : T : never;
+type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> = T extends unknown ? number extends T["length"] ? T extends readonly [infer U, ...infer V] ? StaticPartOfArray<V, [...Result, U]> : Result : T : never;
 /**
  * Returns the variable, non-fixed-length portion of the given array, excluding static-length parts.
  *
@@ -115,4 +116,7 @@ export type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArra
  * //=> string[]
  * ```
  */
-export type VariablePartOfArray<T extends UnknownArray> = T extends unknown ? T extends readonly [...StaticPartOfArray<T>, ...infer U] ? U : [] : never;
+type VariablePartOfArray<T extends UnknownArray> = T extends unknown ? T extends readonly [...StaticPartOfArray<T>, ...infer U] ? U : [] : never;
+//#endregion
+export { Arrayable as a, StaticPartOfArray as c, UnknownArrayOrTuple as d, VariablePartOfArray as f, ArrayValues as i, TypedArray as l, ArrayIndices as n, FirstArrayElement as o, ArrayLength as r, LastArrayElement as s, ArrayElement as t, UnknownArray as u };
+//# sourceMappingURL=array-DVtfX_TI.d.mts.map

package/dist/array-DVtfX_TI.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-DVtfX_TI.d.mts","names":[],"sources":["../src/array.ts"],"sourcesContent":[],"mappings":";;AAqBA;AAEA;AAKY,KAPA,SAOU,CAAA,CAAA,CAAA,GAPK,CAOL,GAPS,CAOT,EAAA;AAClB,KANQ,YAAA,GAMR,SAAA,OAAA,EAAA;;;;AAIA,KALQ,UAAA,GACR,aAIA,GAHA,cAGA,GAFA,YAEA,GADA,YACA,GAAA,SAAA,GACA,UADA,GAEA,UAFA,GAGA,UAHA,GAIA,iBAJA,GAKA,WALA,GAMA,WANA;;;;;;AAMA,KAOQ,WAPR,CAAA,UAAA,SAAA,OAAA,EAAA,CAAA,GAOoD,CAPpD,SAAA;EAAW,SAAA,MAAA,EAAA,KAAA,EAAA;AAOf,CAAA,GAAY,CAAA,GAAA,KAAA;AAaZ;AAqBA;AAqBA;;;;;AAAsE,KA1C1D,YA0C0D,CAAA,CAAA,CAAA,GA1CxC,CA0CwC,SAAA,SAAA,OAAA,EAAA,GA1CT,CA0CS,CAAA,CAAA,CAAA,GAAA,KAAA;AAQtE;AAKA;AAyBA;;;;;;;;;;;;AA2BA;;;;;AAKM,KA3FM,WA2FN,CAAA,UAAA,SAAA,OAAA,EAAA,CAAA,GA3FkD,CA2FlD,CAAA,MAAA,CAAA;;;;;;;;AAgBN;;;;;;;;;;;;KAtFY,mDAAmD,QAC7D,QAAQ,oBACR;;;;KAMU,mBAAA;;;;KAKA,iCAAiC,uBAC3C;;;;;;;;;;;;;;;;;;;;;;;KAwBU,mGAKV,+BACI,oCACA,uDAEE,kDAGE,iBAAiB,GAAG,KACpB,wCACE,oCAAoC;;;;;;;;;;;KAapC,4BACA,6BACK,qBACb,mCACe,cACb,2CACE,kBAAkB,OAAO,QAAQ,MACjC,SACF;;;;;;;;;;;KAaM,8BAA8B,gBAAgB,oBACtD,uBAAuB,kBAAkB"}

package/dist/array-DtIKbcDr.d.cts

@@ -0,0 +1,122 @@
+//#region src/array.d.ts
+/**
+ * Matches any array or array-like object.
+ */
+type Arrayable<T> = T | T[];
+type UnknownArray = readonly unknown[];
+/**
+ * Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
+ */
+type TypedArray = BigInt64Array | BigUint64Array | Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
+/**
+ * Infer the length of the given array `<T>`.
+ *
+ * Check out {@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f | this article} for more information.
+ */
+type ArrayLength<T extends readonly unknown[]> = T extends {
+  readonly length: infer L;
+} ? L : never;
+/**
+ * Extract the element of an array that also works for array union.
+ *
+ * Returns `never` if T is not an array.
+ *
+ * It creates a type-safe way to access the element type of `unknown` type.
+ */
+type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
+/**
+ * Provides all values for a constant array or tuple.
+ *
+ * Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety with their values.
+ *
+ * @example
+ * ```
+ * import type {ArrayValues, ArrayIndices} from 'type-fest';
+ *
+ * const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
+ *
+ * type WeekdayName = ArrayValues<typeof weekdays>;
+ * type Weekday = ArrayIndices<typeof weekdays>;
+ *
+ * const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
+ * ```
+ *
+ * @see {@link ArrayIndices}
+ */
+type ArrayValues<T extends readonly unknown[]> = T[number];
+/**
+ * Provides valid indices for a constant array or tuple.
+ *
+ * Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety for accessing elements by their indices.
+ *
+ * @example
+ * ```
+ * import type {ArrayIndices, ArrayValues} from 'type-fest';
+ *
+ * const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
+ *
+ * type Weekday = ArrayIndices<typeof weekdays>;
+ * type WeekdayName = ArrayValues<typeof weekdays>;
+ *
+ * const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
+ * ```
+ *
+ * @see {@link ArrayValues}
+ */
+type ArrayIndices<Element extends readonly unknown[]> = Exclude<Partial<Element>["length"], Element["length"]>;
+/**
+ * Matches any unknown array or tuple.
+ */
+type UnknownArrayOrTuple = readonly [...unknown[]];
+/**
+ * Extracts the type of the first element of an array or tuple.
+ */
+type FirstArrayElement<TArray extends UnknownArrayOrTuple> = TArray extends readonly [infer THead, ...unknown[]] ? THead : never;
+/**
+ * Extracts the type of the last element of an array.
+ *
+ * Use-case: Defining the return type of functions that extract the last element of an array, for example [`lodash.last`](https://lodash.com/docs/4.17.15#last).
+ *
+ * @example
+ * ```
+ * import type {LastArrayElement} from 'type-fest';
+ *
+ * declare function lastOf<V extends readonly any[]>(array: V): LastArrayElement<V>;
+ *
+ * const array = ['foo', 2];
+ *
+ * typeof lastOf(array);
+ * //=> number
+ *
+ * const array = ['foo', 2] as const;
+ *
+ * typeof lastOf(array);
+ * //=> 2
+ * ```
+ */
+type LastArrayElement<Elements extends readonly unknown[], ElementBeforeTailingSpreadElement = never> = Elements extends readonly [] ? ElementBeforeTailingSpreadElement : Elements extends readonly [...infer _U, infer V] ? V : Elements extends readonly [infer U, ...infer V] ? LastArrayElement<V, U> : Elements extends readonly (infer U)[] ? ElementBeforeTailingSpreadElement | U : never;
+/**
+ * Returns the static, fixed-length portion of the given array, excluding variable-length parts.
+ *
+ * @example
+ * ```
+ * type A = [string, number, boolean, ...string[]];
+ * type B = StaticPartOfArray<A>;
+ * //=> [string, number, boolean]
+ * ```
+ */
+type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> = T extends unknown ? number extends T["length"] ? T extends readonly [infer U, ...infer V] ? StaticPartOfArray<V, [...Result, U]> : Result : T : never;
+/**
+ * Returns the variable, non-fixed-length portion of the given array, excluding static-length parts.
+ *
+ * @example
+ * ```
+ * type A = [string, number, boolean, ...string[]];
+ * type B = VariablePartOfArray<A>;
+ * //=> string[]
+ * ```
+ */
+type VariablePartOfArray<T extends UnknownArray> = T extends unknown ? T extends readonly [...StaticPartOfArray<T>, ...infer U] ? U : [] : never;
+//#endregion
+export { Arrayable as a, StaticPartOfArray as c, UnknownArrayOrTuple as d, VariablePartOfArray as f, ArrayValues as i, TypedArray as l, ArrayIndices as n, FirstArrayElement as o, ArrayLength as r, LastArrayElement as s, ArrayElement as t, UnknownArray as u };
+//# sourceMappingURL=array-DtIKbcDr.d.cts.map

package/dist/array-DtIKbcDr.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-DtIKbcDr.d.cts","names":[],"sources":["../src/array.ts"],"sourcesContent":[],"mappings":";;AAqBA;AAEA;AAKY,KAPA,SAOU,CAAA,CAAA,CAAA,GAPK,CAOL,GAPS,CAOT,EAAA;AAClB,KANQ,YAAA,GAMR,SAAA,OAAA,EAAA;;;;AAIA,KALQ,UAAA,GACR,aAIA,GAHA,cAGA,GAFA,YAEA,GADA,YACA,GAAA,SAAA,GACA,UADA,GAEA,UAFA,GAGA,UAHA,GAIA,iBAJA,GAKA,WALA,GAMA,WANA;;;;;;AAMA,KAOQ,WAPR,CAAA,UAAA,SAAA,OAAA,EAAA,CAAA,GAOoD,CAPpD,SAAA;EAAW,SAAA,MAAA,EAAA,KAAA,EAAA;AAOf,CAAA,GAAY,CAAA,GAAA,KAAA;AAaZ;AAqBA;AAqBA;;;;;AAAsE,KA1C1D,YA0C0D,CAAA,CAAA,CAAA,GA1CxC,CA0CwC,SAAA,SAAA,OAAA,EAAA,GA1CT,CA0CS,CAAA,CAAA,CAAA,GAAA,KAAA;AAQtE;AAKA;AAyBA;;;;;;;;;;;;AA2BA;;;;;AAKM,KA3FM,WA2FN,CAAA,UAAA,SAAA,OAAA,EAAA,CAAA,GA3FkD,CA2FlD,CAAA,MAAA,CAAA;;;;;;;;AAgBN;;;;;;;;;;;;KAtFY,mDAAmD,QAC7D,QAAQ,oBACR;;;;KAMU,mBAAA;;;;KAKA,iCAAiC,uBAC3C;;;;;;;;;;;;;;;;;;;;;;;KAwBU,mGAKV,+BACI,oCACA,uDAEE,kDAGE,iBAAiB,GAAG,KACpB,wCACE,oCAAoC;;;;;;;;;;;KAapC,4BACA,6BACK,qBACb,mCACe,cACb,2CACE,kBAAkB,OAAO,QAAQ,MACjC,SACF;;;;;;;;;;;KAaM,8BAA8B,gBAAgB,oBACtD,uBAAuB,kBAAkB"}

package/dist/array.cjs

@@ -1 +0,0 @@
-"use strict";

package/dist/array.d.cts

@@ -0,0 +1,2 @@
+import { a as Arrayable, c as StaticPartOfArray, d as UnknownArrayOrTuple, f as VariablePartOfArray, i as ArrayValues, l as TypedArray, n as ArrayIndices, o as FirstArrayElement, r as ArrayLength, s as LastArrayElement, t as ArrayElement, u as UnknownArray } from "./array-DtIKbcDr.cjs";
+export { ArrayElement, ArrayIndices, ArrayLength, ArrayValues, Arrayable, FirstArrayElement, LastArrayElement, StaticPartOfArray, TypedArray, UnknownArray, UnknownArrayOrTuple, VariablePartOfArray };

package/dist/array.d.mts

@@ -0,0 +1,2 @@
+import { a as Arrayable, c as StaticPartOfArray, d as UnknownArrayOrTuple, f as VariablePartOfArray, i as ArrayValues, l as TypedArray, n as ArrayIndices, o as FirstArrayElement, r as ArrayLength, s as LastArrayElement, t as ArrayElement, u as UnknownArray } from "./array-DVtfX_TI.mjs";
+export { ArrayElement, ArrayIndices, ArrayLength, ArrayValues, Arrayable, FirstArrayElement, LastArrayElement, StaticPartOfArray, TypedArray, UnknownArray, UnknownArrayOrTuple, VariablePartOfArray };

package/dist/array.mjs

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

package/dist/{async.d.ts → async-BtPWg6IL.d.mts}

@@ -1,4 +1,7 @@
-import type { FunctionLike, IsUnknown } from "./base";
+import { K as IsUnknown, j as FunctionLike } from "./base-CiIyKS-b.mjs";
+
+//#region src/async.d.ts
+
 /**
  * Get the type of the value that a promise resolves to.
  *
@@ -9,7 +12,7 @@ import type { FunctionLike, IsUnknown } from "./base";
  * const value: Awaited<Promise<string>> = 'foo';
  * ```
  */
-export type Awaitable<T> = T | PromiseLike<T>;
+type Awaitable<T> = T | PromiseLike<T>;
 /**
  * A type that can be either a value or a function that returns a value.
  *
@@ -21,7 +24,7 @@ export type Awaitable<T> = T | PromiseLike<T>;
  * const bar: Resolvable<string> = () => 'baz';
  * ```
  */
-export type Resolvable<T> = Awaitable<T> | (() => Awaitable<T>);
+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.
  *
@@ -37,8 +40,8 @@ export type Resolvable<T> = Awaitable<T> | (() => Awaitable<T>);
  * //=> type MyWrappedFunction = (foo: SomeType, bar: unknown) => SomeOtherType | undefined;
  * ```
  */
-export 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;
-export type AsyncFunction = (...arguments_: any[]) => Promise<unknown>;
+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`.
  *
@@ -57,7 +60,7 @@ export type AsyncFunction = (...arguments_: any[]) => Promise<unknown>;
  * asyncFunction().then(value => doSomething(value));
  * ```
  */
-export type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<Target>>;
+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.
  *
@@ -85,7 +88,7 @@ export type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<T
  * }
  * ```
  */
-export type Asyncify<TFunct extends FunctionLike> = SetReturnType<TFunct, Promise<Awaited<ReturnType<TFunct>>>>;
+type Asyncify<TFunct extends FunctionLike> = SetReturnType<TFunct, Promise<Awaited<ReturnType<TFunct>>>>;
 /**
  * Get the result type of a `Promise`
  *
@@ -102,4 +105,7 @@ export type Asyncify<TFunct extends FunctionLike> = SetReturnType<TFunct, Promis
  * @param P - A promise
  * @returns [[Any]]
  */
-export type Await<P> = P extends Promise<infer A> ? A : P;
+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-BtPWg6IL.d.mts.map

package/dist/async-BtPWg6IL.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-BtPWg6IL.d.mts","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/async-eKWh-_sF.d.cts

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

@@ -0,0 +1 @@
+{"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/async.cjs

@@ -1 +0,0 @@
-"use strict";

package/dist/async.d.cts

@@ -0,0 +1,2 @@
+import { a as Awaitable, i as Await, n as AsyncReturnType, o as Resolvable, r as Asyncify, s as SetReturnType, t as AsyncFunction } from "./async-eKWh-_sF.cjs";
+export { AsyncFunction, AsyncReturnType, Asyncify, Await, Awaitable, Resolvable, SetReturnType };

package/dist/async.d.mts

@@ -0,0 +1,2 @@
+import { a as Awaitable, i as Await, n as AsyncReturnType, o as Resolvable, r as Asyncify, s as SetReturnType, t as AsyncFunction } from "./async-BtPWg6IL.mjs";
+export { AsyncFunction, AsyncReturnType, Asyncify, Await, Awaitable, Resolvable, SetReturnType };

package/dist/async.mjs

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