@inf-monkeys-tech/monkeys 1.1.23 → 1.1.24

package/lib/esm/runtime/index.mjs

@@ -25179,6 +25179,39 @@ var schemasCannotOverlap = (left, right) => {
   const property = (schema2, key) => schema2.properties?.[key] ?? (schema2.patternProperties ? true : schema2.additionalProperties ?? true);
   return [...a.required ?? [], ...b.required ?? []].some((key) => schemasCannotOverlap(property(a, key), property(b, key)));
 };
+var numericBound = (schema2, direction) => {
+  const inclusiveKey = direction === "lower" ? "minimum" : "maximum";
+  const exclusiveKey = direction === "lower" ? "exclusiveMinimum" : "exclusiveMaximum";
+  const inclusiveValue = schema2[inclusiveKey];
+  const exclusiveValue = schema2[exclusiveKey];
+  const candidates = [];
+  if (inclusiveValue !== void 0) {
+    if (typeof inclusiveValue !== "number" || !Number.isFinite(inclusiveValue)) return null;
+    candidates.push({ value: inclusiveValue, inclusive: true });
+  }
+  if (typeof exclusiveValue === "number") {
+    if (!Number.isFinite(exclusiveValue)) return null;
+    candidates.push({ value: exclusiveValue, inclusive: false });
+  } else if (exclusiveValue === true) {
+    if (typeof inclusiveValue !== "number" || !Number.isFinite(inclusiveValue)) return null;
+    candidates.push({ value: inclusiveValue, inclusive: false });
+  } else if (exclusiveValue !== void 0 && exclusiveValue !== false) {
+    return null;
+  }
+  if (!candidates.length) return void 0;
+  const compare = direction === "lower" ? Math.max : Math.min;
+  const value = compare(...candidates.map((candidate) => candidate.value));
+  return { value, inclusive: candidates.filter((candidate) => candidate.value === value).every((candidate) => candidate.inclusive) };
+};
+var boundAcceptsPrevious = (previous, next, direction) => {
+  if (previous === null || next === null) return false;
+  if (!next) return true;
+  if (!previous) return false;
+  if (direction === "lower" && previous.value < next.value) return false;
+  if (direction === "upper" && previous.value > next.value) return false;
+  return previous.value !== next.value || !previous.inclusive || next.inclusive;
+};
+var numericRangesAcceptPrevious = (previous, next) => boundAcceptsPrevious(numericBound(previous, "lower"), numericBound(next, "lower"), "lower") && boundAcceptsPrevious(numericBound(previous, "upper"), numericBound(next, "upper"), "upper");
 var acceptsPreviousSchema = (previous, next) => {
   if (canonicalContentHash(previous) === canonicalContentHash(next) || next === true) return true;
   if (previous === false) return true;
@@ -25197,6 +25230,10 @@ var acceptsPreviousSchema = (previous, next) => {
     additionalProperties: oldAdditional,
     enum: oldEnum,
     items: oldItems,
+    minimum: _oldMinimum,
+    maximum: _oldMaximum,
+    exclusiveMinimum: _oldExclusiveMinimum,
+    exclusiveMaximum: _oldExclusiveMaximum,
     ...oldFixed
   } = before;
   const {
@@ -25205,9 +25242,14 @@ var acceptsPreviousSchema = (previous, next) => {
     additionalProperties: newAdditional,
     enum: newEnum,
     items: newItems,
+    minimum: _newMinimum,
+    maximum: _newMaximum,
+    exclusiveMinimum: _newExclusiveMinimum,
+    exclusiveMaximum: _newExclusiveMaximum,
     ...newFixed
   } = after;
   if (canonicalContentHash(oldFixed) !== canonicalContentHash(newFixed)) return false;
+  if (!numericRangesAcceptPrevious(before, after)) return false;
   if (!acceptsPreviousSchema(oldItems ?? true, newItems ?? true)) return false;
   if (newEnum && (!oldEnum || oldEnum.some((value) => !newEnum.some((candidate) => canonicalContentHash(candidate) === canonicalContentHash(value))))) return false;
   if ((newRequired ?? []).some((key) => !(oldRequired ?? []).includes(key))) return false;