@augment-vir/assert 30.0.0

package/dist/assertions/promise.js

@@ -0,0 +1,69 @@
+import { stringify } from '@augment-vir/core';
+import { AssertionError } from '../augments/assertion.error.js';
+import { autoGuard } from '../guard-types/guard-override.js';
+import { createWaitUntil } from '../guard-types/wait-until-function.js';
+function isPromiseLike(actual, failureMessage) {
+    if (!(actual instanceof Promise) &&
+        !(actual &&
+            typeof actual === 'object' &&
+            'then' in actual &&
+            typeof actual.then === 'function')) {
+        throw new AssertionError(`'${stringify(actual)}' is not a PromiseLike.`, failureMessage);
+    }
+}
+function isNotPromiseLike(actual, failureMessage) {
+    try {
+        isPromiseLike(actual);
+    }
+    catch {
+        return;
+    }
+    throw new AssertionError(`'${stringify(actual)}' is a PromiseLike.`, failureMessage);
+}
+/**
+ * Checks if a value is an actual `Promise` object. In reality this is just a simple wrapper for
+ * `instanceof Promise`, but it makes checking a bit more ergonomic.
+ */
+function isPromise(actual, failureMessage) {
+    if (!(actual instanceof Promise)) {
+        throw new AssertionError(`'${stringify(actual)}' is not a Promise.`, failureMessage);
+    }
+}
+function isNotPromise(actual, failureMessage) {
+    if (actual instanceof Promise) {
+        throw new AssertionError(`'${stringify(actual)}' is a Promise.`, failureMessage);
+    }
+}
+const assertions = {
+    isPromiseLike,
+    isNotPromiseLike,
+    isPromise,
+    isNotPromise,
+};
+export const promiseGuards = {
+    assertions,
+    checkOverrides: {
+        isNotPromise: autoGuard(),
+        isNotPromiseLike: autoGuard(),
+    },
+    assertWrapOverrides: {
+        isPromise: autoGuard(),
+        isNotPromise: autoGuard(),
+        isPromiseLike: autoGuard(),
+        isNotPromiseLike: autoGuard(),
+    },
+    checkWrapOverrides: {
+        isNotPromise: autoGuard(),
+        isNotPromiseLike: autoGuard(),
+    },
+    /**
+     * These overrides must explicitly use `createWaitUntil` so they can pass in `true` for the
+     * second parameter, `requireSynchronousResult`.
+     */
+    waitUntilOverrides: {
+        isPromise: createWaitUntil(isPromise, true),
+        isNotPromise: createWaitUntil(isNotPromise, true),
+        isPromiseLike: createWaitUntil(isPromiseLike, true),
+        isNotPromiseLike: createWaitUntil(isNotPromiseLike, true),
+    },
+};

package/dist/assertions/regexp.d.ts

@@ -0,0 +1,19 @@
+declare function matches(actual: string, expected: RegExp, failureMessage?: string | undefined): void;
+declare function mismatches(actual: string, expected: RegExp, failureMessage?: string | undefined): void;
+export declare const regexpGuards: {
+    assertions: {
+        /**
+         * Checks if a string (`actual`) matches a RegExp (`expected`).
+         *
+         * Performs no type guarding.
+         */
+        matches: typeof matches;
+        /**
+         * Checks if a string (`actual`) does _not_ match a RegExp (`expected`).
+         *
+         * Performs no type guarding.
+         */
+        mismatches: typeof mismatches;
+    };
+};
+export {};

package/dist/assertions/regexp.js

@@ -0,0 +1,18 @@
+import { AssertionError } from '../augments/assertion.error.js';
+function matches(actual, expected, failureMessage) {
+    if (!expected.test(actual)) {
+        throw new AssertionError(`'${actual}' does not match ${expected}`, failureMessage);
+    }
+}
+function mismatches(actual, expected, failureMessage) {
+    if (expected.test(actual)) {
+        throw new AssertionError(`'${actual}' matches ${expected}`, failureMessage);
+    }
+}
+const assertions = {
+    matches,
+    mismatches,
+};
+export const regexpGuards = {
+    assertions,
+};

