@tstdl/base 0.93.35 → 0.93.36

package/source/utils/type-guards.ts

@@ -0,0 +1,431 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+/* eslint-disable @typescript-eslint/no-invalid-void-type */
+
+import { supportsBlob, supportsReadableStream } from '#/supports.js';
+import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, Type, TypedArray } from '#/types/index.js';
+import { AssertionError } from '../errors/assertion.error.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 function assert(condition: boolean, message: AssertionMessage = 'assertion failed'): asserts condition {
+  if (!condition) {
+    throw new AssertionError((typeof message == 'function') ? message() : message);
+  }
+}
+
+export function assertNot(condition: boolean, message: AssertionMessage = 'assertion failed'): asserts condition {
+  if (condition) {
+    throw new AssertionError((typeof message == 'function') ? message() : message);
+  }
+}
+
+export function createGuards<N extends string, T>(name: N, testFn: (value: any) => value is T): GuardFunctions<N, T> {
+  const normalizedName = name.split(' ').map((slice) => slice[0]!.toUpperCase() + slice.slice(1)).join('');
+  const defaultMessage = `Expected value to be ${name}.`;
+  const defaultNotMessage = `Expected value to not be ${name}.`;
+
+  return {
+    [`is${normalizedName}`](value: any): value is T {
+      return testFn(value);
+    },
+    [`isNot${normalizedName}`]<V>(value: V): value is Exclude<V, T> {
+      return !testFn(value);
+    },
+    [`assert${normalizedName}`](value: any, message: AssertionMessage = defaultMessage): asserts value is T {
+      assert(testFn(value), message);
+    },
+    [`assertNot${normalizedName}`]<V>(value: V, message: AssertionMessage = defaultNotMessage): asserts value is Exclude<V, T> {
+      assertNot(testFn(value), message);
+    },
+    [`assert${normalizedName}Pass`](value: any, message: AssertionMessage = defaultMessage): T {
+      assert(testFn(value), message);
+      return value;
+    },
+    [`assertNot${normalizedName}Pass`]<V>(value: V, message: AssertionMessage = defaultNotMessage): Exclude<V, T> {
+      assertNot(testFn(value), message);
+      return value as Exclude<V, T>;
+    },
+  } as GuardFunctions<N, T>;
+}
+
+export function createInstanceGuards<N extends string, T>(name: N, type: AbstractConstructor<T>): GuardFunctions<N, T> {
+  return createGuards(name, (value): value is T => value instanceof type);
+}
+
+const undefinedGuards = createGuards('undefined', (value): value is undefined => (value === undefined));
+export const isUndefined: IsFunction<undefined | void> = undefinedGuards.isUndefined;
+export const isDefined: IsNotFunction<undefined | void> = undefinedGuards.isNotUndefined;
+export const assertUndefined: AssertFunction<undefined | void> = undefinedGuards.assertUndefined;
+export const assertDefined: AssertNotFunction<undefined | void> = undefinedGuards.assertNotUndefined;
+export const assertUndefinedPass: AssertPassFunction<undefined | void> = undefinedGuards.assertUndefinedPass;
+export const assertDefinedPass: AssertNotPassFunction<undefined | void> = undefinedGuards.assertNotUndefinedPass;
+
+const nullGuards = createGuards('null', (value): value is null => (value === null));
+export const isNull: IsFunction<null> = nullGuards.isNull;
+export const isNotNull: IsNotFunction<null> = nullGuards.isNotNull;
+export const assertNull: AssertFunction<null> = nullGuards.assertNull;
+export const assertNotNull: AssertNotFunction<null> = nullGuards.assertNotNull;
+export const assertNullPass: AssertPassFunction<null> = nullGuards.assertNullPass;
+export const assertNotNullPass: AssertNotPassFunction<null> = nullGuards.assertNotNullPass;
+
+const nullOrUndefinedGuards = createGuards('null or undefined', (value): value is null | undefined | void => (value === null) || (value === undefined));
+export const isNullOrUndefined: (value: any) => value is null | undefined = nullOrUndefinedGuards.isNullOrUndefined;
+export const isNotNullOrUndefined: IsNotFunction<null | undefined | void> = nullOrUndefinedGuards.isNotNullOrUndefined;
+export const assertNullOrUndefined: (value: any, message?: AssertionMessage) => asserts value is null | undefined = nullOrUndefinedGuards.assertNullOrUndefined;
+export const assertNotNullOrUndefined: AssertNotFunction<null | undefined | void> = nullOrUndefinedGuards.assertNotNullOrUndefined;
+export const assertNullOrUndefinedPass: (value: any, message?: AssertionMessage) => null | undefined = nullOrUndefinedGuards.assertNullOrUndefinedPass;
+export const assertNotNullOrUndefinedPass: AssertNotPassFunction<null | undefined | void> = nullOrUndefinedGuards.assertNotNullOrUndefinedPass;
+
+const numberGuards = createGuards('number', (value): value is number => (typeof value == 'number') && !Number.isNaN(value));
+export const isNumber: IsFunction<number> = numberGuards.isNumber;
+export const isNotNumber: IsNotFunction<number> = numberGuards.isNotNumber;
+export const assertNumber: AssertFunction<number> = numberGuards.assertNumber;
+export const assertNotNumber: AssertNotFunction<number> = numberGuards.assertNotNumber;
+export const assertNumberPass: AssertPassFunction<number> = numberGuards.assertNumberPass;
+export const assertNotNumberPass: AssertNotPassFunction<number> = numberGuards.assertNotNumberPass;
+
+const stringGuards = createGuards('string', (value): value is string => (typeof value == 'string'));
+export const isString: IsFunction<string> = stringGuards.isString;
+export const isNotString: IsNotFunction<string> = stringGuards.isNotString;
+export const assertString: AssertFunction<string> = stringGuards.assertString;
+export const assertNotString: AssertNotFunction<string> = stringGuards.assertNotString;
+export const assertStringPass: AssertPassFunction<string> = stringGuards.assertStringPass;
+export const assertNotStringPass: AssertNotPassFunction<string> = stringGuards.assertNotStringPass;
+
+const booleanGuards = createGuards('boolean', (value): value is boolean => (typeof value == 'boolean'));
+export const isBoolean: IsFunction<boolean> = booleanGuards.isBoolean;
+export const isNotBoolean: IsNotFunction<boolean> = booleanGuards.isNotBoolean;
+export const assertBoolean: AssertFunction<boolean> = booleanGuards.assertBoolean;
+export const assertNotBoolean: AssertNotFunction<boolean> = booleanGuards.assertNotBoolean;
+export const assertBooleanPass: AssertPassFunction<boolean> = booleanGuards.assertBooleanPass;
+export const assertNotBooleanPass: AssertNotPassFunction<boolean> = booleanGuards.assertNotBooleanPass;
+
+const bigintGuards = createGuards('bigint', (value): value is bigint => (typeof value == 'bigint'));
+export const isBigInt: IsFunction<bigint> = bigintGuards.isBigint;
+export const isNotBigInt: IsNotFunction<bigint> = bigintGuards.isNotBigint;
+export const assertBigInt: AssertFunction<bigint> = bigintGuards.assertBigint;
+export const assertNotBigInt: AssertNotFunction<bigint> = bigintGuards.assertNotBigint;
+export const assertBigIntPass: AssertPassFunction<bigint> = bigintGuards.assertBigintPass;
+export const assertNotBigIntPass: AssertNotPassFunction<bigint> = bigintGuards.assertNotBigintPass;
+
+const functionGuards = createGuards('function', (value): value is Function => (typeof value == 'function'));
+export const isFunction: IsFunction<Function> = functionGuards.isFunction;
+export const isNotFunction: IsNotFunction<Function> = functionGuards.isNotFunction;
+export const assertFunction: AssertFunction<Function> = functionGuards.assertFunction;
+export const assertNotFunction: AssertNotFunction<Function> = functionGuards.assertNotFunction;
+export const assertFunctionPass: AssertPassFunction<Function> = functionGuards.assertFunctionPass;
+export const assertNotFunctionPass: AssertNotPassFunction<Function> = functionGuards.assertNotFunctionPass;
+
+const symbolGuards = createGuards('symbol', (value): value is symbol => (typeof value == 'symbol'));
+export const isSymbol: IsFunction<symbol> = symbolGuards.isSymbol;
+export const isNotSymbol: IsNotFunction<symbol> = symbolGuards.isNotSymbol;
+export const assertSymbol: AssertFunction<symbol> = symbolGuards.assertSymbol;
+export const assertNotSymbol: AssertNotFunction<symbol> = symbolGuards.assertNotSymbol;
+export const assertSymbolPass: AssertPassFunction<symbol> = symbolGuards.assertSymbolPass;
+export const assertNotSymbolPass: AssertNotPassFunction<symbol> = symbolGuards.assertNotSymbolPass;
+
+const literalObjectGuards = createGuards('literal object', (value): value is object => (typeof value == 'object') && (value !== null) && (Reflect.getPrototypeOf(value as object) == Object.prototype) && (Reflect.getPrototypeOf(value as object)!.constructor == Object));
+export const isLiteralObject: IsFunction<object> = literalObjectGuards.isLiteralObject;
+export const isNotLiteralObject: IsNotFunction<object> = literalObjectGuards.isNotLiteralObject;
+export const assertLiteralObject: AssertFunction<object> = literalObjectGuards.assertLiteralObject;
+export const assertNotLiteralObject: AssertNotFunction<object> = literalObjectGuards.assertNotLiteralObject;
+export const assertLiteralObjectPass: AssertPassFunction<object> = literalObjectGuards.assertLiteralObjectPass;
+export const assertNotLiteralObjectPass: AssertNotPassFunction<object> = literalObjectGuards.assertNotLiteralObjectPass;
+
+const objectGuards = createGuards('object', (value): value is object => (typeof value == 'object') && (value !== null));
+export const isObject: IsFunction<object> = objectGuards.isObject;
+export const isNotObject: IsNotFunction<object> = objectGuards.isNotObject;
+export const assertObject: AssertFunction<object> = objectGuards.assertObject;
+export const assertNotObject: AssertNotFunction<object> = objectGuards.assertNotObject;
+export const assertObjectPass: AssertPassFunction<object> = objectGuards.assertObjectPass;
+export const assertNotObjectPass: AssertNotPassFunction<object> = objectGuards.assertNotObjectPass;
+
+const primitiveGuards = createGuards('primitive', (value): value is Primitive => {
+  const type = typeof value;
+  return (type == 'string') || (type == 'number') || (type == 'boolean') || (type == 'bigint') || (type == 'symbol') || (value === null) || (value === undefined);
+});
+export const isPrimitive: IsFunction<Primitive> = primitiveGuards.isPrimitive;
+export const isNotPrimitive: IsNotFunction<Primitive> = primitiveGuards.isNotPrimitive;
+export const assertPrimitive: AssertFunction<Primitive> = primitiveGuards.assertPrimitive;
+export const assertNotPrimitive: AssertNotFunction<Primitive> = primitiveGuards.assertNotPrimitive;
+export const assertPrimitivePass: AssertPassFunction<Primitive> = primitiveGuards.assertPrimitivePass;
+export const assertNotPrimitivePass: AssertNotPassFunction<Primitive> = primitiveGuards.assertNotPrimitivePass;
+
+const jsonPrimitiveGuards = createGuards('json primitive', (value): value is JsonPrimitive => {
+  const type = typeof value;
+  return (type == 'string') || (type == 'number') || (type == 'boolean') || (value === null);
+});
+export const isJsonPrimitive: IsFunction<JsonPrimitive> = jsonPrimitiveGuards.isJsonPrimitive;
+export const isNotJsonPrimitive: IsNotFunction<JsonPrimitive> = jsonPrimitiveGuards.isNotJsonPrimitive;
+export const assertJsonPrimitive: AssertFunction<JsonPrimitive> = jsonPrimitiveGuards.assertJsonPrimitive;
+export const assertNotJsonPrimitive: AssertNotFunction<JsonPrimitive> = jsonPrimitiveGuards.assertNotJsonPrimitive;
+export const assertJsonPrimitivePass: AssertPassFunction<JsonPrimitive> = jsonPrimitiveGuards.assertJsonPrimitivePass;
+export const assertNotJsonPrimitivePass: AssertNotPassFunction<JsonPrimitive> = jsonPrimitiveGuards.assertNotJsonPrimitivePass;
+
+const dateGuards = createInstanceGuards('date', Date);
+export const isDate: IsFunction<Date> = dateGuards.isDate;
+export const isNotDate: IsNotFunction<Date> = dateGuards.isNotDate;
+export const assertDate: AssertFunction<Date> = dateGuards.assertDate;
+export const assertNotDate: AssertNotFunction<Date> = dateGuards.assertNotDate;
+export const assertDatePass: AssertPassFunction<Date> = dateGuards.assertDatePass;
+export const assertNotDatePass: AssertNotPassFunction<Date> = dateGuards.assertNotDatePass;
+
+const validDateGuards = createGuards('valid date', (value): value is Date => isDate(value) && !Number.isNaN(value.getTime()));
+export const isValidDate: IsFunction<Date> = validDateGuards.isValidDate;
+export const isNotValidDate: IsNotFunction<Date> = validDateGuards.isNotValidDate;
+export const assertValidDate: AssertFunction<Date> = validDateGuards.assertValidDate;
+export const assertNotValidDate: AssertNotFunction<Date> = validDateGuards.assertNotValidDate;
+export const assertValidDatePass: AssertPassFunction<Date> = validDateGuards.assertValidDatePass;
+export const assertNotValidDatePass: AssertNotPassFunction<Date> = validDateGuards.assertNotValidDatePass;
+
+const regexpGuards = createInstanceGuards('regexp', RegExp);
+export const isRegExp: IsFunction<RegExp> = regexpGuards.isRegexp;
+export const isNotRegExp: IsNotFunction<RegExp> = regexpGuards.isNotRegexp;
+export const assertRegExp: AssertFunction<RegExp> = regexpGuards.assertRegexp;
+export const assertNotRegExp: AssertNotFunction<RegExp> = regexpGuards.assertNotRegexp;
+export const assertRegExpPass: AssertPassFunction<RegExp> = regexpGuards.assertRegexpPass;
+export const assertNotRegExpPass: AssertNotPassFunction<RegExp> = regexpGuards.assertNotRegexpPass;
+
+const arrayGuards = createGuards('array', (value: any): value is readonly any[] => Array.isArray(value));
+export const isArray: <T = any>(value: any) => value is readonly T[] = arrayGuards.isArray;
+export const isNotArray: IsNotFunction<readonly any[]> = arrayGuards.isNotArray;
+export const assertArray: <T = any>(value: any, message?: AssertionMessage) => asserts value is readonly T[] = arrayGuards.assertArray;
+export const assertNotArray: AssertNotFunction<readonly any[]> = arrayGuards.assertNotArray;
+export const assertArrayPass: <T = any>(value: any, message?: AssertionMessage) => readonly T[] = arrayGuards.assertArrayPass;
+export const assertNotArrayPass: AssertNotPassFunction<readonly any[]> = arrayGuards.assertNotArrayPass;
+
+const writableArrayGuards = createGuards('writable array', (value: any): value is any[] => Array.isArray(value));
+export const isWritableArray: <T = any>(value: any) => value is T[] = writableArrayGuards.isWritableArray;
+export const isNotWritableArray: IsNotFunction<any[]> = writableArrayGuards.isNotWritableArray;
+export const assertWritableArray: <T = any>(value: any, message?: AssertionMessage) => asserts value is T[] = writableArrayGuards.assertWritableArray;
+export const assertNotWritableArray: AssertNotFunction<any[]> = writableArrayGuards.assertNotWritableArray;
+export const assertWritableArrayPass: <T = any>(value: any, message?: AssertionMessage) => T[] = writableArrayGuards.assertWritableArrayPass;
+export const assertNotWritableArrayPass: AssertNotPassFunction<any[]> = writableArrayGuards.assertNotWritableArrayPass;
+
+const blobGuards = createGuards('Blob', (value: any): value is Blob => (supportsBlob && (value instanceof Blob)));
+export const isBlob: IsFunction<Blob> = blobGuards.isBlob;
+export const isNotBlob: IsNotFunction<Blob> = blobGuards.isNotBlob;
+export const assertBlob: AssertFunction<Blob> = blobGuards.assertBlob;
+export const assertNotBlob: AssertNotFunction<Blob> = blobGuards.assertNotBlob;
+export const assertBlobPass: AssertPassFunction<Blob> = blobGuards.assertBlobPass;
+export const assertNotBlobPass: AssertNotPassFunction<Blob> = blobGuards.assertNotBlobPass;
+
+const arrayBufferGuards = createInstanceGuards('ArrayBuffer', ArrayBuffer);
+export const isArrayBuffer: IsFunction<ArrayBuffer> = arrayBufferGuards.isArrayBuffer;
+export const isNotArrayBuffer: IsNotFunction<ArrayBuffer> = arrayBufferGuards.isNotArrayBuffer;
+export const assertArrayBuffer: AssertFunction<ArrayBuffer> = arrayBufferGuards.assertArrayBuffer;
+export const assertNotArrayBuffer: AssertNotFunction<ArrayBuffer> = arrayBufferGuards.assertNotArrayBuffer;
+export const assertArrayBufferPass: AssertPassFunction<ArrayBuffer> = arrayBufferGuards.assertArrayBufferPass;
+export const assertNotArrayBufferPass: AssertNotPassFunction<ArrayBuffer> = arrayBufferGuards.assertNotArrayBufferPass;
+
+const sharedArrayBufferGuards = createInstanceGuards('SharedArrayBuffer', globalThis.SharedArrayBuffer ?? class MockSharedArrayBuffer { }); // in case SharedArrayBuffer is not available
+export const isSharedArrayBuffer: IsFunction<SharedArrayBuffer> = sharedArrayBufferGuards.isSharedArrayBuffer;
+export const isNotSharedArrayBuffer: IsNotFunction<SharedArrayBuffer> = sharedArrayBufferGuards.isNotSharedArrayBuffer;
+export const assertSharedArrayBuffer: AssertFunction<SharedArrayBuffer> = sharedArrayBufferGuards.assertSharedArrayBuffer;
+export const assertNotSharedArrayBuffer: AssertNotFunction<SharedArrayBuffer> = sharedArrayBufferGuards.assertNotSharedArrayBuffer;
+export const assertSharedArrayBufferPass: AssertPassFunction<SharedArrayBuffer> = sharedArrayBufferGuards.assertSharedArrayBufferPass;
+export const assertNotSharedArrayBufferPass: AssertNotPassFunction<SharedArrayBuffer> = sharedArrayBufferGuards.assertNotSharedArrayBufferPass;
+
+const arrayBufferLikeGuards = createGuards('ArrayBufferLike', (value): value is ArrayBufferLike => isArrayBuffer(value) || isSharedArrayBuffer(value));
+export const isArrayBufferLike: IsFunction<ArrayBufferLike> = arrayBufferLikeGuards.isArrayBufferLike;
+export const isNotArrayBufferLike: IsNotFunction<ArrayBufferLike> = arrayBufferLikeGuards.isNotArrayBufferLike;
+export const assertArrayBufferLike: AssertFunction<ArrayBufferLike> = arrayBufferLikeGuards.assertArrayBufferLike;
+export const assertNotArrayBufferLike: AssertNotFunction<ArrayBufferLike> = arrayBufferLikeGuards.assertNotArrayBufferLike;
+export const assertArrayBufferLikePass: AssertPassFunction<ArrayBufferLike> = arrayBufferLikeGuards.assertArrayBufferLikePass;
+export const assertNotArrayBufferLikePass: AssertNotPassFunction<ArrayBufferLike> = arrayBufferLikeGuards.assertNotArrayBufferLikePass;
+
+const arrayBufferViewGuards = createGuards('ArrayBufferView', (value: any): value is ArrayBufferView => ArrayBuffer.isView(value));
+export const isArrayBufferView: IsFunction<ArrayBufferView> = arrayBufferViewGuards.isArrayBufferView;
+export const isNotArrayBufferView: IsNotFunction<ArrayBufferView> = arrayBufferViewGuards.isNotArrayBufferView;
+export const assertArrayBufferView: AssertFunction<ArrayBufferView> = arrayBufferViewGuards.assertArrayBufferView;
+export const assertNotArrayBufferView: AssertNotFunction<ArrayBufferView> = arrayBufferViewGuards.assertNotArrayBufferView;
+export const assertArrayBufferViewPass: AssertPassFunction<ArrayBufferView> = arrayBufferViewGuards.assertArrayBufferViewPass;
+export const assertNotArrayBufferViewPass: AssertNotPassFunction<ArrayBufferView> = arrayBufferViewGuards.assertNotArrayBufferViewPass;
+
+const binaryDataGuards = createGuards('BinaryData', (value: any): value is BinaryData => (isArrayBufferLike(value) || isArrayBufferView(value)));
+export const isBinaryData: IsFunction<BinaryData> = binaryDataGuards.isBinaryData;
+export const isNotBinaryData: IsNotFunction<BinaryData> = binaryDataGuards.isNotBinaryData;
+export const assertBinaryData: AssertFunction<BinaryData> = binaryDataGuards.assertBinaryData;
+export const assertNotBinaryData: AssertNotFunction<BinaryData> = binaryDataGuards.assertNotBinaryData;
+export const assertBinaryDataPass: AssertPassFunction<BinaryData> = binaryDataGuards.assertBinaryDataPass;
+export const assertNotBinaryDataPass: AssertNotPassFunction<BinaryData> = binaryDataGuards.assertNotBinaryDataPass;
+
+const int8ArrayGuards = createInstanceGuards('Int8Array', Int8Array);
+export const isInt8Array: IsFunction<Int8Array> = int8ArrayGuards.isInt8Array;
+export const isNotInt8Array: IsNotFunction<Int8Array> = int8ArrayGuards.isNotInt8Array;
+export const assertInt8Array: AssertFunction<Int8Array> = int8ArrayGuards.assertInt8Array;
+export const assertNotInt8Array: AssertNotFunction<Int8Array> = int8ArrayGuards.assertNotInt8Array;
+export const assertInt8ArrayPass: AssertPassFunction<Int8Array> = int8ArrayGuards.assertInt8ArrayPass;
+export const assertNotInt8ArrayPass: AssertNotPassFunction<Int8Array> = int8ArrayGuards.assertNotInt8ArrayPass;
+
+const uint8ArrayGuards = createInstanceGuards('Uint8Array', Uint8Array);
+export const isUint8Array: IsFunction<Uint8Array> = uint8ArrayGuards.isUint8Array;
+export const isNotUint8Array: IsNotFunction<Uint8Array> = uint8ArrayGuards.isNotUint8Array;
+export const assertUint8Array: AssertFunction<Uint8Array> = uint8ArrayGuards.assertUint8Array;
+export const assertNotUint8Array: AssertNotFunction<Uint8Array> = uint8ArrayGuards.assertNotUint8Array;
+export const assertUint8ArrayPass: AssertPassFunction<Uint8Array> = uint8ArrayGuards.assertUint8ArrayPass;
+export const assertNotUint8ArrayPass: AssertNotPassFunction<Uint8Array> = uint8ArrayGuards.assertNotUint8ArrayPass;
+
+const uint8ClampedArrayGuards = createInstanceGuards('Uint8ClampedArray', Uint8ClampedArray);
+export const isUint8ClampedArray: IsFunction<Uint8ClampedArray> = uint8ClampedArrayGuards.isUint8ClampedArray;
+export const isNotUint8ClampedArray: IsNotFunction<Uint8ClampedArray> = uint8ClampedArrayGuards.isNotUint8ClampedArray;
+export const assertUint8ClampedArray: AssertFunction<Uint8ClampedArray> = uint8ClampedArrayGuards.assertUint8ClampedArray;
+export const assertNotUint8ClampedArray: AssertNotFunction<Uint8ClampedArray> = uint8ClampedArrayGuards.assertNotUint8ClampedArray;
+export const assertUint8ClampedArrayPass: AssertPassFunction<Uint8ClampedArray> = uint8ClampedArrayGuards.assertUint8ClampedArrayPass;
+export const assertNotUint8ClampedArrayPass: AssertNotPassFunction<Uint8ClampedArray> = uint8ClampedArrayGuards.assertNotUint8ClampedArrayPass;
+
+const int16ArrayGuards = createInstanceGuards('Int16Array', Int16Array);
+export const isInt16Array: IsFunction<Int16Array> = int16ArrayGuards.isInt16Array;
+export const isNotInt16Array: IsNotFunction<Int16Array> = int16ArrayGuards.isNotInt16Array;
+export const assertInt16Array: AssertFunction<Int16Array> = int16ArrayGuards.assertInt16Array;
+export const assertNotInt16Array: AssertNotFunction<Int16Array> = int16ArrayGuards.assertNotInt16Array;
+export const assertInt16ArrayPass: AssertPassFunction<Int16Array> = int16ArrayGuards.assertInt16ArrayPass;
+export const assertNotInt16ArrayPass: AssertNotPassFunction<Int16Array> = int16ArrayGuards.assertNotInt16ArrayPass;
+
+const uint16ArrayGuards = createInstanceGuards('Uint16Array', Uint16Array);
+export const isUint16Array: IsFunction<Uint16Array> = uint16ArrayGuards.isUint16Array;
+export const isNotUint16Array: IsNotFunction<Uint16Array> = uint16ArrayGuards.isNotUint16Array;
+export const assertUint16Array: AssertFunction<Uint16Array> = uint16ArrayGuards.assertUint16Array;
+export const assertNotUint16Array: AssertNotFunction<Uint16Array> = uint16ArrayGuards.assertNotUint16Array;
+export const assertUint16ArrayPass: AssertPassFunction<Uint16Array> = uint16ArrayGuards.assertUint16ArrayPass;
+export const assertNotUint16ArrayPass: AssertNotPassFunction<Uint16Array> = uint16ArrayGuards.assertNotUint16ArrayPass;
+
+const int32ArrayGuards = createInstanceGuards('Int32Array', Int32Array);
+export const isInt32Array: IsFunction<Int32Array> = int32ArrayGuards.isInt32Array;
+export const isNotInt32Array: IsNotFunction<Int32Array> = int32ArrayGuards.isNotInt32Array;
+export const assertInt32Array: AssertFunction<Int32Array> = int32ArrayGuards.assertInt32Array;
+export const assertNotInt32Array: AssertNotFunction<Int32Array> = int32ArrayGuards.assertNotInt32Array;
+export const assertInt32ArrayPass: AssertPassFunction<Int32Array> = int32ArrayGuards.assertInt32ArrayPass;
+export const assertNotInt32ArrayPass: AssertNotPassFunction<Int32Array> = int32ArrayGuards.assertNotInt32ArrayPass;
+
+const uint32ArrayGuards = createInstanceGuards('Uint32Array', Uint32Array);
+export const isUint32Array: IsFunction<Uint32Array> = uint32ArrayGuards.isUint32Array;
+export const isNotUint32Array: IsNotFunction<Uint32Array> = uint32ArrayGuards.isNotUint32Array;
+export const assertUint32Array: AssertFunction<Uint32Array> = uint32ArrayGuards.assertUint32Array;
+export const assertNotUint32Array: AssertNotFunction<Uint32Array> = uint32ArrayGuards.assertNotUint32Array;
+export const assertUint32ArrayPass: AssertPassFunction<Uint32Array> = uint32ArrayGuards.assertUint32ArrayPass;
+export const assertNotUint32ArrayPass: AssertNotPassFunction<Uint32Array> = uint32ArrayGuards.assertNotUint32ArrayPass;
+
+const float32ArrayGuards = createInstanceGuards('Float32Array', Float32Array);
+export const isFloat32Array: IsFunction<Float32Array> = float32ArrayGuards.isFloat32Array;
+export const isNotFloat32Array: IsNotFunction<Float32Array> = float32ArrayGuards.isNotFloat32Array;
+export const assertFloat32Array: AssertFunction<Float32Array> = float32ArrayGuards.assertFloat32Array;
+export const assertNotFloat32Array: AssertNotFunction<Float32Array> = float32ArrayGuards.assertNotFloat32Array;
+export const assertFloat32ArrayPass: AssertPassFunction<Float32Array> = float32ArrayGuards.assertFloat32ArrayPass;
+export const assertNotFloat32ArrayPass: AssertNotPassFunction<Float32Array> = float32ArrayGuards.assertNotFloat32ArrayPass;
+
+const float64ArrayGuards = createInstanceGuards('Float64Array', Float64Array);
+export const isFloat64Array: IsFunction<Float64Array> = float64ArrayGuards.isFloat64Array;
+export const isNotFloat64Array: IsNotFunction<Float64Array> = float64ArrayGuards.isNotFloat64Array;
+export const assertFloat64Array: AssertFunction<Float64Array> = float64ArrayGuards.assertFloat64Array;
+export const assertNotFloat64Array: AssertNotFunction<Float64Array> = float64ArrayGuards.assertNotFloat64Array;
+export const assertFloat64ArrayPass: AssertPassFunction<Float64Array> = float64ArrayGuards.assertFloat64ArrayPass;
+export const assertNotFloat64ArrayPass: AssertNotPassFunction<Float64Array> = float64ArrayGuards.assertNotFloat64ArrayPass;
+
+const bigInt64ArrayGuards = createInstanceGuards('BigInt64Array', BigInt64Array);
+export const isBigInt64Array: IsFunction<BigInt64Array> = bigInt64ArrayGuards.isBigInt64Array;
+export const isNotBigInt64Array: IsNotFunction<BigInt64Array> = bigInt64ArrayGuards.isNotBigInt64Array;
+export const assertBigInt64Array: AssertFunction<BigInt64Array> = bigInt64ArrayGuards.assertBigInt64Array;
+export const assertNotBigInt64Array: AssertNotFunction<BigInt64Array> = bigInt64ArrayGuards.assertNotBigInt64Array;
+export const assertBigInt64ArrayPass: AssertPassFunction<BigInt64Array> = bigInt64ArrayGuards.assertBigInt64ArrayPass;
+export const assertNotBigInt64ArrayPass: AssertNotPassFunction<BigInt64Array> = bigInt64ArrayGuards.assertNotBigInt64ArrayPass;
+
+const bigUint64ArrayGuards = createInstanceGuards('BigUint64Array', BigUint64Array);
+export const isBigUint64Array: IsFunction<BigUint64Array> = bigUint64ArrayGuards.isBigUint64Array;
+export const isNotBigUint64Array: IsNotFunction<BigUint64Array> = bigUint64ArrayGuards.isNotBigUint64Array;
+export const assertBigUint64Array: AssertFunction<BigUint64Array> = bigUint64ArrayGuards.assertBigUint64Array;
+export const assertNotBigUint64Array: AssertNotFunction<BigUint64Array> = bigUint64ArrayGuards.assertNotBigUint64Array;
+export const assertBigUint64ArrayPass: AssertPassFunction<BigUint64Array> = bigUint64ArrayGuards.assertBigUint64ArrayPass;
+export const assertNotBigUint64ArrayPass: AssertNotPassFunction<BigUint64Array> = bigUint64ArrayGuards.assertNotBigUint64ArrayPass;
+
+const dataViewGuards = createInstanceGuards('DataView', DataView);
+export const isDataView: IsFunction<DataView> = dataViewGuards.isDataView;
+export const isNotDataView: IsNotFunction<DataView> = dataViewGuards.isNotDataView;
+export const assertDataView: AssertFunction<DataView> = dataViewGuards.assertDataView;
+export const assertNotDataView: AssertNotFunction<DataView> = dataViewGuards.assertNotDataView;
+export const assertDataViewPass: AssertPassFunction<DataView> = dataViewGuards.assertDataViewPass;
+export const assertNotDataViewPass: AssertNotPassFunction<DataView> = dataViewGuards.assertNotDataViewPass;
+
+const typedArrayGuards = createGuards('TypedArray', (value): value is TypedArray => (ArrayBuffer.isView(value) && isNotDataView(value)));
+export const isTypedArray: IsFunction<TypedArray> = typedArrayGuards.isTypedArray;
+export const isNotTypedArray: IsNotFunction<TypedArray> = typedArrayGuards.isNotTypedArray;
+export const assertTypedArray: AssertFunction<TypedArray> = typedArrayGuards.assertTypedArray;
+export const assertNotTypedArray: AssertNotFunction<TypedArray> = typedArrayGuards.assertNotTypedArray;
+export const assertTypedArrayPass: AssertPassFunction<TypedArray> = typedArrayGuards.assertTypedArrayPass;
+export const assertNotTypedArrayPass: AssertNotPassFunction<TypedArray> = typedArrayGuards.assertNotTypedArrayPass;
+
+const setGuards = createInstanceGuards('Set', Set);
+export const isSet: IsFunction<Set<any>> = setGuards.isSet;
+export const isNotSet: IsNotFunction<Set<any>> = setGuards.isNotSet;
+export const assertSet: AssertFunction<Set<any>> = setGuards.assertSet;
+export const assertNotSet: AssertNotFunction<Set<any>> = setGuards.assertNotSet;
+export const assertSetPass: AssertPassFunction<Set<any>> = setGuards.assertSetPass;
+export const assertNotSetPass: AssertNotPassFunction<Set<any>> = setGuards.assertNotSetPass;
+
+const mapGuards = createInstanceGuards('Map', Map);
+export const isMap: IsFunction<Map<any, any>> = mapGuards.isMap;
+export const isNotMap: IsNotFunction<Map<any, any>> = mapGuards.isNotMap;
+export const assertMap: AssertFunction<Map<any, any>> = mapGuards.assertMap;
+export const assertNotMap: AssertNotFunction<Map<any, any>> = mapGuards.assertNotMap;
+export const assertMapPass: AssertPassFunction<Map<any, any>> = mapGuards.assertMapPass;
+export const assertNotMapPass: AssertNotPassFunction<Map<any, any>> = mapGuards.assertNotMapPass;
+
+const promiseGuards = createInstanceGuards('Promise', Promise);
+export const isPromise: IsFunction<Promise<any>> = promiseGuards.isPromise;
+export const isNotPromise: IsNotFunction<Promise<any>> = promiseGuards.isNotPromise;
+export const assertPromise: AssertFunction<Promise<any>> = promiseGuards.assertPromise;
+export const assertNotPromise: AssertNotFunction<Promise<any>> = promiseGuards.assertNotPromise;
+export const assertPromisePass: AssertPassFunction<Promise<any>> = promiseGuards.assertPromisePass;
+export const assertNotPromisePass: AssertNotPassFunction<Promise<any>> = promiseGuards.assertNotPromisePass;
+
+const promiseLikeGuards = createGuards('PromiseLike', (value): value is PromiseLike<any> => isPromise(value) || ((((typeof value == 'object') && (value !== null)) || isFunction(value)) && ((typeof (value as PromiseLike<any>).then) == 'function')));
+export const isPromiseLike: IsFunction<PromiseLike<any>> = promiseLikeGuards.isPromiseLike;
+export const isNotPromiseLike: IsNotFunction<PromiseLike<any>> = promiseLikeGuards.isNotPromiseLike;
+export const assertPromiseLike: AssertFunction<PromiseLike<any>> = promiseLikeGuards.assertPromiseLike;
+export const assertNotPromiseLike: AssertNotFunction<PromiseLike<any>> = promiseLikeGuards.assertNotPromiseLike;
+export const assertPromiseLikePass: AssertPassFunction<PromiseLike<any>> = promiseLikeGuards.assertPromiseLikePass;
+export const assertNotPromiseLikePass: AssertNotPassFunction<PromiseLike<any>> = promiseLikeGuards.assertNotPromiseLikePass;
+
+const errorGuards = createInstanceGuards('error', Error);
+export const isError: IsFunction<Error> = errorGuards.isError;
+export const isNotError: IsNotFunction<Error> = errorGuards.isNotError;
+export const assertError: AssertFunction<Error> = errorGuards.assertError;
+export const assertNotError: AssertNotFunction<Error> = errorGuards.assertNotError;
+export const assertErrorPass: AssertPassFunction<Error> = errorGuards.assertErrorPass;
+export const assertNotErrorPass: AssertNotPassFunction<Error> = errorGuards.assertNotErrorPass;
+
+const readableStreamGuards = createGuards('ReadableStream', (value: any): value is ReadableStream => (supportsReadableStream && (value instanceof ReadableStream)));
+export const isReadableStream: <T = any>(value: any) => value is ReadableStream<T> = readableStreamGuards.isReadableStream;
+export const isNotReadableStream: IsNotFunction<ReadableStream> = readableStreamGuards.isNotReadableStream;
+export const assertReadableStream: <T = any>(value: any, message?: AssertionMessage) => asserts value is ReadableStream<T> = readableStreamGuards.assertReadableStream;
+export const assertNotReadableStream: AssertNotFunction<ReadableStream> = readableStreamGuards.assertNotReadableStream;
+export const assertReadableStreamPass: <T = any>(value: any, message?: AssertionMessage) => ReadableStream<T> = readableStreamGuards.assertReadableStreamPass;
+export const assertNotReadableStreamPass: AssertNotPassFunction<ReadableStream> = readableStreamGuards.assertNotReadableStreamPass;
+
+export const isInstanceOf = <T>(value: any, type: Type<T>): value is T => value instanceof type;
+export const isNotInstanceOf = <V, T>(value: V, type: Type<T>): value is Exclude<V, T> => !isInstanceOf(value, type);
+export const assertInstanceOf = <T>(value: any, type: Type<T>, message?: AssertionMessage): asserts value is T => assert(isInstanceOf(value, type), message);
+export const assertNotInstanceOf = <V, T>(value: V, type: Type<T>, message?: AssertionMessage): asserts value is Exclude<V, T> => assertNot(isInstanceOf(value, type), message);
+export const assertInstanceOfPass = <T>(value: any, type: Type<T>, message?: AssertionMessage): T => {
+  assert(isInstanceOf(value, type), message);
+  return value;
+};
+export const assertNotInstanceOfPass = <V, T>(value: V, type: Type<T>, message?: AssertionMessage): Exclude<V, T> => {
+  assertNot(isInstanceOf(value, type), message);
+  return value as Exclude<V, T>;
+};

