@zuplo/cli 6.70.15 → 6.70.21

package/node_modules/@cfworker/json-schema/src/validate.ts

@@ -0,0 +1,1168 @@
+import { deepCompareStrict } from './deep-compare-strict.js';
+import { dereference } from './dereference.js';
+import { format } from './format.js';
+import { encodePointer } from './pointer.js';
+import {
+  InstanceType,
+  OutputUnit,
+  Schema,
+  SchemaDraft,
+  ValidationResult
+} from './types.js';
+import { ucs2length } from './ucs2-length.js';
+
+export type Evaluated = Record<string | number, boolean>;
+
+export function validate(
+  instance: any,
+  schema: Schema | boolean,
+  draft: SchemaDraft = '2019-09',
+  lookup: Record<string, Schema | boolean> = dereference(schema),
+  shortCircuit = true,
+  recursiveAnchor: Schema | null = null,
+  instanceLocation = '#',
+  schemaLocation = '#',
+  evaluated: Evaluated = Object.create(null)
+): ValidationResult {
+  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: Exclude<InstanceType, 'integer'>;
+  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:
+      // undefined, bigint, function, symbol
+      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: OutputUnit[] = [];
+
+  if ($recursiveAnchor === true && recursiveAnchor === null) {
+    recursiveAnchor = schema;
+  }
+
+  if ($recursiveRef === '#') {
+    const refSchema =
+      recursiveAnchor === null
+        ? (lookup[__absolute_recursive_ref__!] as Schema)
+        : 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 !== undefined) {
+    const uri = __absolute_ref__ || $ref;
+    const refSchema = lookup[uri];
+    if (refSchema === undefined) {
+      let message = `Unresolved $ref "${$ref}".`;
+      if (__absolute_ref__ && __absolute_ref__ !== $ref) {
+        message += `  Absolute URI "${__absolute_ref__}".`;
+      }
+      message += `\nKnown schemas:\n- ${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 !== undefined && instanceType !== $type) {
+    errors.push({
+      instanceLocation,
+      keyword: 'type',
+      keywordLocation: `${schemaLocation}/type`,
+      error: `Instance type "${instanceType}" is invalid. Expected "${$type}".`
+    });
+  }
+
+  if ($const !== undefined) {
+    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 !== undefined) {
+    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 !== undefined) {
+    const keywordLocation = `${schemaLocation}/not`;
+    const result = validate(
+      instance,
+      $not,
+      draft,
+      lookup,
+      shortCircuit,
+      recursiveAnchor,
+      instanceLocation,
+      keywordLocation /*,
+      evaluated*/
+    );
+    if (result.valid) {
+      errors.push({
+        instanceLocation,
+        keyword: 'not',
+        keywordLocation,
+        error: 'Instance matched "not" schema.'
+      });
+    }
+  }
+
+  let subEvaluateds: Array<Evaluated> = [];
+
+  if ($anyOf !== undefined) {
+    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: Evaluated = 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 !== undefined) {
+    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: Evaluated = 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 !== undefined) {
+    const keywordLocation = `${schemaLocation}/oneOf`;
+    const errorsLength = errors.length;
+    const matches = $oneOf.filter((subSchema, i) => {
+      const subEvaluated: Evaluated = 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 !== undefined) {
+    const keywordLocation = `${schemaLocation}/if`;
+    const conditionResult = validate(
+      instance,
+      $if,
+      draft,
+      lookup,
+      shortCircuit,
+      recursiveAnchor,
+      instanceLocation,
+      keywordLocation,
+      evaluated
+    ).valid;
+    if (conditionResult) {
+      if ($then !== undefined) {
+        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 !== undefined) {
+      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 !== undefined) {
+      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 !== undefined && keys.length < $minProperties) {
+      errors.push({
+        instanceLocation,
+        keyword: 'minProperties',
+        keywordLocation: `${schemaLocation}/minProperties`,
+        error: `Instance does not have at least ${$minProperties} properties.`
+      });
+    }
+
+    if ($maxProperties !== undefined && keys.length > $maxProperties) {
+      errors.push({
+        instanceLocation,
+        keyword: 'maxProperties',
+        keywordLocation: `${schemaLocation}/maxProperties`,
+        error: `Instance does not have at least ${$maxProperties} properties.`
+      });
+    }
+
+    if ($propertyNames !== undefined) {
+      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 !== undefined) {
+      const keywordLocation = `${schemaLocation}/dependantRequired`;
+      for (const key in $dependentRequired) {
+        if (key in instance) {
+          const required = $dependentRequired[key] as string[];
+          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 !== undefined) {
+      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 !== undefined) {
+      const keywordLocation = `${schemaLocation}/dependencies`;
+      for (const key in $dependencies) {
+        if (key in instance) {
+          const propsOrSchema = $dependencies[key] as Schema | string[];
+          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 = Object.create(null);
+
+    let stop = false;
+
+    if ($properties !== undefined) {
+      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 !== undefined) {
+      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 !== undefined) {
+      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 !== undefined) {
+      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 !== undefined && instance.length > $maxItems) {
+      errors.push({
+        instanceLocation,
+        keyword: 'maxItems',
+        keywordLocation: `${schemaLocation}/maxItems`,
+        error: `Array has too many items (${instance.length} > ${$maxItems}).`
+      });
+    }
+
+    if ($minItems !== undefined && instance.length < $minItems) {
+      errors.push({
+        instanceLocation,
+        keyword: 'minItems',
+        keywordLocation: `${schemaLocation}/minItems`,
+        error: `Array has too few items (${instance.length} < ${$minItems}).`
+      });
+    }
+
+    const length: number = instance.length;
+    let i = 0;
+    let stop = false;
+
+    if ($prefixItems !== undefined) {
+      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 !== undefined) {
+      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 !== undefined) {
+        const keywordLocation = `${schemaLocation}/additionalItems`;
+        for (; i < length; i++) {
+          const result = validate(
+            instance[i],
+            $additionalItems,
+            draft,
+            lookup,
+            shortCircuit,
+            recursiveAnchor,
+            `${instanceLocation}/${i}`,
+            keywordLocation
+          );
+          evaluated[i] = true;
+          if (!result.valid) {
+            stop = shortCircuit;
+            errors.push(
+              {
+                instanceLocation,
+                keyword: 'additionalItems',
+                keywordLocation,
+                error: `Items did not match additional items schema.`
+              },
+              ...result.errors
+            );
+          }
+        }
+      }
+    }
+
+    if ($contains !== undefined) {
+      if (length === 0 && $minContains === undefined) {
+        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 !== undefined && 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 === undefined &&
+          $maxContains === undefined &&
+          contained === 0
+        ) {
+          errors.splice(errorsLength, 0, {
+            instanceLocation,
+            keyword: 'contains',
+            keywordLocation,
+            error: `Array does not contain item matching schema.`
+          });
+        } else if ($minContains !== undefined && 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 !== undefined && 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 !== undefined) {
+      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 !== undefined &&
+        (($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 !== undefined &&
+        (($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 !== undefined && instance < $minimum) {
+        errors.push({
+          instanceLocation,
+          keyword: 'minimum',
+          keywordLocation: `${schemaLocation}/minimum`,
+          error: `${instance} is less than ${$minimum}.`
+        });
+      }
+      if ($maximum !== undefined && instance > $maximum) {
+        errors.push({
+          instanceLocation,
+          keyword: 'maximum',
+          keywordLocation: `${schemaLocation}/maximum`,
+          error: `${instance} is greater than ${$maximum}.`
+        });
+      }
+      if ($exclusiveMinimum !== undefined && instance <= $exclusiveMinimum) {
+        errors.push({
+          instanceLocation,
+          keyword: 'exclusiveMinimum',
+          keywordLocation: `${schemaLocation}/exclusiveMinimum`,
+          error: `${instance} is less than ${$exclusiveMinimum}.`
+        });
+      }
+      if ($exclusiveMaximum !== undefined && instance >= $exclusiveMaximum) {
+        errors.push({
+          instanceLocation,
+          keyword: 'exclusiveMaximum',
+          keywordLocation: `${schemaLocation}/exclusiveMaximum`,
+          error: `${instance} is greater than or equal to ${$exclusiveMaximum}.`
+        });
+      }
+    }
+    if ($multipleOf !== undefined) {
+      const remainder = instance % $multipleOf;
+      if (
+        Math.abs(0 - remainder) >= 1.1920929e-7 &&
+        Math.abs($multipleOf - remainder) >= 1.1920929e-7
+      ) {
+        errors.push({
+          instanceLocation,
+          keyword: 'multipleOf',
+          keywordLocation: `${schemaLocation}/multipleOf`,
+          error: `${instance} is not a multiple of ${$multipleOf}.`
+        });
+      }
+    }
+  } else if (instanceType === 'string') {
+    const length =
+      $minLength === undefined && $maxLength === undefined
+        ? 0
+        : ucs2length(instance);
+    if ($minLength !== undefined && length < $minLength) {
+      errors.push({
+        instanceLocation,
+        keyword: 'minLength',
+        keywordLocation: `${schemaLocation}/minLength`,
+        error: `String is too short (${length} < ${$minLength}).`
+      });
+    }
+    if ($maxLength !== undefined && length > $maxLength) {
+      errors.push({
+        instanceLocation,
+        keyword: 'maxLength',
+        keywordLocation: `${schemaLocation}/maxLength`,
+        error: `String is too long (${length} > ${$maxLength}).`
+      });
+    }
+    if ($pattern !== undefined && !new RegExp($pattern, 'u').test(instance)) {
+      errors.push({
+        instanceLocation,
+        keyword: 'pattern',
+        keywordLocation: `${schemaLocation}/pattern`,
+        error: `String does not match pattern.`
+      });
+    }
+    if (
+      $format !== undefined &&
+      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 };
+}