@jarenjs/validate 0.8.2

package/dist/index.js

@@ -0,0 +1,1802 @@
+// ../core/src/index.js
+function isFn(data) {
+  return typeof data === "function";
+}
+function isScalarTypeEx(typeName) {
+  switch (typeName) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "integer":
+    case "bigint":
+      return true;
+    default:
+      return false;
+  }
+}
+function isScalarType(data) {
+  return data != null && isScalarTypeEx(typeof data);
+}
+function isStringType(data) {
+  return typeof data === "string";
+}
+function isBooleanType(data) {
+  return data === true || data === false;
+}
+function isNumberType(data) {
+  return data != null && typeof data === "number";
+}
+function isIntegerType(data) {
+  return Number.isInteger(data);
+}
+function isBigIntType(data) {
+  return typeof data === "bigint";
+}
+function getStringType(obj, def = void 0) {
+  return isStringType(obj) ? obj : def;
+}
+function getBigIntType(obj, def = void 0) {
+  return isBigIntType(obj) ? obj : def;
+}
+function isNullValue(data) {
+  return data === null;
+}
+function isObjectOfClass(data, type) {
+  return data != null && data.constructor === type;
+}
+function isObjectClass(data) {
+  return isObjectOfClass(data, Object);
+}
+function isMapClass(data) {
+  return isObjectOfClass(data, Map);
+}
+function isObjectType(data) {
+  return data != null && typeof data === "object" && data.constructor !== Array;
+}
+function isArrayClass(data) {
+  return isObjectOfClass(data, Array);
+}
+function isSetClass(data) {
+  return isObjectOfClass(data, Set);
+}
+var TypedArray = Object.getPrototypeOf(Uint8Array);
+function isTypedArray(data) {
+  if (data == null)
+    return false;
+  const proto = data.__proto__.__proto__;
+  return proto != null && proto.constructor === TypedArray;
+}
+function getObjectType(obj, def = void 0) {
+  return isObjectClass(obj) ? obj : def;
+}
+function getInclusiveExclusiveBounds(getType, inclusive, exclusive) {
+  const includes = getType(inclusive);
+  const excludes = exclusive === true ? includes : getType(exclusive);
+  return excludes === void 0 ? [includes, void 0] : [void 0, excludes];
+}
+
+// ../core/src/array.js
+function isArrayish(data) {
+  return data != null && (data instanceof Array || data instanceof Set || data instanceof TypedArray);
+}
+function getUniqueArray(arr, def = void 0) {
+  if (arr == null)
+    return def;
+  return arr.constructor === Array ? arr.filter((el, index, a) => index === a.indexOf(el)) : arr.constructor === Set ? Array.from(arr) : def;
+}
+function isUniqueArray(arr) {
+  const unique = getUniqueArray(arr);
+  return unique != null && unique.length == arr.length;
+}
+function includesAll(arr, values) {
+  return values.every((v) => arr.includes(v));
+}
+
+// ../core/src/number.js
+function isBoolishType(data) {
+  return data === true || data === false || data === "true" || data === "false";
+}
+function getBoolishType(obj, def = void 0) {
+  return isBoolishType(obj) || obj === "true" || obj === "false" ? obj : def;
+}
+function isNumbishType(data) {
+  return typeof data !== "bigint" && !Number.isNaN(Number(data));
+}
+function isIntishType(data) {
+  return Number.isInteger(Number(data));
+}
+function getNumbishType(obj, def = void 0) {
+  return isNumbishType(obj) ? Number(obj) : def;
+}
+function getIntishType(obj, def = void 0) {
+  return isIntishType(obj) ? Number(obj) : def;
+}
+
+// ../core/src/function.js
+function trueThat(whatever, _path = void 0, _root = void 0, _key = void 0) {
+  const that = true;
+  return whatever === true || that;
+}
+function falseThat(whatever, _path = void 0, _root = void 0, _key = void 0) {
+  return false;
+}
+function fallbackFn(compiled, fallback = trueThat) {
+  if (isFn(compiled)) return compiled;
+  return isFn(fallback) ? fallback : trueThat;
+}
+function addFunctionToArray(arr = [], fn) {
+  if (fn == null) return arr;
+  if (isFn(fn))
+    arr.push(fn);
+  else if (fn.constructor === Array) {
+    for (let i = 0; i < fn.length; ++i) {
+      if (isFn(fn[i]))
+        arr.push(fn[i]);
+    }
+  }
+  return arr;
+}
+
+// ../core/src/string.js
+function isStringWhiteSpace(data) {
+  return data == null || /^\s*$/.test(data);
+}
+function isRegExpType(data) {
+  return isObjectOfClass(data, RegExp);
+}
+function createRegExp(pattern) {
+  if (pattern == null)
+    return void 0;
+  if (isRegExpType(pattern))
+    return pattern;
+  if (isStringType(pattern)) {
+    if (pattern[0] === "/") {
+      const e = pattern.lastIndexOf("/");
+      if (e >= 0) {
+        const r = pattern.substring(1, e);
+        const g = pattern.substring(e + 1);
+        return new RegExp(r, g);
+      }
+    } else
+      return new RegExp(pattern);
+  }
+  throw new Error(`Unknown Regular Expression Pattern Type: ${pattern}`);
+}
+
+// src/tools.js
+function isBoolOrObjectClass(obj) {
+  return isBooleanType(obj) || isObjectClass(obj);
+}
+function getBoolOrObjectClass(obj, def = void 0) {
+  return isBoolOrObjectClass(obj) ? obj : def;
+}
+function getArrayClassMinItems(obj, len = 1, def = void 0) {
+  return isArrayClass(obj) && obj.length >= len && obj || def;
+}
+function isOfSchemaType(schema, type) {
+  const stype = schema.type;
+  if (stype == null) return false;
+  if (stype === type) return true;
+  if (stype.constructor === Array) {
+    return stype.includes(type);
+  }
+  if (stype.constructor === Set) {
+    return stype.has(type);
+  }
+  return false;
+}
+function hasSchemaRef(schema) {
+  return isObjectClass(schema) && isStringType(schema.$ref) && !isStringWhiteSpace(schema.$ref);
+}
+function createIsSchemaTypeHandler(type, isStrict = false) {
+  switch (type) {
+    case "null":
+      return isNullValue;
+    case "boolean":
+      return isBooleanType;
+    case "integer":
+      return isIntegerType;
+    case "bigint":
+      return isBigIntType;
+    case "number":
+      return isNumberType;
+    case "string":
+      return isStringType;
+    case "object":
+      return isStrict ? isObjectClass : isObjectType;
+    case "array":
+      return isStrict ? isArrayish : isArrayClass;
+    case "set":
+      return isSetClass;
+    case "map":
+      return isMapClass;
+    case "tuple":
+      return isArrayClass;
+    case "regex":
+      return isRegExpType;
+    default:
+      break;
+  }
+  if (type === null)
+    return isNullValue;
+  if (typeof type === "function")
+    throw new Error("This is interesting!");
+  return void 0;
+}
+var ValidationResult = class _ValidationResult {
+  static undefThat() {
+    return new _ValidationResult();
+  }
+  constructor(match = false, errors = 0) {
+    this.match = match;
+    this.errors = Number(errors);
+  }
+  addValid(valid = true) {
+    if (valid === false)
+      this.errors++;
+    return this;
+  }
+  addMatch(valid = true) {
+    this.match = true;
+    if (valid === false)
+      this.errors++;
+    return this;
+  }
+  addResult(result = new _ValidationResult()) {
+    this.match = this.match || result.match;
+    this.errors += result.errors;
+    return this;
+  }
+  isValid() {
+    return this.errors === 0;
+  }
+};
+
+// src/format.js
+function registerFormatCompiler(registered, name, formatCompiler) {
+  if (registered[name] == null) {
+    if (isFn(formatCompiler)) {
+      registered[name] = formatCompiler;
+      return true;
+    }
+  }
+  return false;
+}
+function registerFormatCompilers(registered, formatCompilers) {
+  const keys = Object.keys(formatCompilers);
+  for (let i = 0; i < keys.length; ++i) {
+    const key = keys[i];
+    const item = formatCompilers[key];
+    registerFormatCompiler(registered, key, item);
+  }
+  return registered;
+}
+function getSchemaFormatCompiler(registered, name) {
+  if (isStringType(name))
+    return registered[name];
+  else
+    return void 0;
+}
+function compileFormatBasic(schemaObj, jsonSchema) {
+  if (!isStringType(jsonSchema.format))
+    return void 0;
+  const compiler = getSchemaFormatCompiler(
+    schemaObj.formats,
+    jsonSchema.format
+  );
+  if (compiler)
+    return compiler(schemaObj, jsonSchema);
+  else
+    throw new Error(`Unknown format ${jsonSchema.format}`);
+}
+
+// ../core/src/object.js
+function equalsDeep(target, source) {
+  if (target === source) return true;
+  if (target == null) return false;
+  if (source == null) return false;
+  if (isBooleanType(target)) return false;
+  if (isBooleanType(source)) return false;
+  if (isFn(target))
+    return target.toString() === source.toString();
+  if (isScalarType(target))
+    return false;
+  if (target.constructor !== source.constructor)
+    return false;
+  if (target.constructor === Object) {
+    const tks = Object.keys(target);
+    const sks = Object.keys(source);
+    if (tks.length !== sks.length)
+      return false;
+    for (let i = 0; i < tks.length; ++i) {
+      const key = tks[i];
+      if (!equalsDeep(target[key], source[key]))
+        return false;
+    }
+    return true;
+  }
+  if (target.constructor === Map) {
+    if (target.size !== source.size)
+      return false;
+    for (const [key, value] of target) {
+      if (source.has(key) === false)
+        return false;
+      if (!equalsDeep(value, source.get(key)))
+        return false;
+    }
+    return true;
+  }
+  if (target.constructor === Array) {
+    if (target.length !== source.length)
+      return false;
+    for (let i = 0; i < target.length; ++i) {
+      if (!equalsDeep(target[i], source[i]))
+        return false;
+    }
+    return true;
+  }
+  if (target.constructor === Set) {
+    if (target.size !== source.size)
+      return false;
+    for (const value of target) {
+      if (source.has(value) === false)
+        return false;
+    }
+    return true;
+  }
+  if (target.constructor === RegExp) {
+    return target.toString() === source.toString();
+  }
+  if (isTypedArray(target)) {
+    if (target.length !== source.length)
+      return false;
+    for (let i = 0; i < target.length; ++i) {
+      if (target[i] !== source[i])
+        return false;
+    }
+    return true;
+  }
+  const tkeys = Object.keys(target);
+  const skeys = Object.keys(source);
+  if (tkeys.length !== skeys.length) return false;
+  if (tkeys.length === 0) return true;
+  for (let i = 0; i < tkeys.length; ++i) {
+    const key = tkeys[i];
+    if (!equalsDeep(target[key], source[key]))
+      return false;
+  }
+  return true;
+}
+
+// src/enum.js
+function compileConst(schemaObj, jsonSchema) {
+  const constant = jsonSchema.const;
+  if (constant === void 0) return void 0;
+  const addError = schemaObj.createErrorHandler(constant, "const");
+  if (constant === null || isScalarType(constant)) {
+    return function validatePrimitiveConst(data, dataPath) {
+      return constant === data || addError(data, dataPath);
+    };
+  } else {
+    return function validateComplexConst(data, dataPath) {
+      return equalsDeep(constant, data) || addError(data, dataPath);
+    };
+  }
+}
+function compileEnum(schemaObj, jsonSchema) {
+  const enums = getArrayClassMinItems(jsonSchema.enum, 1);
+  if (enums == null) return void 0;
+  let hasObjects = false;
+  for (let i = 0; i < enums.length; ++i) {
+    const e = enums[i];
+    if (e != null && typeof e === "object") {
+      hasObjects = true;
+      break;
+    }
+  }
+  const addError = schemaObj.createErrorHandler(enums, "enum");
+  if (hasObjects === false) {
+    return function validateEnumSimple(data, dataPath) {
+      return data === void 0 ? true : enums.includes(data) ? true : addError(data, dataPath);
+    };
+  } else {
+    return function validateEnumDeep(data, dataPath) {
+      if (data === void 0) return true;
+      if (data === null || typeof data !== "object")
+        return enums.includes(data) ? true : addError(data, dataPath);
+      for (let i = 0; i < enums.length; ++i) {
+        if (equalsDeep(enums[i], data) === true)
+          return true;
+      }
+      return addError(data, dataPath);
+    };
+  }
+}
+function compileEnumBasic(schemaObj, jsonSchema) {
+  return [
+    compileConst(schemaObj, jsonSchema),
+    compileEnum(schemaObj, jsonSchema)
+  ];
+}
+
+// src/number.js
+function compileNumberMaximum(schemaObj, jsonSchema) {
+  const [max, emax] = getInclusiveExclusiveBounds(
+    getNumbishType,
+    jsonSchema.maximum,
+    jsonSchema.exclusiveMaximum
+  );
+  if (emax != null) {
+    const addError = schemaObj.createErrorHandler(emax, "exclusiveMaximum");
+    return function validateExclusiveMaximum(data, dataPath) {
+      return data < emax || addError(data, dataPath);
+    };
+  } else if (max != null) {
+    const addError = schemaObj.createErrorHandler(max, "maximum");
+    return function validateMaximum(data, dataPath) {
+      return data <= max || addError(data, dataPath);
+    };
+  }
+  return void 0;
+}
+function compileNumberMinimum(schemaObj, jsonSchema) {
+  const [min, emin] = getInclusiveExclusiveBounds(
+    getNumbishType,
+    jsonSchema.minimum,
+    jsonSchema.exclusiveMinimum
+  );
+  if (emin != null) {
+    const addError = schemaObj.createErrorHandler(emin, "exclusiveMinimum");
+    return function validateExclusiveMinimum(data, dataPath) {
+      return data > emin || addError(data, dataPath);
+    };
+  } else if (min != null) {
+    const addError = schemaObj.createErrorHandler(min, "minimum");
+    return function validateMinimum(data, dataPath) {
+      return data >= min || addError(data, dataPath);
+    };
+  }
+  return void 0;
+}
+function compileNumberMultipleOf(schemaObj, jsonSchema) {
+  const mulOf = getNumbishType(jsonSchema.multipleOf);
+  if (mulOf == null) return void 0;
+  const addError = schemaObj.createErrorHandler(mulOf, "multipleOf");
+  return function validateMultipleOf(data, dataPath) {
+    return data % mulOf === 0 || addError(data, dataPath);
+  };
+}
+function compileNumberIntern(schemaObj, jsonSchema) {
+  const maximum = compileNumberMaximum(schemaObj, jsonSchema);
+  const minimum = compileNumberMinimum(schemaObj, jsonSchema);
+  const multipleOf = compileNumberMultipleOf(schemaObj, jsonSchema);
+  if (maximum == null && minimum == null && multipleOf == null)
+    return void 0;
+  const isMax = maximum || trueThat;
+  const isMin = minimum || trueThat;
+  const isMul = multipleOf || trueThat;
+  return function validateNumberIntern(data, dataPath) {
+    return isMax(data, dataPath) && isMin(data, dataPath) && isMul(data, dataPath);
+  };
+}
+function compileNumberBasic(schemaObj, jsonSchema) {
+  const intern = compileNumberIntern(schemaObj, jsonSchema);
+  if (intern == null) return void 0;
+  return function validateNumber(data, dataPath) {
+    return isNumberType(data) ? intern(data, dataPath) : true;
+  };
+}
+
+// src/bigint.js
+function compileBigIntMaximum(schemaObj, jsonSchema) {
+  const [max, emax] = getInclusiveExclusiveBounds(
+    getBigIntType,
+    jsonSchema.maximum,
+    jsonSchema.exclusiveMaximum
+  );
+  if (emax != null) {
+    const addError = schemaObj.createErrorHandler(emax, "exclusiveMaximum");
+    return function validateExclusiveMaximumBigInt(data, dataPath) {
+      return data < emax || addError(data, dataPath);
+    };
+  } else if (max != null) {
+    const addError = schemaObj.createErrorHandler(max, "maximum");
+    return function validateMaximumBigInt(data, dataPath) {
+      return data <= max || addError(data, dataPath);
+    };
+  }
+  return void 0;
+}
+function compileBigIntMinimum(schemaObj, jsonSchema) {
+  const [min, emin] = getInclusiveExclusiveBounds(
+    getBigIntType,
+    jsonSchema.minimum,
+    jsonSchema.exclusiveMinimum
+  );
+  if (emin != null) {
+    const addError = schemaObj.createErrorHandler(emin, "exclusiveMinimum");
+    return function validateExclusiveMinimumBigInt(data, dataPath) {
+      return data > emin || addError(data, dataPath);
+    };
+  } else if (min != null) {
+    const addError = schemaObj.createErrorHandler(min, "minimum");
+    return function validateMinimumBigInt(data, dataPath) {
+      return data >= min || addError(data, dataPath);
+    };
+  }
+  return void 0;
+}
+function compileBigIntMultipleOf(schemaObj, jsonSchema) {
+  const mulOf = getBigIntType(jsonSchema.multipleOf);
+  if (mulOf == null) return void 0;
+  const addError = schemaObj.createErrorHandler(mulOf, "multipleOf");
+  return function validateMultipleOfBigInt(data, dataPath) {
+    return data % mulOf === BigInt(0) || addError(data, dataPath);
+  };
+}
+function compileBigIntBasic(schemaObj, jsonSchema) {
+  const maximum = compileBigIntMaximum(schemaObj, jsonSchema);
+  const minimum = compileBigIntMinimum(schemaObj, jsonSchema);
+  const multipleOf = compileBigIntMultipleOf(schemaObj, jsonSchema);
+  if (maximum == null && minimum == null && multipleOf == null) return void 0;
+  const isMax = maximum || trueThat;
+  const isMin = minimum || trueThat;
+  const isMul = multipleOf || trueThat;
+  return function validateBigIntSchema(data, dataPath) {
+    if (isBigIntType(data)) {
+      return isMax(data, dataPath) && isMin(data, dataPath) && isMul(data, dataPath);
+    }
+    return true;
+  };
+}
+
+// src/string.js
+function compileMinLength(schemaObj, jsonSchema) {
+  const min = getIntishType(jsonSchema.minLength) || 0;
+  if (min < 1) return void 0;
+  const addError = schemaObj.createErrorHandler(min, "minLength");
+  return function validateIsMinLength(len = 0, dataPath) {
+    return len >= min || addError(len, dataPath);
+  };
+}
+function compileMaxLength(schemaObj, jsonSchema) {
+  const max = getIntishType(jsonSchema.maxLength) || -1;
+  if (max < 0) return void 0;
+  const addError = schemaObj.createErrorHandler(max, "maxlength");
+  return function validateIsMaxLength(len = 0, dataPath) {
+    return len <= max || addError(len, dataPath);
+  };
+}
+function compilePattern(schemaObj, jsonSchema) {
+  const pattern = createRegExp(jsonSchema.pattern);
+  if (pattern == null) return void 0;
+  const addError = schemaObj.createErrorHandler(pattern, "pattern");
+  return function validateIsMatch(str = "", dataPath) {
+    return pattern.test(str) || addError(str, dataPath);
+  };
+}
+function compileStringIntern(schemaObj, jsonSchema) {
+  const minLength = compileMinLength(schemaObj, jsonSchema);
+  const maxLength = compileMaxLength(schemaObj, jsonSchema);
+  const pattern = compilePattern(schemaObj, jsonSchema);
+  if ((minLength || maxLength || pattern) == null) return void 0;
+  const isMinLength = minLength || trueThat;
+  const isMaxLength = maxLength || trueThat;
+  const isMatch = pattern || trueThat;
+  return function validateStringIntern(data, dataPath) {
+    const len = data.length;
+    return isMinLength(len, dataPath) && isMaxLength(len, dataPath) && isMatch(data, dataPath);
+  };
+}
+function compileStringBasic(schemaObj, jsonSchema) {
+  const intern = compileStringIntern(schemaObj, jsonSchema);
+  if (intern == null) return void 0;
+  return function validateStringBasic(data, dataPath) {
+    return isStringType(data) && intern(data, dataPath);
+  };
+}
+
+// src/object.js
+function compileMinProperties(schemaObj, jsonSchema) {
+  const min = getIntishType(jsonSchema.minProperties) || 0;
+  if (min < 1) return void 0;
+  const addError = schemaObj.createErrorHandler(min, "minProperties");
+  return function validateMinProperties(len = 0, dataPath = "") {
+    return len >= min || addError(len, dataPath);
+  };
+}
+function compileMaxProperties(schemaObj, jsonSchema) {
+  const max = getIntishType(jsonSchema.maxProperties) || -1;
+  if (max < 0) return void 0;
+  const min = getIntishType(jsonSchema.minProperties) || 0;
+  if (max < min) throw new Error("maxProperties must be greater then minProperties");
+  const addError = schemaObj.createErrorHandler(max, "maxProperties");
+  return function validateMaxProperties(len = 0, dataPath = "") {
+    return len <= max || addError(len, dataPath);
+  };
+}
+function compileRequiredProperties(schemaObj, jsonSchema) {
+  const required = getArrayClassMinItems(jsonSchema.required, 1);
+  if (required == null) return void 0;
+  const rlength = required.length;
+  const addError = schemaObj.createErrorHandler(required, "requiredProperties");
+  return function validateRequiredProperties(dataKeys = [], dataPath = "") {
+    let valid = true;
+    for (let i = 0; i < rlength; ++i) {
+      const key = required[i];
+      const idx = dataKeys.indexOf(key);
+      if (idx === -1)
+        valid &&= addError(key, dataPath);
+    }
+    return valid;
+  };
+}
+function compilePropertyNames(schemaObj, jsonSchema) {
+  const propNames = getBoolOrObjectClass(jsonSchema.propertyNames);
+  if (propNames == null) return void 0;
+  return schemaObj.createValidator(propNames, "propertyNames");
+}
+function compileProperties(schemaObj, jsonSchema) {
+  const properties = getObjectType(jsonSchema.properties);
+  if (properties == null) return void 0;
+  const keys = Object.keys(properties);
+  if (keys.length === 0) return void 0;
+  const validators = {};
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const schemas = properties[key];
+    const validator = schemaObj.createValidator(schemas, "properties", key);
+    if (validator != null)
+      validators[key] = validator;
+  }
+  if (Object.keys(validators).length === 0)
+    return void 0;
+  return function validatePropertyItem(data, dataPath, dataRoot, dataKey) {
+    const result = new ValidationResult();
+    const validator = validators[dataKey];
+    if (validator == null)
+      return result;
+    else {
+      return result.addMatch(
+        validator(data[dataKey], dataPath, dataRoot, dataKey)
+      );
+    }
+  };
+}
+function compilePatternProperties(schemaObj, jsonSchema) {
+  const entries = getObjectType(jsonSchema.patternProperties);
+  if (entries == null) return void 0;
+  const entryKeys = Object.keys(entries);
+  if (entryKeys.length === 0) return void 0;
+  const patterns = {};
+  for (let i = 0; i < entryKeys.length; ++i) {
+    const key = entryKeys[i];
+    const pattern = createRegExp(key);
+    if (pattern != null)
+      patterns[key] = pattern;
+  }
+  const patternKeys = Object.keys(patterns);
+  if (patternKeys.length === 0) return void 0;
+  const validators = {};
+  for (let i = 0; i < patternKeys.length; ++i) {
+    const key = patternKeys[i];
+    const schema = entries[key];
+    const validator = schemaObj.createValidator(schema, "patternProperties", key);
+    if (validator != null)
+      validators[key] = validator;
+  }
+  const validatorKeys = Object.keys(validators);
+  if (validatorKeys.length === 0) return void 0;
+  return function validatePatternPropertiesItem(data, dataPath, dataRoot, dataKey) {
+    const result = new ValidationResult();
+    for (let i = 0; i < validatorKeys.length; ++i) {
+      const key = validatorKeys[i];
+      const pattern = patterns[key];
+      if (pattern.test(dataKey)) {
+        const validate = validators[key];
+        result.addMatch(validate(data[dataKey], dataPath, dataRoot, dataKey));
+      }
+    }
+    return result;
+  };
+}
+function compileAdditionalProperties(schemaObj, jsonSchema) {
+  const additional = getBoolOrObjectClass(jsonSchema.additionalProperties);
+  if (additional == null) return void 0;
+  if (additional === false) {
+    const addError = schemaObj.createErrorHandler(false, "additionalProperties");
+    return function validateNoAdditionalProperties(data, dataPath, dataRoot, dataKey) {
+      return addError(dataKey, data);
+    };
+  }
+  const validator = schemaObj.createValidator(additional, "additionalProperties");
+  return function validateAdditionalPropertyItem(data, dataPath, dataRoot, dataKey) {
+    return validator(data[dataKey], dataPath, dataRoot, dataKey);
+  };
+}
+function compileUnevaluatedProperties(schemaObj, jsonSchema) {
+  const unevaluatedProperties = getBoolOrObjectClass(jsonSchema.unevaluatedProperties);
+  if (unevaluatedProperties == null) return void 0;
+  if (unevaluatedProperties === false) {
+    const addError = schemaObj.createErrorHandler(false, "unevaluatedProperties");
+    return (data, dataPath, dataRoot, dataKey) => addError(dataKey, data);
+  }
+  return schemaObj.createValidator(unevaluatedProperties, "unevaluatedProperties");
+}
+function compileDependentRequired(schemaObj, jsonSchema) {
+  const dependentRequired = getObjectType(jsonSchema.dependentRequired);
+  if (dependentRequired == null)
+    return void 0;
+  if (Object.keys(dependentRequired).length === 0)
+    return void 0;
+  const addError = schemaObj.createErrorHandler(false, "dependentRequired");
+  return function validateDependentRequiredItem(data, dataPath, dataRoot, dataKey) {
+    if (dataKey in dependentRequired) {
+      const required = dependentRequired[dataKey];
+      return includesAll(Object.keys(data), required) || addError(data, dataKey, dataPath);
+    }
+    return true;
+  };
+}
+function compileDependentSchemas(schemaObj, jsonSchema) {
+  const dependentSchemas = getObjectType(jsonSchema.dependentSchemas);
+  if (dependentSchemas == null) return void 0;
+  const validators = {};
+  for (const key in dependentSchemas) {
+    if (key in dependentSchemas) {
+      const schema = dependentSchemas[key];
+      if (!isBoolOrObjectClass(schema) && !schemaObj.options.skipErrors)
+        throw new Error(`Expected Schema at '${schemaObj.path}/${key}'`);
+      const validator = schemaObj.createValidator(schema, "dependentSchemas", key);
+      if (validator != null)
+        validators[key] = validator;
+      else
+        throw new Error(`Expected Validator at '${schemaObj.path}/${key}'`);
+    }
+  }
+  if (Object.keys(validators).length === 0)
+    return void 0;
+  return function validateDependentSchemasItem(data, dataPath, dataRoot, dataKey) {
+    if (dataKey in validators) {
+      const validator = validators[dataKey];
+      return validator(data, dataPath, dataRoot, dataKey);
+    }
+    return true;
+  };
+}
+function compileDependencies(schemaObj, jsonSchema) {
+  const dependencies = getObjectType(jsonSchema.dependencies);
+  if (dependencies == null)
+    return void 0;
+  const validators = {};
+  for (const key in dependencies) {
+    if (key in dependencies) {
+      const right = dependencies[key];
+      if (isBoolOrObjectClass(right)) {
+        const validator = schemaObj.createValidator(right, "dependencies", key);
+        if (validator != null)
+          validators[key] = validator;
+        else
+          throw new Error(`Expected Validator at '${schemaObj.path}/${key}'`);
+      } else if (isArrayClass(right)) {
+        const addError = schemaObj.createErrorHandler(right, ["dependencies", key]);
+        validators[key] = function validateRequiredDependency(data, dataPath, dataRoot, dataKey) {
+          return includesAll(Object.keys(data), right) || addError(data, dataKey, dataPath);
+        };
+      } else if (!schemaObj.options.skipErrors)
+        throw new Error(`Expected Schema or Array at '${schemaObj.path}/${key}'`);
+    }
+  }
+  if (Object.keys(validators).length === 0)
+    return void 0;
+  return function validateDependenciesItem(data, dataPath, dataRoot, dataKey) {
+    if (dataKey in validators) {
+      const validator = validators[dataKey];
+      return validator(data, dataPath, dataRoot, dataKey);
+    }
+    return true;
+  };
+}
+function compileObjectPrimitives(schemaObj, jsonSchema) {
+  const minProperties = compileMinProperties(schemaObj, jsonSchema);
+  const maxProperties = compileMaxProperties(schemaObj, jsonSchema);
+  const requiredProperties = compileRequiredProperties(schemaObj, jsonSchema);
+  if ((minProperties || maxProperties || requiredProperties) == null)
+    return void 0;
+  const isMinProperties = minProperties || trueThat;
+  const isMaxProperties = maxProperties || trueThat;
+  const hasRequiredProperties = requiredProperties || trueThat;
+  return function validateObjectPrimitives(data, dataPath, dataRoot, dataKeys) {
+    const keys = dataKeys || Object.keys(data);
+    const len = keys.length;
+    return isMinProperties(len, dataPath) && isMaxProperties(len, dataPath) && hasRequiredProperties(keys, dataPath);
+  };
+}
+function compileObjectProperty(schemaObj, jsonSchema) {
+  const namesValidator = compilePropertyNames(schemaObj, jsonSchema);
+  const propertyValidator = compileProperties(schemaObj, jsonSchema);
+  const patternValidator = compilePatternProperties(schemaObj, jsonSchema);
+  const additionalValidator = compileAdditionalProperties(schemaObj, jsonSchema);
+  const depSchemasValidator = compileDependentSchemas(schemaObj, jsonSchema);
+  const dependencyValidator = compileDependencies(schemaObj, jsonSchema);
+  const depRequiredValidator = compileDependentRequired(schemaObj, jsonSchema);
+  const unevaluatedValidator = compileUnevaluatedProperties(schemaObj, jsonSchema);
+  if ((patternValidator || namesValidator || propertyValidator || depRequiredValidator || depSchemasValidator || dependencyValidator || additionalValidator || unevaluatedValidator) == null)
+    return void 0;
+  const validateName = namesValidator || trueThat;
+  const validateProperty = propertyValidator || ValidationResult.undefThat;
+  const validatePattern = patternValidator || ValidationResult.undefThat;
+  const validateDepRequired = depRequiredValidator || trueThat;
+  const validateDepSchemas = depSchemasValidator || trueThat;
+  const validateDependency = dependencyValidator || trueThat;
+  return function validateObjectProperty(data, dataPath, dataRoot, dataKey) {
+    const result = new ValidationResult();
+    result.addValid(validateName(dataKey)).addResult(validateProperty(data, dataPath, dataRoot, dataKey)).addResult(validatePattern(data, dataPath, dataRoot, dataKey)).addValid(validateDepRequired(data, dataPath, dataRoot, dataKey)).addValid(validateDepSchemas(data, dataPath, dataRoot, dataKey)).addValid(validateDependency(data, dataPath, dataRoot, dataKey));
+    if (additionalValidator)
+      return !result.match ? result.addMatch(additionalValidator(data, dataPath, dataRoot, dataKey)) : result;
+    if (unevaluatedValidator)
+      result.addValid(unevaluatedValidator(data, dataPath, dataRoot, dataKey));
+    return result;
+  };
+}
+function compileObjectChildren(schemaObj, jsonSchema) {
+  const propertyValidator = compileObjectProperty(schemaObj, jsonSchema);
+  if (propertyValidator == null)
+    return void 0;
+  return function validateObjectChildren(data, dataPath, dataRoot, dataKeys) {
+    const result = new ValidationResult();
+    for (let i = 0; i < dataKeys.length; ++i) {
+      const dataKey = dataKeys[i];
+      result.addResult(propertyValidator(data, dataPath, dataRoot, dataKey));
+    }
+    return result.isValid();
+  };
+}
+function compileObjectSchema(schemaObj, jsonSchema) {
+  if (isOfSchemaType(jsonSchema, "map"))
+    return void 0;
+  const objectPrimitives = compileObjectPrimitives(schemaObj, jsonSchema);
+  const objectChildren = compileObjectChildren(schemaObj, jsonSchema);
+  if ((objectPrimitives || objectChildren) == null)
+    return void 0;
+  const validatePrimitives = objectPrimitives || trueThat;
+  const validateChildren = objectChildren || trueThat;
+  return function validateObjectSchema(data, dataPath, dataRoot) {
+    if (isObjectClass(data)) {
+      const dataKeys = Object.keys(data);
+      return validatePrimitives(data, dataPath, dataRoot, dataKeys) && validateChildren(data, dataPath, dataRoot, dataKeys);
+    }
+    return true;
+  };
+}
+
+// src/array.js
+function compileMinItems(schemaObj, jsonSchema) {
+  const min = getIntishType(jsonSchema.minItems) || 0;
+  if (min < 1) return void 0;
+  const addError = schemaObj.createErrorHandler(min, "minItems");
+  return function validateMinItems(len = 0, dataPath = "") {
+    return len >= min || addError(len, dataPath);
+  };
+}
+function compileMaxItems(schemaObj, jsonSchema) {
+  const max = getIntishType(jsonSchema.maxItems) || -1;
+  if (max < 0) return void 0;
+  const min = getIntishType(jsonSchema.minItems) || 0;
+  if (max < min) throw new Error("maxItems must be greater then minItems");
+  const addError = schemaObj.createErrorHandler(max, "maxItems");
+  return function validateMaxItems(len = 0, dataPath = "") {
+    return len <= max || addError(len, dataPath);
+  };
+}
+function createBooleanValidator(schemaObj, jsonSchema, key, validationFn) {
+  const value = getBoolishType(jsonSchema[key]);
+  if (value !== true) return void 0;
+  const addError = schemaObj.createErrorHandler(value, key);
+  return function validateBooleanComparator(data, dataPath) {
+    return validationFn(data) || addError(data, dataPath);
+  };
+}
+var compileUniqueItems = (schemaObj, jsonSchema) => createBooleanValidator(schemaObj, jsonSchema, "uniqueItems", isUniqueArray);
+function compileTupleInternal(schemaObj, jsonSchema, itemsKey, additionalKey) {
+  const tuple = getArrayClassMinItems(jsonSchema[itemsKey], 1);
+  if (tuple == null)
+    return void 0;
+  const validators = tuple.map((item, i) => {
+    if (item === true) return trueThat;
+    if (item === false) return falseThat;
+    return schemaObj.createValidator(item, itemsKey, i);
+  });
+  const vlength = validators.length;
+  const additional = getBoolOrObjectClass(jsonSchema[additionalKey], true);
+  if (typeof additional === "boolean") {
+    return function validateTupleBool(data, dataPath, dataRoot, i) {
+      return i >= vlength ? additional : validators[i](data, dataPath, dataRoot);
+    };
+  }
+  const validateAdditional = schemaObj.createValidator(additional, additionalKey);
+  return function validateTupleSchema(data, dataPath, dataRoot, i) {
+    return i < vlength ? validators[i](data, dataPath, dataRoot) : validateAdditional(data, dataPath, dataRoot);
+  };
+}
+function compilePrefixItems(schemaObj, jsonSchema) {
+  return compileTupleInternal(schemaObj, jsonSchema, "prefixItems", "items");
+}
+function compileTupleItems(schemaObj, jsonSchema) {
+  return compileTupleInternal(schemaObj, jsonSchema, "items", "additionalItems");
+}
+function compileArrayContains(schemaObj, jsonSchema) {
+  const contains = getObjectType(jsonSchema.contains);
+  if (contains == null) return void 0;
+  return schemaObj.createValidator(contains, "contains");
+}
+function compileContainsMinMax(schemaObj, jsonSchema) {
+  const contains = getObjectType(jsonSchema.contains);
+  if (contains == null) return void 0;
+  const minContains = getIntishType(jsonSchema.minContains);
+  const maxContains = getIntishType(jsonSchema.maxContains);
+  const addNonError = schemaObj.createErrorHandler(0, "contains");
+  const addMinError = schemaObj.createErrorHandler(minContains, "minContains");
+  const addMaxError = schemaObj.createErrorHandler(maxContains, "maxContains");
+  if (minContains == null && maxContains == null) {
+    return function validateContainsAtLeastOne(count, dataPath) {
+      return count > 0 || addNonError(count, dataPath);
+    };
+  }
+  if (maxContains == null) {
+    return function validateMinContains(count, dataPath) {
+      return count >= (minContains || 0) || addMinError(count, dataPath);
+    };
+  }
+  if (minContains == null) {
+    return function validateMaxContains(count, dataPath) {
+      return count === 0 ? addNonError(count, dataPath) : count <= maxContains || addMaxError(count, dataPath);
+    };
+  }
+  return function validateMinMaxContains(count, dataPath) {
+    return (count >= minContains || addMinError(count, dataPath)) && (count <= maxContains || addMaxError(count, dataPath));
+  };
+}
+function compileArrayContainsBoolean(schemaObj, jsonSchema) {
+  const contains = getBoolishType(jsonSchema.contains);
+  if (contains === true) {
+    const addError = schemaObj.createErrorHandler(true, "contains");
+    return function validateArrayContainsTrue(data, dataPath) {
+      return data.length > 0 || addError(data, dataPath);
+    };
+  }
+  if (contains === false) {
+    const addError = schemaObj.createErrorHandler(false, "contains");
+    return function validateArrayContainsFalse(data, dataPath) {
+      return addError(data, dataPath);
+    };
+  }
+  return void 0;
+}
+function compileArrayItemsBoolean(schemaObj, jsonSchema) {
+  const items = getBoolishType(jsonSchema.items);
+  if (items === true) return trueThat;
+  if (items !== false) return void 0;
+  const addError = schemaObj.createErrorHandler(false, "items");
+  return function validateArrayItemsFalse(data, dataPath) {
+    return data.length === 0 || addError(data, dataPath);
+  };
+}
+function compileArrayItems(schemaObj, jsonSchema) {
+  const items = getObjectType(jsonSchema.items);
+  if (items == null) return void 0;
+  return schemaObj.createValidator(items, "items");
+}
+function compileUnevaluatedItems(schemaObj, jsonSchema) {
+  const unevaluatedItems = getObjectType(jsonSchema.unevaluatedItems);
+  if (unevaluatedItems == null) return void 0;
+  return schemaObj.createValidator(unevaluatedItems, "unevaluatedItems");
+}
+function compileArrayPrimitives(schemaObj, jsonSchema) {
+  const minItems = compileMinItems(schemaObj, jsonSchema);
+  const maxItems = compileMaxItems(schemaObj, jsonSchema);
+  const uniqueItems = compileUniqueItems(schemaObj, jsonSchema);
+  if ((minItems || maxItems || uniqueItems) == null)
+    return void 0;
+  const isMinItems = minItems || trueThat;
+  const isMaxItems = maxItems || trueThat;
+  const isUniqueItems = uniqueItems || trueThat;
+  return function validateArrayPrimitives(data, dataPath) {
+    const len = data.length;
+    return isMinItems(len, dataPath) && isMaxItems(len, dataPath) && isUniqueItems(data, dataPath);
+  };
+}
+function compileArrayChildren(schemaObj, jsonSchema) {
+  const validateItem = compilePrefixItems(schemaObj, jsonSchema) || compileTupleItems(schemaObj, jsonSchema) || compileArrayItems(schemaObj, jsonSchema);
+  const validateContains = compileArrayContains(schemaObj, jsonSchema);
+  const validateUnevaluated = compileUnevaluatedItems(schemaObj, jsonSchema);
+  if ((validateItem || validateContains || validateUnevaluated) == null)
+    return void 0;
+  const validateMinMax = compileContainsMinMax(schemaObj, jsonSchema) || trueThat;
+  const maxItems = getIntishType(jsonSchema.maxItems) || 0;
+  const resolveLength = (len) => maxItems > 0 ? Math.min(maxItems, len) : len;
+  if (validateContains == null) {
+    const addError = schemaObj.createErrorHandler(0, "items");
+    return function validateArrayItemsOnly(data, dataPath, dataRoot) {
+      const len = resolveLength(data.length);
+      let invalid = 0;
+      for (let i = 0; i < len; ++i) {
+        const obj = data[i];
+        if (validateItem(obj, dataPath, dataRoot, i) === false) {
+          invalid++;
+        }
+      }
+      return invalid === 0 || addError(invalid, dataPath);
+    };
+  }
+  if (validateItem == null) {
+    return function validateArrayContainsOnly(data, dataPath) {
+      const len = resolveLength(data.length);
+      let contains = 0;
+      for (let i = 0; i < len; ++i) {
+        const obj = data[i];
+        if (validateContains(obj, dataPath) === true) {
+          contains++;
+        }
+      }
+      return validateMinMax(contains, dataPath);
+    };
+  }
+  return function validateArrayChildren(data, dataPath, dataRoot) {
+    const len = resolveLength(data.length);
+    let invalid = 0;
+    let contains = 0;
+    for (let i = 0; i < len; ++i) {
+      const obj = data[i];
+      if (validateItem(obj, dataPath, dataRoot, i) !== true) {
+        invalid++;
+      }
+      if (validateContains(obj, dataPath, dataRoot) === true) {
+        contains++;
+      }
+    }
+    return invalid === 0 && validateMinMax(contains, dataPath);
+  };
+}
+function compileArraySchema(schemaObj, jsonSchema) {
+  if (isOfSchemaType(jsonSchema, "set"))
+    return void 0;
+  const compiledPrimitives = compileArrayPrimitives(schemaObj, jsonSchema);
+  const compiledItemsBoolean = compileArrayItemsBoolean(schemaObj, jsonSchema);
+  const compiledContainsBoolean = compileArrayContainsBoolean(schemaObj, jsonSchema);
+  const compiledArrayChildren = compileArrayChildren(schemaObj, jsonSchema);
+  if ((compiledPrimitives || compiledItemsBoolean || compiledContainsBoolean || compiledArrayChildren) === void 0)
+    return void 0;
+  const validatePrimitives = compiledPrimitives || trueThat;
+  const hasBooleanItems = compiledItemsBoolean || trueThat;
+  const hasBooleanContains = compiledContainsBoolean || trueThat;
+  const validateItems = compiledArrayChildren || trueThat;
+  return function validateArraySchema(data, dataPath, dataRoot) {
+    if (isArrayClass(data)) {
+      return validatePrimitives(data, dataPath) && hasBooleanItems(data, dataPath, dataRoot) && hasBooleanContains(data, dataPath, dataRoot) && validateItems(data, dataPath, dataRoot);
+    }
+    return true;
+  };
+}
+
+// src/combine.js
+function compileAllOf(schemaObj, jsonSchema) {
+  const allOf = getArrayClassMinItems(jsonSchema.allOf, 1);
+  if (allOf == null) return void 0;
+  const validators = [];
+  for (let i = 0; i < allOf.length; ++i) {
+    const child = allOf[i];
+    if (child === true)
+      validators.push(trueThat);
+    else if (child === false)
+      validators.push(falseThat);
+    else {
+      const validator = schemaObj.createValidator(child, "allOf", i);
+      validators.push(validator);
+    }
+  }
+  if (validators.length === 0) return void 0;
+  const addError = schemaObj.createErrorHandler(allOf, "allOf");
+  return function validateAllOf(data, dataPath, dataRoot, dataKey) {
+    if (data !== void 0) {
+      for (let i = 0; i < validators.length; ++i) {
+        const validator = validators[i];
+        if (validator(data, dataPath, dataRoot, dataKey) === false) {
+          return addError(data, dataPath);
+        }
+      }
+    }
+    return true;
+  };
+}
+function compileAnyOf(schemaObj, jsonSchema) {
+  const anyOf = getArrayClassMinItems(jsonSchema.anyOf, 1);
+  if (anyOf == null) return void 0;
+  const validators = [];
+  for (let i = 0; i < anyOf.length; ++i) {
+    const child = anyOf[i];
+    if (child === true)
+      validators.push(trueThat);
+    else if (child === false)
+      validators.push(falseThat);
+    else {
+      const validator = schemaObj.createValidator(child, "anyOf", i);
+      validators.push(validator);
+    }
+  }
+  if (validators.length === 0) return void 0;
+  const addError = schemaObj.createErrorHandler(anyOf, "anyOf");
+  return function validateAnyOf(data, dataPath, dataRoot, dataKey) {
+    if (data !== void 0) {
+      for (let i = 0; i < validators.length; ++i) {
+        const validator = validators[i];
+        if (validator(data, dataPath, dataRoot, dataKey) === true) return true;
+      }
+      return addError(data, dataPath);
+    }
+    return true;
+  };
+}
+function compileOneOf(schemaObj, jsonSchema) {
+  const oneOf = getArrayClassMinItems(jsonSchema.oneOf, 1);
+  if (oneOf == null)
+    return void 0;
+  const validators = [];
+  for (let i = 0; i < oneOf.length; ++i) {
+    const child = oneOf[i];
+    if (child === true)
+      validators.push(trueThat);
+    else if (child === false)
+      validators.push(falseThat);
+    else {
+      const validator = schemaObj.createValidator(child, "oneOf", i);
+      validators.push(validator);
+    }
+  }
+  if (validators.length === 0)
+    return void 0;
+  const addError = schemaObj.createErrorHandler(oneOf, "oneOf");
+  return function validateOneOf(data, dataPath, dataRoot, dataKey) {
+    let found = false;
+    for (let i = 0; i < validators.length; ++i) {
+      const validator = validators[i];
+      if (validator(data, dataPath, dataRoot, dataKey) === true) {
+        if (found === true)
+          return addError(data, dataPath);
+        found = true;
+      }
+    }
+    return found;
+  };
+}
+function compileNotOf(schemaObj, jsonSchema) {
+  const notOf = getBoolOrObjectClass(jsonSchema.not);
+  if (notOf == null) return void 0;
+  if (notOf === true) return falseThat;
+  if (notOf === false) return trueThat;
+  const validate = schemaObj.createValidator(notOf, "not");
+  const addError = schemaObj.createErrorHandler(notOf, "not");
+  return function validateNotOf(data, dataPath, dataRoot, dataKey) {
+    if (data === void 0) return true;
+    return validate(data, dataPath, dataRoot, dataKey) === false ? true : addError(data, dataPath);
+  };
+}
+function compileCombineSchema(schemaObj, jsonSchema) {
+  const validators = [];
+  function addValidator(compiler) {
+    if (isFn(compiler))
+      validators.push(compiler);
+  }
+  addValidator(compileAllOf(schemaObj, jsonSchema));
+  addValidator(compileAnyOf(schemaObj, jsonSchema));
+  addValidator(compileOneOf(schemaObj, jsonSchema));
+  addValidator(compileNotOf(schemaObj, jsonSchema));
+  if (validators.length === 0)
+    return void 0;
+  if (validators.length === 1)
+    return validators[0];
+  if (validators.length === 2) {
+    const first = validators[0];
+    const second = validators[1];
+    return function validateCombinaSchemaPair(data, dataPath, dataRoot, dataKey) {
+      return first(data, dataPath, dataRoot, dataKey) && second(data, dataPath, dataRoot, dataKey);
+    };
+  } else {
+    return function validateCombineSchema(data, dataPath, dataRoot, dataKey) {
+      for (let i = 0; i < validators.length; ++i) {
+        const validator = validators[i];
+        if (validator(data, dataPath, dataRoot, dataKey) === false)
+          return false;
+      }
+      return true;
+    };
+  }
+}
+
+// src/condition.js
+function compileConditionSchema(schemaObj, jsonSchema) {
+  const validateIf = schemaObj.createValidator(jsonSchema.if, "if");
+  const tmpThen = schemaObj.createValidator(jsonSchema.then, "then");
+  const tmpElse = schemaObj.createValidator(jsonSchema.else, "else");
+  if (validateIf == null) return void 0;
+  if (tmpThen == null && tmpElse == null) return void 0;
+  const validateThen = fallbackFn(tmpThen);
+  const validateElse = fallbackFn(tmpElse);
+  return function validateCondition(data, dataRoot) {
+    if (validateIf(data))
+      return validateThen(data, dataRoot);
+    else
+      return validateElse(data, dataRoot);
+  };
+}
+
+// src/schema.js
+function compileRequired(schemaObj, jsonSchema) {
+  const required = getBoolishType(jsonSchema.required);
+  if (required !== true) return void 0;
+  const addError = schemaObj.createErrorHandler(required, "required");
+  return function validateRequiredType(data, dataPath) {
+    return data === void 0 ? addError(data, dataPath) : true;
+  };
+}
+function compileTypeSimple(schemaObj, jsonSchema) {
+  const type = getStringType(jsonSchema.type);
+  if (type == null) return void 0;
+  const isDataType = createIsSchemaTypeHandler(type);
+  if (!isDataType) throw new Error(`The explicit schema type '${type}' is unknown. (TODO: add trace)`);
+  const addError = schemaObj.createErrorHandler(type, "type");
+  return function validateTypeSimple(data, dataPath) {
+    return isDataType(data) ? true : addError(data, dataPath);
+  };
+}
+function compileTypeArray(schemaObj, jsonSchema) {
+  const schemaTypes = getUniqueArray(jsonSchema.type);
+  if (schemaTypes == null) return void 0;
+  if (schemaTypes.length === 0)
+    throw new Error("The schema type property can not be an empty array.");
+  const types = [];
+  const names = [];
+  for (let i = 0; i < schemaTypes.length; ++i) {
+    const type = schemaTypes[i];
+    const callback = createIsSchemaTypeHandler(type);
+    if (!callback)
+      throw new Error(`The explicit schema type '${type}' of '${types} is unknown. (TODO: add trace)`);
+    types.push(callback);
+    names.push(type);
+  }
+  const addError = schemaObj.createErrorHandler(names, "type");
+  if (types.length === 1) {
+    const one = types[0];
+    return function validateSingleType(data, dataPath) {
+      return one(data) ? true : addError(data, dataPath);
+    };
+  } else if (types.length === 2) {
+    const one = types[0];
+    const two = types[1];
+    return function validateDoubleTypes(data, dataPath) {
+      return one(data) || two(data) ? true : addError(data, dataPath);
+    };
+  } else if (types.length === 3) {
+    const one = types[0];
+    const two = types[1];
+    const three = types[2];
+    return function validateTripleTypes(data, dataPath) {
+      return one(data) || two(data) || three(data) ? true : addError(data, dataPath);
+    };
+  } else {
+    return function validateAllTypes(data, dataPath) {
+      for (let i = 0; i < types.length; ++i) {
+        if (types[i](data) === true) return true;
+      }
+      return addError(data, dataPath);
+    };
+  }
+}
+function compileTypeBasic(schemaObj, jsonSchema) {
+  const validator = compileTypeSimple(schemaObj, jsonSchema) || compileTypeArray(schemaObj, jsonSchema);
+  const nullable = getBoolishType(jsonSchema.nullable);
+  if (validator == null) {
+    if (nullable !== false) return void 0;
+    const addError = schemaObj.createErrorHandler(nullable, "nullable");
+    return function validateNotIsNull(data, dataPath) {
+      return data === void 0 || data !== null || addError(data, dataPath);
+    };
+  }
+  if (nullable === true) {
+    return function validateNullableType(data, dataPath) {
+      return data === void 0 || data === null || validator(data, dataPath);
+    };
+  }
+  return function validateType(data, dataPath) {
+    return data === void 0 || validator(data, dataPath);
+  };
+}
+function compileSchemaObject(schemaObj, jsonSchema) {
+  if (jsonSchema === true) return trueThat;
+  if (jsonSchema === false) return falseThat;
+  if (!isObjectType(jsonSchema))
+    throw new Error("JSON Schema MUST be a boolean or Object Type");
+  if (Object.keys(jsonSchema).length === 0)
+    return trueThat;
+  const validators = [];
+  addFunctionToArray(validators, compileRequired(schemaObj, jsonSchema));
+  addFunctionToArray(validators, compileTypeBasic(schemaObj, jsonSchema));
+  addFunctionToArray(validators, compileEnumBasic(schemaObj, jsonSchema));
+  addFunctionToArray(validators, compileNumberBasic(schemaObj, jsonSchema));
+  addFunctionToArray(validators, compileBigIntBasic(schemaObj, jsonSchema));
+  addFunctionToArray(validators, compileStringBasic(schemaObj, jsonSchema));
+  addFunctionToArray(validators, compileFormatBasic(schemaObj, jsonSchema));
+  addFunctionToArray(validators, compileArraySchema(schemaObj, jsonSchema));
+  addFunctionToArray(validators, compileObjectSchema(schemaObj, jsonSchema));
+  addFunctionToArray(validators, compileCombineSchema(schemaObj, jsonSchema));
+  addFunctionToArray(validators, compileConditionSchema(schemaObj, jsonSchema));
+  if (validators.length === 0)
+    return trueThat;
+  if (validators.length === 1)
+    return validators[0];
+  if (validators.length === 2) {
+    const first = validators[0];
+    const second = validators[1];
+    return function validateDoubleSchemaObject(data, dataPath, dataRoot) {
+      return first(data, dataPath, dataRoot) && second(data, dataPath, dataRoot);
+    };
+  }
+  if (validators.length === 3) {
+    const first = validators[0];
+    const second = validators[1];
+    const thirth = validators[2];
+    return function validateTripleSchemaObject(data, dataPath, dataRoot) {
+      return first(data, dataPath, dataRoot) && second(data, dataPath, dataRoot) && thirth(data, dataPath, dataRoot);
+    };
+  }
+  return function validateAllSchemaObject(data, dataPath, dataRoot) {
+    for (let i = 0; i < validators.length; ++i) {
+      const validator = validators[i];
+      if (validator(data, dataPath, dataRoot) === false) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+
+// ../strings/src/punycode.js
+var base = 36;
+var tMin = 1;
+var baseMinusTMin = base - tMin;
+var stringFromCharCode = String.fromCharCode;
+
+// ../strings/src/index.js
+var CONST_REGEXP_HTML_IDENTIFIER = /^[A-Za-z]+[\w\-\:\.]{0,30}$/;
+function isStringHtmlIdentifier(str) {
+  return (
+    /* str != null && */
+    CONST_REGEXP_HTML_IDENTIFIER.test(str)
+  );
+}
+
+// src/traverse.js
+function encodeJsonPointerKey(key) {
+  return encodeURIComponent(key.replace("~", "~0").replace("/", "~1"));
+}
+function encodeJsonPointerPath(path, key, index) {
+  return index == null ? `${path}/${encodeJsonPointerKey(key)}` : `${path}/${encodeJsonPointerKey(key)}/${encodeJsonPointerKey(index)}`;
+}
+function decodeJsonPointerKey(key) {
+  return decodeURIComponent(key.replace("~0", "~").replace("~1", "/"));
+}
+function decodeJsonPointerPath(path) {
+  return path.split("/").map(decodeJsonPointerKey).splice(1);
+}
+var JsonPointerOptions = class {
+  constructor(anchorsGlobal = true, anchorsAllowed = true, skipErrors = true) {
+    this.anchorsGlobal = anchorsGlobal;
+    this.anchorsAllowed = anchorsAllowed;
+    this.skipErrors = skipErrors;
+  }
+};
+var JsonPointer = class {
+  constructor(id, search, leftUri, fragment) {
+    this.id = id;
+    this.search = search;
+    this.leftUri = leftUri;
+    this.fragment = fragment;
+  }
+};
+function createJsonPointer(refUri, baseUri, opts = new JsonPointerOptions()) {
+  const url = !isStringType(refUri) || isStringWhiteSpace(refUri) ? new URL(baseUri) : !isStringType(baseUri) || isStringWhiteSpace(baseUri) ? new URL(refUri) : new URL(refUri, baseUri);
+  const [uri, fragment] = url.href.split("#");
+  const [leftUri, search] = uri.split("?");
+  if (!isStringWhiteSpace(fragment)) {
+    if (opts.anchorsAllowed == true && isStringHtmlIdentifier(fragment)) {
+      return opts.anchorsGlobal == true ? new JsonPointer(`#${fragment}`, search, `${leftUri}#`, fragment) : new JsonPointer(`${leftUri}#${fragment}`, search, `${leftUri}#`, fragment);
+    } else if (fragment.startsWith("/")) {
+      return new JsonPointer(`${leftUri}#${fragment}`, search, `${leftUri}#`, fragment);
+    }
+  }
+  return new JsonPointer(`${leftUri}#`, search, `${leftUri}#`, null);
+}
+var TRAVERSE_SCHEMA_OBJECTS = [
+  "items",
+  "prefixItems",
+  "additionalItems",
+  "contains",
+  "unevaluatedItems",
+  "additionalProperties",
+  "propertyNames",
+  "unevaluatedProperties",
+  "not",
+  "oneOf",
+  "anyOf",
+  "allOf",
+  "if",
+  "then",
+  "else"
+];
+var TRAVERSE_SCHEMA_MAPS = [
+  "properties",
+  "patternProperties",
+  "dependencies",
+  "dependentSchemas",
+  "dependentRequired",
+  "definitions",
+  "$defs",
+  "components"
+];
+function storeSchemaIdsInMap(schemas, baseUri, schema, opts = new JsonPointerOptions()) {
+  if (!isObjectClass(schema)) {
+    schemas.set(baseUri, schema);
+    return null;
+  }
+  const { id: rootUri } = createJsonPointer(schema.$id, baseUri, opts);
+  if (!isStringType(schema.$id) || isStringWhiteSpace(schema.$id)) {
+    if (schemas.has(rootUri))
+      throw new Error(`Schema '${rootUri}' already exists`);
+    schemas.set(rootUri, schema);
+  }
+  baseUri = rootUri;
+  const queue = [{ obj: schema, base: rootUri, path: "#" }];
+  while (queue.length > 0) {
+    const { obj, base: base2, path } = queue.shift();
+    if (isStringType(obj.$id) && !isStringWhiteSpace(obj.$id)) {
+      const { id } = createJsonPointer(obj.$id, base2, opts);
+      if (!schemas.has(id))
+        schemas.set(id, obj);
+      else if (schemas.get(id) == null)
+        schemas.set(id, obj);
+      else
+        throw new Error(`Schema '${id}' for path '${path}' in '${base2}' already exists`);
+      baseUri = id;
+    } else
+      baseUri = base2;
+    if (isStringType(obj.$anchor) && !isStringWhiteSpace(obj.$anchor)) {
+      const { id } = createJsonPointer(`#${obj.$anchor}`, baseUri, opts);
+      if (!schemas.has(id))
+        schemas.set(id, obj);
+      else if (schemas.get(id) == null)
+        schemas.set(id, obj);
+      else
+        throw new Error(`Schema '${id}' for path '${path}' in '${base2}' already exists`);
+      if (!id.startsWith("#"))
+        baseUri = id;
+    }
+    if (isStringType(obj.$ref) && !isStringWhiteSpace(obj.$ref)) {
+      const { id: ref } = createJsonPointer(obj.$ref, baseUri, opts);
+      if (!schemas.has(ref))
+        schemas.set(ref, null);
+      continue;
+    }
+    for (const [key, value] of Object.entries(obj)) {
+      if (!isObjectClass(value))
+        continue;
+      if (TRAVERSE_SCHEMA_OBJECTS.includes(key)) {
+        if (Array.isArray(value)) {
+          const len = value.length;
+          for (let index = 0; index < len; index++) {
+            const item = value[index];
+            const nextpath = encodeJsonPointerPath(path, key, index);
+            if (isBoolishType(item))
+              continue;
+            if (!isObjectClass(item)) {
+              if (opts.skipErrors === true)
+                continue;
+              else
+                throw new Error(`${nextpath} is not a schema`);
+            }
+            queue.push({ obj: item, base: baseUri, path: nextpath });
+          }
+        } else {
+          const nextpath = encodeJsonPointerPath(path, key);
+          queue.push({ obj: value, base: baseUri, path: nextpath });
+        }
+      } else if (TRAVERSE_SCHEMA_MAPS.includes(key)) {
+        if (Array.isArray(value))
+          continue;
+        for (const [index, item] of Object.entries(value)) {
+          const nextpath = encodeJsonPointerPath(path, key, index);
+          if (isBoolishType(item))
+            continue;
+          if (!isObjectClass(item)) {
+            if (opts.skipErrors === true)
+              continue;
+            else
+              throw new Error(`${nextpath} is not a schema`);
+          }
+          queue.push({ obj: item, base: baseUri, path: nextpath });
+        }
+      }
+    }
+  }
+  return rootUri;
+}
+function resolveRefSchemaShallow(schemas, refUri, baseUri, opts = new JsonPointerOptions()) {
+  const { id: base2, leftUri, fragment } = createJsonPointer(refUri, baseUri, opts);
+  if (!schemas.has(leftUri))
+    throw new Error(`The root of reference: '$ref': '${base2}', is not found in init-cache`);
+  let schema = schemas.get(leftUri);
+  if (isStringWhiteSpace(fragment)) {
+    return { id: base2, schema };
+  }
+  const fragments = decodeJsonPointerPath(fragment);
+  let current = "";
+  for (const part of fragments) {
+    current = current + "/" + part;
+    if (!isBoolOrObjectClass(schema[part]))
+      throw new Error(`The '${current}' is not is not a valid schema in '${leftUri}'`);
+    schema = schema[part];
+  }
+  return { id: base2, schema };
+}
+function restoreSchemaRefsInMap(schemas, opts = new JsonPointerOptions()) {
+  for (const [id, item] of schemas.entries()) {
+    if (item != null)
+      continue;
+    const { schema } = resolveRefSchemaShallow(schemas, id, null, opts);
+    if (schema == null)
+      throw new Error(`Can not resolve schema for '${id}'`);
+    schemas.set(id, schema);
+  }
+}
+var TraverseOptions = class extends JsonPointerOptions {
+  constructor(origin = "https://github.com/jklarenbeek/jaren", mergeSchemas = true, anchorsGlobal, anchorsAllowed, skipErrors) {
+    super(anchorsGlobal, anchorsAllowed, skipErrors);
+    this.origin = origin, this.mergeSchemas = mergeSchemas;
+  }
+};
+function resolveRefSchemaDeep(schemas, baseUri, refschema, opts = new TraverseOptions()) {
+  if (!isObjectClass(refschema))
+    return { id: baseUri, schema: refschema };
+  if (!hasSchemaRef(refschema))
+    return { id: baseUri, schema: refschema };
+  const queue = [{ item: refschema, base: baseUri }];
+  const seen = /* @__PURE__ */ new Set();
+  let result = {};
+  while (queue.length > 0) {
+    const { item, base: base2 } = queue.shift();
+    if (!isObjectClass(item))
+      return { id: base2, schema: item };
+    result = opts.mergeSchemas == true ? { ...item, ...result } : { ...item };
+    if (!hasSchemaRef(item))
+      return { id: base2, schema: result };
+    delete result.$ref;
+    const ref = item.$ref;
+    const { id, schema } = resolveRefSchemaShallow(schemas, ref, base2, opts);
+    if (seen.has(id))
+      return { id: base2, schema: result };
+    seen.add(id);
+    queue.push({ item: schema, base: id });
+  }
+  throw new Error(`The json schema '${baseUri}' can not be resolved!`);
+}
+
+// src/index.js
+var isBrowser = typeof window !== "undefined";
+var performance = (() => isBrowser ? window.performance : {
+  now: function performanceNow(start) {
+    const ps = process;
+    if (!start) return ps.hrtime();
+    const end = ps.hrtime(start);
+    return Math.round(end[0] * 1e3 + end[1] / 1e6);
+  }
+})();
+var ValidationError = class {
+  constructor(obj, key, expected, dataKey, value, rest) {
+    this.timeStamp = performance.now();
+    this.object = obj;
+    this.key = key;
+    this.expected = expected;
+    this.dataKey = dataKey;
+    this.value = value;
+    this.rest = rest;
+  }
+};
+var ValidationOptions = class {
+  constructor(skipErrors = true) {
+    this.skipErrors = skipErrors;
+  }
+};
+var ValidationRoot = class _ValidationRoot {
+  static _createObject(self, path, schema) {
+    const objects = self._objects;
+    if (objects.has(path)) {
+      const p = objects.get(path);
+      if (p != null)
+        throw new Error(`Object at '${path}' is already created`);
+    }
+    const obj = new ValidationObject(self, path, schema);
+    objects.set(path, obj);
+    return obj;
+  }
+  constructor(schemas, schema, origin, formats, opts = new ValidationOptions(), traverse = new TraverseOptions()) {
+    this._options = opts;
+    this._traverse = traverse;
+    this._schemas = schemas;
+    this._rootOrigin = origin;
+    this._formats = formats;
+    this._objects = /* @__PURE__ */ new Map();
+    this._errors = [];
+    this._firstSchema = _ValidationRoot._createObject(this, origin, schema);
+  }
+  get options() {
+    return this._options;
+  }
+  get formats() {
+    return this._formats;
+  }
+  createObject(path, schema) {
+    return _ValidationRoot._createObject(this, path, schema);
+  }
+  unresolvedObject(path) {
+    const objects = this._objects;
+    if (objects.has(path))
+      return objects.get(path);
+    objects.set(path, null);
+    return null;
+  }
+  resolveObject(ref, path, schema) {
+    const objects = this._objects;
+    if (objects.has(ref)) {
+      const obj = objects.get(ref);
+      if (obj != null)
+        return objects.get(ref);
+    }
+    const schemas = this._schemas;
+    const traverse = this._traverse;
+    const { id, schema: root } = resolveRefSchemaDeep(schemas, path, schema, traverse);
+    return _ValidationRoot._createObject(this, id, root);
+  }
+  addError(error) {
+    this._errors.push(error);
+    return false;
+  }
+  validate(data) {
+    this._errors.length = 0;
+    return this._firstSchema.validate(data, data);
+  }
+};
+var ValidationObject = class _ValidationObject {
+  /**
+   * Compiles a schema validation error handler
+   * @param {ValidationObject} self The validation object that is compiling this validator
+   * @param {string} path The path to this schema object
+   * @param {any} schema The schema object to compile
+   * @returns {function(any, any):boolean} A function that validates data against the compiled schema and returns a boolean.
+   */
+  static _compileValidator(self, path, schema) {
+    if (!hasSchemaRef(schema))
+      return compileSchemaObject(self, schema);
+    const root = self._root;
+    const { id: ref } = createJsonPointer(schema.$ref, path, root.options);
+    const resolved = root.unresolvedObject(ref);
+    if (resolved != null) {
+      const validator = resolved.validate;
+      self._validator = function validateRefSchemaOnTime(data, dataRoot) {
+        return validator(data, dataRoot);
+      };
+      return self._validator;
+    }
+    return function resolveSchemaCompiler(data, dataRoot) {
+      const obj = root.resolveObject(ref, path, schema);
+      const validator = obj.validate;
+      self._validator = function validateRefSchemaLate(_data, _dataRoot) {
+        return validator(_data, _dataRoot);
+      };
+      return self._validator(data, dataRoot);
+    };
+  }
+  constructor(root, path, schema) {
+    this._root = root;
+    this._path = path;
+    this._members = [];
+    this._schema = schema;
+    this._validator = null;
+    this._validator = _ValidationObject._compileValidator(this, path, schema);
+  }
+  get path() {
+    return this._path;
+  }
+  get errors() {
+    return this._root.errors;
+  }
+  get validate() {
+    return this._validator;
+  }
+  get options() {
+    return this._root.options;
+  }
+  get formats() {
+    return this._root.formats;
+  }
+  /**
+   * Compiles a schema validation error handler
+   * @param {any} expected - anything that is expected by this handler
+   * @param {string | string[]} key - the key or keys that is expected
+   * @returns {function(unknown): boolean} A function that validates data against the compiled schema and returns a boolean.
+   */
+  createErrorHandler(expected, key) {
+    const self = this;
+    if (!Array.isArray(key)) {
+      return function addNormalError(data, ...meta) {
+        const error = new ValidationError(self, key, expected, null, data, meta);
+        return self._root.addError(error);
+      };
+    } else {
+      return function addKeyedError(dataKey, data, ...meta) {
+        const error = new ValidationError(self, key, expected, dataKey, data, meta);
+        return self._root.addError(error);
+      };
+    }
+  }
+  createValidator(schema, key, index) {
+    if (!isBoolOrObjectClass(schema))
+      return void 0;
+    const id = isObjectClass(schema) ? createJsonPointer(schema.$id, this._path).id : this._path;
+    const root = this._root;
+    const path = index == null ? encodeJsonPointerPath(id, key) : encodeJsonPointerPath(id, key, String(index));
+    const child = root.createObject(path, schema);
+    this._members.push(child);
+    return child._validator;
+  }
+};
+var ValidatorOptions = class {
+  constructor(formats = {}, schemas = [], validation = new ValidationOptions(), traverse = new TraverseOptions()) {
+    this.formats = formats;
+    this.schemas = schemas;
+    this.validation = validation;
+    this.traverse = traverse;
+  }
+};
+function compileSchemaValidator(schema, opts = new ValidatorOptions()) {
+  const schemas = /* @__PURE__ */ new Map();
+  const origin = storeSchemaIdsInMap(
+    schemas,
+    opts.traverse.origin,
+    schema,
+    opts.traverse
+  );
+  opts.schemas.forEach((ref) => storeSchemaIdsInMap(
+    schemas,
+    origin,
+    ref,
+    opts.traverse
+  ));
+  restoreSchemaRefsInMap(schemas, opts.traverse);
+  const root = new ValidationRoot(
+    schemas,
+    schema,
+    origin,
+    opts.formats,
+    opts.validation,
+    opts.traverse
+  );
+  return {
+    validate: (data) => root.validate(data)
+  };
+}
+export {
+  TraverseOptions,
+  ValidatorOptions,
+  compileSchemaValidator,
+  registerFormatCompilers
+};
+//# sourceMappingURL=index.js.map