package/source/utils/type-of.ts

@@ -0,0 +1,50 @@
+import type { Function } from '#/types/index.js';
+import { isNull } from './type-guards.js';
+
+export type TypeOfTypes =
+  | 'string'
+  | 'number'
+  | 'bigint'
+  | 'boolean'
+  | 'symbol'
+  | 'undefined'
+  | 'object'
+  | 'null'
+  | `[class ${string}]`
+  | `[function ${string}]`
+  | `[instanceof ${string}]`;
+
+/**
+ * Get the type of value. Returns 'null' instead of 'object' for null, tries to distinguish between function and class and to get their names
+ * @param value value to get type of
+ */
+export function typeOf(value: unknown): TypeOfTypes {
+  const type = typeof value;
+
+  if (type == 'function') {
+    const functionString = (value as Function).toString();
+
+    const name = ((value as Function).name.length == 0) ? 'anonymous' : (value as Function).name;
+
+    if (functionString.startsWith('class')) {
+      return `[class ${name}]`;
+    }
+
+    return `[function ${name}]`;
+  }
+
+  if (type == 'object') {
+    if (isNull(value)) {
+      return 'null';
+    }
+
+    const constructor = (((value as object['constructor']).prototype ?? Object.getPrototypeOf(value)) as { constructor: Function }).constructor;
+
+    if (constructor != Object) {
+      const name = (constructor.name.length == 0) ? 'anonymous' : constructor.name;
+      return `[instanceof ${name}]`;
+    }
+  }
+
+  return type;
+}

