@tstdl/base 0.92.123 → 0.92.124

package/types/utils/type-guards.d.ts

@@ -0,0 +1,259 @@
+import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, TypedArray } from '../../types.js';
+export type AssertionMessage = string | (() => string);
+export type IsFunction<T> = <U extends T = T>(value: any) => value is U;
+export type IsNotFunction<T> = <V>(value: V) => value is Exclude<V, T>;
+export type AssertFunction<T> = <U extends T = T>(value: any, message?: AssertionMessage) => asserts value is U;
+export type AssertNotFunction<T> = <V>(value: V, message?: AssertionMessage) => asserts value is Exclude<V, T>;
+export type AssertPassFunction<T> = <U extends T = T>(value: any, message?: AssertionMessage) => U;
+export type AssertNotPassFunction<T> = <V>(value: V, message?: AssertionMessage) => Exclude<V, T>;
+export type GuardFunctions<N extends string, T> = Record<`is${PascalCase<N>}`, IsFunction<T>> & Record<`isNot${PascalCase<N>}`, IsNotFunction<T>> & Record<`assert${PascalCase<N>}`, AssertFunction<T>> & Record<`assertNot${PascalCase<N>}`, AssertNotFunction<T>> & Record<`assert${PascalCase<N>}Pass`, AssertPassFunction<T>> & Record<`assertNot${PascalCase<N>}Pass`, AssertNotPassFunction<T>>;
+export declare function assert(condition: boolean, message?: AssertionMessage): asserts condition;
+export declare function assertNot(condition: boolean, message?: AssertionMessage): asserts condition;
+export declare function createGuards<N extends string, T>(name: N, testFn: (value: any) => value is T): GuardFunctions<N, T>;
+export declare function createInstanceGuards<N extends string, T>(name: N, type: AbstractConstructor<T>): GuardFunctions<N, T>;
+export declare const isUndefined: IsFunction<undefined | void>;
+export declare const isDefined: IsNotFunction<undefined | void>;
+export declare const assertUndefined: AssertFunction<undefined | void>;
+export declare const assertDefined: AssertNotFunction<undefined | void>;
+export declare const assertUndefinedPass: AssertPassFunction<undefined | void>;
+export declare const assertDefinedPass: AssertNotPassFunction<undefined | void>;
+export declare const isNull: IsFunction<null>;
+export declare const isNotNull: IsNotFunction<null>;
+export declare const assertNull: AssertFunction<null>;
+export declare const assertNotNull: AssertNotFunction<null>;
+export declare const assertNullPass: AssertPassFunction<null>;
+export declare const assertNotNullPass: AssertNotPassFunction<null>;
+export declare const isNullOrUndefined: (value: any) => value is null | undefined;
+export declare const isNotNullOrUndefined: IsNotFunction<null | undefined | void>;
+export declare const assertNullOrUndefined: (value: any, message?: AssertionMessage) => asserts value is null | undefined;
+export declare const assertNotNullOrUndefined: AssertNotFunction<null | undefined | void>;
+export declare const assertNullOrUndefinedPass: (value: any, message?: AssertionMessage) => null | undefined;
+export declare const assertNotNullOrUndefinedPass: AssertNotPassFunction<null | undefined | void>;
+export declare const isNumber: IsFunction<number>;
+export declare const isNotNumber: IsNotFunction<number>;
+export declare const assertNumber: AssertFunction<number>;
+export declare const assertNotNumber: AssertNotFunction<number>;
+export declare const assertNumberPass: AssertPassFunction<number>;
+export declare const assertNotNumberPass: AssertNotPassFunction<number>;
+export declare const isString: IsFunction<string>;
+export declare const isNotString: IsNotFunction<string>;
+export declare const assertString: AssertFunction<string>;
+export declare const assertNotString: AssertNotFunction<string>;
+export declare const assertStringPass: AssertPassFunction<string>;
+export declare const assertNotStringPass: AssertNotPassFunction<string>;
+export declare const isBoolean: IsFunction<boolean>;
+export declare const isNotBoolean: IsNotFunction<boolean>;
+export declare const assertBoolean: AssertFunction<boolean>;
+export declare const assertNotBoolean: AssertNotFunction<boolean>;
+export declare const assertBooleanPass: AssertPassFunction<boolean>;
+export declare const assertNotBooleanPass: AssertNotPassFunction<boolean>;
+export declare const isBigInt: IsFunction<bigint>;
+export declare const isNotBigInt: IsNotFunction<bigint>;
+export declare const assertBigInt: AssertFunction<bigint>;
+export declare const assertNotBigInt: AssertNotFunction<bigint>;
+export declare const assertBigIntPass: AssertPassFunction<bigint>;
+export declare const assertNotBigIntPass: AssertNotPassFunction<bigint>;
+export declare const isFunction: IsFunction<Function>;
+export declare const isNotFunction: IsNotFunction<Function>;
+export declare const assertFunction: AssertFunction<Function>;
+export declare const assertNotFunction: AssertNotFunction<Function>;
+export declare const assertFunctionPass: AssertPassFunction<Function>;
+export declare const assertNotFunctionPass: AssertNotPassFunction<Function>;
+export declare const isSymbol: IsFunction<symbol>;
+export declare const isNotSymbol: IsNotFunction<symbol>;
+export declare const assertSymbol: AssertFunction<symbol>;
+export declare const assertNotSymbol: AssertNotFunction<symbol>;
+export declare const assertSymbolPass: AssertPassFunction<symbol>;
+export declare const assertNotSymbolPass: AssertNotPassFunction<symbol>;
+export declare const isLiteralObject: IsFunction<object>;
+export declare const isNotLiteralObject: IsNotFunction<object>;
+export declare const assertLiteralObject: AssertFunction<object>;
+export declare const assertNotLiteralObject: AssertNotFunction<object>;
+export declare const assertLiteralObjectPass: AssertPassFunction<object>;
+export declare const assertNotLiteralObjectPass: AssertNotPassFunction<object>;
+export declare const isObject: IsFunction<object>;
+export declare const isNotObject: IsNotFunction<object>;
+export declare const assertObject: AssertFunction<object>;
+export declare const assertNotObject: AssertNotFunction<object>;
+export declare const assertObjectPass: AssertPassFunction<object>;
+export declare const assertNotObjectPass: AssertNotPassFunction<object>;
+export declare const isPrimitive: IsFunction<Primitive>;
+export declare const isNotPrimitive: IsNotFunction<Primitive>;
+export declare const assertPrimitive: AssertFunction<Primitive>;
+export declare const assertNotPrimitive: AssertNotFunction<Primitive>;
+export declare const assertPrimitivePass: AssertPassFunction<Primitive>;
+export declare const assertNotPrimitivePass: AssertNotPassFunction<Primitive>;
+export declare const isJsonPrimitive: IsFunction<JsonPrimitive>;
+export declare const isNotJsonPrimitive: IsNotFunction<JsonPrimitive>;
+export declare const assertJsonPrimitive: AssertFunction<JsonPrimitive>;
+export declare const assertNotJsonPrimitive: AssertNotFunction<JsonPrimitive>;
+export declare const assertJsonPrimitivePass: AssertPassFunction<JsonPrimitive>;
+export declare const assertNotJsonPrimitivePass: AssertNotPassFunction<JsonPrimitive>;
+export declare const isDate: IsFunction<Date>;
+export declare const isNotDate: IsNotFunction<Date>;
+export declare const assertDate: AssertFunction<Date>;
+export declare const assertNotDate: AssertNotFunction<Date>;
+export declare const assertDatePass: AssertPassFunction<Date>;
+export declare const assertNotDatePass: AssertNotPassFunction<Date>;
+export declare const isValidDate: IsFunction<Date>;
+export declare const isNotValidDate: IsNotFunction<Date>;
+export declare const assertValidDate: AssertFunction<Date>;
+export declare const assertNotValidDate: AssertNotFunction<Date>;
+export declare const assertValidDatePass: AssertPassFunction<Date>;
+export declare const assertNotValidDatePass: AssertNotPassFunction<Date>;
+export declare const isRegExp: IsFunction<RegExp>;
+export declare const isNotRegExp: IsNotFunction<RegExp>;
+export declare const assertRegExp: AssertFunction<RegExp>;
+export declare const assertNotRegExp: AssertNotFunction<RegExp>;
+export declare const assertRegExpPass: AssertPassFunction<RegExp>;
+export declare const assertNotRegExpPass: AssertNotPassFunction<RegExp>;
+export declare const isArray: <T = any>(value: any) => value is readonly T[];
+export declare const isNotArray: IsNotFunction<readonly any[]>;
+export declare const assertArray: <T = any>(value: any, message?: AssertionMessage) => asserts value is readonly T[];
+export declare const assertNotArray: AssertNotFunction<readonly any[]>;
+export declare const assertArrayPass: <T = any>(value: any, message?: AssertionMessage) => readonly T[];
+export declare const assertNotArrayPass: AssertNotPassFunction<readonly any[]>;
+export declare const isWritableArray: <T = any>(value: any) => value is T[];
+export declare const isNotWritableArray: IsNotFunction<any[]>;
+export declare const assertWritableArray: <T = any>(value: any, message?: AssertionMessage) => asserts value is T[];
+export declare const assertNotWritableArray: AssertNotFunction<any[]>;
+export declare const assertWritableArrayPass: <T = any>(value: any, message?: AssertionMessage) => T[];
+export declare const assertNotWritableArrayPass: AssertNotPassFunction<any[]>;
+export declare const isBlob: IsFunction<Blob>;
+export declare const isNotBlob: IsNotFunction<Blob>;
+export declare const assertBlob: AssertFunction<Blob>;
+export declare const assertNotBlob: AssertNotFunction<Blob>;
+export declare const assertBlobPass: AssertPassFunction<Blob>;
+export declare const assertNotBlobPass: AssertNotPassFunction<Blob>;
+export declare const isArrayBuffer: IsFunction<ArrayBuffer>;
+export declare const isNotArrayBuffer: IsNotFunction<ArrayBuffer>;
+export declare const assertArrayBuffer: AssertFunction<ArrayBuffer>;
+export declare const assertNotArrayBuffer: AssertNotFunction<ArrayBuffer>;
+export declare const assertArrayBufferPass: AssertPassFunction<ArrayBuffer>;
+export declare const assertNotArrayBufferPass: AssertNotPassFunction<ArrayBuffer>;
+export declare const isArrayBufferView: IsFunction<ArrayBufferView>;
+export declare const isNotArrayBufferView: IsNotFunction<ArrayBufferView>;
+export declare const assertArrayBufferView: AssertFunction<ArrayBufferView>;
+export declare const assertNotArrayBufferView: AssertNotFunction<ArrayBufferView>;
+export declare const assertArrayBufferViewPass: AssertPassFunction<ArrayBufferView>;
+export declare const assertNotArrayBufferViewPass: AssertNotPassFunction<ArrayBufferView>;
+export declare const isBinaryData: IsFunction<BinaryData>;
+export declare const isNotBinaryData: IsNotFunction<BinaryData>;
+export declare const assertBinaryData: AssertFunction<BinaryData>;
+export declare const assertNotBinaryData: AssertNotFunction<BinaryData>;
+export declare const assertBinaryDataPass: AssertPassFunction<BinaryData>;
+export declare const assertNotBinaryDataPass: AssertNotPassFunction<BinaryData>;
+export declare const isInt8Array: IsFunction<Int8Array>;
+export declare const isNotInt8Array: IsNotFunction<Int8Array>;
+export declare const assertInt8Array: AssertFunction<Int8Array>;
+export declare const assertNotInt8Array: AssertNotFunction<Int8Array>;
+export declare const assertInt8ArrayPass: AssertPassFunction<Int8Array>;
+export declare const assertNotInt8ArrayPass: AssertNotPassFunction<Int8Array>;
+export declare const isUint8Array: IsFunction<Uint8Array>;
+export declare const isNotUint8Array: IsNotFunction<Uint8Array>;
+export declare const assertUint8Array: AssertFunction<Uint8Array>;
+export declare const assertNotUint8Array: AssertNotFunction<Uint8Array>;
+export declare const assertUint8ArrayPass: AssertPassFunction<Uint8Array>;
+export declare const assertNotUint8ArrayPass: AssertNotPassFunction<Uint8Array>;
+export declare const isUint8ClampedArray: IsFunction<Uint8ClampedArray>;
+export declare const isNotUint8ClampedArray: IsNotFunction<Uint8ClampedArray>;
+export declare const assertUint8ClampedArray: AssertFunction<Uint8ClampedArray>;
+export declare const assertNotUint8ClampedArray: AssertNotFunction<Uint8ClampedArray>;
+export declare const assertUint8ClampedArrayPass: AssertPassFunction<Uint8ClampedArray>;
+export declare const assertNotUint8ClampedArrayPass: AssertNotPassFunction<Uint8ClampedArray>;
+export declare const isInt16Array: IsFunction<Int16Array>;
+export declare const isNotInt16Array: IsNotFunction<Int16Array>;
+export declare const assertInt16Array: AssertFunction<Int16Array>;
+export declare const assertNotInt16Array: AssertNotFunction<Int16Array>;
+export declare const assertInt16ArrayPass: AssertPassFunction<Int16Array>;
+export declare const assertNotInt16ArrayPass: AssertNotPassFunction<Int16Array>;
+export declare const isUint16Array: IsFunction<Uint16Array>;
+export declare const isNotUint16Array: IsNotFunction<Uint16Array>;
+export declare const assertUint16Array: AssertFunction<Uint16Array>;
+export declare const assertNotUint16Array: AssertNotFunction<Uint16Array>;
+export declare const assertUint16ArrayPass: AssertPassFunction<Uint16Array>;
+export declare const assertNotUint16ArrayPass: AssertNotPassFunction<Uint16Array>;
+export declare const isInt32Array: IsFunction<Int32Array>;
+export declare const isNotInt32Array: IsNotFunction<Int32Array>;
+export declare const assertInt32Array: AssertFunction<Int32Array>;
+export declare const assertNotInt32Array: AssertNotFunction<Int32Array>;
+export declare const assertInt32ArrayPass: AssertPassFunction<Int32Array>;
+export declare const assertNotInt32ArrayPass: AssertNotPassFunction<Int32Array>;
+export declare const isUint32Array: IsFunction<Uint32Array>;
+export declare const isNotUint32Array: IsNotFunction<Uint32Array>;
+export declare const assertUint32Array: AssertFunction<Uint32Array>;
+export declare const assertNotUint32Array: AssertNotFunction<Uint32Array>;
+export declare const assertUint32ArrayPass: AssertPassFunction<Uint32Array>;
+export declare const assertNotUint32ArrayPass: AssertNotPassFunction<Uint32Array>;
+export declare const isFloat32Array: IsFunction<Float32Array>;
+export declare const isNotFloat32Array: IsNotFunction<Float32Array>;
+export declare const assertFloat32Array: AssertFunction<Float32Array>;
+export declare const assertNotFloat32Array: AssertNotFunction<Float32Array>;
+export declare const assertFloat32ArrayPass: AssertPassFunction<Float32Array>;
+export declare const assertNotFloat32ArrayPass: AssertNotPassFunction<Float32Array>;
+export declare const isFloat64Array: IsFunction<Float64Array>;
+export declare const isNotFloat64Array: IsNotFunction<Float64Array>;
+export declare const assertFloat64Array: AssertFunction<Float64Array>;
+export declare const assertNotFloat64Array: AssertNotFunction<Float64Array>;
+export declare const assertFloat64ArrayPass: AssertPassFunction<Float64Array>;
+export declare const assertNotFloat64ArrayPass: AssertNotPassFunction<Float64Array>;
+export declare const isBigInt64Array: IsFunction<BigInt64Array>;
+export declare const isNotBigInt64Array: IsNotFunction<BigInt64Array>;
+export declare const assertBigInt64Array: AssertFunction<BigInt64Array>;
+export declare const assertNotBigInt64Array: AssertNotFunction<BigInt64Array>;
+export declare const assertBigInt64ArrayPass: AssertPassFunction<BigInt64Array>;
+export declare const assertNotBigInt64ArrayPass: AssertNotPassFunction<BigInt64Array>;
+export declare const isBigUint64Array: IsFunction<BigUint64Array>;
+export declare const isNotBigUint64Array: IsNotFunction<BigUint64Array>;
+export declare const assertBigUint64Array: AssertFunction<BigUint64Array>;
+export declare const assertNotBigUint64Array: AssertNotFunction<BigUint64Array>;
+export declare const assertBigUint64ArrayPass: AssertPassFunction<BigUint64Array>;
+export declare const assertNotBigUint64ArrayPass: AssertNotPassFunction<BigUint64Array>;
+export declare const isDataView: IsFunction<DataView>;
+export declare const isNotDataView: IsNotFunction<DataView>;
+export declare const assertDataView: AssertFunction<DataView>;
+export declare const assertNotDataView: AssertNotFunction<DataView>;
+export declare const assertDataViewPass: AssertPassFunction<DataView>;
+export declare const assertNotDataViewPass: AssertNotPassFunction<DataView>;
+export declare const isTypedArray: IsFunction<TypedArray>;
+export declare const isNotTypedArray: IsNotFunction<TypedArray>;
+export declare const assertTypedArray: AssertFunction<TypedArray>;
+export declare const assertNotTypedArray: AssertNotFunction<TypedArray>;
+export declare const assertTypedArrayPass: AssertPassFunction<TypedArray>;
+export declare const assertNotTypedArrayPass: AssertNotPassFunction<TypedArray>;
+export declare const isSet: IsFunction<Set<any>>;
+export declare const isNotSet: IsNotFunction<Set<any>>;
+export declare const assertSet: AssertFunction<Set<any>>;
+export declare const assertNotSet: AssertNotFunction<Set<any>>;
+export declare const assertSetPass: AssertPassFunction<Set<any>>;
+export declare const assertNotSetPass: AssertNotPassFunction<Set<any>>;
+export declare const isMap: IsFunction<Map<any, any>>;
+export declare const isNotMap: IsNotFunction<Map<any, any>>;
+export declare const assertMap: AssertFunction<Map<any, any>>;
+export declare const assertNotMap: AssertNotFunction<Map<any, any>>;
+export declare const assertMapPass: AssertPassFunction<Map<any, any>>;
+export declare const assertNotMapPass: AssertNotPassFunction<Map<any, any>>;
+export declare const isPromise: IsFunction<Promise<any>>;
+export declare const isNotPromise: IsNotFunction<Promise<any>>;
+export declare const assertPromise: AssertFunction<Promise<any>>;
+export declare const assertNotPromise: AssertNotFunction<Promise<any>>;
+export declare const assertPromisePass: AssertPassFunction<Promise<any>>;
+export declare const assertNotPromisePass: AssertNotPassFunction<Promise<any>>;
+export declare const isPromiseLike: IsFunction<PromiseLike<any>>;
+export declare const isNotPromiseLike: IsNotFunction<PromiseLike<any>>;
+export declare const assertPromiseLike: AssertFunction<PromiseLike<any>>;
+export declare const assertNotPromiseLike: AssertNotFunction<PromiseLike<any>>;
+export declare const assertPromiseLikePass: AssertPassFunction<PromiseLike<any>>;
+export declare const assertNotPromiseLikePass: AssertNotPassFunction<PromiseLike<any>>;
+export declare const isError: IsFunction<Error>;
+export declare const isNotError: IsNotFunction<Error>;
+export declare const assertError: AssertFunction<Error>;
+export declare const assertNotError: AssertNotFunction<Error>;
+export declare const assertErrorPass: AssertPassFunction<Error>;
+export declare const assertNotErrorPass: AssertNotPassFunction<Error>;
+export declare const isReadableStream: <T = any>(value: any) => value is ReadableStream<T>;
+export declare const isNotReadableStream: IsNotFunction<ReadableStream>;
+export declare const assertReadableStream: <T = any>(value: any, message?: AssertionMessage) => asserts value is ReadableStream<T>;
+export declare const assertNotReadableStream: AssertNotFunction<ReadableStream>;
+export declare const assertReadableStreamPass: <T = any>(value: any, message?: AssertionMessage) => ReadableStream<T>;
+export declare const assertNotReadableStreamPass: AssertNotPassFunction<ReadableStream>;

