@ls-stack/utils 3.48.0 → 3.49.0

package/dist/partialEqual.js

@@ -1,6 +1,7 @@
 import {
-  deepEqual
-} from "./chunk-JQFUKJU5.js";
+  exhaustiveCheck
+} from "./chunk-C2SVCIWE.js";
+import "./chunk-JF2MDHOJ.js";
 
 // src/partialEqual.ts
 import { err, ok } from "t-result";
@@ -42,8 +43,24 @@ var match = {
   partialEqual: (value) => createComparison(["partialEqual", value]),
   custom: (isEqual) => createComparison(["custom", isEqual]),
   keyNotBePresent: createComparison(["keyNotBePresent", null]),
-  any: (...comparisons) => createComparison(["any", comparisons.map((c) => c["~sc"])]),
-  all: (...comparisons) => createComparison(["all", comparisons.map((c) => c["~sc"])]),
+  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];
+    })
+  ]),
   not: {
     hasType: {
       string: createComparison(["not", ["hasType", "string"]]),
@@ -74,741 +91,640 @@ var match = {
     equal: (value) => createComparison(["not", ["deepEqual", value]]),
     partialEqual: (value) => createComparison(["not", ["partialEqual", value]]),
     custom: (value) => createComparison(["not", ["custom", value]]),
-    any: (...comparisons) => createComparison(["not", ["any", comparisons.map((c) => c["~sc"])]]),
-    all: (...comparisons) => createComparison(["not", ["all", comparisons.map((c) => c["~sc"])]]),
+    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]])
   }
 };
