langgraph-ui-components 0.0.4 → 0.0.6

package/dist/index.es228.js

@@ -1,765 +1,95 @@
-import { deepCompareStrict } from "./index.es144.js";
-import { dereference } from "./index.es147.js";
-import { format } from "./index.es226.js";
-import { encodePointer } from "./index.es225.js";
-import { ucs2length } from "./index.es227.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 ($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 };
-    }
-  }
-  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 ($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 ($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 ($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.'
-      });
-    }
-  }
-  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 {
-      errors.splice(errorsLength, 0, {
-        instanceLocation,
-        keyword: "anyOf",
-        keywordLocation,
-        error: "Instance does not match any subschemas."
-      });
-    }
-  }
-  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.`
-      });
-    }
-  }
-  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).`
-      });
-    }
-  }
-  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}".`
-      });
-    }
+const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i;
+const HOSTNAME = /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i;
+const URIREF = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+const URITEMPLATE = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i;
+const URL_ = /^(?:(?:https?|ftp):\/\/)(?:\S+(?::\S*)?@)?(?:(?!10(?:\.\d{1,3}){3})(?!127(?:\.\d{1,3}){3})(?!169\.254(?:\.\d{1,3}){2})(?!192\.168(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)(?:\.(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu;
+const UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
+const JSON_POINTER = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
+const JSON_POINTER_URI_FRAGMENT = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;
+const RELATIVE_JSON_POINTER = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
+const EMAIL = (input) => {
+  if (input[0] === '"')
+    return false;
+  const [name, host, ...rest] = input.split("@");
+  if (!name || !host || rest.length !== 0 || name.length > 64 || host.length > 253)
+    return false;
+  if (name[0] === "." || name.endsWith(".") || name.includes(".."))
+    return false;
+  if (!/^[a-z0-9.-]+$/i.test(host) || !/^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+$/i.test(name))
+    return false;
+  return host.split(".").every((part) => /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/i.test(part));
+};
+const IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
+const IPV6 = /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i;
+const DURATION = (input) => input.length > 1 && input.length < 80 && (/^P\d+([.,]\d+)?W$/.test(input) || /^P[\dYMDTHS]*(\d[.,]\d+)?[YMDHS]$/.test(input) && /^P([.,\d]+Y)?([.,\d]+M)?([.,\d]+D)?(T([.,\d]+H)?([.,\d]+M)?([.,\d]+S)?)?$/.test(input));
+function bind(r) {
+  return r.test.bind(r);
+}
+const format = {
+  date,
+  time: time.bind(void 0, false),
+  "date-time": date_time,
+  duration: DURATION,
+  uri,
+  "uri-reference": bind(URIREF),
+  "uri-template": bind(URITEMPLATE),
+  url: bind(URL_),
+  email: EMAIL,
+  hostname: bind(HOSTNAME),
+  ipv4: bind(IPV4),
+  ipv6: bind(IPV6),
+  regex,
+  uuid: bind(UUID),
+  "json-pointer": bind(JSON_POINTER),
+  "json-pointer-uri-fragment": bind(JSON_POINTER_URI_FRAGMENT),
+  "relative-json-pointer": bind(RELATIVE_JSON_POINTER)
+};
+function isLeapYear(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function date(str) {
+  const matches = str.match(DATE);
+  if (!matches)
+    return false;
+  const year = +matches[1];
+  const month = +matches[2];
+  const day = +matches[3];
+  return month >= 1 && month <= 12 && day >= 1 && day <= (month == 2 && isLeapYear(year) ? 29 : DAYS[month]);
+}
+function time(full, str) {
+  const matches = str.match(TIME);
+  if (!matches)
+    return false;
+  const hour = +matches[1];
+  const minute = +matches[2];
+  const second = +matches[3];
+  const timeZone = !!matches[5];
+  return (hour <= 23 && minute <= 59 && second <= 59 || hour == 23 && minute == 59 && second == 60) && (!full || timeZone);
+}
+const DATE_TIME_SEPARATOR = /t|\s/i;
+function date_time(str) {
+  const dateTime = str.split(DATE_TIME_SEPARATOR);
+  return dateTime.length == 2 && date(dateTime[0]) && time(true, dateTime[1]);
+}
+const NOT_URI_FRAGMENT = /\/|:/;
+const URI_PATTERN = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+function uri(str) {
+  return NOT_URI_FRAGMENT.test(str) && URI_PATTERN.test(str);
+}
+const Z_ANCHOR = /[^\\]\\Z/;
+function regex(str) {
+  if (Z_ANCHOR.test(str))
+    return false;
+  try {
+    new RegExp(str, "u");
+    return true;
+  } catch (e) {
+    return false;
   }
-  return { valid: errors.length === 0, errors };
 }
 export {
-  validate
+  format
 };
 //# sourceMappingURL=index.es228.js.map