package/source/utils/units.ts

@@ -0,0 +1,61 @@
+/* Data sizes */
+export const kilobyte = 1000;
+export const megabyte = 1000 * kilobyte;
+export const gigabyte = 1000 * megabyte;
+export const terabyte = 1000 * gigabyte;
+export const petabyte = 1000 * terabyte;
+export const exabyte = 1000 * petabyte;
+export const zettabyte = 1000 * exabyte;
+export const yottabyte = 1000 * zettabyte;
+
+export const kibibyte = 1024;
+export const mebibyte = 1024 * kibibyte;
+export const gibibyte = 1024 * mebibyte;
+export const tebibyte = 1024 * gibibyte;
+export const pebibyte = 1024 * tebibyte;
+export const exbibyte = 1024 * pebibyte;
+export const zebibyte = 1024 * exbibyte;
+export const yobibyte = 1024 * zebibyte;
+
+/* Durations */
+export const nanosecondsPerMicrosecond = 1000;
+export const nanosecondsPerMillisecond = 1000 * nanosecondsPerMicrosecond;
+export const nanosecondsPerSecond = 1000 * nanosecondsPerMillisecond;
+export const nanosecondsPerMinute = 60 * nanosecondsPerSecond;
+export const nanosecondsPerHour = 60 * nanosecondsPerMinute;
+export const nanosecondsPerDay = 24 * nanosecondsPerHour;
+export const nanosecondsPerWeek = 7 * nanosecondsPerDay;
+export const nanosecondsPerYear = 365 * nanosecondsPerDay;
+
+export const microsecondsPerMillisecond = 1000;
+export const microsecondsPerSecond = 1000 * microsecondsPerMillisecond;
+export const microsecondsPerMinute = 60 * microsecondsPerSecond;
+export const microsecondsPerHour = 60 * microsecondsPerMinute;
+export const microsecondsPerDay = 24 * microsecondsPerHour;
+export const microsecondsPerWeek = 7 * microsecondsPerDay;
+export const microsecondsPerYear = 365 * microsecondsPerDay;
+
+export const millisecondsPerSecond = 1000;
+export const millisecondsPerMinute = 60 * millisecondsPerSecond;
+export const millisecondsPerHour = 60 * millisecondsPerMinute;
+export const millisecondsPerDay = 24 * millisecondsPerHour;
+export const millisecondsPerWeek = 7 * millisecondsPerDay;
+export const millisecondsPerYear = 365 * millisecondsPerDay;
+
+export const secondsPerMinute = 60;
+export const secondsPerHour = 60 * secondsPerMinute;
+export const secondsPerDay = 24 * secondsPerHour;
+export const secondsPerWeek = 7 * secondsPerDay;
+export const secondsPerYear = 365 * secondsPerDay;
+
+export const minutesPerHour = 60;
+export const minutesPerDay = 24 * minutesPerHour;
+export const minutesPerWeek = 7 * minutesPerDay;
+export const minutesPerYear = 365 * minutesPerDay;
+
+export const hoursPerDay = 24;
+export const hoursPerWeek = 7 * hoursPerDay;
+export const hoursPerYear = 365 * hoursPerDay;
+
+export const daysPerWeek = 7;
+export const daysPerYear = 365;

