@ls-stack/utils 3.47.0 → 3.49.0

package/dist/partialEqual.js

@@ -1,8 +1,10 @@
 import {
-  deepEqual
-} from "./chunk-JQFUKJU5.js";
+  exhaustiveCheck
+} from "./chunk-C2SVCIWE.js";
+import "./chunk-JF2MDHOJ.js";
 
 // src/partialEqual.ts
+import { err, ok } from "t-result";
 var has = Object.prototype.hasOwnProperty;
 function createComparison(type) {
   return { "~sc": type };
@@ -41,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"]]),
@@ -73,311 +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);
+      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":
-      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 {
+      if (typeof target !== "string") {
+        addError(context, {
+          message: `Expected string ending with "${value}"`,
+          received: target
+        });
         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;
-        }
+      if (!target.endsWith(value)) {
+        addError(context, {
+          message: `Expected string ending with "${value}"`,
+          received: target
+        });
+        return false;
       }
-      return false;
-    case "all":
-      for (const comp of value) {
-        if (!executeComparison(target, comp)) {
-          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 "not":
-      return !executeComparison(target, value);
-    case "withNoExtraKeys":
-      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) && !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;
-          }
-          if (!partialEqual(target[key], value[key])) {
-            return false;
-          }
-        }
+      if (actualType !== value) {
+        addError(context, {
+          message: `Expected type ${value}`,
+          received: target
+        });
+        return false;
       }
       return true;
-    case "withDeepNoExtraKeys":
-      if (typeof target !== "object" || target === null || Array.isArray(target)) {
+    }
+    case "deepEqual":
+      if (!deepEqual(target, value)) {
+        addError(context, {
+          message: "Values are not deeply equal",
+          received: target,
+          expected: value
+        });
         return false;
       }
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return true;
+    case "numIsGreaterThan":
+      if (typeof target !== "number" || target <= value) {
+        addError(context, {
+          message: `Expected number greater than ${value}`,
+          received: target
+        });
         return false;
       }
-      for (const key in target) {
-        if (has.call(target, key) && !has.call(value, key)) {
-          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;
       }
-      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 "numIsLessThan":
+      if (typeof target !== "number" || target >= value) {
+        addError(context, {
+          message: `Expected number less than ${value}`,
+          received: target
+        });
+        return false;
       }
       return true;
-    case "noExtraDefinedKeys":
-      if (typeof target !== "object" || target === null || Array.isArray(target)) {
+    case "numIsLessThanOrEqual":
+      if (typeof target !== "number" || target > value) {
+        addError(context, {
+          message: `Expected number less than or equal to ${value}`,
+          received: target
+        });
         return false;
       }
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      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;
       }
-      for (const key in target) {
-        if (has.call(target, key) && target[key] !== void 0 && !has.call(value, key)) {
+      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;
       }
-      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 "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 "deepNoExtraDefinedKeys":
-      if (typeof target !== "object" || target === null || Array.isArray(target)) {
+    }
+    case "isInstanceOf":
+      if (!(target instanceof value)) {
+        addError(context, {
+          message: `Expected instance of ${value.name}`,
+          received: target
+        });
         return false;
       }
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return true;
+    case "keyNotBePresent":
+      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;
       }
-      for (const key in target) {
-        if (has.call(target, key) && target[key] !== void 0 && !has.call(value, key)) {
-          return false;
+      return true;
+    }
+    case "any": {
+      for (const subComparison of value) {
+        const anyTempContext = {
+          errors: [],
+          path: context.path
+        };
+        if (executeComparison(target, subComparison, anyTempContext)) {
+          return true;
         }
       }
-      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;
-            }
-          }
+      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 true;
+      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);
     default:
-      return false;
+      throw exhaustiveCheck(type);
   }
 }
-function partialEqual(target, sub) {
-  if (sub === target) return true;
-  if (sub && typeof sub === "object" && "~sc" in sub) {
-    return executeComparison(target, sub["~sc"]);
+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;
+      }
+    }
   }
-  if (sub && target && sub.constructor === target.constructor) {
-    const ctor = sub.constructor;
-    if (ctor === Date) {
-      return sub.getTime() === target.getTime();
+  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;
     }
-    if (ctor === RegExp) {
-      return sub.toString() === target.toString();
+    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;
     }
-    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;
+    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: "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 === 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);
+    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) {
+        const tempContext = {
+          errors: [],
+          path: context.path
+        };
+        if (partialEqualInternal(targetValue, subValue, tempContext)) {
+          found = true;
+          break;
         }
-        if (!found) return false;
       }
-      return true;
+      if (!found) {
+        addError(context, {
+          message: "Set element not found",
+          received: target,
+          expected: sub
+        });
+        return false;
+      }
     }
-    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;
+  }
+  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;
         }
       }
-      return true;
+      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];
-          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;
+    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"
+            );
+            if (hasKeyNotBePresent) {
+              continue;
             }
           }
         }
+        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;
       }
-      return true;
+      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 (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}" not expected`
+      });
+      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}" not expected`
+      });
+      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 sub !== sub && target !== target;
+  return result;
 }
 export {
   match,