hein 2.0.0-alpha.1 → 2.0.0-alpha.3

package/dist/assert-DZjgWjOw.cjs

@@ -1,1626 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (all) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let lodash_cloneDeep_js = require("lodash/cloneDeep.js");
-lodash_cloneDeep_js = __toESM(lodash_cloneDeep_js);
-let hein_assertion_utils = require("hein-assertion-utils");
-hein_assertion_utils = __toESM(hein_assertion_utils);
-let lodash_isObjectLike_js = require("lodash/isObjectLike.js");
-lodash_isObjectLike_js = __toESM(lodash_isObjectLike_js);
-let lodash_isPlainObject_js = require("lodash/isPlainObject.js");
-lodash_isPlainObject_js = __toESM(lodash_isPlainObject_js);
-let lodash_get_js = require("lodash/get.js");
-lodash_get_js = __toESM(lodash_get_js);
-let lodash_has_js = require("lodash/has.js");
-lodash_has_js = __toESM(lodash_has_js);
-let lodash_castArray_js = require("lodash/castArray.js");
-lodash_castArray_js = __toESM(lodash_castArray_js);
-
-//#region src/utils/xor.ts
-const xor = (a, b) => {
-	return a && !b || !a && b;
-};
-
-//#endregion
-//#region src/utils/match.ts
-const evaluationSymbol = Symbol();
-const createEvaluation = (callback) => {
-	const evaluation = (value) => {
-		return callback(value);
-	};
-	evaluation[evaluationSymbol] = true;
-	return evaluation;
-};
-const any = createEvaluation(() => true);
-const isEvaluation = (value) => value && value[evaluationSymbol];
-const match$1 = (actual, expected, { mutate = false, partial = false } = {}) => {
-	if (actual === expected) return true;
-	if (isEvaluation(expected)) return expected(actual);
-	if (actual == null || expected == null || !(0, lodash_isObjectLike_js.default)(actual) && !(0, lodash_isObjectLike_js.default)(expected)) return actual !== actual && expected !== expected;
-	let result = true;
-	if (actual instanceof Map || expected instanceof Map) {
-		if (!(actual instanceof Map && expected instanceof Map)) return false;
-		if (actual.size !== expected.size && !partial) result = false;
-		for (const [key, value] of expected.entries()) {
-			if (!actual.has(key)) {
-				result = false;
-				continue;
-			}
-			const actualValue = actual.get(key);
-			if (mutate && isEvaluation(value)) {
-				expected.set(key, actualValue);
-				result && (result = value(actualValue));
-				continue;
-			}
-			result = match$1(actualValue, value, {
-				mutate,
-				partial
-			}) && result;
-			continue;
-		}
-		return result;
-	}
-	if (actual instanceof WeakMap || expected instanceof WeakMap) return false;
-	if (actual instanceof Set || expected instanceof Set) {
-		if (!(actual instanceof Set && expected instanceof Set)) return false;
-		if (actual.size !== expected.size && !partial) return false;
-		return [...expected.values()].every((value) => {
-			return actual.has(value);
-		});
-	}
-	if (actual instanceof WeakSet || expected instanceof WeakSet) return false;
-	if (actual instanceof Date || expected instanceof Date) {
-		if (!(actual instanceof Date && expected instanceof Date)) {
-			const date1 = new Date(actual);
-			const date2 = new Date(expected);
-			return date1.getTime() === date2.getTime();
-		}
-		if (actual.getTime() !== expected.getTime()) return false;
-		return true;
-	}
-	if (xor((0, lodash_isObjectLike_js.default)(actual), (0, lodash_isObjectLike_js.default)(expected))) return false;
-	if (Array.isArray(actual) || Array.isArray(expected)) {
-		if (!(Array.isArray(actual) && Array.isArray(expected))) return false;
-		if (actual.length !== expected.length && !partial) result = false;
-		if (partial && actual.length < expected.length) result = false;
-		for (const [index, value] of actual.entries()) {
-			if (index >= expected.length) continue;
-			const expectedValue = expected[index];
-			if (mutate && isEvaluation(expectedValue)) {
-				const matchesEvaluation = expectedValue(value);
-				if (matchesEvaluation) expected[index] = value;
-				result && (result = matchesEvaluation);
-				continue;
-			}
-			result && (result = match$1(value, expectedValue, {
-				mutate,
-				partial
-			}));
-			continue;
-		}
-		return result;
-	}
-	if (Object.keys(actual).length !== Object.keys(expected).length && !partial) result = false;
-	if (globalThis.Buffer && actual instanceof globalThis.Buffer && expected instanceof globalThis.Buffer) return Buffer.compare(actual, expected) === 0;
-	for (const key in expected) if (!(key in actual)) {
-		result && (result = false);
-		continue;
-	}
-	for (const index in actual) {
-		const expectedValue = expected[index];
-		const actualValue = actual[index];
-		if (!(index in expected)) {
-			if (partial) continue;
-			result && (result = false);
-			continue;
-		}
-		if (isEvaluation(expectedValue)) {
-			if (!expectedValue(actualValue)) {
-				result && (result = false);
-				continue;
-			}
-			if (mutate) expected[index] = actualValue;
-			continue;
-		}
-		if (!match$1(actual[index], expectedValue, {
-			mutate,
-			partial
-		})) result = false;
-	}
-	return result;
-};
-
-//#endregion
-//#region src/assert/deep-equal.ts
-const [deepEqual, notDeepEqual] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		notEql: "Expected {{= it.actual }} to deep equal {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not deep equal {{= it.expected }}"
-	},
-	test: (report) => (actual, expected, partialOrMessage = false, message) => {
-		const partial = typeof partialOrMessage === "boolean" ? partialOrMessage : false;
-		message = typeof partialOrMessage === "string" ? partialOrMessage : message;
-		if (typeof expected !== "function") expected = (0, lodash_cloneDeep_js.default)(expected);
-		if (match$1(actual, expected, {
-			mutate: true,
-			partial
-		})) return report({
-			message,
-			status: "ok",
-			expected,
-			actual
-		});
-		return report({
-			message,
-			status: "notok",
-			messageId: "notEql",
-			expected,
-			actual
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/equal.ts
-const [equal, notEqual] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		equal: "Expected {{= it.actual }} to equal {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not equal {{= it.expected }}"
-	},
-	test: (report) => (a, b, message) => {
-		if (Number.isNaN(a) && Number.isNaN(b)) return report({
-			status: "ok",
-			expected: b,
-			actual: a,
-			message
-		});
-		if (a !== b) return report({
-			status: "notok",
-			messageId: "equal",
-			actual: a,
-			expected: b,
-			message
-		});
-		return report({
-			status: "ok",
-			expected: a,
-			actual: b,
-			message
-		});
-	}
-});
-
-//#endregion
-//#region src/utils/get-type.ts
-const getType = (value) => {
-	if (value !== value) return "NaN";
-	if (Array.isArray(value)) return "array";
-	if (value === null) return "null";
-	return typeof value;
-};
-
-//#endregion
-//#region src/utils/validate-numeric-and-dates.ts
-const allowedTypes = [
-	"number",
-	"bigint",
-	"date"
-];
-const validateNumericsAndDates = (actual, expected) => {
-	const actualType = actual instanceof Date ? "date" : getType(actual);
-	const expectedType = expected instanceof Date ? "date" : getType(expected);
-	if (!allowedTypes.includes(actualType) || !allowedTypes.includes(expectedType)) throw new hein_assertion_utils.AssertionError(actualType, expectedType, `Expected arguments to be ${allowedTypes.join("/")}, received ${actualType}/${expectedType}`);
-};
-
-//#endregion
-//#region src/assert/greater-than.ts
-const [greaterThan, notGreaterThan] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		smaller: "Expected {{= it.actual }} to be greater than {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not be greater than {{= it.expected }}"
-	},
-	test: (report) => (actual, expected) => {
-		validateNumericsAndDates(actual, expected);
-		if (actual > expected) return report({
-			status: "ok",
-			messageId: "not",
-			expected,
-			actual
-		});
-		return report({
-			status: "notok",
-			messageId: "smaller",
-			actual,
-			expected,
-			noStringify: true
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/greater-than-equal.ts
-const [greaterThanEqual, notGreaterThanEqual] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		notGreaterThanEqual: "Expected {{= it.actual }} to not be greater than or equal to {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not be greater than or equal to {{= it.expected }}"
-	},
-	test: (report) => (a, b, message) => {
-		validateNumericsAndDates(a, b);
-		if (a < b) return report({
-			status: "notok",
-			messageId: "notGreaterThanEqual",
-			actual: a,
-			expected: b,
-			message
-		});
-		return report({
-			status: "ok",
-			expected: a,
-			actual: b
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/has-property.ts
-const [hasProperty, notHasProperty] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		noProperty: "Expected {{= it.actual }} to have property {{= it.expected }}",
-		wrongValue: "Expected {{= it.obj }} to have property {{= it.expected }} with value {{= it.value }}",
-		not: "Expected {{= it.actual }} to not have property {{= it.expected }}",
-		notWrongValue: "Expected {{= it.obj }} to not have property {{= it.expected }} with value {{= it.value }}"
-	},
-	test: (report) => (...args) => {
-		const [actual, expected, value] = args;
-		const actualStringified = (0, hein_assertion_utils.stringify)(actual);
-		if (expected in actual) {
-			if (args.length === 3) {
-				if (actual[expected] === value) return report({
-					status: "ok",
-					messageId: "notWrongValue",
-					expected,
-					actual: actualStringified,
-					data: {
-						value,
-						expected,
-						obj: actual
-					}
-				});
-				return report({
-					status: "notok",
-					messageId: "wrongValue",
-					expected,
-					actual: actualStringified,
-					data: {
-						value,
-						obj: actualStringified
-					},
-					noStringify: true
-				});
-			}
-			return report({
-				status: "ok",
-				noStringify: true,
-				expected,
-				actual: actualStringified
-			});
-		}
-		return report({
-			status: "notok",
-			messageId: "noProperty",
-			expected,
-			actual: actualStringified,
-			noStringify: true
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/has-size.ts
-const [hasSize, notHasSize] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		array: "Expected array to have length of {{= it.expected }}",
-		object: "Expected object to have size of {{= it.expected }}",
-		map: "Expected Map to have size of {{= it.expected }}",
-		set: "Expected Set to have size of {{= it.expected }}",
-		string: "Expected string to have length of {{= it.expected }}",
-		not: "Expected array to not have length of {{= it.expected }}",
-		notObject: "Expected object to not have size of {{= it.expected }}",
-		notMap: "Expected Map to not have size of {{= it.expected }}",
-		notSet: "Expected Set to not have size of {{= it.expected }}",
-		notString: "Expected string to not have length of {{= it.expected }}",
-		invalidValue: "Expected {{= it.actual }} to be an array, object, Map, Set or string"
-	},
-	test: (report) => (actual, expected, message) => {
-		if (Array.isArray(actual)) {
-			if (actual.length === expected) return report({
-				message,
-				status: "ok",
-				expected,
-				actual: actual.length
-			});
-			return report({
-				message,
-				status: "notok",
-				messageId: "array",
-				expected,
-				actual: actual.length
-			});
-		}
-		if ((0, lodash_isPlainObject_js.default)(actual)) {
-			if (Object.keys(actual).length === expected) return report({
-				message,
-				status: "ok",
-				messageId: "notObject",
-				expected,
-				actual: Object.keys(actual).length
-			});
-			return report({
-				message,
-				status: "notok",
-				messageId: "object",
-				expected,
-				actual: Object.keys(actual).length
-			});
-		}
-		if (actual instanceof Map) {
-			if (actual.size === expected) return report({
-				message,
-				status: "ok",
-				messageId: "notMap",
-				expected,
-				actual: actual.size
-			});
-			return report({
-				message,
-				status: "notok",
-				messageId: "map",
-				expected,
-				actual: actual.size
-			});
-		}
-		if (actual instanceof Set) {
-			if (actual.size === expected) return report({
-				message,
-				status: "ok",
-				messageId: "notSet",
-				expected,
-				actual: actual.size
-			});
-			return report({
-				message,
-				status: "notok",
-				messageId: "set",
-				expected,
-				actual: actual.size
-			});
-		}
-		if (typeof actual === "string") {
-			if (actual.length === expected) return report({
-				message,
-				status: "ok",
-				messageId: "notString",
-				expected,
-				actual: actual.length
-			});
-			return report({
-				message,
-				status: "notok",
-				messageId: "string",
-				expected,
-				actual: actual.length
-			});
-		}
-		report({
-			message,
-			status: "notok",
-			messageId: "invalidValue",
-			actual: typeof actual,
-			noStringify: true
-		});
-		report({
-			message,
-			status: "ok",
-			messageId: "invalidValue",
-			actual: typeof actual,
-			noStringify: true
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/includes.ts
-const [includes, notIncludes] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		arrayMisses: "Expected {{= it.actual }} to include {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not include {{= it.expected }}"
-	},
-	test: (report) => (actual, ...elements) => {
-		for (const element of elements) if (actual.includes(element)) report({
-			messageId: "not",
-			status: "ok",
-			actual,
-			expected: element
-		});
-		else report({
-			messageId: "arrayMisses",
-			status: "notok",
-			actual,
-			expected: element
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/instance-of.ts
-const [instanceOf, notInstanceOf] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		notInstanceOf: "Expected {{= it.actual }} to be an instance of {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not be an instance of {{= it.expected }}"
-	},
-	test: (report) => (actual, expected) => {
-		if (!(0, lodash_isObjectLike_js.default)(actual)) throw new hein_assertion_utils.AssertionError(getType(actual), "object", "Expected value to be an object");
-		if (!(actual instanceof expected)) return report({
-			status: "notok",
-			messageId: "notInstanceOf",
-			expected: expected.name,
-			actual: actual.constructor.name,
-			noStringify: true
-		});
-		return report({
-			status: "ok",
-			expected: expected.name,
-			actual: actual.constructor.name,
-			messageId: "not",
-			noStringify: true
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/is-empty.ts
-const [isEmpty, notIsEmpty] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		array: "Expected array to be empty",
-		object: "Expected object to be empty",
-		map: "Expected Map to be empty",
-		set: "Expected Set to be empty",
-		not: "Expected array to not be empty",
-		notObject: "Expected object to not be empty",
-		notMap: "Expected Map to not be empty",
-		notSet: "Expected Set to not be empty",
-		invalidArgument: "Expected {{= it.actual }} to be an array, object, Map, or Set"
-	},
-	test: (report) => (actual, message) => {
-		if (Array.isArray(actual)) {
-			if (actual.length === 0) return report({
-				message,
-				status: "ok",
-				actual,
-				expected: []
-			});
-			return report({
-				message,
-				status: "notok",
-				messageId: "array",
-				actual,
-				expected: []
-			});
-		}
-		if ((0, lodash_isPlainObject_js.default)(actual)) {
-			if (Object.keys(actual).length === 0) return report({
-				message,
-				status: "ok",
-				messageId: "notObject",
-				actual
-			});
-			return report({
-				message,
-				status: "notok",
-				messageId: "object",
-				actual,
-				expected: {}
-			});
-		}
-		if (actual instanceof Map) {
-			if (actual.size === 0) return report({
-				message,
-				status: "ok",
-				messageId: "notMap",
-				actual
-			});
-			return report({
-				message,
-				status: "notok",
-				messageId: "map",
-				actual,
-				expected: /* @__PURE__ */ new Map()
-			});
-		}
-		if (actual instanceof Set) {
-			if (actual.size === 0) return report({
-				message,
-				status: "ok",
-				messageId: "notSet",
-				actual
-			});
-			return report({
-				message,
-				status: "notok",
-				messageId: "set",
-				actual
-			});
-		}
-		report({
-			message,
-			status: "notok",
-			messageId: "invalidArgument",
-			actual
-		});
-		report({
-			message,
-			status: "ok",
-			messageId: "invalidArgument",
-			actual
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/is-type.ts
-const [isType, notIsType] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		wrongType: "Expected {{= it.actual }} to be a(n) {{= it.expected }}",
-		not: `Expected {{= it.actual }} to not be a(n) {{= it.expected }}`
-	},
-	test: (report) => (value, expectedType) => {
-		const actualType = getType(value);
-		if (actualType !== expectedType) return report({
-			status: "notok",
-			messageId: "wrongType",
-			actual: actualType,
-			expected: expectedType,
-			noStringify: true
-		});
-		return report({
-			status: "ok",
-			messageId: "not",
-			actual: actualType,
-			expected: expectedType,
-			noStringify: true
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/less-than.ts
-const [lessThan, notLessThan] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		lesserThan: "Expected {{= it.actual }} to be less than {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not be less than {{= it.expected }}"
-	},
-	test: (report) => (actual, expected, message) => {
-		validateNumericsAndDates(actual, expected);
-		if (actual >= expected) return report({
-			status: "notok",
-			messageId: "lesserThan",
-			actual,
-			expected,
-			message
-		});
-		return report({
-			status: "ok",
-			actual,
-			expected,
-			message,
-			messageId: "not"
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/less-than-equal.ts
-const [lessThanEqual, notLessThanEqual] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		lesserThanEqual: "Expected {{= it.actual }} to be less than or equal to {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not be less than or equal to {{= it.expected }}"
-	},
-	test: (report) => (actual, expected, message) => {
-		validateNumericsAndDates(actual, expected);
-		if (actual > expected) return report({
-			status: "notok",
-			messageId: "lesserThanEqual",
-			actual,
-			expected,
-			message,
-			noStringify: true
-		});
-		return report({
-			status: "ok",
-			actual,
-			expected,
-			message,
-			messageId: "not",
-			noStringify: true
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/match.ts
-const [match, notMatch] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		noMatch: "Expected {{= it.actual }} to match {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not match {{= it.expected }}"
-	},
-	test: (report) => (actual, regex) => {
-		if (!regex.test(actual)) return report({
-			messageId: "noMatch",
-			status: "notok",
-			actual,
-			noStringify: true,
-			expected: regex.toString()
-		});
-		report({
-			status: "ok",
-			actual,
-			expected: regex.toString(),
-			noStringify: true
-		});
-	}
-});
-
-//#endregion
-//#region src/utils/process-error.ts
-const isConstructor = (value) => {
-	return typeof value === "function" && value.prototype && value.prototype.isPrototypeOf;
-};
-const processError = (report, error, narrowerOrMessage, message) => {
-	message = (typeof narrowerOrMessage === "string" ? narrowerOrMessage : message) ?? null;
-	if (!(error instanceof Error)) return report({
-		noStringify: true,
-		status: "notok",
-		messageId: "nonError",
-		actual: typeof error,
-		expected: "Error"
-	});
-	if (narrowerOrMessage) {
-		if (isConstructor(narrowerOrMessage)) {
-			if (!(error instanceof narrowerOrMessage)) return report({
-				noStringify: true,
-				status: "notok",
-				messageId: "invalidConstructor",
-				actual: error.name,
-				expected: narrowerOrMessage.name,
-				message
-			});
-			return report({
-				noStringify: true,
-				status: "ok",
-				messageId: "notConstructor",
-				actual: error.name,
-				expected: narrowerOrMessage.name,
-				message
-			});
-		} else if (typeof narrowerOrMessage === "function") {
-			if (!narrowerOrMessage(error)) return report({
-				noStringify: true,
-				status: "notok",
-				messageId: "predicate",
-				actual: error,
-				expected: null,
-				message
-			});
-			return report({
-				noStringify: true,
-				status: "ok",
-				messageId: "notPredicate",
-				actual: error,
-				expected: null,
-				message
-			});
-		} else if (typeof narrowerOrMessage === "string") return report({
-			noStringify: true,
-			status: "ok",
-			messageId: "throws",
-			actual: error,
-			message: narrowerOrMessage
-		});
-		else if (narrowerOrMessage instanceof RegExp) {
-			if (!narrowerOrMessage.test(error.message)) return report({
-				noStringify: true,
-				status: "notok",
-				messageId: "regex",
-				actual: error.message,
-				expected: narrowerOrMessage.toString(),
-				message
-			});
-			return report({
-				noStringify: true,
-				status: "ok",
-				messageId: "notRegex",
-				actual: error.message,
-				expected: narrowerOrMessage.toString(),
-				message
-			});
-		}
-	}
-	return report({
-		noStringify: true,
-		status: "ok",
-		actual: error,
-		message
-	});
-};
-
-//#endregion
-//#region src/assert/rejects.ts
-const [rejects, notRejects] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		invalidArgument: "Expected {{= it.actual }} to be a Promise",
-		nonError: "Expected Promise to reject with an instance of Error",
-		throws: "Expected Promise to reject",
-		invalidConstructor: "Expected Promise to reject with {{= it.expected }}",
-		predicate: "Expected {{= it.actual }} to match predicate function",
-		regex: "Expected Promise to reject with an error matching {{= it.expected }}",
-		not: "Expected Promise to not reject",
-		notConstructor: "Expected Promise to not reject with a {{= it.expected }}",
-		notPredicate: "Expected {{= it.actual }} to not match predicate function",
-		notRegex: "Expected Promise to not reject with an error matching {{= it.expected }}"
-	},
-	test: (report) => async (promise, narrowerOrMessage, message) => {
-		if (!promise || typeof promise.then !== "function") {
-			report({
-				noStringify: true,
-				status: "notok",
-				messageId: "invalidArgument",
-				actual: typeof promise,
-				expected: "Promise"
-			});
-			return;
-		}
-		try {
-			await promise;
-		} catch (error) {
-			processError(report, error, narrowerOrMessage, message);
-			return;
-		}
-		report({
-			noStringify: true,
-			status: "notok",
-			messageId: "throws",
-			message: typeof narrowerOrMessage === "string" ? narrowerOrMessage : message
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/throws.ts
-const messages = {
-	nonError: "Expected function to throw an instance of Error",
-	throws: "Expected function to throw",
-	invalidConstructor: "Expected function to throw {{= it.expected }}",
-	predicate: "Expected {{= it.actual }} to match predicate function",
-	regex: "Expected function to throw an error matching {{= it.expected }}",
-	not: "Expected function to not throw",
-	notConstructor: "Expected function to not throw a {{= it.expected }}",
-	notPredicate: "Expected function to not throw an error matching the predicate",
-	notRegex: "Expected function to not throw an error matching {{= it.expected }}"
-};
-const [throws, notThrows] = (0, hein_assertion_utils.createAssertion)({
-	messages,
-	test: (report) => ((callback, narrowerOrMessage, message) => {
-		const argumentType = getType(callback);
-		if (argumentType !== "function") throw new hein_assertion_utils.AssertionError(argumentType, "function", `Expected ${argumentType} to be a function`);
-		try {
-			callback();
-		} catch (error) {
-			return processError(report, error, narrowerOrMessage, message);
-		}
-		return report({
-			noStringify: true,
-			status: "notok",
-			messageId: "throws",
-			message: typeof narrowerOrMessage === "string" ? narrowerOrMessage : message
-		});
-	})
-});
-
-//#endregion
-//#region src/assert/deep-has-property.ts
-const [deepHasProperty, deepNotHasProperty] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		noProperty: "Expected {{= it.actual }} to have property {{= it.expected }}",
-		wrongValue: "Expected {{= it.obj }} to have property {{= it.expected }} with value {{= it.value }}",
-		not: "Expected {{= it.actual }} to not have property {{= it.expected }}",
-		notWrongValue: "Expected {{= it.obj }} to not have property {{= it.expected }} with value {{= it.value }}"
-	},
-	test: (report) => (...args) => {
-		const [actual, expected, value] = args;
-		const actualStringified = (0, hein_assertion_utils.stringify)(actual);
-		if ((0, lodash_has_js.default)(actual, expected)) {
-			if (args.length === 3) {
-				const actualValue = (0, lodash_get_js.default)(actual, expected);
-				if (actualValue === value) return report({
-					status: "ok",
-					messageId: "notWrongValue",
-					expected: value,
-					actual: actualValue,
-					data: {
-						value,
-						expected,
-						obj: actualStringified
-					},
-					noStringify: true
-				});
-				return report({
-					status: "notok",
-					messageId: "wrongValue",
-					expected: value,
-					actual: actualValue,
-					data: {
-						value,
-						expected,
-						obj: actualStringified
-					},
-					noStringify: true
-				});
-			}
-			return report({
-				status: "ok",
-				noStringify: true,
-				expected,
-				actual: actualStringified
-			});
-		}
-		return report({
-			status: "notok",
-			messageId: "noProperty",
-			expected,
-			actual: actualStringified,
-			noStringify: true
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/starts-with.ts
-const [startsWith, notStartsWith] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		wrongStart: "Expected {{= it.actual }} to start with {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not start with {{= it.expected }}"
-	},
-	test: (report) => (actual, start) => {
-		if (actual.startsWith(start)) report({
-			messageId: "not",
-			status: "ok",
-			actual,
-			expected: start
-		});
-		else report({
-			messageId: "wrongStart",
-			status: "notok",
-			actual,
-			expected: start
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/ends-with.ts
-const [endsWith, notEndsWith] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		wrongEnd: "Expected {{= it.actual }} to end with {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not end with {{= it.expected }}"
-	},
-	test: (report) => (actual, end) => {
-		if (actual.endsWith(end)) report({
-			messageId: "not",
-			status: "ok",
-			actual,
-			expected: end
-		});
-		else report({
-			messageId: "wrongEnd",
-			status: "notok",
-			actual,
-			expected: end
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/is-before.ts
-const [isBefore, notBefore] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		after: "Expected {{= it.actual }} to be before {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not be before {{= it.expected }}"
-	},
-	test: (report) => (actual, expected) => {
-		if (actual >= expected) return report({
-			messageId: "after",
-			status: "notok",
-			actual,
-			expected
-		});
-		return report({
-			status: "ok",
-			actual,
-			expected
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/is-after.ts
-const [isAfter, notAfter] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		before: "Expected {{= it.actual }} to be after {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not be after {{= it.expected }}"
-	},
-	test: (report) => (actual, expected) => {
-		if (actual <= expected) return report({
-			messageId: "before",
-			status: "notok",
-			actual,
-			expected
-		});
-		return report({
-			status: "ok",
-			actual,
-			expected
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/is-between.ts
-const [isBetween, notBetween] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		notBetween: "Expected {{= it.actual }} to be between {{= it.lesser }} and {{= it.greater }}",
-		not: "Expected {{= it.actual }} to not be between {{= it.lesser }} and {{= it.greater }}"
-	},
-	test: (report) => (actual, start, end, { inclusive = true } = {}) => {
-		const [greater, lesser] = end > start ? [end, start] : [start, end];
-		const inclusivelyBetween = actual <= greater && actual >= lesser;
-		const exclusivelyBetween = actual < greater && actual > lesser;
-		if (inclusive && !inclusivelyBetween) return report({
-			messageId: "notBetween",
-			status: "notok",
-			actual,
-			data: {
-				lesser,
-				greater
-			}
-		});
-		if (!inclusive && !exclusivelyBetween) return report({
-			messageId: "notBetween",
-			status: "notok",
-			actual,
-			data: {
-				lesser,
-				greater
-			}
-		});
-		return report({
-			status: "ok",
-			actual,
-			data: {
-				lesser,
-				greater
-			}
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/in-ballpark.ts
-const [inBallpark, notInBallpark] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		miss: "Expected {{= it.actual }} to be in ballpark of {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not be in ballpark of {{= it.expected }}",
-		invalidMultiplier: "Expected multiplier to be between 0 and 1"
-	},
-	test: (report) => (actual, expected, allowedDifference = .1) => {
-		const absActual = Math.abs(actual);
-		const absExpected = Math.abs(expected);
-		if (allowedDifference <= 0 || allowedDifference >= 1) {
-			report({
-				status: "ok",
-				messageId: "invalidMultiplier",
-				actual: allowedDifference
-			});
-			return report({
-				status: "notok",
-				messageId: "invalidMultiplier",
-				actual: allowedDifference
-			});
-		}
-		if (absActual <= absExpected * (1 + allowedDifference) && absActual >= absExpected * (1 - allowedDifference)) return report({
-			status: "ok",
-			expected,
-			actual
-		});
-		return report({
-			status: "notok",
-			messageId: "miss",
-			expected,
-			actual
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/round-to.ts
-const [roundTo, notRoundTo] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		miss: "Expected {{= it.actual }} to round to {{= it.expected }}",
-		tooManyDecimals: "Invalid argument for target, decimals for target ({{= it.expected }}) cannot be less than rounding decimals ({{= it.decimals }})",
-		not: "Expected {{= it.actual }} to not round to {{= it.expected }}"
-	},
-	test: (report) => (actual, expected, decimals = 0) => {
-		var _expected$toString$sp;
-		if (((_expected$toString$sp = expected.toString().split(".")[1]) === null || _expected$toString$sp === void 0 ? void 0 : _expected$toString$sp.length) > decimals) {
-			report({
-				status: "notok",
-				messageId: "tooManyDecimals",
-				expected,
-				actual,
-				data: { decimals },
-				noStringify: true
-			});
-			report({
-				status: "ok",
-				messageId: "tooManyDecimals",
-				expected,
-				actual,
-				data: { decimals },
-				noStringify: true
-			});
-			return true;
-		}
-		if (round(actual, decimals) === expected) return report({
-			status: "ok",
-			expected,
-			actual
-		});
-		return report({
-			status: "notok",
-			messageId: "miss",
-			expected,
-			actual
-		});
-	}
-});
-const round = (value, decimals) => {
-	const factor = 10 ** decimals;
-	return Math.round(value * factor) / factor;
-};
-
-//#endregion
-//#region src/assert/has-members.ts
-const [hasMembers, notHasMembers] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		hasMembers: "Expected {{= it.actual }} to have members {{= it.expected }}",
-		same: "Expected {{= it.actual }} to have same members as {{= it.expected }}",
-		order: "Expected {{= it.actual }} to have ordered members {{= it.expected }}",
-		not: "Expected {{= it.actual }} to not have members {{= it.expected }}",
-		notSame: "Expected {{= it.actual }} to not have same members as {{= it.expected }}"
-	},
-	test: (report) => (actual, expected, { deep = false, partial = false, ordered = false, same = false } = {}, message) => {
-		let lastIndex = -1;
-		for (const item of expected) if (deep || partial) {
-			const actualIndex = actual.findIndex((actualItem, index) => {
-				if (!ordered) return match$1(actualItem, item, { partial });
-				if (lastIndex >= index) return false;
-				return match$1(actualItem, item, { partial });
-			});
-			lastIndex = actualIndex;
-			if (actualIndex === -1) return report({
-				status: "notok",
-				messageId: ordered ? "order" : "hasMembers",
-				actual,
-				expected,
-				message
-			});
-		} else if (actual.includes(item)) {
-			if (ordered && lastIndex >= actual.indexOf(item, lastIndex + 1)) return report({
-				status: "notok",
-				messageId: "order",
-				actual,
-				expected,
-				message
-			});
-			lastIndex = actual.indexOf(item, lastIndex + 1);
-		} else return report({
-			status: "notok",
-			messageId: "hasMembers",
-			actual,
-			expected,
-			message
-		});
-		if (same && actual.length !== expected.length) return report({
-			status: "notok",
-			messageId: "same",
-			actual,
-			expected,
-			message
-		});
-		return report({
-			status: "ok",
-			messageId: same ? "notSame" : "not",
-			actual,
-			expected,
-			message
-		});
-	}
-});
-
-//#endregion
-//#region src/assert/has-keys.ts
-const [hasKeys, notHasKeys] = (0, hein_assertion_utils.createAssertion)({
-	messages: {
-		noKey: "Expected {{= it.object }} to have keys {{= it.expected }}",
-		not: "Expected {{= it.object }} to not have keys {{= it.expected }}"
-	},
-	test: (report) => (object, keys, message) => {
-		const keysArray = (0, lodash_castArray_js.default)(keys);
-		if (object instanceof Map) {
-			for (const key of keysArray) if (!object.has(key)) {
-				report({
-					status: "notok",
-					message,
-					messageId: "noKey",
-					data: { object },
-					actual: [...object.keys()],
-					expected: keysArray
-				});
-				return;
-			}
-			report({
-				status: "ok",
-				data: { object },
-				actual: [...object.keys()],
-				expected: keysArray
-			});
-			return;
-		}
-		for (const key of keysArray) if (!(key in object)) {
-			report({
-				status: "notok",
-				message,
-				messageId: "noKey",
-				data: { object },
-				actual: object,
-				expected: keysArray
-			});
-			return;
-		}
-		report({
-			status: "ok",
-			data: { object },
-			actual: Object.keys(object),
-			expected: keysArray
-		});
-	}
-});
-
-//#endregion
-//#region src/assert.ts
-var assert_exports = /* @__PURE__ */ __export({
-	assert: () => assert,
-	deepEqual: () => deepEqual,
-	deepHasProperty: () => deepHasProperty,
-	deepNotHasProperty: () => deepNotHasProperty,
-	endsWith: () => endsWith,
-	equal: () => equal,
-	greaterThan: () => greaterThan,
-	greaterThanEqual: () => greaterThanEqual,
-	hasKeys: () => hasKeys,
-	hasMembers: () => hasMembers,
-	hasProperty: () => hasProperty,
-	hasSize: () => hasSize,
-	inBallpark: () => inBallpark,
-	includes: () => includes,
-	instanceOf: () => instanceOf,
-	isAfter: () => isAfter,
-	isBefore: () => isBefore,
-	isBetween: () => isBetween,
-	isEmpty: () => isEmpty,
-	isType: () => isType,
-	lessThan: () => lessThan,
-	lessThanEqual: () => lessThanEqual,
-	match: () => match,
-	notAfter: () => notAfter,
-	notBefore: () => notBefore,
-	notBetween: () => notBetween,
-	notDeepEqual: () => notDeepEqual,
-	notEndsWith: () => notEndsWith,
-	notEqual: () => notEqual,
-	notGreaterThan: () => notGreaterThan,
-	notGreaterThanEqual: () => notGreaterThanEqual,
-	notHasKeys: () => notHasKeys,
-	notHasMembers: () => notHasMembers,
-	notHasProperty: () => notHasProperty,
-	notHasSize: () => notHasSize,
-	notInBallpark: () => notInBallpark,
-	notIncludes: () => notIncludes,
-	notInstanceOf: () => notInstanceOf,
-	notIsEmpty: () => notIsEmpty,
-	notIsType: () => notIsType,
-	notLessThan: () => notLessThan,
-	notLessThanEqual: () => notLessThanEqual,
-	notMatch: () => notMatch,
-	notRejects: () => notRejects,
-	notRoundTo: () => notRoundTo,
-	notStartsWith: () => notStartsWith,
-	notThrows: () => notThrows,
-	rejects: () => rejects,
-	roundTo: () => roundTo,
-	startsWith: () => startsWith,
-	throws: () => throws
-});
-const assert = () => {
-	throw new Error("Not implemented");
-};
-
-//#endregion
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});
-Object.defineProperty(exports, 'any', {
-  enumerable: true,
-  get: function () {
-    return any;
-  }
-});
-Object.defineProperty(exports, 'assert', {
-  enumerable: true,
-  get: function () {
-    return assert;
-  }
-});
-Object.defineProperty(exports, 'assert_exports', {
-  enumerable: true,
-  get: function () {
-    return assert_exports;
-  }
-});
-Object.defineProperty(exports, 'createEvaluation', {
-  enumerable: true,
-  get: function () {
-    return createEvaluation;
-  }
-});
-Object.defineProperty(exports, 'deepEqual', {
-  enumerable: true,
-  get: function () {
-    return deepEqual;
-  }
-});
-Object.defineProperty(exports, 'deepHasProperty', {
-  enumerable: true,
-  get: function () {
-    return deepHasProperty;
-  }
-});
-Object.defineProperty(exports, 'deepNotHasProperty', {
-  enumerable: true,
-  get: function () {
-    return deepNotHasProperty;
-  }
-});
-Object.defineProperty(exports, 'endsWith', {
-  enumerable: true,
-  get: function () {
-    return endsWith;
-  }
-});
-Object.defineProperty(exports, 'equal', {
-  enumerable: true,
-  get: function () {
-    return equal;
-  }
-});
-Object.defineProperty(exports, 'greaterThan', {
-  enumerable: true,
-  get: function () {
-    return greaterThan;
-  }
-});
-Object.defineProperty(exports, 'greaterThanEqual', {
-  enumerable: true,
-  get: function () {
-    return greaterThanEqual;
-  }
-});
-Object.defineProperty(exports, 'hasKeys', {
-  enumerable: true,
-  get: function () {
-    return hasKeys;
-  }
-});
-Object.defineProperty(exports, 'hasMembers', {
-  enumerable: true,
-  get: function () {
-    return hasMembers;
-  }
-});
-Object.defineProperty(exports, 'hasProperty', {
-  enumerable: true,
-  get: function () {
-    return hasProperty;
-  }
-});
-Object.defineProperty(exports, 'hasSize', {
-  enumerable: true,
-  get: function () {
-    return hasSize;
-  }
-});
-Object.defineProperty(exports, 'inBallpark', {
-  enumerable: true,
-  get: function () {
-    return inBallpark;
-  }
-});
-Object.defineProperty(exports, 'includes', {
-  enumerable: true,
-  get: function () {
-    return includes;
-  }
-});
-Object.defineProperty(exports, 'instanceOf', {
-  enumerable: true,
-  get: function () {
-    return instanceOf;
-  }
-});
-Object.defineProperty(exports, 'isAfter', {
-  enumerable: true,
-  get: function () {
-    return isAfter;
-  }
-});
-Object.defineProperty(exports, 'isBefore', {
-  enumerable: true,
-  get: function () {
-    return isBefore;
-  }
-});
-Object.defineProperty(exports, 'isBetween', {
-  enumerable: true,
-  get: function () {
-    return isBetween;
-  }
-});
-Object.defineProperty(exports, 'isEmpty', {
-  enumerable: true,
-  get: function () {
-    return isEmpty;
-  }
-});
-Object.defineProperty(exports, 'isType', {
-  enumerable: true,
-  get: function () {
-    return isType;
-  }
-});
-Object.defineProperty(exports, 'lessThan', {
-  enumerable: true,
-  get: function () {
-    return lessThan;
-  }
-});
-Object.defineProperty(exports, 'lessThanEqual', {
-  enumerable: true,
-  get: function () {
-    return lessThanEqual;
-  }
-});
-Object.defineProperty(exports, 'match', {
-  enumerable: true,
-  get: function () {
-    return match;
-  }
-});
-Object.defineProperty(exports, 'notAfter', {
-  enumerable: true,
-  get: function () {
-    return notAfter;
-  }
-});
-Object.defineProperty(exports, 'notBefore', {
-  enumerable: true,
-  get: function () {
-    return notBefore;
-  }
-});
-Object.defineProperty(exports, 'notBetween', {
-  enumerable: true,
-  get: function () {
-    return notBetween;
-  }
-});
-Object.defineProperty(exports, 'notDeepEqual', {
-  enumerable: true,
-  get: function () {
-    return notDeepEqual;
-  }
-});
-Object.defineProperty(exports, 'notEndsWith', {
-  enumerable: true,
-  get: function () {
-    return notEndsWith;
-  }
-});
-Object.defineProperty(exports, 'notEqual', {
-  enumerable: true,
-  get: function () {
-    return notEqual;
-  }
-});
-Object.defineProperty(exports, 'notGreaterThan', {
-  enumerable: true,
-  get: function () {
-    return notGreaterThan;
-  }
-});
-Object.defineProperty(exports, 'notGreaterThanEqual', {
-  enumerable: true,
-  get: function () {
-    return notGreaterThanEqual;
-  }
-});
-Object.defineProperty(exports, 'notHasKeys', {
-  enumerable: true,
-  get: function () {
-    return notHasKeys;
-  }
-});
-Object.defineProperty(exports, 'notHasMembers', {
-  enumerable: true,
-  get: function () {
-    return notHasMembers;
-  }
-});
-Object.defineProperty(exports, 'notHasProperty', {
-  enumerable: true,
-  get: function () {
-    return notHasProperty;
-  }
-});
-Object.defineProperty(exports, 'notHasSize', {
-  enumerable: true,
-  get: function () {
-    return notHasSize;
-  }
-});
-Object.defineProperty(exports, 'notInBallpark', {
-  enumerable: true,
-  get: function () {
-    return notInBallpark;
-  }
-});
-Object.defineProperty(exports, 'notIncludes', {
-  enumerable: true,
-  get: function () {
-    return notIncludes;
-  }
-});
-Object.defineProperty(exports, 'notInstanceOf', {
-  enumerable: true,
-  get: function () {
-    return notInstanceOf;
-  }
-});
-Object.defineProperty(exports, 'notIsEmpty', {
-  enumerable: true,
-  get: function () {
-    return notIsEmpty;
-  }
-});
-Object.defineProperty(exports, 'notIsType', {
-  enumerable: true,
-  get: function () {
-    return notIsType;
-  }
-});
-Object.defineProperty(exports, 'notLessThan', {
-  enumerable: true,
-  get: function () {
-    return notLessThan;
-  }
-});
-Object.defineProperty(exports, 'notLessThanEqual', {
-  enumerable: true,
-  get: function () {
-    return notLessThanEqual;
-  }
-});
-Object.defineProperty(exports, 'notMatch', {
-  enumerable: true,
-  get: function () {
-    return notMatch;
-  }
-});
-Object.defineProperty(exports, 'notRejects', {
-  enumerable: true,
-  get: function () {
-    return notRejects;
-  }
-});
-Object.defineProperty(exports, 'notRoundTo', {
-  enumerable: true,
-  get: function () {
-    return notRoundTo;
-  }
-});
-Object.defineProperty(exports, 'notStartsWith', {
-  enumerable: true,
-  get: function () {
-    return notStartsWith;
-  }
-});
-Object.defineProperty(exports, 'notThrows', {
-  enumerable: true,
-  get: function () {
-    return notThrows;
-  }
-});
-Object.defineProperty(exports, 'rejects', {
-  enumerable: true,
-  get: function () {
-    return rejects;
-  }
-});
-Object.defineProperty(exports, 'roundTo', {
-  enumerable: true,
-  get: function () {
-    return roundTo;
-  }
-});
-Object.defineProperty(exports, 'startsWith', {
-  enumerable: true,
-  get: function () {
-    return startsWith;
-  }
-});
-Object.defineProperty(exports, 'throws', {
-  enumerable: true,
-  get: function () {
-    return throws;
-  }
-});
-//# sourceMappingURL=assert-DZjgWjOw.cjs.map