langgraph-ui-components 0.0.4 → 0.0.6

package/dist/index.es230.js

@@ -1,177 +1,765 @@
-import isNetworkError from "./index.es231.js";
-function validateRetries(retries) {
-  if (typeof retries === "number") {
-    if (retries < 0) {
-      throw new TypeError("Expected `retries` to be a non-negative number.");
+import { deepCompareStrict } from "./index.es148.js";
+import { dereference } from "./index.es151.js";
+import { format } from "./index.es228.js";
+import { encodePointer } from "./index.es227.js";
+import { ucs2length } from "./index.es229.js";
+function validate(instance, schema, draft = "2019-09", lookup = dereference(schema), shortCircuit = true, recursiveAnchor = null, instanceLocation = "#", schemaLocation = "#", evaluated = /* @__PURE__ */ Object.create(null)) {
+  if (schema === true) {
+    return { valid: true, errors: [] };
+  }
+  if (schema === false) {
+    return {
+      valid: false,
+      errors: [
+        {
+          instanceLocation,
+          keyword: "false",
+          keywordLocation: instanceLocation,
+          error: "False boolean schema."
+        }
+      ]
+    };
+  }
+  const rawInstanceType = typeof instance;
+  let instanceType;
+  switch (rawInstanceType) {
+    case "boolean":
+    case "number":
+    case "string":
+      instanceType = rawInstanceType;
+      break;
+    case "object":
+      if (instance === null) {
+        instanceType = "null";
+      } else if (Array.isArray(instance)) {
+        instanceType = "array";
+      } else {
+        instanceType = "object";
+      }
+      break;
+    default:
+      throw new Error(`Instances of "${rawInstanceType}" type are not supported.`);
+  }
+  const { $ref, $recursiveRef, $recursiveAnchor, type: $type, const: $const, enum: $enum, required: $required, not: $not, anyOf: $anyOf, allOf: $allOf, oneOf: $oneOf, if: $if, then: $then, else: $else, format: $format, properties: $properties, patternProperties: $patternProperties, additionalProperties: $additionalProperties, unevaluatedProperties: $unevaluatedProperties, minProperties: $minProperties, maxProperties: $maxProperties, propertyNames: $propertyNames, dependentRequired: $dependentRequired, dependentSchemas: $dependentSchemas, dependencies: $dependencies, prefixItems: $prefixItems, items: $items, additionalItems: $additionalItems, unevaluatedItems: $unevaluatedItems, contains: $contains, minContains: $minContains, maxContains: $maxContains, minItems: $minItems, maxItems: $maxItems, uniqueItems: $uniqueItems, minimum: $minimum, maximum: $maximum, exclusiveMinimum: $exclusiveMinimum, exclusiveMaximum: $exclusiveMaximum, multipleOf: $multipleOf, minLength: $minLength, maxLength: $maxLength, pattern: $pattern, __absolute_ref__, __absolute_recursive_ref__ } = schema;
+  const errors = [];
+  if ($recursiveAnchor === true && recursiveAnchor === null) {
+    recursiveAnchor = schema;
+  }
+  if ($recursiveRef === "#") {
+    const refSchema = recursiveAnchor === null ? lookup[__absolute_recursive_ref__] : recursiveAnchor;
+    const keywordLocation = `${schemaLocation}/$recursiveRef`;
+    const result = validate(instance, recursiveAnchor === null ? schema : recursiveAnchor, draft, lookup, shortCircuit, refSchema, instanceLocation, keywordLocation, evaluated);
+    if (!result.valid) {
+      errors.push({
+        instanceLocation,
+        keyword: "$recursiveRef",
+        keywordLocation,
+        error: "A subschema had errors."
+      }, ...result.errors);
     }
-    if (Number.isNaN(retries)) {
-      throw new TypeError("Expected `retries` to be a valid number or Infinity, got NaN.");
+  }
+  if ($ref !== void 0) {
+    const uri = __absolute_ref__ || $ref;
+    const refSchema = lookup[uri];
+    if (refSchema === void 0) {
+      let message = `Unresolved $ref "${$ref}".`;
+      if (__absolute_ref__ && __absolute_ref__ !== $ref) {
+        message += `  Absolute URI "${__absolute_ref__}".`;
+      }
+      message += `
+Known schemas:
+- ${Object.keys(lookup).join("\n- ")}`;
+      throw new Error(message);
+    }
+    const keywordLocation = `${schemaLocation}/$ref`;
+    const result = validate(instance, refSchema, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation, evaluated);
+    if (!result.valid) {
+      errors.push({
+        instanceLocation,
+        keyword: "$ref",
+        keywordLocation,
+        error: "A subschema had errors."
+      }, ...result.errors);
+    }
+    if (draft === "4" || draft === "7") {
+      return { valid: errors.length === 0, errors };
     }
-  } else if (retries !== void 0) {
-    throw new TypeError("Expected `retries` to be a number or Infinity.");
   }
-}
-function validateNumberOption(name, value, { min = 0, allowInfinity = false } = {}) {
-  if (value === void 0) {
-    return;
+  if (Array.isArray($type)) {
+    let length = $type.length;
+    let valid = false;
+    for (let i = 0; i < length; i++) {
+      if (instanceType === $type[i] || $type[i] === "integer" && instanceType === "number" && instance % 1 === 0 && instance === instance) {
+        valid = true;
+        break;
+      }
+    }
+    if (!valid) {
+      errors.push({
+        instanceLocation,
+        keyword: "type",
+        keywordLocation: `${schemaLocation}/type`,
+        error: `Instance type "${instanceType}" is invalid. Expected "${$type.join('", "')}".`
+      });
+    }
+  } else if ($type === "integer") {
+    if (instanceType !== "number" || instance % 1 || instance !== instance) {
+      errors.push({
+        instanceLocation,
+        keyword: "type",
+        keywordLocation: `${schemaLocation}/type`,
+        error: `Instance type "${instanceType}" is invalid. Expected "${$type}".`
+      });
+    }
+  } else if ($type !== void 0 && instanceType !== $type) {
+    errors.push({
+      instanceLocation,
+      keyword: "type",
+      keywordLocation: `${schemaLocation}/type`,
+      error: `Instance type "${instanceType}" is invalid. Expected "${$type}".`
+    });
   }
-  if (typeof value !== "number" || Number.isNaN(value)) {
-    throw new TypeError(`Expected \`${name}\` to be a number${allowInfinity ? " or Infinity" : ""}.`);
+  if ($const !== void 0) {
+    if (instanceType === "object" || instanceType === "array") {
+      if (!deepCompareStrict(instance, $const)) {
+        errors.push({
+          instanceLocation,
+          keyword: "const",
+          keywordLocation: `${schemaLocation}/const`,
+          error: `Instance does not match ${JSON.stringify($const)}.`
+        });
+      }
+    } else if (instance !== $const) {
+      errors.push({
+        instanceLocation,
+        keyword: "const",
+        keywordLocation: `${schemaLocation}/const`,
+        error: `Instance does not match ${JSON.stringify($const)}.`
+      });
+    }
   }
-  if (!allowInfinity && !Number.isFinite(value)) {
-    throw new TypeError(`Expected \`${name}\` to be a finite number.`);
+  if ($enum !== void 0) {
+    if (instanceType === "object" || instanceType === "array") {
+      if (!$enum.some((value) => deepCompareStrict(instance, value))) {
+        errors.push({
+          instanceLocation,
+          keyword: "enum",
+          keywordLocation: `${schemaLocation}/enum`,
+          error: `Instance does not match any of ${JSON.stringify($enum)}.`
+        });
+      }
+    } else if (!$enum.some((value) => instance === value)) {
+      errors.push({
+        instanceLocation,
+        keyword: "enum",
+        keywordLocation: `${schemaLocation}/enum`,
+        error: `Instance does not match any of ${JSON.stringify($enum)}.`
+      });
+    }
   }
-  if (value < min) {
-    throw new TypeError(`Expected \`${name}\` to be ≥ ${min}.`);
+  if ($not !== void 0) {
+    const keywordLocation = `${schemaLocation}/not`;
+    const result = validate(instance, $not, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation);
+    if (result.valid) {
+      errors.push({
+        instanceLocation,
+        keyword: "not",
+        keywordLocation,
+        error: 'Instance matched "not" schema.'
+      });
+    }
   }
-}
-class AbortError extends Error {
-  constructor(message) {
-    super();
-    if (message instanceof Error) {
-      this.originalError = message;
-      ({ message } = message);
+  let subEvaluateds = [];
+  if ($anyOf !== void 0) {
+    const keywordLocation = `${schemaLocation}/anyOf`;
+    const errorsLength = errors.length;
+    let anyValid = false;
+    for (let i = 0; i < $anyOf.length; i++) {
+      const subSchema = $anyOf[i];
+      const subEvaluated = Object.create(evaluated);
+      const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
+      errors.push(...result.errors);
+      anyValid = anyValid || result.valid;
+      if (result.valid) {
+        subEvaluateds.push(subEvaluated);
+      }
+    }
+    if (anyValid) {
+      errors.length = errorsLength;
     } else {
-      this.originalError = new Error(message);
-      this.originalError.stack = this.stack;
+      errors.splice(errorsLength, 0, {
+        instanceLocation,
+        keyword: "anyOf",
+        keywordLocation,
+        error: "Instance does not match any subschemas."
+      });
     }
-    this.name = "AbortError";
-    this.message = message;
   }
-}
-function calculateDelay(retriesConsumed, options) {
-  const attempt = Math.max(1, retriesConsumed + 1);
-  const random = options.randomize ? Math.random() + 1 : 1;
-  let timeout = Math.round(random * options.minTimeout * options.factor ** (attempt - 1));
-  timeout = Math.min(timeout, options.maxTimeout);
-  return timeout;
-}
-function calculateRemainingTime(start, max) {
-  if (!Number.isFinite(max)) {
-    return max;
+  if ($allOf !== void 0) {
+    const keywordLocation = `${schemaLocation}/allOf`;
+    const errorsLength = errors.length;
+    let allValid = true;
+    for (let i = 0; i < $allOf.length; i++) {
+      const subSchema = $allOf[i];
+      const subEvaluated = Object.create(evaluated);
+      const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
+      errors.push(...result.errors);
+      allValid = allValid && result.valid;
+      if (result.valid) {
+        subEvaluateds.push(subEvaluated);
+      }
+    }
+    if (allValid) {
+      errors.length = errorsLength;
+    } else {
+      errors.splice(errorsLength, 0, {
+        instanceLocation,
+        keyword: "allOf",
+        keywordLocation,
+        error: `Instance does not match every subschema.`
+      });
+    }
   }
-  return max - (performance.now() - start);
-}
-async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTime, options }) {
-  const normalizedError = error instanceof Error ? error : new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
-  if (normalizedError instanceof AbortError) {
-    throw normalizedError.originalError;
-  }
-  const retriesLeft = Number.isFinite(options.retries) ? Math.max(0, options.retries - retriesConsumed) : options.retries;
-  const maxRetryTime = options.maxRetryTime ?? Number.POSITIVE_INFINITY;
-  const context = Object.freeze({
-    error: normalizedError,
-    attemptNumber,
-    retriesLeft,
-    retriesConsumed
-  });
-  await options.onFailedAttempt(context);
-  if (calculateRemainingTime(startTime, maxRetryTime) <= 0) {
-    throw normalizedError;
-  }
-  const consumeRetry = await options.shouldConsumeRetry(context);
-  const remainingTime = calculateRemainingTime(startTime, maxRetryTime);
-  if (remainingTime <= 0 || retriesLeft <= 0) {
-    throw normalizedError;
-  }
-  if (normalizedError instanceof TypeError && !isNetworkError(normalizedError)) {
-    if (consumeRetry) {
-      throw normalizedError;
-    }
-    options.signal?.throwIfAborted();
-    return false;
-  }
-  if (!await options.shouldRetry(context)) {
-    throw normalizedError;
-  }
-  if (!consumeRetry) {
-    options.signal?.throwIfAborted();
-    return false;
-  }
-  const delayTime = calculateDelay(retriesConsumed, options);
-  const finalDelay = Math.min(delayTime, remainingTime);
-  if (finalDelay > 0) {
-    await new Promise((resolve, reject) => {
-      const onAbort = () => {
-        clearTimeout(timeoutToken);
-        options.signal?.removeEventListener("abort", onAbort);
-        reject(options.signal.reason);
-      };
-      const timeoutToken = setTimeout(() => {
-        options.signal?.removeEventListener("abort", onAbort);
-        resolve();
-      }, finalDelay);
-      if (options.unref) {
-        timeoutToken.unref?.();
-      }
-      options.signal?.addEventListener("abort", onAbort, { once: true });
-    });
+  if ($oneOf !== void 0) {
+    const keywordLocation = `${schemaLocation}/oneOf`;
+    const errorsLength = errors.length;
+    const matches = $oneOf.filter((subSchema, i) => {
+      const subEvaluated = Object.create(evaluated);
+      const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
+      errors.push(...result.errors);
+      if (result.valid) {
+        subEvaluateds.push(subEvaluated);
+      }
+      return result.valid;
+    }).length;
+    if (matches === 1) {
+      errors.length = errorsLength;
+    } else {
+      errors.splice(errorsLength, 0, {
+        instanceLocation,
+        keyword: "oneOf",
+        keywordLocation,
+        error: `Instance does not match exactly one subschema (${matches} matches).`
+      });
+    }
   }
-  options.signal?.throwIfAborted();
-  return true;
-}
-async function pRetry(input, options = {}) {
-  options = { ...options };
-  validateRetries(options.retries);
-  if (Object.hasOwn(options, "forever")) {
-    throw new Error("The `forever` option is no longer supported. For many use-cases, you can set `retries: Infinity` instead.");
-  }
-  options.retries ??= 10;
-  options.factor ??= 2;
-  options.minTimeout ??= 1e3;
-  options.maxTimeout ??= Number.POSITIVE_INFINITY;
-  options.maxRetryTime ??= Number.POSITIVE_INFINITY;
-  options.randomize ??= false;
-  options.onFailedAttempt ??= () => {
-  };
-  options.shouldRetry ??= () => true;
-  options.shouldConsumeRetry ??= () => true;
-  validateNumberOption("factor", options.factor, {
-    min: 0,
-    allowInfinity: false
-  });
-  validateNumberOption("minTimeout", options.minTimeout, {
-    min: 0,
-    allowInfinity: false
-  });
-  validateNumberOption("maxTimeout", options.maxTimeout, {
-    min: 0,
-    allowInfinity: true
-  });
-  validateNumberOption("maxRetryTime", options.maxRetryTime, {
-    min: 0,
-    allowInfinity: true
-  });
-  if (!(options.factor > 0)) {
-    options.factor = 1;
-  }
-  options.signal?.throwIfAborted();
-  let attemptNumber = 0;
-  let retriesConsumed = 0;
-  const startTime = performance.now();
-  while (Number.isFinite(options.retries) ? retriesConsumed <= options.retries : true) {
-    attemptNumber++;
-    try {
-      options.signal?.throwIfAborted();
-      const result = await input(attemptNumber);
-      options.signal?.throwIfAborted();
-      return result;
-    } catch (error) {
-      if (await onAttemptFailure({
-        error,
-        attemptNumber,
-        retriesConsumed,
-        startTime,
-        options
-      })) {
-        retriesConsumed++;
-      }
-    }
-  }
-  throw new Error("Retry attempts exhausted without throwing an error.");
+  if (instanceType === "object" || instanceType === "array") {
+    Object.assign(evaluated, ...subEvaluateds);
+  }
+  if ($if !== void 0) {
+    const keywordLocation = `${schemaLocation}/if`;
+    const conditionResult = validate(instance, $if, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation, evaluated).valid;
+    if (conditionResult) {
+      if ($then !== void 0) {
+        const thenResult = validate(instance, $then, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${schemaLocation}/then`, evaluated);
+        if (!thenResult.valid) {
+          errors.push({
+            instanceLocation,
+            keyword: "if",
+            keywordLocation,
+            error: `Instance does not match "then" schema.`
+          }, ...thenResult.errors);
+        }
+      }
+    } else if ($else !== void 0) {
+      const elseResult = validate(instance, $else, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${schemaLocation}/else`, evaluated);
+      if (!elseResult.valid) {
+        errors.push({
+          instanceLocation,
+          keyword: "if",
+          keywordLocation,
+          error: `Instance does not match "else" schema.`
+        }, ...elseResult.errors);
+      }
+    }
+  }
+  if (instanceType === "object") {
+    if ($required !== void 0) {
+      for (const key of $required) {
+        if (!(key in instance)) {
+          errors.push({
+            instanceLocation,
+            keyword: "required",
+            keywordLocation: `${schemaLocation}/required`,
+            error: `Instance does not have required property "${key}".`
+          });
+        }
+      }
+    }
+    const keys = Object.keys(instance);
+    if ($minProperties !== void 0 && keys.length < $minProperties) {
+      errors.push({
+        instanceLocation,
+        keyword: "minProperties",
+        keywordLocation: `${schemaLocation}/minProperties`,
+        error: `Instance does not have at least ${$minProperties} properties.`
+      });
+    }
+    if ($maxProperties !== void 0 && keys.length > $maxProperties) {
+      errors.push({
+        instanceLocation,
+        keyword: "maxProperties",
+        keywordLocation: `${schemaLocation}/maxProperties`,
+        error: `Instance does not have at least ${$maxProperties} properties.`
+      });
+    }
+    if ($propertyNames !== void 0) {
+      const keywordLocation = `${schemaLocation}/propertyNames`;
+      for (const key in instance) {
+        const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+        const result = validate(key, $propertyNames, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
+        if (!result.valid) {
+          errors.push({
+            instanceLocation,
+            keyword: "propertyNames",
+            keywordLocation,
+            error: `Property name "${key}" does not match schema.`
+          }, ...result.errors);
+        }
+      }
+    }
+    if ($dependentRequired !== void 0) {
+      const keywordLocation = `${schemaLocation}/dependantRequired`;
+      for (const key in $dependentRequired) {
+        if (key in instance) {
+          const required = $dependentRequired[key];
+          for (const dependantKey of required) {
+            if (!(dependantKey in instance)) {
+              errors.push({
+                instanceLocation,
+                keyword: "dependentRequired",
+                keywordLocation,
+                error: `Instance has "${key}" but does not have "${dependantKey}".`
+              });
+            }
+          }
+        }
+      }
+    }
+    if ($dependentSchemas !== void 0) {
+      for (const key in $dependentSchemas) {
+        const keywordLocation = `${schemaLocation}/dependentSchemas`;
+        if (key in instance) {
+          const result = validate(instance, $dependentSchemas[key], draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${keywordLocation}/${encodePointer(key)}`, evaluated);
+          if (!result.valid) {
+            errors.push({
+              instanceLocation,
+              keyword: "dependentSchemas",
+              keywordLocation,
+              error: `Instance has "${key}" but does not match dependant schema.`
+            }, ...result.errors);
+          }
+        }
+      }
+    }
+    if ($dependencies !== void 0) {
+      const keywordLocation = `${schemaLocation}/dependencies`;
+      for (const key in $dependencies) {
+        if (key in instance) {
+          const propsOrSchema = $dependencies[key];
+          if (Array.isArray(propsOrSchema)) {
+            for (const dependantKey of propsOrSchema) {
+              if (!(dependantKey in instance)) {
+                errors.push({
+                  instanceLocation,
+                  keyword: "dependencies",
+                  keywordLocation,
+                  error: `Instance has "${key}" but does not have "${dependantKey}".`
+                });
+              }
+            }
+          } else {
+            const result = validate(instance, propsOrSchema, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${keywordLocation}/${encodePointer(key)}`);
+            if (!result.valid) {
+              errors.push({
+                instanceLocation,
+                keyword: "dependencies",
+                keywordLocation,
+                error: `Instance has "${key}" but does not match dependant schema.`
+              }, ...result.errors);
+            }
+          }
+        }
+      }
+    }
+    const thisEvaluated = /* @__PURE__ */ Object.create(null);
+    let stop = false;
+    if ($properties !== void 0) {
+      const keywordLocation = `${schemaLocation}/properties`;
+      for (const key in $properties) {
+        if (!(key in instance)) {
+          continue;
+        }
+        const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+        const result = validate(instance[key], $properties[key], draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, `${keywordLocation}/${encodePointer(key)}`);
+        if (result.valid) {
+          evaluated[key] = thisEvaluated[key] = true;
+        } else {
+          stop = shortCircuit;
+          errors.push({
+            instanceLocation,
+            keyword: "properties",
+            keywordLocation,
+            error: `Property "${key}" does not match schema.`
+          }, ...result.errors);
+          if (stop)
+            break;
+        }
+      }
+    }
+    if (!stop && $patternProperties !== void 0) {
+      const keywordLocation = `${schemaLocation}/patternProperties`;
+      for (const pattern in $patternProperties) {
+        const regex = new RegExp(pattern, "u");
+        const subSchema = $patternProperties[pattern];
+        for (const key in instance) {
+          if (!regex.test(key)) {
+            continue;
+          }
+          const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+          const result = validate(instance[key], subSchema, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, `${keywordLocation}/${encodePointer(pattern)}`);
+          if (result.valid) {
+            evaluated[key] = thisEvaluated[key] = true;
+          } else {
+            stop = shortCircuit;
+            errors.push({
+              instanceLocation,
+              keyword: "patternProperties",
+              keywordLocation,
+              error: `Property "${key}" matches pattern "${pattern}" but does not match associated schema.`
+            }, ...result.errors);
+          }
+        }
+      }
+    }
+    if (!stop && $additionalProperties !== void 0) {
+      const keywordLocation = `${schemaLocation}/additionalProperties`;
+      for (const key in instance) {
+        if (thisEvaluated[key]) {
+          continue;
+        }
+        const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+        const result = validate(instance[key], $additionalProperties, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
+        if (result.valid) {
+          evaluated[key] = true;
+        } else {
+          stop = shortCircuit;
+          errors.push({
+            instanceLocation,
+            keyword: "additionalProperties",
+            keywordLocation,
+            error: `Property "${key}" does not match additional properties schema.`
+          }, ...result.errors);
+        }
+      }
+    } else if (!stop && $unevaluatedProperties !== void 0) {
+      const keywordLocation = `${schemaLocation}/unevaluatedProperties`;
+      for (const key in instance) {
+        if (!evaluated[key]) {
+          const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+          const result = validate(instance[key], $unevaluatedProperties, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
+          if (result.valid) {
+            evaluated[key] = true;
+          } else {
+            errors.push({
+              instanceLocation,
+              keyword: "unevaluatedProperties",
+              keywordLocation,
+              error: `Property "${key}" does not match unevaluated properties schema.`
+            }, ...result.errors);
+          }
+        }
+      }
+    }
+  } else if (instanceType === "array") {
+    if ($maxItems !== void 0 && instance.length > $maxItems) {
+      errors.push({
+        instanceLocation,
+        keyword: "maxItems",
+        keywordLocation: `${schemaLocation}/maxItems`,
+        error: `Array has too many items (${instance.length} > ${$maxItems}).`
+      });
+    }
+    if ($minItems !== void 0 && instance.length < $minItems) {
+      errors.push({
+        instanceLocation,
+        keyword: "minItems",
+        keywordLocation: `${schemaLocation}/minItems`,
+        error: `Array has too few items (${instance.length} < ${$minItems}).`
+      });
+    }
+    const length = instance.length;
+    let i = 0;
+    let stop = false;
+    if ($prefixItems !== void 0) {
+      const keywordLocation = `${schemaLocation}/prefixItems`;
+      const length2 = Math.min($prefixItems.length, length);
+      for (; i < length2; i++) {
+        const result = validate(instance[i], $prefixItems[i], draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, `${keywordLocation}/${i}`);
+        evaluated[i] = true;
+        if (!result.valid) {
+          stop = shortCircuit;
+          errors.push({
+            instanceLocation,
+            keyword: "prefixItems",
+            keywordLocation,
+            error: `Items did not match schema.`
+          }, ...result.errors);
+          if (stop)
+            break;
+        }
+      }
+    }
+    if ($items !== void 0) {
+      const keywordLocation = `${schemaLocation}/items`;
+      if (Array.isArray($items)) {
+        const length2 = Math.min($items.length, length);
+        for (; i < length2; i++) {
+          const result = validate(instance[i], $items[i], draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, `${keywordLocation}/${i}`);
+          evaluated[i] = true;
+          if (!result.valid) {
+            stop = shortCircuit;
+            errors.push({
+              instanceLocation,
+              keyword: "items",
+              keywordLocation,
+              error: `Items did not match schema.`
+            }, ...result.errors);
+            if (stop)
+              break;
+          }
+        }
+      } else {
+        for (; i < length; i++) {
+          const result = validate(instance[i], $items, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
+          evaluated[i] = true;
+          if (!result.valid) {
+            stop = shortCircuit;
+            errors.push({
+              instanceLocation,
+              keyword: "items",
+              keywordLocation,
+              error: `Items did not match schema.`
+            }, ...result.errors);
+            if (stop)
+              break;
+          }
+        }
+      }
+      if (!stop && $additionalItems !== void 0) {
+        const keywordLocation2 = `${schemaLocation}/additionalItems`;
+        for (; i < length; i++) {
+          const result = validate(instance[i], $additionalItems, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation2);
+          evaluated[i] = true;
+          if (!result.valid) {
+            stop = shortCircuit;
+            errors.push({
+              instanceLocation,
+              keyword: "additionalItems",
+              keywordLocation: keywordLocation2,
+              error: `Items did not match additional items schema.`
+            }, ...result.errors);
+          }
+        }
+      }
+    }
+    if ($contains !== void 0) {
+      if (length === 0 && $minContains === void 0) {
+        errors.push({
+          instanceLocation,
+          keyword: "contains",
+          keywordLocation: `${schemaLocation}/contains`,
+          error: `Array is empty. It must contain at least one item matching the schema.`
+        });
+      } else if ($minContains !== void 0 && length < $minContains) {
+        errors.push({
+          instanceLocation,
+          keyword: "minContains",
+          keywordLocation: `${schemaLocation}/minContains`,
+          error: `Array has less items (${length}) than minContains (${$minContains}).`
+        });
+      } else {
+        const keywordLocation = `${schemaLocation}/contains`;
+        const errorsLength = errors.length;
+        let contained = 0;
+        for (let j = 0; j < length; j++) {
+          const result = validate(instance[j], $contains, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${j}`, keywordLocation);
+          if (result.valid) {
+            evaluated[j] = true;
+            contained++;
+          } else {
+            errors.push(...result.errors);
+          }
+        }
+        if (contained >= ($minContains || 0)) {
+          errors.length = errorsLength;
+        }
+        if ($minContains === void 0 && $maxContains === void 0 && contained === 0) {
+          errors.splice(errorsLength, 0, {
+            instanceLocation,
+            keyword: "contains",
+            keywordLocation,
+            error: `Array does not contain item matching schema.`
+          });
+        } else if ($minContains !== void 0 && contained < $minContains) {
+          errors.push({
+            instanceLocation,
+            keyword: "minContains",
+            keywordLocation: `${schemaLocation}/minContains`,
+            error: `Array must contain at least ${$minContains} items matching schema. Only ${contained} items were found.`
+          });
+        } else if ($maxContains !== void 0 && contained > $maxContains) {
+          errors.push({
+            instanceLocation,
+            keyword: "maxContains",
+            keywordLocation: `${schemaLocation}/maxContains`,
+            error: `Array may contain at most ${$maxContains} items matching schema. ${contained} items were found.`
+          });
+        }
+      }
+    }
+    if (!stop && $unevaluatedItems !== void 0) {
+      const keywordLocation = `${schemaLocation}/unevaluatedItems`;
+      for (i; i < length; i++) {
+        if (evaluated[i]) {
+          continue;
+        }
+        const result = validate(instance[i], $unevaluatedItems, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
+        evaluated[i] = true;
+        if (!result.valid) {
+          errors.push({
+            instanceLocation,
+            keyword: "unevaluatedItems",
+            keywordLocation,
+            error: `Items did not match unevaluated items schema.`
+          }, ...result.errors);
+        }
+      }
+    }
+    if ($uniqueItems) {
+      for (let j = 0; j < length; j++) {
+        const a = instance[j];
+        const ao = typeof a === "object" && a !== null;
+        for (let k = 0; k < length; k++) {
+          if (j === k) {
+            continue;
+          }
+          const b = instance[k];
+          const bo = typeof b === "object" && b !== null;
+          if (a === b || ao && bo && deepCompareStrict(a, b)) {
+            errors.push({
+              instanceLocation,
+              keyword: "uniqueItems",
+              keywordLocation: `${schemaLocation}/uniqueItems`,
+              error: `Duplicate items at indexes ${j} and ${k}.`
+            });
+            j = Number.MAX_SAFE_INTEGER;
+            k = Number.MAX_SAFE_INTEGER;
+          }
+        }
+      }
+    }
+  } else if (instanceType === "number") {
+    if (draft === "4") {
+      if ($minimum !== void 0 && ($exclusiveMinimum === true && instance <= $minimum || instance < $minimum)) {
+        errors.push({
+          instanceLocation,
+          keyword: "minimum",
+          keywordLocation: `${schemaLocation}/minimum`,
+          error: `${instance} is less than ${$exclusiveMinimum ? "or equal to " : ""} ${$minimum}.`
+        });
+      }
+      if ($maximum !== void 0 && ($exclusiveMaximum === true && instance >= $maximum || instance > $maximum)) {
+        errors.push({
+          instanceLocation,
+          keyword: "maximum",
+          keywordLocation: `${schemaLocation}/maximum`,
+          error: `${instance} is greater than ${$exclusiveMaximum ? "or equal to " : ""} ${$maximum}.`
+        });
+      }
+    } else {
+      if ($minimum !== void 0 && instance < $minimum) {
+        errors.push({
+          instanceLocation,
+          keyword: "minimum",
+          keywordLocation: `${schemaLocation}/minimum`,
+          error: `${instance} is less than ${$minimum}.`
+        });
+      }
+      if ($maximum !== void 0 && instance > $maximum) {
+        errors.push({
+          instanceLocation,
+          keyword: "maximum",
+          keywordLocation: `${schemaLocation}/maximum`,
+          error: `${instance} is greater than ${$maximum}.`
+        });
+      }
+      if ($exclusiveMinimum !== void 0 && instance <= $exclusiveMinimum) {
+        errors.push({
+          instanceLocation,
+          keyword: "exclusiveMinimum",
+          keywordLocation: `${schemaLocation}/exclusiveMinimum`,
+          error: `${instance} is less than ${$exclusiveMinimum}.`
+        });
+      }
+      if ($exclusiveMaximum !== void 0 && instance >= $exclusiveMaximum) {
+        errors.push({
+          instanceLocation,
+          keyword: "exclusiveMaximum",
+          keywordLocation: `${schemaLocation}/exclusiveMaximum`,
+          error: `${instance} is greater than or equal to ${$exclusiveMaximum}.`
+        });
+      }
+    }
+    if ($multipleOf !== void 0) {
+      const remainder = instance % $multipleOf;
+      if (Math.abs(0 - remainder) >= 11920929e-14 && Math.abs($multipleOf - remainder) >= 11920929e-14) {
+        errors.push({
+          instanceLocation,
+          keyword: "multipleOf",
+          keywordLocation: `${schemaLocation}/multipleOf`,
+          error: `${instance} is not a multiple of ${$multipleOf}.`
+        });
+      }
+    }
+  } else if (instanceType === "string") {
+    const length = $minLength === void 0 && $maxLength === void 0 ? 0 : ucs2length(instance);
+    if ($minLength !== void 0 && length < $minLength) {
+      errors.push({
+        instanceLocation,
+        keyword: "minLength",
+        keywordLocation: `${schemaLocation}/minLength`,
+        error: `String is too short (${length} < ${$minLength}).`
+      });
+    }
+    if ($maxLength !== void 0 && length > $maxLength) {
+      errors.push({
+        instanceLocation,
+        keyword: "maxLength",
+        keywordLocation: `${schemaLocation}/maxLength`,
+        error: `String is too long (${length} > ${$maxLength}).`
+      });
+    }
+    if ($pattern !== void 0 && !new RegExp($pattern, "u").test(instance)) {
+      errors.push({
+        instanceLocation,
+        keyword: "pattern",
+        keywordLocation: `${schemaLocation}/pattern`,
+        error: `String does not match pattern.`
+      });
+    }
+    if ($format !== void 0 && format[$format] && !format[$format](instance)) {
+      errors.push({
+        instanceLocation,
+        keyword: "format",
+        keywordLocation: `${schemaLocation}/format`,
+        error: `String does not match format "${$format}".`
+      });
+    }
+  }
+  return { valid: errors.length === 0, errors };
 }
 export {
-  AbortError,
-  pRetry as default
+  validate
 };
 //# sourceMappingURL=index.es230.js.map