@ls-stack/utils 3.65.0 → 3.67.0

package/dist/partialEqual.mjs

@@ -0,0 +1,1055 @@
+import { r as exhaustiveCheck } from "./assertions-qMxfVhSu.mjs";
+import { err, ok } from "t-result";
+
+//#region src/partialEqual.ts
+const has = Object.prototype.hasOwnProperty;
+function createComparison(type) {
+	return { "~sc": type };
+}
+const match = {
+	noExtraKeys: (partialShape) => createComparison(["withNoExtraKeys", partialShape]),
+	deepNoExtraKeys: (partialShape) => createComparison(["withDeepNoExtraKeys", partialShape]),
+	noExtraDefinedKeys: (partialShape) => createComparison(["noExtraDefinedKeys", partialShape]),
+	deepNoExtraDefinedKeys: (partialShape) => createComparison(["deepNoExtraDefinedKeys", partialShape]),
+	hasType: {
+		string: createComparison(["hasType", "string"]),
+		number: createComparison(["hasType", "number"]),
+		boolean: createComparison(["hasType", "boolean"]),
+		object: createComparison(["hasType", "object"]),
+		array: createComparison(["hasType", "array"]),
+		function: createComparison(["hasType", "function"])
+	},
+	isInstanceOf: (constructor) => createComparison(["isInstanceOf", constructor]),
+	str: {
+		contains: (substring) => createComparison(["strContains", substring]),
+		startsWith: (substring) => createComparison(["strStartsWith", substring]),
+		endsWith: (substring) => createComparison(["strEndsWith", substring]),
+		matchesRegex: (regex) => createComparison(["strMatchesRegex", regex])
+	},
+	num: {
+		isGreaterThan: (value) => createComparison(["numIsGreaterThan", value]),
+		isGreaterThanOrEqual: (value) => createComparison(["numIsGreaterThanOrEqual", value]),
+		isLessThan: (value) => createComparison(["numIsLessThan", value]),
+		isLessThanOrEqual: (value) => createComparison(["numIsLessThanOrEqual", value]),
+		isInRange: (value) => createComparison(["numIsInRange", value])
+	},
+	array: {
+		contains: (elements) => createComparison(["arrayContains", elements]),
+		containsInOrder: (elements) => createComparison(["arrayContainsInOrder", elements]),
+		startsWith: (elements) => createComparison(["arrayStartsWith", elements]),
+		endsWith: (elements) => createComparison(["arrayEndsWith", elements]),
+		length: (n) => createComparison(["arrayLength", n]),
+		minLength: (n) => createComparison(["arrayMinLength", n]),
+		maxLength: (n) => createComparison(["arrayMaxLength", n]),
+		includes: (element) => createComparison(["arrayIncludes", element]),
+		every: (matcher) => createComparison(["arrayEvery", matcher["~sc"]]),
+		some: (matcher) => createComparison(["arraySome", matcher["~sc"]])
+	},
+	jsonString: { hasPartial: (value) => createComparison(["jsonStringHasPartial", value]) },
+	equal: (value) => createComparison(["deepEqual", value]),
+	partialEqual: (value) => createComparison(["partialEqual", value]),
+	custom: (isEqual) => createComparison(["custom", isEqual]),
+	keyNotBePresent: createComparison(["keyNotBePresent", null]),
+	any: (...values) => createComparison(["any", values.map((v) => {
+		if (isComparison(v)) return v["~sc"];
+		if (typeof v === "object" && v !== null) return ["partialEqual", v];
+		return ["deepEqual", v];
+	})]),
+	all: (...values) => createComparison(["all", values.map((v) => {
+		if (isComparison(v)) return v["~sc"];
+		if (typeof v === "object" && v !== null) return ["partialEqual", v];
+		return ["deepEqual", v];
+	})]),
+	key: {
+		any: "$pqkc:any$",
+		anyOther: "$pqkc:anyOther$",
+		numeric: "$pqkc:numeric$",
+		startingWith: (substring) => `$pqkc:startingWith:${substring}$`,
+		endingWith: (substring) => `$pqkc:endingWith:${substring}$`,
+		containing: (substring) => `$pqkc:contains:${substring}$`,
+		matchingRegex: (regex) => `$pqkc:matchesRegex:${regex}$`
+	},
+	not: {
+		hasType: {
+			string: createComparison(["not", ["hasType", "string"]]),
+			number: createComparison(["not", ["hasType", "number"]]),
+			boolean: createComparison(["not", ["hasType", "boolean"]]),
+			object: createComparison(["not", ["hasType", "object"]]),
+			array: createComparison(["not", ["hasType", "array"]]),
+			function: createComparison(["not", ["hasType", "function"]])
+		},
+		keyNotBePresent: createComparison(["not", ["keyNotBePresent", null]]),
+		isInstanceOf: (constructor) => createComparison(["not", ["isInstanceOf", constructor]]),
+		str: {
+			contains: (substring) => createComparison(["not", ["strContains", substring]]),
+			startsWith: (substring) => createComparison(["not", ["strStartsWith", substring]]),
+			endsWith: (substring) => createComparison(["not", ["strEndsWith", substring]]),
+			matchesRegex: (regex) => createComparison(["not", ["strMatchesRegex", regex]])
+		},
+		num: {
+			isGreaterThan: (value) => createComparison(["not", ["numIsGreaterThan", value]]),
+			isGreaterThanOrEqual: (value) => createComparison(["not", ["numIsGreaterThanOrEqual", value]]),
+			isLessThan: (value) => createComparison(["not", ["numIsLessThan", value]]),
+			isLessThanOrEqual: (value) => createComparison(["not", ["numIsLessThanOrEqual", value]]),
+			isInRange: (value) => createComparison(["not", ["numIsInRange", value]])
+		},
+		array: {
+			contains: (elements) => createComparison(["not", ["arrayContains", elements]]),
+			containsInOrder: (elements) => createComparison(["not", ["arrayContainsInOrder", elements]]),
+			startsWith: (elements) => createComparison(["not", ["arrayStartsWith", elements]]),
+			endsWith: (elements) => createComparison(["not", ["arrayEndsWith", elements]]),
+			length: (n) => createComparison(["not", ["arrayLength", n]]),
+			minLength: (n) => createComparison(["not", ["arrayMinLength", n]]),
+			maxLength: (n) => createComparison(["not", ["arrayMaxLength", n]]),
+			includes: (element) => createComparison(["not", ["arrayIncludes", element]]),
+			every: (matcher) => createComparison(["not", ["arrayEvery", matcher["~sc"]]]),
+			some: (matcher) => createComparison(["not", ["arraySome", matcher["~sc"]]])
+		},
+		jsonString: { hasPartial: (value) => createComparison(["not", ["jsonStringHasPartial", value]]) },
+		equal: (value) => createComparison(["not", ["deepEqual", value]]),
+		partialEqual: (value) => createComparison(["not", ["partialEqual", value]]),
+		custom: (value) => createComparison(["not", ["custom", value]]),
+		any: (...values) => createComparison(["not", ["any", values.map((v) => {
+			if (isComparison(v)) return v["~sc"];
+			if (typeof v === "object" && v !== null) return ["partialEqual", v];
+			return ["deepEqual", v];
+		})]]),
+		all: (...values) => createComparison(["not", ["all", values.map((v) => {
+			if (isComparison(v)) return v["~sc"];
+			if (typeof v === "object" && v !== null) return ["partialEqual", v];
+			return ["deepEqual", v];
+		})]]),
+		noExtraKeys: (partialShape) => createComparison(["not", ["withNoExtraKeys", partialShape]]),
+		deepNoExtraKeys: (partialShape) => createComparison(["not", ["withDeepNoExtraKeys", partialShape]]),
+		noExtraDefinedKeys: (partialShape) => createComparison(["not", ["noExtraDefinedKeys", partialShape]]),
+		deepNoExtraDefinedKeys: (partialShape) => createComparison(["not", ["deepNoExtraDefinedKeys", partialShape]]),
+		key: {
+			any: "$pqkc-not:any$",
+			anyOther: "$pqkc-not:anyOther$",
+			numeric: "$pqkc-not:numeric$",
+			startingWith: (substring) => `$pqkc-not:startingWith:${substring}$`,
+			endingWith: (substring) => `$pqkc-not:endingWith:${substring}$`,
+			containing: (substring) => `$pqkc-not:contains:${substring}$`,
+			matchingRegex: (regex) => `$pqkc-not:matchesRegex:${regex}$`
+		}
+	}
+};
+function isComparison(value) {
+	return value && typeof value === "object" && "~sc" in value;
+}
+function isKeyMatcher(key) {
+	return typeof key === "string" && (key.startsWith("$pqkc:") || key.startsWith("$pqkc-not:"));
+}
+function parseKeyMatcher(key) {
+	if (!isKeyMatcher(key)) return null;
+	const negated = key.startsWith("$pqkc-not:");
+	const prefix = negated ? "$pqkc-not:" : "$pqkc:";
+	if (!key.endsWith("$")) return null;
+	const content = key.slice(prefix.length, -1);
+	if (content === "any") return {
+		type: "any",
+		negated
+	};
+	if (content === "anyOther") return {
+		type: "anyOther",
+		negated
+	};
+	if (content === "numeric") return {
+		type: "numeric",
+		negated
+	};
+	if (content.startsWith("startingWith:")) return {
+		type: "startingWith",
+		parameter: content.slice(13),
+		negated
+	};
+	if (content.startsWith("endingWith:")) return {
+		type: "endingWith",
+		parameter: content.slice(11),
+		negated
+	};
+	if (content.startsWith("contains:")) return {
+		type: "contains",
+		parameter: content.slice(9),
+		negated
+	};
+	if (content.startsWith("matchesRegex:")) {
+		const regexStr = content.slice(13);
+		try {
+			if (regexStr.startsWith("/") && regexStr.lastIndexOf("/") > 0) {
+				const lastSlashIndex = regexStr.lastIndexOf("/");
+				const pattern = regexStr.slice(1, lastSlashIndex);
+				const flags = regexStr.slice(lastSlashIndex + 1);
+				return {
+					type: "matchesRegex",
+					parameter: new RegExp(pattern, flags),
+					negated
+				};
+			} else return {
+				type: "matchesRegex",
+				parameter: new RegExp(regexStr),
+				negated
+			};
+		} catch {
+			return null;
+		}
+	}
+	return null;
+}
+function keyMatchesPattern(key, matcher) {
+	let matches = false;
+	switch (matcher.type) {
+		case "any":
+			matches = true;
+			break;
+		case "anyOther":
+			matches = true;
+			break;
+		case "numeric":
+			matches = /^\d+$/.test(key);
+			break;
+		case "startingWith":
+			matches = key.startsWith(matcher.parameter);
+			break;
+		case "endingWith":
+			matches = key.endsWith(matcher.parameter);
+			break;
+		case "contains":
+			matches = key.includes(matcher.parameter);
+			break;
+		case "matchesRegex":
+			matches = matcher.parameter.test(key);
+			break;
+	}
+	return matcher.negated ? !matches : matches;
+}
+function executeComparison(target, comparison, context) {
+	const [type, value] = comparison;
+	switch (type) {
+		case "strStartsWith":
+			if (typeof target !== "string") {
+				addError(context, {
+					message: `Expected string starting with "${value}"`,
+					received: target
+				});
+				return false;
+			}
+			if (!target.startsWith(value)) {
+				addError(context, {
+					message: `Expected string starting with "${value}"`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "strEndsWith":
+			if (typeof target !== "string") {
+				addError(context, {
+					message: `Expected string ending with "${value}"`,
+					received: target
+				});
+				return false;
+			}
+			if (!target.endsWith(value)) {
+				addError(context, {
+					message: `Expected string ending with "${value}"`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "strContains":
+			if (typeof target !== "string") {
+				addError(context, {
+					message: `Expected string containing "${value}"`,
+					received: target
+				});
+				return false;
+			}
+			if (!target.includes(value)) {
+				addError(context, {
+					message: `Expected string containing "${value}"`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "strMatchesRegex":
+			if (typeof target !== "string") {
+				addError(context, {
+					message: `Expected string matching regex ${value}`,
+					received: target
+				});
+				return false;
+			}
+			if (!value.test(target)) {
+				addError(context, {
+					message: `Expected string matching regex ${value}`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "hasType": {
+			let actualType;
+			if (value === "array") actualType = Array.isArray(target) ? "array" : typeof target;
+			else if (value === "object") if (target === null || Array.isArray(target)) actualType = "not-object";
+			else actualType = typeof target;
+			else actualType = typeof target;
+			if (actualType !== value) {
+				addError(context, {
+					message: `Expected type ${value}`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		}
+		case "deepEqual":
+			if (!deepEqual(target, value)) {
+				addError(context, {
+					message: "Values are not deeply equal",
+					received: target,
+					expected: value
+				});
+				return false;
+			}
+			return true;
+		case "numIsGreaterThan":
+			if (typeof target !== "number" || target <= value) {
+				addError(context, {
+					message: `Expected number greater than ${value}`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "numIsGreaterThanOrEqual":
+			if (typeof target !== "number" || target < value) {
+				addError(context, {
+					message: `Expected number greater than or equal to ${value}`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "numIsLessThan":
+			if (typeof target !== "number" || target >= value) {
+				addError(context, {
+					message: `Expected number less than ${value}`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "numIsLessThanOrEqual":
+			if (typeof target !== "number" || target > value) {
+				addError(context, {
+					message: `Expected number less than or equal to ${value}`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "numIsInRange":
+			if (typeof target !== "number" || target < value[0] || target > value[1]) {
+				addError(context, {
+					message: `Expected number in range [${value[0]}, ${value[1]}]`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "jsonStringHasPartial":
+			if (typeof target !== "string") {
+				addError(context, {
+					message: "Expected JSON string",
+					received: target
+				});
+				return false;
+			}
+			try {
+				if (!partialEqualInternal(JSON.parse(target), value, context)) return false;
+			} catch {
+				addError(context, {
+					message: "Expected valid JSON string",
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "partialEqual": return partialEqualInternal(target, value, context);
+		case "custom": {
+			const result = value(target);
+			if (result !== true) {
+				addError(context, {
+					message: `Custom validation failed ${typeof result === "object" ? `: ${result.error}` : ""}`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		}
+		case "isInstanceOf":
+			if (!(target instanceof value)) {
+				addError(context, {
+					message: `Expected instance of ${value.name}`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "keyNotBePresent":
+			addError(context, {
+				message: "This property should not be present",
+				received: target
+			});
+			return false;
+		case "not":
+			if (executeComparison(target, value, {
+				errors: [],
+				path: context.path
+			})) {
+				addError(context, {
+					message: "Expected negated condition to fail",
+					received: target,
+					expected: { "not match": value }
+				});
+				return false;
+			}
+			return true;
+		case "any":
+			for (const subComparison of value) if (executeComparison(target, subComparison, {
+				errors: [],
+				path: context.path
+			})) return true;
+			addError(context, {
+				message: "None of the alternative comparisons matched",
+				received: target,
+				expected: { matchAny: value }
+			});
+			return false;
+		case "all": {
+			let allMatch = true;
+			for (const subComparison of value) if (!executeComparison(target, subComparison, context)) allMatch = false;
+			return allMatch;
+		}
+		case "withNoExtraKeys": return checkNoExtraKeys(target, value, context, false);
+		case "withDeepNoExtraKeys": return checkNoExtraKeys(target, value, context, true);
+		case "noExtraDefinedKeys": return checkNoExtraDefinedKeys(target, value, context, false);
+		case "deepNoExtraDefinedKeys": return checkNoExtraDefinedKeys(target, value, context, true);
+		case "arrayContains":
+			if (!Array.isArray(target)) {
+				addError(context, {
+					message: "Expected array",
+					received: target
+				});
+				return false;
+			}
+			for (const element of value) {
+				let found = false;
+				for (const targetElement of target) if (partialEqualInternal(targetElement, element, {
+					errors: [],
+					path: context.path
+				})) {
+					found = true;
+					break;
+				}
+				if (!found) {
+					addError(context, {
+						message: "Array does not contain expected element",
+						received: target,
+						expected: element
+					});
+					return false;
+				}
+			}
+			return true;
+		case "arrayContainsInOrder": {
+			if (!Array.isArray(target)) {
+				addError(context, {
+					message: "Expected array",
+					received: target
+				});
+				return false;
+			}
+			let targetIndex = 0;
+			for (const element of value) {
+				let found = false;
+				for (let i = targetIndex; i < target.length; i++) {
+					const tempContext = {
+						errors: [],
+						path: context.path
+					};
+					if (partialEqualInternal(target[i], element, tempContext)) {
+						targetIndex = i + 1;
+						found = true;
+						break;
+					}
+				}
+				if (!found) {
+					addError(context, {
+						message: "Array does not contain expected elements in order",
+						received: target,
+						expected: value
+					});
+					return false;
+				}
+			}
+			return true;
+		}
+		case "arrayStartsWith": {
+			if (!Array.isArray(target)) {
+				addError(context, {
+					message: "Expected array",
+					received: target
+				});
+				return false;
+			}
+			if (target.length < value.length) {
+				addError(context, {
+					message: `Array too short: expected to start with ${value.length} elements, got ${target.length}`,
+					received: target,
+					expected: value
+				});
+				return false;
+			}
+			let allMatch = true;
+			for (let i = 0; i < value.length; i++) {
+				const oldPath = context.path;
+				context.path = [...oldPath, `[${i}]`];
+				const result = partialEqualInternal(target[i], value[i], context);
+				context.path = oldPath;
+				if (!result) allMatch = false;
+			}
+			return allMatch;
+		}
+		case "arrayEndsWith": {
+			if (!Array.isArray(target)) {
+				addError(context, {
+					message: "Expected array",
+					received: target
+				});
+				return false;
+			}
+			if (target.length < value.length) {
+				addError(context, {
+					message: `Array too short: expected to end with ${value.length} elements, got ${target.length}`,
+					received: target,
+					expected: value
+				});
+				return false;
+			}
+			let allMatch = true;
+			const startIndex = target.length - value.length;
+			for (let i = 0; i < value.length; i++) {
+				const oldPath = context.path;
+				context.path = [...oldPath, `[${startIndex + i}]`];
+				const result = partialEqualInternal(target[startIndex + i], value[i], context);
+				context.path = oldPath;
+				if (!result) allMatch = false;
+			}
+			return allMatch;
+		}
+		case "arrayLength":
+			if (!Array.isArray(target)) {
+				addError(context, {
+					message: "Expected array",
+					received: target
+				});
+				return false;
+			}
+			if (target.length !== value) {
+				addError(context, {
+					message: `Expected array length ${value}, got ${target.length}`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "arrayMinLength":
+			if (!Array.isArray(target)) {
+				addError(context, {
+					message: "Expected array",
+					received: target
+				});
+				return false;
+			}
+			if (target.length < value) {
+				addError(context, {
+					message: `Expected array with at least ${value} elements, got ${target.length}`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "arrayMaxLength":
+			if (!Array.isArray(target)) {
+				addError(context, {
+					message: "Expected array",
+					received: target
+				});
+				return false;
+			}
+			if (target.length > value) {
+				addError(context, {
+					message: `Expected array with at most ${value} elements, got ${target.length}`,
+					received: target
+				});
+				return false;
+			}
+			return true;
+		case "arrayIncludes": {
+			if (!Array.isArray(target)) {
+				addError(context, {
+					message: "Expected array",
+					received: target
+				});
+				return false;
+			}
+			let found = false;
+			for (const targetElement of target) if (partialEqualInternal(targetElement, value, {
+				errors: [],
+				path: context.path
+			})) {
+				found = true;
+				break;
+			}
+			if (!found) {
+				addError(context, {
+					message: "Array does not include expected element",
+					received: target,
+					expected: value
+				});
+				return false;
+			}
+			return true;
+		}
+		case "arrayEvery": {
+			if (!Array.isArray(target)) {
+				addError(context, {
+					message: "Expected array",
+					received: target
+				});
+				return false;
+			}
+			let allMatch = true;
+			for (let i = 0; i < target.length; i++) {
+				const oldPath = context.path;
+				context.path = [...oldPath, `[${i}]`];
+				const result = executeComparison(target[i], value, context);
+				context.path = oldPath;
+				if (!result) allMatch = false;
+			}
+			return allMatch;
+		}
+		case "arraySome":
+			if (!Array.isArray(target)) {
+				addError(context, {
+					message: "Expected array",
+					received: target
+				});
+				return false;
+			}
+			for (let i = 0; i < target.length; i++) {
+				const tempContext = {
+					errors: [],
+					path: [...context.path, `[${i}]`]
+				};
+				if (executeComparison(target[i], value, tempContext)) return true;
+			}
+			addError(context, {
+				message: "No array element matches the condition",
+				received: target
+			});
+			return false;
+		default: throw exhaustiveCheck(type);
+	}
+}
+function formatPath(path) {
+	if (path.length === 0) return "";
+	let result = path[0] || "";
+	for (let i = 1; i < path.length; i++) {
+		const segment = path[i];
+		if (segment && segment.startsWith("[") && segment.endsWith("]")) result += segment;
+		else if (segment) if (result) result += `.${segment}`;
+		else result += segment;
+	}
+	return result;
+}
+function addError(context, error) {
+	context.errors.push({
+		path: formatPath(context.path),
+		...error
+	});
+}
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (Number.isNaN(a) && Number.isNaN(b)) return true;
+	if (a === null || b === null) return false;
+	if (typeof a !== typeof b) return false;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
+		return true;
+	}
+	if (typeof a === "object") {
+		const keysA = Object.keys(a);
+		const keysB = Object.keys(b);
+		if (keysA.length !== keysB.length) return false;
+		for (const key of keysA) if (!has.call(b, key) || !deepEqual(a[key], b[key])) return false;
+		return true;
+	}
+	return false;
+}
+function partialEqualInternal(target, sub, context) {
+	if (isComparison(sub)) return executeComparison(target, sub["~sc"], context);
+	if (isComparison(sub) && sub["~sc"][0] === "keyNotBePresent") {
+		addError(context, {
+			message: "This property should not be present",
+			received: target
+		});
+		return false;
+	}
+	if (target === sub) return true;
+	if (Number.isNaN(target) && Number.isNaN(sub)) return true;
+	if (target === null || sub === null || target === void 0 || sub === void 0) {
+		if (target !== sub) {
+			addError(context, {
+				message: "Value mismatch",
+				received: target,
+				expected: sub
+			});
+			return false;
+		}
+		return true;
+	}
+	if (target instanceof Date && sub instanceof Date) {
+		if (target.getTime() !== sub.getTime()) {
+			addError(context, {
+				message: "Date mismatch",
+				received: target,
+				expected: sub
+			});
+			return false;
+		}
+		return true;
+	}
+	if (target instanceof RegExp && sub instanceof RegExp) {
+		if (target.source !== sub.source || target.flags !== sub.flags) {
+			addError(context, {
+				message: "RegExp mismatch",
+				received: target,
+				expected: sub
+			});
+			return false;
+		}
+		return true;
+	}
+	if (target instanceof Set && sub instanceof Set) {
+		if (sub.size > target.size) {
+			addError(context, {
+				message: "Set too small",
+				received: target,
+				expected: sub
+			});
+			return false;
+		}
+		for (const subValue of sub) {
+			let found = false;
+			for (const targetValue of target) if (partialEqualInternal(targetValue, subValue, {
+				errors: [],
+				path: context.path
+			})) {
+				found = true;
+				break;
+			}
+			if (!found) {
+				addError(context, {
+					message: "Set element not found",
+					received: target,
+					expected: sub
+				});
+				return false;
+			}
+		}
+		return true;
+	}
+	if (target instanceof Map && sub instanceof Map) {
+		if (sub.size > target.size) {
+			addError(context, {
+				message: "Map has less entries than expected",
+				received: `${target.size} entries`,
+				expected: `${sub.size} entries`
+			});
+			return false;
+		}
+		for (const [subKey, subValue] of sub) {
+			let found = false;
+			for (const [targetKey, targetValue] of target) {
+				const tempContextKey = {
+					errors: [],
+					path: context.path
+				};
+				const tempContextValue = {
+					errors: [],
+					path: context.path
+				};
+				if (partialEqualInternal(targetKey, subKey, tempContextKey) && partialEqualInternal(targetValue, subValue, tempContextValue)) {
+					found = true;
+					break;
+				}
+			}
+			if (!found) {
+				addError(context, {
+					message: "Map entry not found",
+					received: target,
+					expected: sub
+				});
+				return false;
+			}
+		}
+		return true;
+	}
+	if (typeof target !== typeof sub) {
+		addError(context, {
+			message: "Value mismatch",
+			received: target,
+			expected: sub
+		});
+		return false;
+	}
+	if (Array.isArray(sub)) {
+		if (!Array.isArray(target)) {
+			addError(context, {
+				message: "Expected array",
+				received: target,
+				expected: sub
+			});
+			return false;
+		}
+		if (target.length < sub.length) {
+			addError(context, {
+				message: `Array too short: expected at least ${sub.length} elements, got ${target.length}`,
+				received: target,
+				expected: sub
+			});
+			return false;
+		}
+		let allMatch = true;
+		for (let i = 0; i < sub.length; i++) {
+			const oldPath = context.path;
+			context.path = [...oldPath, `[${i}]`];
+			const result = partialEqualInternal(target[i], sub[i], context);
+			context.path = oldPath;
+			if (!result) allMatch = false;
+		}
+		return allMatch;
+	}
+	if (typeof sub === "object") {
+		if (typeof target !== "object" || Array.isArray(target)) {
+			addError(context, {
+				message: "Expected object",
+				received: target,
+				expected: sub
+			});
+			return false;
+		}
+		let allMatch = true;
+		const regularKeys = [];
+		const keyMatchers = [];
+		for (const key of Object.keys(sub)) if (isKeyMatcher(key)) {
+			const matcher = parseKeyMatcher(key);
+			if (matcher) keyMatchers.push({
+				key,
+				matcher,
+				value: sub[key]
+			});
+		} else regularKeys.push(key);
+		const explicitlySpecifiedKeys = /* @__PURE__ */ new Set();
+		for (const key of regularKeys) {
+			explicitlySpecifiedKeys.add(key);
+			if (isComparison(sub[key]) && sub[key]["~sc"][0] === "keyNotBePresent") {
+				if (has.call(target, key)) {
+					const oldPath$1 = context.path;
+					context.path = [...oldPath$1, key];
+					addError(context, {
+						message: "Key should not be present",
+						received: target[key]
+					});
+					context.path = oldPath$1;
+					allMatch = false;
+				}
+				continue;
+			}
+			if (!has.call(target, key)) {
+				if (isComparison(sub[key])) {
+					const comparison = sub[key]["~sc"];
+					if (comparison[0] === "any") {
+						if (comparison[1].some((comp) => comp[0] === "keyNotBePresent")) continue;
+					}
+				}
+				const oldPath$1 = context.path;
+				context.path = [...oldPath$1, key];
+				addError(context, {
+					message: "Missing property",
+					expected: sub[key],
+					received: { objectWithKeys: Object.keys(target) }
+				});
+				context.path = oldPath$1;
+				allMatch = false;
+				continue;
+			}
+			const oldPath = context.path;
+			context.path = [...oldPath, key];
+			const result = partialEqualInternal(target[key], sub[key], context);
+			context.path = oldPath;
+			if (!result) allMatch = false;
+		}
+		for (const { matcher, value } of keyMatchers) {
+			let foundMatch = false;
+			const matchedKeys = [];
+			if (matcher.type === "anyOther") {
+				for (const targetKey of Object.keys(target)) if (!explicitlySpecifiedKeys.has(targetKey)) {
+					if (keyMatchesPattern(targetKey, matcher)) {
+						foundMatch = true;
+						matchedKeys.push(targetKey);
+						const oldPath = context.path;
+						context.path = [...oldPath, targetKey];
+						const result = partialEqualInternal(target[targetKey], value, context);
+						context.path = oldPath;
+						if (!result) allMatch = false;
+					}
+				}
+			} else if (matcher.type === "any") {
+				let anyKeyMatched = false;
+				for (const targetKey of Object.keys(target)) if (keyMatchesPattern(targetKey, matcher)) {
+					foundMatch = true;
+					matchedKeys.push(targetKey);
+					explicitlySpecifiedKeys.add(targetKey);
+					const tempContext = {
+						errors: [],
+						path: [...context.path, targetKey]
+					};
+					if (partialEqualInternal(target[targetKey], value, tempContext)) {
+						anyKeyMatched = true;
+						break;
+					}
+				}
+				if (foundMatch && !anyKeyMatched) {
+					addError(context, {
+						message: `No keys matching pattern had the expected value`,
+						received: {
+							keysChecked: matchedKeys,
+							availableKeys: Object.keys(target)
+						}
+					});
+					allMatch = false;
+				}
+			} else for (const targetKey of Object.keys(target)) if (keyMatchesPattern(targetKey, matcher)) {
+				foundMatch = true;
+				matchedKeys.push(targetKey);
+				explicitlySpecifiedKeys.add(targetKey);
+				const oldPath = context.path;
+				context.path = [...oldPath, targetKey];
+				const result = partialEqualInternal(target[targetKey], value, context);
+				context.path = oldPath;
+				if (!result) allMatch = false;
+			}
+			if (!foundMatch) {
+				addError(context, {
+					message: `No keys found matching pattern: ${matcher.type === "anyOther" ? "anyOther (keys not explicitly specified)" : `${matcher.type}${matcher.parameter ? ` (${matcher.parameter})` : ""}`}`,
+					received: {
+						availableKeys: Object.keys(target),
+						explicitKeys: Array.from(explicitlySpecifiedKeys)
+					}
+				});
+				allMatch = false;
+			}
+		}
+		return allMatch;
+	}
+	if (target !== sub) {
+		addError(context, {
+			message: "Value mismatch",
+			received: target,
+			expected: sub
+		});
+		return false;
+	}
+	return true;
+}
+function checkNoExtraKeys(target, partialShape, context, deep) {
+	if (typeof target !== "object" || target === null || Array.isArray(target)) {
+		addError(context, {
+			message: "Expected object for key validation",
+			received: target
+		});
+		return false;
+	}
+	if (!partialEqualInternal(target, partialShape, context)) return false;
+	const allowedKeys = new Set(Object.keys(partialShape));
+	for (const key of Object.keys(target)) if (!allowedKeys.has(key)) {
+		const oldPath = context.path;
+		context.path = [...oldPath, key];
+		addError(context, {
+			message: `Extra key "${key}" should not be present`,
+			received: target[key]
+		});
+		context.path = oldPath;
+		return false;
+	}
+	if (deep) {
+		for (const key of Object.keys(partialShape)) if (typeof partialShape[key] === "object" && partialShape[key] !== null && !Array.isArray(partialShape[key]) && !isComparison(partialShape[key])) {
+			const oldPath = context.path;
+			context.path = [...oldPath, key];
+			const result = checkNoExtraKeys(target[key], partialShape[key], context, true);
+			context.path = oldPath;
+			if (!result) return false;
+		}
+	}
+	return true;
+}
+function checkNoExtraDefinedKeys(target, partialShape, context, deep) {
+	if (typeof target !== "object" || target === null || Array.isArray(target)) {
+		addError(context, {
+			message: "Expected object for key validation",
+			received: target
+		});
+		return false;
+	}
+	if (!partialEqualInternal(target, partialShape, context)) return false;
+	const allowedKeys = new Set(Object.keys(partialShape));
+	for (const key of Object.keys(target)) if (!allowedKeys.has(key) && target[key] !== void 0) {
+		const oldPath = context.path;
+		context.path = [...oldPath, key];
+		addError(context, {
+			message: `Extra defined key "${key}" should not be present`,
+			received: target[key]
+		});
+		context.path = oldPath;
+		return false;
+	}
+	if (deep) {
+		for (const key of Object.keys(partialShape)) if (typeof partialShape[key] === "object" && partialShape[key] !== null && !Array.isArray(partialShape[key]) && !isComparison(partialShape[key])) {
+			const oldPath = context.path;
+			context.path = [...oldPath, key];
+			const result = checkNoExtraDefinedKeys(target[key], partialShape[key], context, true);
+			context.path = oldPath;
+			if (!result) return false;
+		}
+	}
+	return true;
+}
+function partialEqual(target, sub, returnErrors) {
+	const context = {
+		errors: [],
+		path: []
+	};
+	const result = partialEqualInternal(target, sub, context);
+	if (returnErrors) return result ? ok(void 0) : err(context.errors);
+	return result;
+}
+
+//#endregion
+export { match, partialEqual };