@ls-stack/utils 3.63.0 → 3.66.0

package/dist/partialEqual.js

@@ -1,1168 +0,0 @@
-import {
-  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 };
-}
-var 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:";
-  const suffix = "$";
-  if (!key.endsWith(suffix)) return null;
-  const content = key.slice(prefix.length, -suffix.length);
-  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("startingWith:".length), negated };
-  }
-  if (content.startsWith("endingWith:")) {
-    return { type: "endingWith", parameter: content.slice("endingWith:".length), negated };
-  }
-  if (content.startsWith("contains:")) {
-    return { type: "contains", parameter: content.slice("contains:".length), negated };
-  }
-  if (content.startsWith("matchesRegex:")) {
-    const regexStr = content.slice("matchesRegex:".length);
-    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 {
-        const parsed = JSON.parse(target);
-        if (!partialEqualInternal(parsed, 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": {
-      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 subComparison of value) {
-        const anyTempContext = {
-          errors: [],
-          path: context.path
-        };
-        if (executeComparison(target, subComparison, anyTempContext)) {
-          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) {
-          const tempContext = {
-            errors: [],
-            path: context.path
-          };
-          if (partialEqualInternal(targetElement, element, tempContext)) {
-            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) {
-        const tempContext = {
-          errors: [],
-          path: context.path
-        };
-        if (partialEqualInternal(targetElement, value, tempContext)) {
-          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) {
-        const tempContext = {
-          errors: [],
-          path: context.path
-        };
-        if (partialEqualInternal(targetValue, subValue, tempContext)) {
-          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 oldPath2 = context.path;
-          context.path = [...oldPath2, key];
-          addError(context, {
-            message: "Key should not be present",
-            received: target[key]
-          });
-          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",
-          expected: sub[key],
-          received: { objectWithKeys: Object.keys(target) }
-        });
-        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;
-    }
-    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)) {
-            const matches = keyMatchesPattern(targetKey, matcher);
-            if (matches) {
-              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]
-            };
-            const result = partialEqualInternal(target[targetKey], value, tempContext);
-            if (result) {
-              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) {
-        const patternDescription = matcher.type === "anyOther" ? "anyOther (keys not explicitly specified)" : `${matcher.type}${matcher.parameter ? ` (${matcher.parameter})` : ""}`;
-        addError(context, {
-          message: `No keys found matching pattern: ${patternDescription}`,
-          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;
-}
-export {
-  match,
-  partialEqual
-};