package/types/utils/z-base32.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryData } from '../../types.js';
+export declare function zBase32Encode(buffer: BinaryData): string;
+export declare function zBase32Decode(input: string): Uint8Array;

package/utils/async-hook/async-hook.js

@@ -0,0 +1,21 @@
+export function asyncHook() {
+    const handlers = [];
+    return {
+        register: (handler) => {
+            handlers.push(handler);
+            return {
+                unregister() {
+                    handlers.splice(handlers.indexOf(handler));
+                },
+            };
+        },
+        trigger: async (value, context) => {
+            let returnValues = [];
+            for (const handler of handlers) {
+                const returnValue = await handler(value, context);
+                returnValues.push(returnValue);
+            }
+            return returnValues;
+        },
+    };
+}

package/utils/async-hook/index.js

@@ -0,0 +1 @@
+export * from './async-hook.js';

package/utils/compression.js

@@ -1,7 +1,7 @@
 import { dynamicImport } from '../import.js';
 import { encodeBase64, encodeBase64Url } from './base64.js';
 import { decodeText, encodeHex, encodeUtf8 } from './encoding.js';
-import { readableStreamFromPromise } from './stream/readable-stream-from-promise.js';
+import { readableStreamFromPromise } from './stream/from-promise.js';
 import { assertDefined, isNotNullOrUndefined } from './type-guards.js';
 import { zBase32Encode } from './z-base32.js';
 export function compressString(input, algorithm, options) {

package/utils/function/class.js

@@ -0,0 +1,9 @@
+import { isUndefined } from '../type-guards.js';
+export function getClassOfName(name, extend) {
+    if (isUndefined(extend)) {
+        return { [name]: class {
+            } }[name];
+    }
+    return { [name]: class extends extend {
+        } }[name];
+}

package/utils/function/index.js

@@ -1,2 +1,3 @@
+export * from './class.js';
 export * from './memoize.js';
 export * from './throttle.js';

package/utils/function/memoize.js

@@ -1,5 +1,7 @@
 import { IterableWeakMap } from '../../data-structures/iterable-weak-map.js';
 import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
+import { createAccessorDecorator } from '../../reflection/index.js';
+import { assertDefinedPass } from '../type-guards.js';
 /**
  * Memoizes a function with an arbitrary number of parameters. If you only need a single parameter, {@link memoizeSingle} is faster
  * @param fn function memoize
@@ -15,7 +17,7 @@ import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
             const result = fn.call(this, ...parameters);
             cache.set(parameters, result);
             return result;
-        }
+        },
     }[name];
 }
 /**
@@ -34,7 +36,7 @@ export function memoizeSingle(fn, options = {}) {
             const result = fn.call(this, parameter);
             cache.set(parameter, result);
             return result;
-        }
+        },
     }[name];
 }
 export function memoizeClass(type, options = {}) {
@@ -43,6 +45,43 @@ export function memoizeClass(type, options = {}) {
 export function memoizeClassSingle(type, options = {}) {
     return memoizeSingle((parameter) => new type(parameter), options);
 }
+/**
+ * Memoizes an accessor (getter)
+ *
+ * @example
+ * ```typescript
+ * class MyClass {
+ *   @Memoize()
+ *   get myValue() {
+ *     // expensive calculation
+ *     return 123;
+ *   }
+ * }
+ * ```
+ *
+ * @remarks
+ * The getter will be called only once for each instance of the class.
+ */
+export function Memoize() {
+    const cache = new WeakMap();
+    return createAccessorDecorator({
+        handler: (data) => {
+            const getter = assertDefinedPass(data.descriptor.get, 'Memoize requires an getter for accessors.'); // eslint-disable-line @typescript-eslint/unbound-method
+            function cachedGetter() {
+                if (cache.has(this)) {
+                    return cache.get(this); // eslint-disable-line @typescript-eslint/no-unsafe-return
+                }
+                const value = getter.call(this);
+                cache.set(this, value);
+                return value; // eslint-disable-line @typescript-eslint/no-unsafe-return
+            }
+            return {
+                writable: false,
+                get: cachedGetter,
+            };
+        },
+    });
+}
 function getMemoizedName(fn) {
     return `memoized${fn.name[0]?.toUpperCase() ?? ''}${fn.name.slice(1)}`;
 }

package/utils/jwt.js

@@ -15,30 +15,30 @@ export function parseJwtTokenString(tokenString) {
     const encoded = {
         header: encodedHeader,
         payload: encodedPayload,
-        signature: encodedSignature
+        signature: encodedSignature,
     };
     const bytes = {
         header: decodeBase64Url(encodedHeader),
         payload: decodeBase64Url(encodedPayload),
-        signature: decodeBase64Url(encodedSignature)
+        signature: decodeBase64Url(encodedSignature),
     };
     const string = {
         header: textDecoder.decode(bytes.header),
-        payload: textDecoder.decode(bytes.payload)
+        payload: textDecoder.decode(bytes.payload),
     };
     try {
         const header = JSON.parse(string.header);
         const payload = JSON.parse(string.payload);
         const token = {
             header,
-            payload
+            payload,
         };
         return {
             raw: tokenString,
             token: token,
             encoded,
             bytes,
-            string
+            string,
         };
     }
     catch {

package/utils/object/forward-ref.js

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { getClassOfName } from '../function/index.js';
 import { propertyReflectMethods, reflectMethods } from '../proxy.js';
-import { assert, isDefined, isUndefined } from '../type-guards.js';
-import { lazyObject } from './lazy-property.js';
+import { assert, isDefined, isFunction, isUndefined } from '../type-guards.js';
+import { lazyObject, lazyObjectValue } from './lazy-property.js';
 const contexts = new WeakMap();
-// eslint-disable-next-line @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention
 export const ForwardRef = {
     create(options) {
         const context = getContext(options);
@@ -30,24 +30,26 @@ export const ForwardRef = {
     setRef(forwardRef, reference) {
         assert(ForwardRef.isForwardRef(forwardRef), 'provided value is not a ForwardRef');
         contexts.get(forwardRef).reference = reference;
-    }
+    },
 };
 function getForwardRefProxy(context) {
-    const target = (context.typeHint == 'function')
-        ? function forwardRef() { }
-        : { forwardRef: true };
+    const target = isFunction(context.typeHint)
+        ? new (getClassOfName(`${context.typeHint.name}ForwardRef`))()
+        : (context.typeHint == 'function')
+            ? function forwardRef() { }
+            : { forwardRef: true };
     const handler = {};
     for (const method of reflectMethods) {
         handler[method] = {
             [method](_originalTarget, ...args) {
                 if (isUndefined(context.reference)) {
                     const message = propertyReflectMethods.has(method)
-                        ? `cannot forward "${method}" to property "${args[0].toString()}" on a ForwardRef which has no reference`
+                        ? `cannot forward "${method}" to property "${String(args[0])}" on a ForwardRef which has no reference`
                         : `cannot forward "${method}" on a ForwardRef which has no reference`;
                     throw new Error(message);
                 }
                 return Reflect[method](context.reference, ...args);
-            }
+            },
         }[method];
     }
     return new Proxy(target, handler);
@@ -58,7 +60,5 @@ function getContext(options) {
         : isDefined(options?.initializer)
             ? { initializer: options.initializer }
             : { value: undefined };
-    return lazyObject({
-        reference
-    });
+    return lazyObject({ reference, typeHint: lazyObjectValue(options?.typeHint) });
 }

package/utils/object/lazy-property.js

@@ -33,7 +33,7 @@ export function lazyProperty(object, propertyKey, initializer, descriptor = {})
             }
             : undefined,
         enumerable,
-        configurable
+        configurable,
     });
 }
 export function lazyObject(initializers) {
@@ -61,7 +61,7 @@ export function lazyObject(initializers) {
         const descriptor = {
             configurable: definition.configurable,
             enumerable: definition.enumerable,
-            writable: definition.writable
+            writable: definition.writable,
         };
         if (hasInitializer) {
             lazyProperty(object, key, definition.initializer, descriptor);

package/utils/proxy.js

@@ -12,7 +12,7 @@ export const reflectMethodsMap = {
     ownKeys: true,
     preventExtensions: true,
     set: true,
-    setPrototypeOf: true
+    setPrototypeOf: true,
 };
 export const reflectMethods = objectKeys(reflectMethodsMap);
 export const propertyReflectMethods = new Set(['defineProperty', 'deleteProperty', 'get', 'getOwnPropertyDescriptor', 'has', 'set']);

package/utils/stream/from-promise.js

@@ -0,0 +1,27 @@
+import { resolveValueOrProvider } from '../value-or-provider.js';
+export function readableStreamFromPromise(promiseOrProvider) {
+    const stream = new TransformStream();
+    resolveValueOrProvider(promiseOrProvider)
+        .then(async (readable) => readable.pipeTo(stream.writable))
+        .catch(async (error) => stream.writable.abort(error).catch(() => { }));
+    return stream.readable;
+}
+export function transformStreamFromPromise(promiseOrProvider) {
+    const incoming = new TransformStream();
+    const outgoing = new TransformStream();
+    void (async () => {
+        try {
+            const sourceTransformer = await resolveValueOrProvider(promiseOrProvider);
+            await incoming.readable.pipeTo(sourceTransformer.writable);
+            await sourceTransformer.readable.pipeTo(outgoing.writable);
+        }
+        catch (e) {
+            await incoming.writable.abort(e).catch(() => { });
+            await outgoing.writable.abort(e).catch(() => { });
+        }
+    })();
+    return {
+        writable: incoming.writable,
+        readable: outgoing.readable,
+    };
+}

package/utils/stream/index.js

@@ -1,6 +1,6 @@
 export * from './finalize-stream.js';
 export * from './readable-stream-adapter.js';
-export * from './readable-stream-from-promise.js';
+export * from './from-promise.js';
 export * from './size-limited-stream.js';
 export * from './slice.js';
 export * from './stream-helper-types.js';