package/dist/assertions/runtime-type.d.ts

@@ -0,0 +1,274 @@
+import { AnyFunction, MaybePromise, NarrowToActual, NarrowToExpected, UnknownObject } from '@augment-vir/core';
+import { WaitUntilOptions } from '../guard-types/wait-until-function.js';
+declare function isNotArray<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, ReadonlyArray<unknown>>;
+declare function isNotBigInt<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, bigint>;
+declare function isNotBoolean<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, boolean>;
+declare function isNotFunction<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, AnyFunction>;
+declare function isNotNumber<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, number>;
+declare function isNotObject<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, UnknownObject>;
+declare function isNotString<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, string>;
+declare function isNotSymbol<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, symbol>;
+declare function isNotUndefined<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, undefined>;
+declare function isNotNull<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is Exclude<Actual, null>;
+declare function isArray(actual: unknown, failureMessage?: string | undefined): asserts actual is unknown[];
+declare function isBigInt(actual: unknown, failureMessage?: string | undefined): asserts actual is bigint;
+declare function isBoolean(actual: unknown, failureMessage?: string | undefined): asserts actual is boolean;
+declare function isFunction<const Actual>(actual: Actual, failureMessage?: string | undefined): asserts actual is NarrowToActual<Actual, AnyFunction>;
+declare function isNumber(actual: unknown, failureMessage?: string | undefined): asserts actual is number;
+declare function isObject(actual: unknown, failureMessage?: string | undefined): asserts actual is UnknownObject;
+declare function isString(actual: unknown, failureMessage?: string | undefined): asserts actual is string;
+declare function isSymbol(actual: unknown, failureMessage?: string | undefined): asserts actual is symbol;
+declare function isUndefined(actual: unknown, failureMessage?: string | undefined): asserts actual is undefined;
+declare function isNull(actual: unknown, failureMessage?: string | undefined): asserts actual is null;
+export declare const runtimeTypeGuards: {
+    assertions: {
+        /**
+         * Check if a value is an array.
+         *
+         * Type guards the value.
+         */
+        isArray: typeof isArray;
+        /**
+         * Check if a value is a bigint.
+         *
+         * Type guards the value.
+         */
+        isBigInt: typeof isBigInt;
+        /**
+         * Check if a value is a boolean.
+         *
+         * Type guards the value.
+         */
+        isBoolean: typeof isBoolean;
+        /**
+         * Check if a value is a function.
+         *
+         * Type guards the value.
+         */
+        isFunction: typeof isFunction;
+        /**
+         * Check if a value is null.
+         *
+         * Type guards the value.
+         */
+        isNull: typeof isNull;
+        /**
+         * Check if a value is a number.
+         *
+         * Type guards the value.
+         */
+        isNumber: typeof isNumber;
+        /**
+         * Check if a value is an object.
+         *
+         * Type guards the value.
+         */
+        isObject: typeof isObject;
+        /**
+         * Check if a value is a string.
+         *
+         * Type guards the value.
+         */
+        isString: typeof isString;
+        /**
+         * Check if a value is a symbol.
+         *
+         * Type guards the value.
+         */
+        isSymbol: typeof isSymbol;
+        /**
+         * Check if a value is undefined.
+         *
+         * Type guards the value.
+         */
+        isUndefined: typeof isUndefined;
+        /**
+         * Check if a value not an array.
+         *
+         * Type guards the value.
+         */
+        isNotArray: typeof isNotArray;
+        /**
+         * Check if a value is not a bigint.
+         *
+         * Type guards the value.
+         */
+        isNotBigInt: typeof isNotBigInt;
+        /**
+         * Check if a value is not a boolean.
+         *
+         * Type guards the value.
+         */
+        isNotBoolean: typeof isNotBoolean;
+        /**
+         * Check if a value is not a function.
+         *
+         * Type guards the value.
+         */
+        isNotFunction: typeof isNotFunction;
+        /**
+         * Check if a value is not a number.
+         *
+         * Type guards the value.
+         */
+        isNotNumber: typeof isNotNumber;
+        /**
+         * Check if a value is not an object.
+         *
+         * Type guards the value.
+         */
+        isNotObject: typeof isNotObject;
+        /**
+         * Check if a value is not a string.
+         *
+         * Type guards the value.
+         */
+        isNotString: typeof isNotString;
+        /**
+         * Check if a value is not a symbol.
+         *
+         * Type guards the value.
+         */
+        isNotSymbol: typeof isNotSymbol;
+        /**
+         * Check if a value is not undefined.
+         *
+         * Type guards the value.
+         */
+        isNotUndefined: typeof isNotUndefined;
+        /**
+         * Check if a value not Null.
+         *
+         * Type guards the value.
+         */
+        isNotNull: typeof isNotNull;
+    };
+    checkOverrides: {
+        isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is NarrowToActual<Actual, AnyFunction>;
+        isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, ReadonlyArray<unknown>>;
+        isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, bigint>;
+        isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, boolean>;
+        isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, AnyFunction>;
+        isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, null>;
+        isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, number>;
+        isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, UnknownObject>;
+        isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, string>;
+        isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, undefined>;
+        isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => actual is Exclude<Actual, symbol>;
+    };
+    assertWrapOverrides: {
+        isFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => NarrowToActual<Actual, AnyFunction>;
+        /**
+         * Trying to assign a unique symbol to another variable kills the `unique` part of the
+         * symbol. this seems to be a bug with TypeScript itself.
+         *
+         * For some reason `checkWrap` does not suffer from this issue though.
+         *
+         * @example Const mySymbol = Symbol('mine'); const mySymbol2 = mySymbol; // this is no
+         * longer `unique symbol`
+         */
+        isSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => NarrowToExpected<Actual, symbol>;
+        isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, ReadonlyArray<unknown>>;
+        isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, bigint>;
+        isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, boolean>;
+        isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, AnyFunction>;
+        isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, null>;
+        isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, number>;
+        isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, UnknownObject>;
+        isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, string>;
+        isNotUndefined: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, undefined>;
+        isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, symbol>;
+    };
+    checkWrapOverrides: {
+        isFunction: <const Actual>(actual: Actual) => NarrowToActual<Actual, AnyFunction> | undefined;
+        /**
+         * It doesn't make any sense for `checkWrap.isUndefined` to exist. If the input is
+         * `undefined`, it returns `undefined`. If the input isn't `undefined`, it still returns
+         * `undefined`.
+         */
+        isUndefined: undefined;
+        /**
+         * It doesn't make any sense for `checkWrap.isNotUndefined` to exist. If the input is not
+         * `undefined`, then it still returns `undefined`.
+         */
+        isNotUndefined: undefined;
+        isNotArray: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, ReadonlyArray<unknown>> | undefined;
+        isNotBigInt: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, bigint> | undefined;
+        isNotBoolean: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, boolean> | undefined;
+        isNotFunction: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, AnyFunction> | undefined;
+        isNotNull: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, null> | undefined;
+        isNotNumber: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, number> | undefined;
+        isNotObject: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, UnknownObject> | undefined;
+        isNotString: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, string> | undefined;
+        isNotSymbol: <const Actual>(actual: Actual, failureMessage?: string | undefined) => Exclude<Actual, symbol> | undefined;
+    };
+    waitUntilOverrides: {
+        isFunction: <const Actual>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<NarrowToActual<Actual, AnyFunction>>;
+        isNotArray: <const Actual>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, ReadonlyArray<unknown>>>;
+        isNotBigInt: <const Actual>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, bigint>>;
+        isNotBoolean: <const Actual>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, boolean>>;
+        isNotFunction: <const Actual>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, AnyFunction>>;
+        isNotNull: <const Actual>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, null>>;
+        isNotNumber: <const Actual>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, number>>;
+        isNotObject: <const Actual>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, UnknownObject>>;
+        isNotString: <const Actual>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, string>>;
+        isNotUndefined: <const Actual>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, undefined>>;
+        isNotSymbol: <const Actual>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, symbol>>;
+    };
+};
+/**
+ * An enum representing the possible values returned by {@link getRuntimeType}. These values are
+ * similar to the output of the built-in
+ * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof) operator
+ * except that this includes new types `array` and `null`, that `typeof` does not have, which are
+ * both distinct from `object`.
+ *
+ * @category Assert : Util
+ * @package @augment-vir/assert
+ */
+export declare enum RuntimeType {
+    String = "string",
+    Number = "number",
+    Bigint = "bigint",
+    Boolean = "boolean",
+    Symbol = "symbol",
+    Undefined = "undefined",
+    Object = "object",
+    Function = "function",
+    /**
+     * This is not included in {@link RuntimeType.Object}. (Compared to
+     * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof)
+     * which _does_ include `null` in the `'object'` type.)
+     */
+    Array = "array",
+    /**
+     * This is not included in {@link RuntimeType.Object}. (Compared to
+     * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof)
+     * which _does_ include `null` in the `'object'` type.)
+     */
+    Null = "null"
+}
+/**
+ * Determines the {@link RuntimeType} of a variable. This is similar to the built-in
+ * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof) operator
+ * except in the following ways:
+ *
+ * - This returns an enum value ({@link RuntimeType}) rather than just a string (though the enum values
+ *   are strings anyway).
+ * - This includes new types `array` and `null`, that `typeof` does not have, which are both distinct
+ *   from `object`.
+ *
+ * @category Assert : Util
+ * @example
+ *
+ * ```ts
+ * import {getRuntimeType} from '@augment-vir/assert';
+ *
+ * getRuntimeType(['a']); // RuntimeType.Array
+ * getRuntimeType({a: 'a'}); // RuntimeType.Object
+ * ```
+ *
+ * @package @augment-vir/assert
+ */
+export declare function getRuntimeType(actual: unknown): RuntimeType;
+export {};