-function find(iter, tar) {
-  for (const key of iter.keys()) {
-    if (partialEqual(key, tar)) return key;
-  }
-}
-function executeComparisonWithKeyContext(target, comp, keyExists) {
-  const [type, value] = comp;
-  if (type === "keyNotBePresent") {
-    return !keyExists;
-  }
-  if (type === "any") {
-    for (const childComp of value) {
-      if (executeComparisonWithKeyContext(target, childComp, keyExists)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  if (type === "not") {
-    return !executeComparisonWithKeyContext(target, value, keyExists);
-  }
-  return executeComparison(target, comp);
+function isComparison(value) {
+  return value && typeof value === "object" && "~sc" in value;
 }
-function executeComparison(target, comparison) {
+function executeComparison(target, comparison, context) {
   const [type, value] = comparison;
   switch (type) {
-    case "hasType":
-      switch (value) {
-        case "string":
-          return typeof target === "string";
-        case "number":
-          return typeof target === "number";
-        case "boolean":
-          return typeof target === "boolean";
-        case "function":
-          return typeof target === "function";
-        case "array":
-          return Array.isArray(target);
-        case "object":
-          return typeof target === "object" && target !== null && !Array.isArray(target);
-        default:
-          return false;
-      }
-    case "isInstanceOf":
-      return target instanceof value;
     case "strStartsWith":
-      return typeof target === "string" && target.startsWith(value);
-    case "strEndsWith":
-      return typeof target === "string" && target.endsWith(value);
-    case "strContains":
-      return typeof target === "string" && target.includes(value);
-    case "strMatchesRegex":
-      return typeof target === "string" && value.test(target);
-    case "numIsGreaterThan":
-      return typeof target === "number" && target > value;
-    case "numIsGreaterThanOrEqual":
-      return typeof target === "number" && target >= value;
-    case "numIsLessThan":
-      return typeof target === "number" && target < value;
-    case "numIsLessThanOrEqual":
-      return typeof target === "number" && target <= value;
-    case "numIsInRange":
-      return typeof target === "number" && target >= value[0] && target <= value[1];
-    case "jsonStringHasPartial":
-      if (typeof target !== "string") return false;
-      try {
-        const parsed = JSON.parse(target);
-        return partialEqual(parsed, value);
-      } catch {
-        return false;
-      }
-    case "deepEqual":
-      return deepEqual(target, value);
-    case "partialEqual":
-      return partialEqual(target, value);
-    case "custom":
-      return value(target);
-    case "keyNotBePresent":
-      return false;
-    case "any":
-      for (const comp of value) {
-        if (executeComparison(target, comp)) {
-          return true;
-        }
-      }
-      return false;
-    case "all":
-      for (const comp of value) {
-        if (!executeComparison(target, comp)) {
-          return false;
-        }
-      }
-      return true;
-    case "not":
-      return !executeComparison(target, value);
-    case "withNoExtraKeys":
-      if (typeof target !== "object" || target === null || Array.isArray(target)) {
+      if (typeof target !== "string") {
+        addError(context, {
+          message: `Expected string starting with "${value}"`,
+          received: target
+        });
         return false;
       }
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      if (!target.startsWith(value)) {
+        addError(context, {
+          message: `Expected string starting with "${value}"`,
+          received: target
+        });
         return false;
       }
-      for (const key in target) {
-        if (has.call(target, key) && !has.call(value, key)) {
-          return false;
-        }
-      }
-      for (const key in value) {
-        if (has.call(value, key)) {
-          if (!has.call(target, key)) {
-            return false;
-          }
-          if (!partialEqual(target[key], value[key])) {
-            return false;
-          }
-        }
-      }
       return true;
-    case "withDeepNoExtraKeys":
-      if (typeof target !== "object" || target === null || Array.isArray(target)) {
+    case "strEndsWith":
+      if (typeof target !== "string") {
+        addError(context, {
+          message: `Expected string ending with "${value}"`,
+          received: target
+        });
         return false;
       }
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      if (!target.endsWith(value)) {
+        addError(context, {
+          message: `Expected string ending with "${value}"`,
+          received: target
+        });
         return false;
       }
-      for (const key in target) {
-        if (has.call(target, key) && !has.call(value, key)) {
-          return false;
-        }
-      }
-      for (const key in value) {
-        if (has.call(value, key)) {
-          if (!has.call(target, key)) {
-            return false;
-          }
-          const targetValue = target[key];
-          const partialValue = value[key];
-          if (partialValue && typeof partialValue === "object" && "~sc" in partialValue && partialValue["~sc"][0] === "withDeepNoExtraKeys") {
-            if (!executeComparison(targetValue, partialValue["~sc"])) {
-              return false;
-            }
-          } else if (partialValue && typeof partialValue === "object" && !Array.isArray(partialValue) && partialValue.constructor === Object && targetValue && typeof targetValue === "object" && !Array.isArray(targetValue) && targetValue.constructor === Object) {
-            if (!executeComparison(targetValue, [
-              "withDeepNoExtraKeys",
-              partialValue
-            ])) {
-              return false;
-            }
-          } else {
-            if (!partialEqual(targetValue, partialValue)) {
-              return false;
-            }
-          }
-        }
-      }
       return true;
-    case "noExtraDefinedKeys":
-      if (typeof target !== "object" || target === null || Array.isArray(target)) {
+    case "strContains":
+      if (typeof target !== "string") {
+        addError(context, {
+          message: `Expected string containing "${value}"`,
+          received: target
+        });
         return false;
       }
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      if (!target.includes(value)) {
+        addError(context, {
+          message: `Expected string containing "${value}"`,
+          received: target
+        });
         return false;
       }
-      for (const key in target) {
-        if (has.call(target, key) && target[key] !== void 0 && !has.call(value, key)) {
-          return false;
-        }
-      }
-      for (const key in value) {
-        if (has.call(value, key)) {
-          if (!has.call(target, key)) {
-            return false;
-          }
-          if (!partialEqual(target[key], value[key])) {
-            return false;
-          }
-        }
-      }
       return true;
-    case "deepNoExtraDefinedKeys":
-      if (typeof target !== "object" || target === null || Array.isArray(target)) {
+    case "strMatchesRegex":
+      if (typeof target !== "string") {
+        addError(context, {
+          message: `Expected string matching regex ${value}`,
+          received: target
+        });
         return false;
       }
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      if (!value.test(target)) {
+        addError(context, {
+          message: `Expected string matching regex ${value}`,
+          received: target
+        });
         return false;
       }
-      for (const key in target) {
-        if (has.call(target, key) && target[key] !== void 0 && !has.call(value, key)) {
-          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;
       }
-      for (const key in value) {
-        if (has.call(value, key)) {
-          if (!has.call(target, key)) {
-            return false;
-          }
-          const targetValue = target[key];
-          const partialValue = value[key];
-          if (partialValue && typeof partialValue === "object" && "~sc" in partialValue && partialValue["~sc"][0] === "deepNoExtraDefinedKeys") {
-            if (!executeComparison(targetValue, partialValue["~sc"])) {
-              return false;
-            }
-          } else if (partialValue && typeof partialValue === "object" && !Array.isArray(partialValue) && partialValue.constructor === Object && targetValue && typeof targetValue === "object" && !Array.isArray(targetValue) && targetValue.constructor === Object) {
-            if (!executeComparison(targetValue, [
-              "deepNoExtraDefinedKeys",
-              partialValue
-            ])) {
-              return false;
-            }
-          } else {
-            if (!partialEqual(targetValue, partialValue)) {
-              return false;
-            }
-          }
-        }
+      if (actualType !== value) {
+        addError(context, {
+          message: `Expected type ${value}`,
+          received: target
+        });
+        return false;
       }
       return true;
-    default:
-      return false;
-  }
-}
-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) {
-      result += `.${segment}`;
     }
-  }
-  return result;
-}
-function addError(context, message, received, expected) {
-  const error = {
-    path: formatPath(context.path),
-    message,
-    received
-  };
-  if (expected !== void 0) {
-    error.expected = expected;
-  }
-  context.errors.push(error);
-}
-function executeComparisonWithErrorCollection(target, comparison, context) {
-  const [type, value] = comparison;
-  switch (type) {
-    case "hasType":
-      switch (value) {
-        case "string":
-          if (typeof target !== "string") {
-            addError(context, `Expected type string`, target);
-          }
-          break;
-        case "number":
-          if (typeof target !== "number") {
-            addError(context, `Expected type number`, target);
-          }
-          break;
-        case "boolean":
-          if (typeof target !== "boolean") {
-            addError(context, `Expected type boolean`, target);
-          }
-          break;
-        case "function":
-          if (typeof target !== "function") {
-            addError(context, `Expected type function`, target);
-          }
-          break;
-        case "array":
-          if (!Array.isArray(target)) {
-            addError(context, `Expected array`, target);
-          }
-          break;
-        case "object":
-          if (typeof target !== "object" || target === null || Array.isArray(target)) {
-            addError(context, `Expected object`, target);
-          }
-          break;
-      }
-      break;
-    case "isInstanceOf":
-      if (!(target instanceof value)) {
-        addError(
-          context,
-          `Expected instance of ${value.name}`,
-          target
-        );
-      }
-      break;
-    case "strStartsWith":
-      if (typeof target !== "string" || !target.startsWith(value)) {
-        addError(
-          context,
-          `Expected string starting with "${value}"`,
-          target
-        );
-      }
-      break;
-    case "strEndsWith":
-      if (typeof target !== "string" || !target.endsWith(value)) {
-        addError(
-          context,
-          `Expected string ending with "${value}"`,
-          target
-        );
-      }
-      break;
-    case "strContains":
-      if (typeof target !== "string" || !target.includes(value)) {
-        addError(
-          context,
-          `Expected string containing "${value}"`,
-          target
-        );
-      }
-      break;
-    case "strMatchesRegex":
-      if (typeof target !== "string" || !value.test(target)) {
-        addError(
-          context,
-          `Expected string matching regex ${value}`,
-          target
-        );
+    case "deepEqual":
+      if (!deepEqual(target, value)) {
+        addError(context, {
+          message: "Values are not deeply equal",
+          received: target,
+          expected: value
+        });
+        return false;
       }
-      break;
+      return true;
     case "numIsGreaterThan":
       if (typeof target !== "number" || target <= value) {
-        addError(
-          context,
-          `Expected number greater than ${value}`,
-          target
-        );
+        addError(context, {
+          message: `Expected number greater than ${value}`,
+          received: target
+        });
+        return false;
       }
-      break;
+      return true;
     case "numIsGreaterThanOrEqual":
       if (typeof target !== "number" || target < value) {
-        addError(
-          context,
-          `Expected number greater than or equal to ${value}`,
-          target
-        );
+        addError(context, {
+          message: `Expected number greater than or equal to ${value}`,
+          received: target
+        });
+        return false;
       }
-      break;
+      return true;
     case "numIsLessThan":
       if (typeof target !== "number" || target >= value) {
-        addError(
-          context,
-          `Expected number less than ${value}`,
-          target
-        );
+        addError(context, {
+          message: `Expected number less than ${value}`,
+          received: target
+        });
+        return false;
       }
-      break;
+      return true;
     case "numIsLessThanOrEqual":
       if (typeof target !== "number" || target > value) {
-        addError(
-          context,
-          `Expected number less than or equal to ${value}`,
-          target
-        );
+        addError(context, {
+          message: `Expected number less than or equal to ${value}`,
+          received: target
+        });
+        return false;
       }
-      break;
+      return true;
     case "numIsInRange":
       if (typeof target !== "number" || target < value[0] || target > value[1]) {
-        addError(
-          context,
-          `Expected number in range [${value[0]}, ${value[1]}]`,
-          target
-        );
+        addError(context, {
+          message: `Expected number in range [${value[0]}, ${value[1]}]`,
+          received: target
+        });
+        return false;
       }
-      break;
+      return true;
     case "jsonStringHasPartial":
       if (typeof target !== "string") {
-        addError(context, `Expected JSON string`, target);
-      } else {
-        try {
-          const parsed = JSON.parse(target);
-          partialEqualWithErrorCollection(parsed, value, context);
-        } catch {
-          addError(
-            context,
-            `Expected valid JSON string`,
-            target
-          );
-        }
+        addError(context, {
+          message: "Expected JSON string",
+          received: target
+        });
+        return false;
       }
-      break;
-    case "deepEqual":
-      if (!deepEqual(target, value)) {
-        addError(context, `Expected deep equal`, target, value);
+      try {
+        const parsed = JSON.parse(target);
+        if (!partialEqualInternal(parsed, value, context)) {
+          return false;
+        }
+      } catch {
+        addError(context, {
+          message: "Expected valid JSON string",
+          received: target
+        });
+        return false;
       }
-      break;
+      return true;
     case "partialEqual":
-      partialEqualWithErrorCollection(target, value, context);
-      break;
-    case "custom":
-      if (!value(target)) {
-        addError(context, `Custom validation failed`, target, "valid value");
+      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;
       }
-      break;
+      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, `Key should not be present`, target);
-      break;
+      addError(context, {
+        message: "This property should not be present",
+        received: target
+      });
+      return false;
+    case "not": {
+      const tempContext = {
+        errors: [],
+        path: context.path
+      };
+      const result = executeComparison(target, value, tempContext);
+      if (result) {
+        addError(context, {
+          message: "Expected negated condition to fail",
+          received: target,
+          expected: { "not match": value }
+        });
+        return false;
+      }
+      return true;
+    }
     case "any": {
-      for (const comp of value) {
-        const subContext = {
+      for (const subComparison of value) {
+        const anyTempContext = {
           errors: [],
-          path: [...context.path]
+          path: context.path
         };
-        executeComparisonWithErrorCollection(target, comp, subContext);
-        if (subContext.errors.length === 0) {
-          return;
+        if (executeComparison(target, subComparison, anyTempContext)) {
+          return true;
         }
       }
-      addError(
-        context,
-        `None of the alternative comparisons matched`,
-        target
-      );
-      break;
+      addError(context, {
+        message: "None of the alternative comparisons matched",
+        received: target,
+        expected: {
+          matchAny: value
+        }
+      });
+      return false;
     }
-    case "all":
-      for (const comp of value) {
-        executeComparisonWithErrorCollection(target, comp, context);
-      }
-      break;
-    case "not": {
-      const subContext = {
-        errors: [],
-        path: [...context.path]
-      };
-      executeComparisonWithErrorCollection(target, value, subContext);
-      if (subContext.errors.length === 0) {
-        addError(
-          context,
-          `Expected negated condition to fail`,
-          target
-        );
+    case "all": {
+      let allMatch = true;
+      for (const subComparison of value) {
+        if (!executeComparison(target, subComparison, context)) {
+          allMatch = false;
+        }
       }
-      break;
+      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":
-      addError(
-        context,
-        `Complex validation not supported in error collection mode yet`,
-        target
-      );
-      break;
+      return checkNoExtraDefinedKeys(target, value, context, true);
+    default:
+      throw exhaustiveCheck(type);
   }
 }
-function executeComparisonWithKeyContextAndErrorCollection(target, comp, keyExists, context) {
-  const [type, value] = comp;
-  if (type === "keyNotBePresent") {
-    if (keyExists) {
-      addError(context, `Key should not be present`, target);
+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;
   }
-  if (type === "any") {
-    for (const childComp of value) {
-      const subContext = {
-        errors: [],
-        path: [...context.path]
-      };
-      executeComparisonWithKeyContextAndErrorCollection(
-        target,
-        childComp,
-        keyExists,
-        subContext
-      );
-      if (subContext.errors.length === 0) {
-        return;
-      }
+  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;
     }
-    addError(
-      context,
-      `None of the alternative comparisons matched`,
-      target,
-      "any alternative match"
-    );
-    return;
+    return true;
   }
-  if (type === "not") {
-    const subContext = {
-      errors: [],
-      path: [...context.path]
-    };
-    executeComparisonWithKeyContextAndErrorCollection(
-      target,
-      value,
-      keyExists,
-      subContext
-    );
-    if (subContext.errors.length === 0) {
-      addError(
-        context,
-        `Expected negated condition to fail`,
-        target,
-        "negated condition"
-      );
+  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;
+    return true;
   }
-  executeComparisonWithErrorCollection(target, comp, context);
+  return false;
 }
-function partialEqualWithErrorCollection(target, sub, context) {
-  if (sub === target) return;
-  if (sub && typeof sub === "object" && "~sc" in sub) {
-    executeComparisonWithErrorCollection(target, sub["~sc"], context);
-    return;
+function partialEqualInternal(target, sub, context) {
+  if (isComparison(sub)) {
+    return executeComparison(target, sub["~sc"], context);
   }
-  if (sub && target && sub.constructor === target.constructor) {
-    const ctor = sub.constructor;
-    if (ctor === Date) {
-      if (sub.getTime() !== target.getTime()) {
-        addError(context, `Date mismatch`, target, sub);
-      }
-      return;
+  if (isComparison(sub) && sub["~sc"][0] === "keyNotBePresent") {
+    addError(context, {
+      message: "Key should not be present",
+      received: target,
+      expected: "key not present"
+    });
+    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;
     }
-    if (ctor === RegExp) {
-      if (sub.toString() !== target.toString()) {
-        addError(context, `RegExp mismatch`, target, sub);
-      }
-      return;
+    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;
     }
-    if (ctor === Array) {
-      if (sub.length > target.length) {
-        addError(
-          context,
-          `Array too short: expected at least ${sub.length} elements, got ${target.length}`,
-          target,
-          sub
-        );
-        return;
-      }
-      for (let i = 0; i < sub.length; i++) {
-        context.path.push(`[${i}]`);
-        partialEqualWithErrorCollection(target[i], sub[i], context);
-        context.path.pop();
-      }
-      return;
+    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;
     }
-    if (ctor === Set) {
-      if (sub.size > target.size) {
-        addError(
-          context,
-          `Set too small: expected at least ${sub.size} elements, got ${target.size}`,
-          target,
-          sub
-        );
-        return;
-      }
-      for (const value of sub) {
-        let found = false;
-        if (value && typeof value === "object") {
-          found = !!find(target, value);
-        } else {
-          found = target.has(value);
-        }
-        if (!found) {
-          addError(context, `Set missing value`, target, value);
+    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) {
+        const tempContext = {
+          errors: [],
+          path: context.path
+        };
+        if (partialEqualInternal(targetValue, subValue, tempContext)) {
+          found = true;
+          break;
         }
       }
-      return;
+      if (!found) {
+        addError(context, {
+          message: "Set element not found",
+          received: target,
+          expected: sub
+        });
+        return false;
+      }
     }
-    if (ctor === Map) {
-      if (sub.size > target.size) {
-        addError(
-          context,
-          `Map too small: expected at least ${sub.size} entries, got ${target.size}`,
-          target,
-          sub
-        );
-        return;
-      }
-      for (const [key, value] of sub) {
-        let targetKey = key;
-        if (key && typeof key === "object") {
-          targetKey = find(target, key);
-          if (!targetKey) {
-            addError(context, `Map missing key`, target, key);
-            continue;
-          }
-        }
-        if (!target.has(targetKey)) {
-          addError(context, `Map missing key`, target, key);
-          continue;
+    return true;
+  }
+  if (target instanceof Map && sub instanceof Map) {
+    if (sub.size > target.size) {
+      addError(context, {
+        message: "Map too small",
+        received: target,
+        expected: sub
+      });
+      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;
         }
-        context.path.push(`[${key}]`);
-        partialEqualWithErrorCollection(target.get(targetKey), value, context);
-        context.path.pop();
       }
-      return;
+      if (!found) {
+        addError(context, {
+          message: "Map entry not found",
+          received: target,
+          expected: sub
+        });
+        return false;
+      }
     }
-    if (!ctor || typeof sub === "object") {
-      for (const key in sub) {
-        if (has.call(sub, key)) {
-          const subValue = sub[key];
-          context.path.push(key);
-          if (subValue && typeof subValue === "object" && "~sc" in subValue && subValue["~sc"][0] === "keyNotBePresent") {
-            if (has.call(target, key)) {
-              addError(
-                context,
-                `Key should not be present`,
-                target[key],
-                "key not present"
-              );
-            }
-          } else if (subValue && typeof subValue === "object" && "~sc" in subValue && subValue["~sc"][0] === "any") {
-            const targetHasKey = has.call(target, key);
-            const targetValue = targetHasKey ? target[key] : void 0;
-            executeComparisonWithKeyContextAndErrorCollection(
-              targetValue,
-              subValue["~sc"],
-              targetHasKey,
-              context
+    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;
+    for (const key of Object.keys(sub)) {
+      if (isComparison(sub[key]) && sub[key]["~sc"][0] === "keyNotBePresent") {
+        if (has.call(target, key)) {
+          const oldPath2 = context.path;
+          context.path = [...oldPath2, key];
+          addError(context, {
+            message: "Key should not be present",
+            received: target[key],
+            expected: "key not present"
+          });
+          context.path = oldPath2;
+          allMatch = false;
+        }
+        continue;
+      }
+      if (!has.call(target, key)) {
+        if (isComparison(sub[key])) {
+          const comparison = sub[key]["~sc"];
+          if (comparison[0] === "any") {
+            const anyComparisons = comparison[1];
+            const hasKeyNotBePresent = anyComparisons.some(
+              (comp) => comp[0] === "keyNotBePresent"
             );
-          } else {
-            if (!has.call(target, key)) {
-              addError(context, `Missing property`, void 0, subValue);
-            } else {
-              partialEqualWithErrorCollection(target[key], subValue, context);
+            if (hasKeyNotBePresent) {
+              continue;
             }
           }
-          context.path.pop();
         }
-      }
-      return;
+        const oldPath2 = context.path;
+        context.path = [...oldPath2, key];
+        addError(context, {
+          message: "Missing property",
+          received: void 0,
+          expected: sub[key]
+        });
+        context.path = oldPath2;
+        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;
     }
+    return allMatch;
   }
-  if (sub !== sub && target !== target) {
-    return;
+  if (target !== sub) {
+    addError(context, {
+      message: "Value mismatch",
+      received: target,
+      expected: sub
+    });
+    return false;
   }
-  addError(context, `Value mismatch`, target, sub);
+  return true;
 }
-function partialEqual(target, sub, returnErrors) {
-  if (returnErrors === true) {
-    const context = {
-      errors: [],
-      path: []
-    };
-    partialEqualWithErrorCollection(target, sub, context);
-    if (context.errors.length === 0) {
-      return ok(void 0);
-    } else {
-      return err(context.errors);
-    }
+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 (sub === target) return true;
-  if (sub && typeof sub === "object" && "~sc" in sub) {
-    return executeComparison(target, sub["~sc"]);
+  if (!partialEqualInternal(target, partialShape, context)) {
+    return false;
   }
-  if (sub && target && sub.constructor === target.constructor) {
-    const ctor = sub.constructor;
-    if (ctor === Date) {
-      return sub.getTime() === target.getTime();
-    }
-    if (ctor === RegExp) {
-      return sub.toString() === target.toString();
-    }
-    if (ctor === Array) {
-      if (sub.length > target.length) return false;
-      for (let i = 0; i < sub.length; i++) {
-        if (!partialEqual(target[i], sub[i])) return false;
-      }
-      return true;
+  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}" not expected`
+      });
+      context.path = oldPath;
+      return false;
     }
-    if (ctor === Set) {
-      if (sub.size > target.size) return false;
-      for (const value of sub) {
-        let found = false;
-        if (value && typeof value === "object") {
-          found = !!find(target, value);
-        } else {
-          found = target.has(value);
-        }
-        if (!found) 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;
     }
-    if (ctor === Map) {
-      if (sub.size > target.size) return false;
-      for (const [key, value] of sub) {
-        let targetKey = key;
-        if (key && typeof key === "object") {
-          targetKey = find(target, key);
-          if (!targetKey) return false;
-        }
-        if (!target.has(targetKey) || !partialEqual(target.get(targetKey), value)) {
-          return false;
-        }
-      }
-      return true;
+  }
+  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}" not expected`
+      });
+      context.path = oldPath;
+      return false;
     }
-    if (!ctor || typeof sub === "object") {
-      for (const key in sub) {
-        if (has.call(sub, key)) {
-          const subValue = sub[key];
-          if (subValue && typeof subValue === "object" && "~sc" in subValue && subValue["~sc"][0] === "keyNotBePresent") {
-            if (has.call(target, key)) {
-              return false;
-            }
-          } else if (subValue && typeof subValue === "object" && "~sc" in subValue && subValue["~sc"][0] === "any") {
-            const targetHasKey = has.call(target, key);
-            const targetValue = targetHasKey ? target[key] : void 0;
-            if (!executeComparisonWithKeyContext(
-              targetValue,
-              subValue["~sc"],
-              targetHasKey
-            )) {
-              return false;
-            }
-          } else {
-            if (!has.call(target, key) || !partialEqual(target[key], subValue)) {
-              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;
     }
   }
-  return sub !== sub && target !== target;
+  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;
 }
 export {
   match,