hein 1.4.2 → 2.0.0-alpha.0

package/dist/assert-DZjgWjOw.cjs

@@ -0,0 +1,1626 @@
+//#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