package/source/utils/url-builder.ts

@@ -0,0 +1,78 @@
+import { normalizeSingleHttpValue, type HttpValue } from '#/http/types.js';
+import type { UndefinableJson, UndefinableJsonObject, UndefinableJsonPrimitive } from '#/types/index.js';
+import { memoizeSingle } from './function/memoize.js';
+import { isArray, isDefined, isObject, isUndefined } from './type-guards.js';
+
+const enum UrlBuilderPartType {
+  Literal = 0,
+  Parameter = 1,
+}
+
+type UrlBuilderPart = {
+  type: UrlBuilderPartType,
+  value: string
+};
+
+export type UrlBuilderParameterValue = UndefinableJsonPrimitive;
+export type UrlBuilderParameters = UndefinableJsonObject;
+export type UrlBuilderOptions = { arraySeparator?: string };
+export type UrlBuilderResult = { parsedUrl: string, parametersRest: UrlBuilderParameters };
+
+const urlParseRegex = /(?<literal>[^:]+|:\/+|:\d[^:]+)|:(?<parameter>[\w-]+)/ug;
+
+export function compileUrlBuilder(url: string): (parameters?: UrlBuilderParameters, options?: UrlBuilderOptions) => UrlBuilderResult {
+  const parts: UrlBuilderPart[] = [];
+
+  let parseUrl = url;
+
+  const matches = parseUrl.matchAll(urlParseRegex);
+
+  for (const { groups } of matches) {
+    const { literal, parameter } = groups!;
+
+    if (isDefined(literal)) {
+      parts.push({ type: UrlBuilderPartType.Literal, value: literal });
+    }
+    else if (isDefined(parameter)) {
+      parts.push({ type: UrlBuilderPartType.Parameter, value: parameter });
+    }
+  }
+
+  function buildUrlCompiled(parameters: UrlBuilderParameters = {}, { arraySeparator = ',' }: UrlBuilderOptions = {}): UrlBuilderResult {
+    let parsedUrl = '';
+    let value: UndefinableJson | undefined;
+    let parametersRest = parameters;
+
+    for (const part of parts) {
+      if (part.type == UrlBuilderPartType.Literal) {
+        parsedUrl += part.value;
+      }
+      else {
+        ({ [part.value]: value, ...parametersRest } = parametersRest);
+
+        if (isUndefined(value)) {
+          throw new Error(`Url parameter ${part.value} not provided. (${url})`);
+        }
+
+        if (isObject(value) && !isArray(value)) {
+          throw new Error(`Url parameter ${part.value} is an object. (${url})`);
+        }
+
+        parsedUrl += isArray(value)
+          ? (value as HttpValue[]).map((httpValue) => encodeURIComponent(normalizeSingleHttpValue(httpValue))).join(arraySeparator)
+          : encodeURIComponent(normalizeSingleHttpValue(value));
+      }
+    }
+
+    return { parsedUrl, parametersRest };
+  }
+
+  return buildUrlCompiled;
+}
+
+const memoizedCompileUrlBuilder = memoizeSingle(compileUrlBuilder);
+
+export function buildUrl(url: string, parameters: UrlBuilderParameters = {}, options?: UrlBuilderOptions): UrlBuilderResult {
+  const builder = memoizedCompileUrlBuilder(url);
+  return builder(parameters, options);
+}