hein 1.4.2 → 2.0.0-alpha.0

package/dist/assert-kFXp7i_B.js

@@ -0,0 +1,1260 @@
+import { __export } from "./chunk-CTAAG5j7.js";
+import cloneDeep from "lodash/cloneDeep.js";
+import { AssertionError, createAssertion, stringify } from "hein-assertion-utils";
+import isObjectLike from "lodash/isObjectLike.js";
+import isPlainObject from "lodash/isPlainObject.js";
+import get from "lodash/get.js";
+import has from "lodash/has.js";
+import castArray from "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 || !isObjectLike(actual) && !isObjectLike(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(isObjectLike(actual), isObjectLike(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] = 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 = cloneDeep(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] = 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 AssertionError(actualType, expectedType, `Expected arguments to be ${allowedTypes.join("/")}, received ${actualType}/${expectedType}`);
+};
+
+//#endregion
+//#region src/assert/greater-than.ts
+const [greaterThan, notGreaterThan] = 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] = 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] = 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 = 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] = 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 (isPlainObject(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] = 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] = 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 (!isObjectLike(actual)) throw new 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] = 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 (isPlainObject(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] = 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] = 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] = 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] = 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] = 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] = createAssertion({
+	messages,
+	test: (report) => ((callback, narrowerOrMessage, message) => {
+		const argumentType = getType(callback);
+		if (argumentType !== "function") throw new 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] = 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 = stringify(actual);
+		if (has(actual, expected)) {
+			if (args.length === 3) {
+				const actualValue = get(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] = 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] = 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] = 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] = 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] = 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] = 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] = 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] = 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] = 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 = castArray(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
+export { any, assert, assert_exports, createEvaluation, deepEqual, deepHasProperty, deepNotHasProperty, endsWith, equal, greaterThan, greaterThanEqual, hasKeys, hasMembers, hasProperty, hasSize, inBallpark, includes, instanceOf, isAfter, isBefore, isBetween, isEmpty, isType, lessThan, lessThanEqual, match, notAfter, notBefore, notBetween, notDeepEqual, notEndsWith, notEqual, notGreaterThan, notGreaterThanEqual, notHasKeys, notHasMembers, notHasProperty, notHasSize, notInBallpark, notIncludes, notInstanceOf, notIsEmpty, notIsType, notLessThan, notLessThanEqual, notMatch, notRejects, notRoundTo, notStartsWith, notThrows, rejects, roundTo, startsWith, throws };
+//# sourceMappingURL=assert-kFXp7i_B.js.map