package/dist/assertions/runtime-type.example.d.ts

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

package/dist/assertions/runtime-type.example.js

@@ -0,0 +1,3 @@
+import { getRuntimeType } from '@augment-vir/assert';
+getRuntimeType(['a']); // RuntimeType.Array
+getRuntimeType({ a: 'a' }); // RuntimeType.Object

package/dist/assertions/runtime-type.js

@@ -0,0 +1,242 @@
+import { stringify, } from '@augment-vir/core';
+import { AssertionError } from '../augments/assertion.error.js';
+import { autoGuard } from '../guard-types/guard-override.js';
+function isNotArray(actual, failureMessage) {
+    assertNotRuntimeType(actual, 'array', failureMessage);
+}
+function isNotBigInt(actual, failureMessage) {
+    assertNotRuntimeType(actual, 'bigint', failureMessage);
+}
+function isNotBoolean(actual, failureMessage) {
+    assertNotRuntimeType(actual, 'boolean', failureMessage);
+}
+function isNotFunction(actual, failureMessage) {
+    assertNotRuntimeType(actual, 'function', failureMessage);
+}
+function isNotNumber(actual, failureMessage) {
+    assertNotRuntimeType(actual, 'number', failureMessage);
+}
+function isNotObject(actual, failureMessage) {
+    assertNotRuntimeType(actual, 'object', failureMessage);
+}
+function isNotString(actual, failureMessage) {
+    assertNotRuntimeType(actual, 'string', failureMessage);
+}
+function isNotSymbol(actual, failureMessage) {
+    assertNotRuntimeType(actual, 'symbol', failureMessage);
+}
+function isNotUndefined(actual, failureMessage) {
+    assertNotRuntimeType(actual, 'undefined', failureMessage);
+}
+function isNotNull(actual, failureMessage) {
+    assertNotRuntimeType(actual, 'null', failureMessage);
+}
+function isArray(actual, failureMessage) {
+    assertRuntimeType(actual, 'array', failureMessage);
+}
+function isBigInt(actual, failureMessage) {
+    assertRuntimeType(actual, 'bigint', failureMessage);
+}
+function isBoolean(actual, failureMessage) {
+    assertRuntimeType(actual, 'boolean', failureMessage);
+}
+function isFunction(actual, failureMessage) {
+    assertRuntimeType(actual, 'function', failureMessage);
+}
+function isNumber(actual, failureMessage) {
+    assertRuntimeType(actual, 'number', failureMessage);
+}
+function isObject(actual, failureMessage) {
+    assertRuntimeType(actual, 'object', failureMessage);
+}
+function isString(actual, failureMessage) {
+    assertRuntimeType(actual, 'string', failureMessage);
+}
+function isSymbol(actual, failureMessage) {
+    assertRuntimeType(actual, 'symbol', failureMessage);
+}
+function isUndefined(actual, failureMessage) {
+    assertRuntimeType(actual, 'undefined', failureMessage);
+}
+function isNull(actual, failureMessage) {
+    assertRuntimeType(actual, 'null', failureMessage);
+}
+const assertions = {
+    isArray,
+    isBigInt,
+    isBoolean,
+    isFunction,
+    isNull,
+    isNumber,
+    isObject,
+    isString,
+    isSymbol,
+    isUndefined,
+    isNotArray,
+    isNotBigInt,
+    isNotBoolean,
+    isNotFunction,
+    isNotNumber,
+    isNotObject,
+    isNotString,
+    isNotSymbol,
+    isNotUndefined,
+    isNotNull,
+};
+export const runtimeTypeGuards = {
+    assertions,
+    checkOverrides: {
+        isFunction: autoGuard(),
+        isNotArray: autoGuard(),
+        isNotBigInt: autoGuard(),
+        isNotBoolean: autoGuard(),
+        isNotFunction: autoGuard(),
+        isNotNull: autoGuard(),
+        isNotNumber: autoGuard(),
+        isNotObject: autoGuard(),
+        isNotString: autoGuard(),
+        isNotUndefined: autoGuard(),
+        isNotSymbol: autoGuard(),
+    },
+    assertWrapOverrides: {
+        isFunction: autoGuard(),
+        /**
+         * Trying to assign a unique symbol to another variable kills the `unique` part of the
+         * symbol. this seems to be a bug with TypeScript itself.
+         *
+         * For some reason `checkWrap` does not suffer from this issue though.
+         *
+         * @example Const mySymbol = Symbol('mine'); const mySymbol2 = mySymbol; // this is no
+         * longer `unique symbol`
+         */
+        isSymbol: autoGuard(),
+        isNotArray: autoGuard(),
+        isNotBigInt: autoGuard(),
+        isNotBoolean: autoGuard(),
+        isNotFunction: autoGuard(),
+        isNotNull: autoGuard(),
+        isNotNumber: autoGuard(),
+        isNotObject: autoGuard(),
+        isNotString: autoGuard(),
+        isNotUndefined: autoGuard(),
+        isNotSymbol: autoGuard(),
+    },
+    checkWrapOverrides: {
+        isFunction: autoGuard(),
+        /**
+         * It doesn't make any sense for `checkWrap.isUndefined` to exist. If the input is
+         * `undefined`, it returns `undefined`. If the input isn't `undefined`, it still returns
+         * `undefined`.
+         */
+        isUndefined: undefined,
+        /**
+         * It doesn't make any sense for `checkWrap.isNotUndefined` to exist. If the input is not
+         * `undefined`, then it still returns `undefined`.
+         */
+        isNotUndefined: undefined,
+        isNotArray: autoGuard(),
+        isNotBigInt: autoGuard(),
+        isNotBoolean: autoGuard(),
+        isNotFunction: autoGuard(),
+        isNotNull: autoGuard(),
+        isNotNumber: autoGuard(),
+        isNotObject: autoGuard(),
+        isNotString: autoGuard(),
+        isNotSymbol: autoGuard(),
+    },
+    waitUntilOverrides: {
+        isFunction: autoGuard(),
+        isNotArray: autoGuard(),
+        isNotBigInt: autoGuard(),
+        isNotBoolean: autoGuard(),
+        isNotFunction: autoGuard(),
+        isNotNull: autoGuard(),
+        isNotNumber: autoGuard(),
+        isNotObject: autoGuard(),
+        isNotString: autoGuard(),
+        isNotUndefined: autoGuard(),
+        isNotSymbol: autoGuard(),
+    },
+};
+/**
+ * An enum representing the possible values returned by {@link getRuntimeType}. These values are
+ * similar to the output of the built-in
+ * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof) operator
+ * except that this includes new types `array` and `null`, that `typeof` does not have, which are
+ * both distinct from `object`.
+ *
+ * @category Assert : Util
+ * @package @augment-vir/assert
+ */
+export var RuntimeType;
+(function (RuntimeType) {
+    RuntimeType["String"] = "string";
+    RuntimeType["Number"] = "number";
+    RuntimeType["Bigint"] = "bigint";
+    RuntimeType["Boolean"] = "boolean";
+    RuntimeType["Symbol"] = "symbol";
+    RuntimeType["Undefined"] = "undefined";
+    RuntimeType["Object"] = "object";
+    RuntimeType["Function"] = "function";
+    /**
+     * This is not included in {@link RuntimeType.Object}. (Compared to
+     * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof)
+     * which _does_ include `null` in the `'object'` type.)
+     */
+    RuntimeType["Array"] = "array";
+    /**
+     * This is not included in {@link RuntimeType.Object}. (Compared to
+     * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof)
+     * which _does_ include `null` in the `'object'` type.)
+     */
+    RuntimeType["Null"] = "null";
+})(RuntimeType || (RuntimeType = {}));
+/**
+ * Determines the {@link RuntimeType} of a variable. This is similar to the built-in
+ * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof) operator
+ * except in the following ways:
+ *
+ * - This returns an enum value ({@link RuntimeType}) rather than just a string (though the enum values
+ *   are strings anyway).
+ * - This includes new types `array` and `null`, that `typeof` does not have, which are both distinct
+ *   from `object`.
+ *
+ * @category Assert : Util
+ * @example
+ *
+ * ```ts
+ * import {getRuntimeType} from '@augment-vir/assert';
+ *
+ * getRuntimeType(['a']); // RuntimeType.Array
+ * getRuntimeType({a: 'a'}); // RuntimeType.Object
+ * ```
+ *
+ * @package @augment-vir/assert
+ */
+export function getRuntimeType(actual) {
+    if (actual === null) {
+        return RuntimeType.Null;
+    }
+    else if (Array.isArray(actual)) {
+        return RuntimeType.Array;
+    }
+    else {
+        return typeof actual;
+    }
+}
+/**
+ * Asserts that the given actual matches the given test type. Note that an name for the actual must
+ * be provided for error messaging purposes.
+ */
+function assertRuntimeType(actual, testType, failureMessage) {
+    const actualType = getRuntimeType(actual);
+    if (actualType !== testType) {
+        throw new AssertionError(`'${stringify(actual)}' is '${actualType}', not '${testType}'.`, failureMessage);
+    }
+}
+function assertNotRuntimeType(actual, testType, failureMessage) {
+    const actualType = getRuntimeType(actual);
+    if (actualType === testType) {
+        throw new AssertionError(`'${stringify(actual)}' is '${actualType}'.`, failureMessage);
+    }
+}