@hyperjump/json-schema 0.22.0 → 0.23.2

package/dist/json-schema-umd.js

@@ -6,7 +6,7 @@
 
 	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-	var justCurryIt = curry$a;
+	var justCurryIt$1 = curry$b;
 
 	/*
 	  function add(a, b, c) {
@@ -31,7 +31,7 @@
 	  milesToKm(10); // 16.2
 	*/
 
-	function curry$a(fn, arity) {
+	function curry$b(fn, arity) {
 	  return function curried() {
 	    if (arity == null) {
 	      arity = fn.length;
@@ -1902,12 +1902,12 @@
 
 	var common$1 = { jsonTypeOf: jsonTypeOf$2, resolveUrl: resolveUrl$3, urlFragment: urlFragment$1, pathRelative: pathRelative$1 };
 
-	const curry$9 = justCurryIt;
+	const curry$a = justCurryIt$1;
 
 
 	const nil$2 = "";
 
-	const compile$P = (pointer) => {
+	const compile$N = (pointer) => {
 	  if (pointer.length > 0 && pointer[0] !== "/") {
 	    throw Error("Invalid JSON Pointer");
 	  }
@@ -1915,8 +1915,8 @@
 	  return pointer.split("/").slice(1).map(unescape);
 	};
 
-	const get$1 = (pointer, value = undefined) => {
-	  const ptr = compile$P(pointer);
+	const get$2 = (pointer, value = undefined) => {
+	  const ptr = compile$N(pointer);
 
 	  const fn = (value) => ptr.reduce(([value, pointer], segment) => {
 	    return [applySegment(value, segment, pointer), append(segment, pointer)];
@@ -1926,8 +1926,8 @@
 	};
 
 	const set = (pointer, subject = undefined, value = undefined) => {
-	  const ptr = compile$P(pointer);
-	  const fn = curry$9((subject, value) => _set(ptr, subject, value, nil$2));
+	  const ptr = compile$N(pointer);
+	  const fn = curry$a((subject, value) => _set(ptr, subject, value, nil$2));
 	  return subject === undefined ? fn : fn(subject, value);
 	};
 
@@ -1935,8 +1935,15 @@
 	  if (pointer.length === 0) {
 	    return value;
 	  } else if (pointer.length > 1) {
-	    const segment = pointer.shift();
-	    return { ...subject, [segment]: _set(pointer, applySegment(subject, segment, cursor), value, append(segment, cursor)) };
+	    if (Array.isArray(subject)) {
+	      const index = pointer.shift();
+	      const clonedSubject = [...subject];
+	      clonedSubject[index] = _set(pointer, applySegment(subject, index, cursor), value, append(index, cursor));
+	      return clonedSubject;
+	    } else {
+	      const segment = pointer.shift();
+	      return { ...subject, [segment]: _set(pointer, applySegment(subject, segment, cursor), value, append(segment, cursor)) };
+	    }
 	  } else if (Array.isArray(subject)) {
 	    const clonedSubject = [...subject];
 	    const segment = computeSegment(subject, pointer[0]);
@@ -1950,8 +1957,8 @@
 	};
 
 	const assign = (pointer, subject = undefined, value = undefined) => {
-	  const ptr = compile$P(pointer);
-	  const fn = curry$9((subject, value) => _assign(ptr, subject, value, nil$2));
+	  const ptr = compile$N(pointer);
+	  const fn = curry$a((subject, value) => _assign(ptr, subject, value, nil$2));
 	  return subject === undefined ? fn : fn(subject, value);
 	};
 
@@ -1968,7 +1975,7 @@
 	};
 
 	const unset = (pointer, subject = undefined) => {
-	  const ptr = compile$P(pointer);
+	  const ptr = compile$N(pointer);
 	  const fn = (subject) => _unset(ptr, subject, nil$2);
 	  return subject === undefined ? fn : fn(subject);
 	};
@@ -1992,7 +1999,7 @@
 	};
 
 	const remove = (pointer, subject = undefined) => {
-	  const ptr = compile$P(pointer);
+	  const ptr = compile$N(pointer);
 	  const fn = (subject) => _remove(ptr, subject, nil$2);
 	  return subject === undefined ? fn : fn(subject);
 	};
@@ -2013,7 +2020,7 @@
 	  }
 	};
 
-	const append = curry$9((segment, pointer) => pointer + "/" + escape(segment));
+	const append = curry$a((segment, pointer) => pointer + "/" + escape(segment));
 
 	const escape = (segment) => segment.toString().replace(/~/g, "~0").replace(/\//g, "~1");
 	const unescape = (segment) => segment.toString().replace(/~1/g, "/").replace(/~0/g, "~");
@@ -2034,7 +2041,7 @@
 
 	const isScalar = (value) => value === null || typeof value !== "object";
 
-	var lib$3 = { nil: nil$2, append, get: get$1, set, assign, unset, remove };
+	var lib$3 = { nil: nil$2, append, get: get$2, set, assign, unset, remove };
 
 	const $__value = Symbol("$__value");
 	const $__href = Symbol("$__href");
@@ -2051,17 +2058,26 @@
 	var reference = { cons: cons$1, isReference, href, value: value$2 };
 
 	const JsonPointer$1 = lib$3;
-	const curry$8 = justCurryIt;
+	const curry$9 = justCurryIt$1;
 	const { resolveUrl: resolveUrl$2, jsonTypeOf: jsonTypeOf$1 } = common$1;
 	const Reference$2 = reference;
 
 
 	const nil$1 = Object.freeze({ id: "", pointer: "", instance: undefined, value: undefined });
 	const cons = (instance, id = "") => Object.freeze({ ...nil$1, id: resolveUrl$2(id, ""), instance, value: instance });
+
+	const get$1 = (url, instance = nil$1) => {
+	  if (!url.startsWith("#")) {
+	    throw Error(`No JSON document found at '${url.split("#")[0]}'`);
+	  }
+
+	  return Object.freeze({ ...instance, pointer: url.substr(1) });
+	};
+
 	const uri$1 = (doc) => `${doc.id}#${encodeURI(doc.pointer)}`;
 	const value$1 = (doc) => Reference$2.isReference(doc.value) ? Reference$2.value(doc.value) : doc.value;
 	const has$1 = (key, doc) => key in value$1(doc);
-	const typeOf$1 = curry$8((doc, type) => jsonTypeOf$1(value$1(doc), type));
+	const typeOf$1 = curry$9((doc, type) => jsonTypeOf$1(value$1(doc), type));
 
 	const step$1 = (key, doc) => Object.freeze({
 	  ...doc,
@@ -2074,28 +2090,75 @@
 
 	const keys$1 = (doc) => Object.keys(value$1(doc));
 
-	const map$4 = curry$8((fn, doc) => value$1(doc)
+	const map$4 = curry$9((fn, doc) => value$1(doc)
 	  .map((item, ndx, array, thisArg) => fn(step$1(ndx, doc), ndx, array, thisArg)));
 
-	const filter$1 = curry$8((fn, doc) => value$1(doc)
+	const forEach = curry$9((fn, doc) => value$1(doc)
+	  .forEach((item, ndx, array, thisArg) => fn(step$1(ndx, doc), ndx, array, thisArg)));
+
+	const filter$1 = curry$9((fn, doc) => value$1(doc)
 	  .map((item, ndx, array, thisArg) => step$1(ndx, doc))
 	  .filter((item, ndx, array, thisArg) => fn(item, ndx, array, thisArg)));
 
-	const reduce$3 = curry$8((fn, acc, doc) => value$1(doc)
+	const reduce$3 = curry$9((fn, acc, doc) => value$1(doc)
 	  .reduce((acc, item, ndx) => fn(acc, step$1(ndx, doc), ndx), acc));
 
-	const every$1 = curry$8((fn, doc) => value$1(doc)
+	const every$1 = curry$9((fn, doc) => value$1(doc)
 	  .every((item, ndx, array, thisArg) => fn(step$1(ndx, doc), ndx, array, thisArg)));
 
-	const some$1 = curry$8((fn, doc) => value$1(doc)
+	const some$1 = curry$9((fn, doc) => value$1(doc)
 	  .some((item, ndx, array, thisArg) => fn(step$1(ndx, doc), ndx, array, thisArg)));
 
 	const length$1 = (doc) => value$1(doc).length;
 
-	var instance = { nil: nil$1, cons, uri: uri$1, value: value$1, has: has$1, typeOf: typeOf$1, step: step$1, entries: entries$3, keys: keys$1, map: map$4, filter: filter$1, reduce: reduce$3, every: every$1, some: some$1, length: length$1 };
+	var instance = {
+	  nil: nil$1, cons, get: get$1, uri: uri$1, value: value$1, has: has$1, typeOf: typeOf$1, length: length$1,
+	  step: step$1, entries: entries$3, keys: keys$1, map: map$4, forEach, filter: filter$1, reduce: reduce$3, every: every$1, some: some$1
+	};
 
 	var entries$2 = async (doc) => Object.entries(await doc);
 
+	var justCurryIt = curry$8;
+
+	/*
+	  function add(a, b, c) {
+	    return a + b + c;
+	  }
+	  curry(add)(1)(2)(3); // 6
+	  curry(add)(1)(2)(2); // 5
+	  curry(add)(2)(4, 3); // 9
+
+	  function add(...args) {
+	    return args.reduce((sum, n) => sum + n, 0)
+	  }
+	  var curryAdd4 = curry(add, 4)
+	  curryAdd4(1)(2, 3)(4); // 10
+
+	  function converter(ratio, input) {
+	    return (input*ratio).toFixed(1);
+	  }
+	  const curriedConverter = curry(converter)
+	  const milesToKm = curriedConverter(1.62);
+	  milesToKm(35); // 56.7
+	  milesToKm(10); // 16.2
+	*/
+
+	function curry$8(fn, arity) {
+	  return function curried() {
+	    if (arity == null) {
+	      arity = fn.length;
+	    }
+	    var args = [].slice.call(arguments);
+	    if (args.length >= arity) {
+	      return fn.apply(this, args);
+	    } else {
+	      return function() {
+	        return curried.apply(this, args.concat([].slice.call(arguments)));
+	      };
+	    }
+	  };
+	}
+
 	const curry$7 = justCurryIt;
 
 
@@ -2409,11 +2472,11 @@
 	};
 
 	const parse = (response) => {
-	  const contentType = contentTypeParser.parse(response.headers.get("content-type")).type;
-	  if (!(contentType in mediaTypePlugins)) {
-	    throw Error(`${response.url} is not a schema. Found a document with media type: ${contentType}`);
+	  const contentType = contentTypeParser.parse(response.headers.get("content-type"));
+	  if (!(contentType.type in mediaTypePlugins)) {
+	    throw Error(`${response.url} is not a schema. Found a document with media type: ${contentType.type}`);
 	  }
-	  return mediaTypePlugins[contentType].parse(response);
+	  return mediaTypePlugins[contentType.type].parse(response, contentType.parameters);
 	};
 
 	const getContentType = (path) => {
@@ -2428,7 +2491,7 @@
 
 	var mediaTypes = { addPlugin, parse, getContentType };
 
-	const curry$1 = justCurryIt;
+	const curry$1 = justCurryIt$1;
 	const Pact$a = lib$2;
 	const JsonPointer = lib$3;
 	const { jsonTypeOf, resolveUrl: resolveUrl$1, urlFragment, pathRelative } = common$1;
@@ -2445,6 +2508,8 @@
 	const dialectJsonSchemaVersion = {};
 
 	const setConfig = (jsonSchemaVersion, key, value) => {
+	  dialectJsonSchemaVersion[jsonSchemaVersion] = jsonSchemaVersion;
+
 	  if (!config[jsonSchemaVersion]) {
 	    config[jsonSchemaVersion] = {};
 	  }
@@ -2471,23 +2536,25 @@
 	  }
 	  delete schema["$schema"];
 
-	  // JSON Schema version
+	  // Determine JSON Schema version
 	  if (!(dialectId in dialectJsonSchemaVersion)) {
 	    if (schema?.$vocabulary?.[core201909Id] === true && dialectId === getSchemaIdentifier(schema, externalId, core201909Id)[0]) {
+	      // Self describing 2019-09 meta-schema
 	      dialectJsonSchemaVersion[dialectId] = core201909Id;
 	    } else if (schema?.$vocabulary?.[core202012Id] === true && dialectId === getSchemaIdentifier(schema, externalId, core202012Id)[0]) {
+	      // Self describing 2020-12 meta-schema
 	      dialectJsonSchemaVersion[dialectId] = core202012Id;
-	    } else if (dialectId === getSchemaIdentifier(schema, externalId, dialectId)[0]) {
-	      dialectJsonSchemaVersion[dialectId] = dialectId;
-	    } else if (!(dialectId in schemaStore)) {
-	      throw Error(`Couldn't determine JSON Schema version for dialect: '${dialectId}'`);
 	    } else {
+	      // Need to look at meta-schema to determine version
 	      const metaSchema = schemaStore[dialectId];
-	      if (metaSchema.vocabulary[core201909Id] === true) {
+	      if (!metaSchema) {
+	        throw Error(`Couldn't determine JSON Schema version for dialect: '${dialectId}'`);
+	      } else if (metaSchema.vocabulary[core201909Id] === true) {
 	        dialectJsonSchemaVersion[dialectId] = core201909Id;
 	      } else if (metaSchema.vocabulary[core202012Id] === true) {
 	        dialectJsonSchemaVersion[dialectId] = core202012Id;
 	      } else {
+	        // Assume the jsonSchemaVersion is the meta-schema's dialectId (non-standard behavior)
 	        dialectJsonSchemaVersion[dialectId] = dialectJsonSchemaVersion[metaSchema.dialectId];
 	      }
 	    }
@@ -2626,7 +2693,23 @@
 	      throw Error(`Failed to retrieve schema with id: ${id}`);
 	    }
 
-	    add$1(await MediaTypes$1.parse(response), id);
+	    const [schema, defaultDialectId] = await MediaTypes$1.parse(response);
+
+	    let dialectId;
+	    if (schema.$schema) {
+	      dialectId = resolveUrl$1(schema.$schema, "");
+	    } else if (defaultDialectId) {
+	      dialectId = resolveUrl$1(id, defaultDialectId);
+	    } else {
+	      dialectId = "";
+	    }
+
+	    // Make sure the meta-schema is loaded if this isn't a known dialect
+	    if (dialectId && id !== dialectId && !(dialectId in dialectJsonSchemaVersion)) {
+	      await get(dialectId);
+	    }
+
+	    add$1(schema, id, dialectId);
 	  }
 
 	  const storedSchema = getStoredSchema(id);
@@ -2710,21 +2793,16 @@
 	  const dynamicAnchorToken = getConfig(schemaDoc.dialectId, "dynamicAnchorToken");
 	  Object.entries(schemaDoc.dynamicAnchors)
 	    .forEach(([anchor, uri]) => {
-	      const pointer = urlFragment(uri);
-	      JsonPointer.assign(pointer, schema, {
-	        [dynamicAnchorToken]: anchor,
-	        ...JsonPointer.get(pointer, schema)
-	      });
+	      const pointer = JsonPointer.append(dynamicAnchorToken, urlFragment(uri));
+	      JsonPointer.assign(pointer, schema, anchor);
 	    });
 
 	  const anchorToken = getConfig(schemaDoc.dialectId, "anchorToken");
 	  Object.entries(schemaDoc.anchors)
-	    .filter(([anchor]) => anchor !== "")
+	    .filter(([anchor]) => anchor !== "" && !(anchor in schemaDoc.dynamicAnchors))
 	    .forEach(([anchor, pointer]) => {
-	      JsonPointer.assign(pointer, schema, {
-	        [anchorToken]: anchor,
-	        ...JsonPointer.get(pointer, schema)
-	      });
+	      const anchorPointer = JsonPointer.append(anchorToken, pointer);
+	      JsonPointer.assign(anchorPointer, schema, anchor);
 	    });
 
 	  const baseToken = getConfig(schemaDoc.dialectId, "baseToken");
@@ -2763,19 +2841,19 @@
 
 	var invalidSchemaError = InvalidSchemaError$3;
 
-	const Schema$R = schema$5;
+	const Schema$P = schema$5;
 
 
-	const compile$O = (schema) => Schema$R.value(schema);
-	const interpret$O = () => true;
+	const compile$M = (schema) => Schema$P.value(schema);
+	const interpret$M = () => true;
 
-	var metaData$4 = { compile: compile$O, interpret: interpret$O };
+	var metaData$4 = { compile: compile$M, interpret: interpret$M };
 
-	const curry = justCurryIt;
+	const curry = justCurryIt$1;
 	const PubSub$1 = pubsub.exports;
 	const { resolveUrl } = common$1;
-	const Instance$E = instance;
-	const Schema$Q = schema$5;
+	const Instance$C = instance;
+	const Schema$O = schema$5;
 	const InvalidSchemaError$2 = invalidSchemaError;
 	const MediaTypes = mediaTypes;
 	const metaData$3 = metaData$4;
@@ -2787,24 +2865,27 @@
 	let shouldMetaValidate = true;
 
 	MediaTypes.addPlugin("application/schema+json", {
-	  parse: async (response) => await response.json(),
+	  parse: async (response, contentTypeParameters) => [
+	    await response.json(),
+	    contentTypeParameters.schema || contentTypeParameters.profile
+	  ],
 	  matcher: (path) => path.endsWith(".schema.json")
 	});
 
 	const validate$2 = async (schema, value = undefined, outputFormat = undefined) => {
-	  const compiled = await compile$N(schema);
-	  const interpretAst = (value, outputFormat) => interpret$N(compiled, Instance$E.cons(value), outputFormat);
+	  const compiled = await compile$L(schema);
+	  const interpretAst = (value, outputFormat) => interpret$L(compiled, Instance$C.cons(value), outputFormat);
 
 	  return value === undefined ? interpretAst : interpretAst(value, outputFormat);
 	};
 
-	const compile$N = async (schema) => {
+	const compile$L = async (schema) => {
 	  const ast = { metaData: {} };
 	  const schemaUri = await compileSchema(schema, ast);
 	  return { ast, schemaUri };
 	};
 
-	const interpret$N = curry(({ ast, schemaUri }, value, outputFormat = FLAG) => {
+	const interpret$L = curry(({ ast, schemaUri }, value, outputFormat = FLAG) => {
 	  if (![FLAG, BASIC, DETAILED, VERBOSE].includes(outputFormat)) {
 	    throw Error(`The '${outputFormat}' error format is not supported`);
 	  }
@@ -2879,10 +2960,10 @@
 
 	  // Vocabularies
 	  if (!hasKeyword(`${schema.dialectId}#validate`)) {
-	    const metaSchema = await Schema$Q.get(schema.dialectId);
+	    const metaSchema = await Schema$O.get(schema.dialectId);
 
 	    // Check for mandatory vocabularies
-	    const mandatoryVocabularies = Schema$Q.getConfig(metaSchema.id, "mandatoryVocabularies") || [];
+	    const mandatoryVocabularies = Schema$O.getConfig(metaSchema.id, "mandatoryVocabularies") || [];
 	    mandatoryVocabularies.forEach((vocabularyId) => {
 	      if (!metaSchema.vocabulary[vocabularyId]) {
 	        throw Error(`Vocabulary '${vocabularyId}' must be explicitly declared and required`);
@@ -2905,17 +2986,17 @@
 
 	  // Meta validation
 	  if (shouldMetaValidate && !schema.validated) {
-	    Schema$Q.markValidated(schema.id);
+	    Schema$O.markValidated(schema.id);
 
 	    // Compile
 	    if (!(schema.dialectId in metaValidators)) {
-	      const metaSchema = await Schema$Q.get(schema.dialectId);
-	      const compiledSchema = await compile$N(metaSchema);
-	      metaValidators[metaSchema.id] = interpret$N(compiledSchema);
+	      const metaSchema = await Schema$O.get(schema.dialectId);
+	      const compiledSchema = await compile$L(metaSchema);
+	      metaValidators[metaSchema.id] = interpret$L(compiledSchema);
 	    }
 
 	    // Interpret
-	    const schemaInstance = Instance$E.cons(schema.schema, schema.id);
+	    const schemaInstance = Instance$C.cons(schema.schema, schema.id);
 	    const metaResults = metaValidators[schema.dialectId](schemaInstance, metaOutputFormat);
 	    if (!metaResults.valid) {
 	      throw new InvalidSchemaError$2(metaResults);
@@ -2934,7 +3015,7 @@
 	};
 
 	const followReferences = async (doc) => {
-	  return Schema$Q.typeOf(doc, "string") ? followReferences(await Schema$Q.get(Schema$Q.value(doc), doc)) : doc;
+	  return Schema$O.typeOf(doc, "string") ? followReferences(await Schema$O.get(Schema$O.value(doc), doc)) : doc;
 	};
 
 	const interpretSchema = (schemaUri, instance, ast, dynamicAnchors) => {
@@ -2962,12 +3043,12 @@
 	};
 
 	const add = (schema, url = "", defaultSchemaVersion = "") => {
-	  const id = Schema$Q.add(schema, url, defaultSchemaVersion);
+	  const id = Schema$O.add(schema, url, defaultSchemaVersion);
 	  delete metaValidators[id];
 	};
 
 	var core$2 = {
-	  validate: validate$2, compile: compile$N, interpret: interpret$N,
+	  validate: validate$2, compile: compile$L, interpret: interpret$L,
 	  setMetaOutputFormat, setShouldMetaValidate, FLAG, BASIC, DETAILED, VERBOSE,
 	  add, getKeyword, hasKeyword, defineVocabulary,
 	  compileSchema, interpretSchema, collectEvaluatedProperties: collectEvaluatedProperties$e, collectEvaluatedItems: collectEvaluatedItems$f,
@@ -2977,30 +3058,30 @@
 	const Pact$9 = lib$2;
 	const PubSub = pubsub.exports;
 	const Core$x = core$2;
-	const Instance$D = instance;
-	const Schema$P = schema$5;
+	const Instance$B = instance;
+	const Schema$N = schema$5;
 
 
-	const compile$M = async (schema, ast) => {
-	  const url = Schema$P.uri(schema);
+	const compile$K = async (schema, ast) => {
+	  const url = Schema$N.uri(schema);
 	  if (!(url in ast)) {
 	    ast[url] = false; // Place dummy entry in ast to avoid recursive loops
 
-	    const schemaValue = Schema$P.value(schema);
+	    const schemaValue = Schema$N.value(schema);
 	    if (!["object", "boolean"].includes(typeof schemaValue)) {
-	      throw Error(`No schema found at '${Schema$P.uri(schema)}'`);
+	      throw Error(`No schema found at '${Schema$N.uri(schema)}'`);
 	    }
 
 	    ast[url] = [
 	      `${schema.dialectId}#validate`,
-	      Schema$P.uri(schema),
+	      Schema$N.uri(schema),
 	      typeof schemaValue === "boolean" ? schemaValue : await Pact$9.pipeline([
-	        Schema$P.entries,
+	        Schema$N.entries,
 	        Pact$9.map(([keyword, keywordSchema]) => [`${schema.dialectId}#${keyword}`, keywordSchema]),
 	        Pact$9.filter(([keywordId]) => keywordId !== `${schema.dialectId}#validate`),
 	        Pact$9.map(async ([keywordId, keywordSchema]) => {
 	          const keywordAst = await Core$x.getKeyword(keywordId).compile(keywordSchema, ast, schema);
-	          return [keywordId, Schema$P.uri(keywordSchema), keywordAst];
+	          return [keywordId, Schema$N.uri(keywordSchema), keywordAst];
 	        }),
 	        Pact$9.all
 	      ], schema)
@@ -3010,7 +3091,7 @@
 	  return url;
 	};
 
-	const interpret$M = (uri, instance, ast, dynamicAnchors) => {
+	const interpret$K = (uri, instance, ast, dynamicAnchors) => {
 	  const [keywordId, schemaUrl, nodes] = ast[uri];
 
 	  PubSub.publishSync("result.start");
@@ -3022,7 +3103,7 @@
 	      PubSub.publishSync("result", {
 	        keyword: keywordId,
 	        absoluteKeywordLocation: schemaUrl,
-	        instanceLocation: Instance$D.uri(instance),
+	        instanceLocation: Instance$B.uri(instance),
 	        valid: isValid,
 	        ast: keywordValue
 	      });
@@ -3033,7 +3114,7 @@
 	  PubSub.publishSync("result", {
 	    keyword: keywordId,
 	    absoluteKeywordLocation: schemaUrl,
-	    instanceLocation: Instance$D.uri(instance),
+	    instanceLocation: Instance$B.uri(instance),
 	    valid: isValid,
 	    ast: uri
 	  });
@@ -3071,7 +3152,7 @@
 	    }, new Set());
 	};
 
-	var validate$1 = { compile: compile$M, interpret: interpret$M, collectEvaluatedProperties: collectEvaluatedProperties$d, collectEvaluatedItems: collectEvaluatedItems$e };
+	var validate$1 = { compile: compile$K, interpret: interpret$K, collectEvaluatedProperties: collectEvaluatedProperties$d, collectEvaluatedItems: collectEvaluatedItems$e };
 
 	const metaData$2 = metaData$4;
 	const validate = validate$1;
@@ -3080,90 +3161,90 @@
 	var keywords$6 = { metaData: metaData$2, validate };
 
 	const Core$w = core$2;
-	const Schema$O = schema$5;
-	const Instance$C = instance;
+	const Schema$M = schema$5;
+	const Instance$A = instance;
 	const Reference = reference;
 	const Keywords$2 = keywords$6;
 	const InvalidSchemaError$1 = invalidSchemaError;
 
 
-	var lib$1 = { Core: Core$w, Schema: Schema$O, Instance: Instance$C, Reference, Keywords: Keywords$2, InvalidSchemaError: InvalidSchemaError$1 };
+	var lib$1 = { Core: Core$w, Schema: Schema$M, Instance: Instance$A, Reference, Keywords: Keywords$2, InvalidSchemaError: InvalidSchemaError$1 };
 
-	const { Core: Core$v, Schema: Schema$N, Instance: Instance$B } = lib$1;
+	const { Core: Core$v, Schema: Schema$L, Instance: Instance$z } = lib$1;
 
 
-	const compile$L = async (schema, ast, parentSchema) => {
-	  const items = await Schema$N.step("items", parentSchema);
-	  const numberOfItems = Schema$N.typeOf(items, "array") ? Schema$N.length(items) : Number.MAX_SAFE_INTEGER;
+	const compile$J = async (schema, ast, parentSchema) => {
+	  const items = await Schema$L.step("items", parentSchema);
+	  const numberOfItems = Schema$L.typeOf(items, "array") ? Schema$L.length(items) : Number.MAX_SAFE_INTEGER;
 
-	  if (Schema$N.typeOf(schema, "boolean")) {
-	    return [numberOfItems, Schema$N.value(schema)];
+	  if (Schema$L.typeOf(schema, "boolean")) {
+	    return [numberOfItems, Schema$L.value(schema)];
 	  } else {
 	    return [numberOfItems, await Core$v.compileSchema(schema, ast)];
 	  }
 	};
 
-	const interpret$L = ([numberOfItems, additionalItems], instance, ast, dynamicAnchors) => {
-	  if (!Instance$B.typeOf(instance, "array")) {
+	const interpret$J = ([numberOfItems, additionalItems], instance, ast, dynamicAnchors) => {
+	  if (!Instance$z.typeOf(instance, "array")) {
 	    return true;
 	  }
 
 	  if (typeof additionalItems === "string") {
-	    return Instance$B.every((item, ndx) => ndx < numberOfItems || Core$v.interpretSchema(additionalItems, item, ast, dynamicAnchors), instance);
+	    return Instance$z.every((item, ndx) => ndx < numberOfItems || Core$v.interpretSchema(additionalItems, item, ast, dynamicAnchors), instance);
 	  } else {
-	    return Instance$B.every((item, ndx) => ndx < numberOfItems ? true : additionalItems, instance);
+	    return Instance$z.every((item, ndx) => ndx < numberOfItems ? true : additionalItems, instance);
 	  }
 	};
 
-	var additionalItems = { compile: compile$L, interpret: interpret$L };
+	var additionalItems = { compile: compile$J, interpret: interpret$J };
 
-	const { Core: Core$u, Schema: Schema$M, Instance: Instance$A } = lib$1;
+	const { Core: Core$u, Schema: Schema$K, Instance: Instance$y } = lib$1;
 
 
-	const compile$K = async (schema, ast, parentSchema) => {
-	  const items = await Schema$M.step("items", parentSchema);
-	  const numberOfItems = Schema$M.typeOf(items, "array") ? Schema$M.length(items) : Number.MAX_SAFE_INTEGER;
+	const compile$I = async (schema, ast, parentSchema) => {
+	  const items = await Schema$K.step("items", parentSchema);
+	  const numberOfItems = Schema$K.typeOf(items, "array") ? Schema$K.length(items) : Number.MAX_SAFE_INTEGER;
 
 	  return [numberOfItems, await Core$u.compileSchema(schema, ast)];
 	};
 
-	const interpret$K = ([numberOfItems, additionalItems], instance, ast, dynamicAnchors) => {
-	  if (!Instance$A.typeOf(instance, "array")) {
+	const interpret$I = ([numberOfItems, additionalItems], instance, ast, dynamicAnchors) => {
+	  if (!Instance$y.typeOf(instance, "array")) {
 	    return true;
 	  }
 
-	  return Instance$A.every((item, ndx) => ndx < numberOfItems || Core$u.interpretSchema(additionalItems, item, ast, dynamicAnchors), instance);
+	  return Instance$y.every((item, ndx) => ndx < numberOfItems || Core$u.interpretSchema(additionalItems, item, ast, dynamicAnchors), instance);
 	};
 
 	const collectEvaluatedItems$d = (keywordValue, instance, ast, dynamicAnchors) => {
-	  return interpret$K(keywordValue, instance, ast, dynamicAnchors) && new Set(Instance$A.map((item, ndx) => ndx, instance));
+	  return interpret$I(keywordValue, instance, ast, dynamicAnchors) && new Set(Instance$y.map((item, ndx) => ndx, instance));
 	};
 
-	var additionalItems6 = { compile: compile$K, interpret: interpret$K, collectEvaluatedItems: collectEvaluatedItems$d };
+	var additionalItems6 = { compile: compile$I, interpret: interpret$I, collectEvaluatedItems: collectEvaluatedItems$d };
 
-	const { Core: Core$t, Schema: Schema$L, Instance: Instance$z } = lib$1;
+	const { Core: Core$t, Schema: Schema$J, Instance: Instance$x } = lib$1;
 
 
-	const compile$J = async (schema, ast, parentSchema) => {
-	  const properties = await Schema$L.step("properties", parentSchema);
-	  const propertyNames = Schema$L.typeOf(properties, "object") ? Schema$L.keys(properties) : [];
+	const compile$H = async (schema, ast, parentSchema) => {
+	  const properties = await Schema$J.step("properties", parentSchema);
+	  const propertyNames = Schema$J.typeOf(properties, "object") ? Schema$J.keys(properties) : [];
 
-	  const patternProperties = await Schema$L.step("patternProperties", parentSchema);
-	  const propertyNamePatterns = Schema$L.typeOf(patternProperties, "object") ? Schema$L.keys(patternProperties).map((pattern) => new RegExp(pattern)) : [];
+	  const patternProperties = await Schema$J.step("patternProperties", parentSchema);
+	  const propertyNamePatterns = Schema$J.typeOf(patternProperties, "object") ? Schema$J.keys(patternProperties).map((pattern) => new RegExp(pattern)) : [];
 
-	  if (Schema$L.typeOf(schema, "boolean")) {
-	    return [propertyNames, propertyNamePatterns, Schema$L.value(schema)];
+	  if (Schema$J.typeOf(schema, "boolean")) {
+	    return [propertyNames, propertyNamePatterns, Schema$J.value(schema)];
 	  } else {
 	    return [propertyNames, propertyNamePatterns, await Core$t.compileSchema(schema, ast)];
 	  }
 	};
 
-	const interpret$J = ([propertyNames, propertyNamePatterns, additionalProperties], instance, ast, dynamicAnchors) => {
-	  if (!Instance$z.typeOf(instance, "object")) {
+	const interpret$H = ([propertyNames, propertyNamePatterns, additionalProperties], instance, ast, dynamicAnchors) => {
+	  if (!Instance$x.typeOf(instance, "object")) {
 	    return true;
 	  }
 
-	  const properties = Instance$z.entries(instance)
+	  const properties = Instance$x.entries(instance)
 	    .filter(([propertyName]) => !propertyNames.includes(propertyName) && !propertyNamePatterns.some((pattern) => pattern.test(propertyName)));
 
 	  if (typeof additionalProperties === "string") {
@@ -3173,47 +3254,47 @@
 	  }
 	};
 
-	var additionalProperties = { compile: compile$J, interpret: interpret$J };
+	var additionalProperties = { compile: compile$H, interpret: interpret$H };
 
-	const { Core: Core$s, Schema: Schema$K, Instance: Instance$y } = lib$1;
+	const { Core: Core$s, Schema: Schema$I, Instance: Instance$w } = lib$1;
 
 
-	const compile$I = async (schema, ast, parentSchema) => {
-	  const propertiesSchema = await Schema$K.step("properties", parentSchema);
-	  const propertyNames = Schema$K.typeOf(propertiesSchema, "object") ? Schema$K.keys(propertiesSchema) : [];
+	const compile$G = async (schema, ast, parentSchema) => {
+	  const propertiesSchema = await Schema$I.step("properties", parentSchema);
+	  const propertyNames = Schema$I.typeOf(propertiesSchema, "object") ? Schema$I.keys(propertiesSchema) : [];
 
-	  const patternProperties = await Schema$K.step("patternProperties", parentSchema);
-	  const propertyNamePatterns = Schema$K.typeOf(patternProperties, "object") ? Schema$K.keys(patternProperties).map((pattern) => new RegExp(pattern)) : [];
+	  const patternProperties = await Schema$I.step("patternProperties", parentSchema);
+	  const propertyNamePatterns = Schema$I.typeOf(patternProperties, "object") ? Schema$I.keys(patternProperties).map((pattern) => new RegExp(pattern)) : [];
 
 	  return [propertyNames, propertyNamePatterns, await Core$s.compileSchema(schema, ast)];
 	};
 
-	const interpret$I = ([propertyNames, propertyNamePatterns, additionalProperties], instance, ast, dynamicAnchors) => {
-	  if (!Instance$y.typeOf(instance, "object")) {
+	const interpret$G = ([propertyNames, propertyNamePatterns, additionalProperties], instance, ast, dynamicAnchors) => {
+	  if (!Instance$w.typeOf(instance, "object")) {
 	    return true;
 	  }
 
-	  return Instance$y.entries(instance)
+	  return Instance$w.entries(instance)
 	    .filter(([propertyName]) => !propertyNames.includes(propertyName) && !propertyNamePatterns.some((pattern) => pattern.test(propertyName)))
 	    .every(([, property]) => Core$s.interpretSchema(additionalProperties, property, ast, dynamicAnchors));
 	};
 
 	const collectEvaluatedProperties$c = (keywordValue, instance, ast, dynamicAnchors) => {
-	  return interpret$I(keywordValue, instance, ast, dynamicAnchors) && [new RegExp("")];
+	  return interpret$G(keywordValue, instance, ast, dynamicAnchors) && [new RegExp("")];
 	};
 
-	var additionalProperties6 = { compile: compile$I, interpret: interpret$I, collectEvaluatedProperties: collectEvaluatedProperties$c };
+	var additionalProperties6 = { compile: compile$G, interpret: interpret$G, collectEvaluatedProperties: collectEvaluatedProperties$c };
 
-	const { Core: Core$r, Schema: Schema$J } = lib$1;
+	const { Core: Core$r, Schema: Schema$H } = lib$1;
 	const Pact$8 = lib$2;
 
 
-	const compile$H = (schema, ast) => Pact$8.pipeline([
-	  Schema$J.map(async (itemSchema) => Core$r.compileSchema(await itemSchema, ast)),
+	const compile$F = (schema, ast) => Pact$8.pipeline([
+	  Schema$H.map(async (itemSchema) => Core$r.compileSchema(await itemSchema, ast)),
 	  Pact$8.all
 	], schema);
 
-	const interpret$H = (allOf, instance, ast, dynamicAnchors) => {
+	const interpret$F = (allOf, instance, ast, dynamicAnchors) => {
 	  return allOf.every((schemaUrl) => Core$r.interpretSchema(schemaUrl, instance, ast, dynamicAnchors));
 	};
 
@@ -3231,18 +3312,18 @@
 	  }, new Set());
 	};
 
-	var allOf = { compile: compile$H, interpret: interpret$H, collectEvaluatedProperties: collectEvaluatedProperties$b, collectEvaluatedItems: collectEvaluatedItems$c };
+	var allOf = { compile: compile$F, interpret: interpret$F, collectEvaluatedProperties: collectEvaluatedProperties$b, collectEvaluatedItems: collectEvaluatedItems$c };
 
-	const { Core: Core$q, Schema: Schema$I } = lib$1;
+	const { Core: Core$q, Schema: Schema$G } = lib$1;
 	const Pact$7 = lib$2;
 
 
-	const compile$G = (schema, ast) => Pact$7.pipeline([
-	  Schema$I.map(async (itemSchema) => Core$q.compileSchema(await itemSchema, ast)),
+	const compile$E = (schema, ast) => Pact$7.pipeline([
+	  Schema$G.map(async (itemSchema) => Core$q.compileSchema(await itemSchema, ast)),
 	  Pact$7.all
 	], schema);
 
-	const interpret$G = (anyOf, instance, ast, dynamicAnchors) => {
+	const interpret$E = (anyOf, instance, ast, dynamicAnchors) => {
 	  const matches = anyOf.filter((schemaUrl) => Core$q.interpretSchema(schemaUrl, instance, ast, dynamicAnchors));
 	  return matches.length > 0;
 	};
@@ -3261,7 +3342,7 @@
 	  }, false);
 	};
 
-	var anyOf = { compile: compile$G, interpret: interpret$G, collectEvaluatedProperties: collectEvaluatedProperties$a, collectEvaluatedItems: collectEvaluatedItems$b };
+	var anyOf = { compile: compile$E, interpret: interpret$E, collectEvaluatedProperties: collectEvaluatedProperties$a, collectEvaluatedItems: collectEvaluatedItems$b };
 
 	var keyList = Object.keys;
 	var native_stringify = JSON.stringify;
@@ -3322,92 +3403,92 @@
 
 	var fastestStableStringify = function(obj) { return '' + stringify(obj, false); };
 
-	const { Schema: Schema$H, Instance: Instance$x } = lib$1;
+	const { Schema: Schema$F, Instance: Instance$v } = lib$1;
 	const jsonStringify$2 = fastestStableStringify;
 
 
-	const compile$F = (schema) => jsonStringify$2(Schema$H.value(schema));
-	const interpret$F = (const_, instance) => jsonStringify$2(Instance$x.value(instance)) === const_;
+	const compile$D = (schema) => jsonStringify$2(Schema$F.value(schema));
+	const interpret$D = (const_, instance) => jsonStringify$2(Instance$v.value(instance)) === const_;
 
-	var _const = { compile: compile$F, interpret: interpret$F };
+	var _const = { compile: compile$D, interpret: interpret$D };
 
-	const { Core: Core$p, Instance: Instance$w } = lib$1;
+	const { Core: Core$p, Instance: Instance$u } = lib$1;
 
 
-	const compile$E = (schema, ast) => Core$p.compileSchema(schema, ast);
+	const compile$C = (schema, ast) => Core$p.compileSchema(schema, ast);
 
-	const interpret$E = (contains, instance, ast, dynamicAnchors) => {
-	  return !Instance$w.typeOf(instance, "array") || Instance$w.some((item) => Core$p.interpretSchema(contains, item, ast, dynamicAnchors), instance);
+	const interpret$C = (contains, instance, ast, dynamicAnchors) => {
+	  return !Instance$u.typeOf(instance, "array") || Instance$u.some((item) => Core$p.interpretSchema(contains, item, ast, dynamicAnchors), instance);
 	};
 
-	var contains = { compile: compile$E, interpret: interpret$E };
+	var contains = { compile: compile$C, interpret: interpret$C };
 
-	const { Core: Core$o, Schema: Schema$G, Instance: Instance$v } = lib$1;
+	const { Core: Core$o, Schema: Schema$E, Instance: Instance$t } = lib$1;
 
 
-	const compile$D = async (schema, ast, parentSchema) => {
+	const compile$B = async (schema, ast, parentSchema) => {
 	  const contains = await Core$o.compileSchema(schema, ast);
 
-	  const minContainsSchema = await Schema$G.step("minContains", parentSchema);
-	  const minContains = Schema$G.typeOf(minContainsSchema, "number") ? Schema$G.value(minContainsSchema) : 1;
+	  const minContainsSchema = await Schema$E.step("minContains", parentSchema);
+	  const minContains = Schema$E.typeOf(minContainsSchema, "number") ? Schema$E.value(minContainsSchema) : 1;
 
-	  const maxContainsSchema = await Schema$G.step("maxContains", parentSchema);
-	  const maxContains = Schema$G.typeOf(maxContainsSchema, "number") ? Schema$G.value(maxContainsSchema) : Number.MAX_SAFE_INTEGER;
+	  const maxContainsSchema = await Schema$E.step("maxContains", parentSchema);
+	  const maxContains = Schema$E.typeOf(maxContainsSchema, "number") ? Schema$E.value(maxContainsSchema) : Number.MAX_SAFE_INTEGER;
 
 	  return { contains, minContains, maxContains };
 	};
 
-	const interpret$D = ({ contains, minContains, maxContains }, instance, ast, dynamicAnchors) => {
-	  if (!Instance$v.typeOf(instance, "array")) {
+	const interpret$B = ({ contains, minContains, maxContains }, instance, ast, dynamicAnchors) => {
+	  if (!Instance$t.typeOf(instance, "array")) {
 	    return true;
 	  }
 
-	  const matches = Instance$v.reduce((matches, item) => {
+	  const matches = Instance$t.reduce((matches, item) => {
 	    return Core$o.interpretSchema(contains, item, ast, dynamicAnchors) ? matches + 1 : matches;
 	  }, 0, instance);
 	  return matches >= minContains && matches <= maxContains;
 	};
 
 	const collectEvaluatedItems$a = (keywordValue, instance, ast, dynamicAnchors) => {
-	  return interpret$D(keywordValue, instance, ast, dynamicAnchors) && Instance$v.reduce((matchedIndexes, item, itemIndex) => {
+	  return interpret$B(keywordValue, instance, ast, dynamicAnchors) && Instance$t.reduce((matchedIndexes, item, itemIndex) => {
 	    return Core$o.interpretSchema(keywordValue.contains, item, ast, dynamicAnchors) ? matchedIndexes.add(itemIndex) : matchedIndexes;
 	  }, new Set(), instance);
 	};
 
-	var containsMinContainsMaxContains = { compile: compile$D, interpret: interpret$D, collectEvaluatedItems: collectEvaluatedItems$a };
+	var containsMinContainsMaxContains = { compile: compile$B, interpret: interpret$B, collectEvaluatedItems: collectEvaluatedItems$a };
 
-	const { Core: Core$n, Schema: Schema$F } = lib$1;
+	const { Core: Core$n, Schema: Schema$D } = lib$1;
 	const Pact$6 = lib$2;
 
 
-	const compile$C = async (schema, ast) => {
+	const compile$A = async (schema, ast) => {
 	  await Pact$6.pipeline([
-	    Schema$F.entries,
+	    Schema$D.entries,
 	    Pact$6.map(([, definitionSchema]) => Core$n.compileSchema(definitionSchema, ast)),
 	    Pact$6.all
 	  ], schema);
 	};
 
-	const interpret$C = () => true;
+	const interpret$A = () => true;
 
-	var definitions = { compile: compile$C, interpret: interpret$C };
+	var definitions = { compile: compile$A, interpret: interpret$A };
 
-	const { Core: Core$m, Schema: Schema$E, Instance: Instance$u } = lib$1;
+	const { Core: Core$m, Schema: Schema$C, Instance: Instance$s } = lib$1;
 	const Pact$5 = lib$2;
 
 
-	const compile$B = (schema, ast) => Pact$5.pipeline([
-	  Schema$E.entries,
+	const compile$z = (schema, ast) => Pact$5.pipeline([
+	  Schema$C.entries,
 	  Pact$5.map(async ([key, dependency]) => {
-	    return [key, Schema$E.typeOf(dependency, "array") ? Schema$E.value(dependency) : await Core$m.compileSchema(dependency, ast)];
+	    return [key, Schema$C.typeOf(dependency, "array") ? Schema$C.value(dependency) : await Core$m.compileSchema(dependency, ast)];
 	  }),
 	  Pact$5.all
 	], schema);
 
-	const interpret$B = (dependencies, instance, ast, dynamicAnchors) => {
-	  const value = Instance$u.value(instance);
+	const interpret$z = (dependencies, instance, ast, dynamicAnchors) => {
+	  const value = Instance$s.value(instance);
 
-	  return !Instance$u.typeOf(instance, "object") || dependencies.every(([propertyName, dependency]) => {
+	  return !Instance$s.typeOf(instance, "object") || dependencies.every(([propertyName, dependency]) => {
 	    if (!(propertyName in value)) {
 	      return true;
 	    }
@@ -3420,49 +3501,49 @@
 	  });
 	};
 
-	var dependencies = { compile: compile$B, interpret: interpret$B };
+	var dependencies = { compile: compile$z, interpret: interpret$z };
 
-	const { Schema: Schema$D, Instance: Instance$t } = lib$1;
+	const { Schema: Schema$B, Instance: Instance$r } = lib$1;
 	const Pact$4 = lib$2;
 
 
-	const compile$A = (schema) => Pact$4.pipeline([
-	  Schema$D.entries,
-	  Pact$4.map(([key, dependentRequired]) => [key, Schema$D.value(dependentRequired)]),
+	const compile$y = (schema) => Pact$4.pipeline([
+	  Schema$B.entries,
+	  Pact$4.map(([key, dependentRequired]) => [key, Schema$B.value(dependentRequired)]),
 	  Pact$4.all
 	], schema);
 
-	const interpret$A = (dependentRequired, instance) => {
-	  const value = Instance$t.value(instance);
+	const interpret$y = (dependentRequired, instance) => {
+	  const value = Instance$r.value(instance);
 
-	  return !Instance$t.typeOf(instance, "object") || dependentRequired.every(([propertyName, required]) => {
+	  return !Instance$r.typeOf(instance, "object") || dependentRequired.every(([propertyName, required]) => {
 	    return !(propertyName in value) || required.every((key) => key in value);
 	  });
 	};
 
-	var dependentRequired = { compile: compile$A, interpret: interpret$A };
+	var dependentRequired = { compile: compile$y, interpret: interpret$y };
 
-	const { Core: Core$l, Schema: Schema$C, Instance: Instance$s } = lib$1;
+	const { Core: Core$l, Schema: Schema$A, Instance: Instance$q } = lib$1;
 	const Pact$3 = lib$2;
 
 
-	const compile$z = (schema, ast) => Pact$3.pipeline([
-	  Schema$C.entries,
+	const compile$x = (schema, ast) => Pact$3.pipeline([
+	  Schema$A.entries,
 	  Pact$3.map(async ([key, dependentSchema]) => [key, await Core$l.compileSchema(dependentSchema, ast)]),
 	  Pact$3.all
 	], schema);
 
-	const interpret$z = (dependentSchemas, instance, ast, dynamicAnchors) => {
-	  const value = Instance$s.value(instance);
+	const interpret$x = (dependentSchemas, instance, ast, dynamicAnchors) => {
+	  const value = Instance$q.value(instance);
 
-	  return !Instance$s.typeOf(instance, "object") || dependentSchemas.every(([propertyName, dependentSchema]) => {
+	  return !Instance$q.typeOf(instance, "object") || dependentSchemas.every(([propertyName, dependentSchema]) => {
 	    return !(propertyName in value) || Core$l.interpretSchema(dependentSchema, instance, ast, dynamicAnchors);
 	  });
 	};
 
 	const collectEvaluatedProperties$9 = (dependentSchemas, instance, ast, dynamicAnchors) => {
 	  return dependentSchemas.reduce((acc, [propertyName, dependentSchema]) => {
-	    if (!acc || !Instance$s.has(propertyName, instance)) {
+	    if (!acc || !Instance$q.has(propertyName, instance)) {
 	      return acc;
 	    }
 
@@ -3471,39 +3552,39 @@
 	  }, []);
 	};
 
-	var dependentSchemas = { compile: compile$z, interpret: interpret$z, collectEvaluatedProperties: collectEvaluatedProperties$9 };
+	var dependentSchemas = { compile: compile$x, interpret: interpret$x, collectEvaluatedProperties: collectEvaluatedProperties$9 };
 
-	const { Schema: Schema$B, Instance: Instance$r } = lib$1;
+	const { Schema: Schema$z, Instance: Instance$p } = lib$1;
 	const jsonStringify$1 = fastestStableStringify;
 
 
-	const compile$y = (schema) => Schema$B.value(schema).map(jsonStringify$1);
-	const interpret$y = (enum_, instance) => enum_.some((enumValue) => jsonStringify$1(Instance$r.value(instance)) === enumValue);
+	const compile$w = (schema) => Schema$z.value(schema).map(jsonStringify$1);
+	const interpret$w = (enum_, instance) => enum_.some((enumValue) => jsonStringify$1(Instance$p.value(instance)) === enumValue);
 
-	var _enum = { compile: compile$y, interpret: interpret$y };
+	var _enum = { compile: compile$w, interpret: interpret$w };
 
-	const { Schema: Schema$A, Instance: Instance$q } = lib$1;
+	const { Schema: Schema$y, Instance: Instance$o } = lib$1;
 
 
-	const compile$x = async (schema) => Schema$A.value(schema);
-	const interpret$x = (exclusiveMaximum, instance) => !Instance$q.typeOf(instance, "number") || Instance$q.value(instance) < exclusiveMaximum;
+	const compile$v = async (schema) => Schema$y.value(schema);
+	const interpret$v = (exclusiveMaximum, instance) => !Instance$o.typeOf(instance, "number") || Instance$o.value(instance) < exclusiveMaximum;
 
-	var exclusiveMaximum = { compile: compile$x, interpret: interpret$x };
+	var exclusiveMaximum = { compile: compile$v, interpret: interpret$v };
 
-	const { Schema: Schema$z, Instance: Instance$p } = lib$1;
+	const { Schema: Schema$x, Instance: Instance$n } = lib$1;
 
 
-	const compile$w = async (schema) => Schema$z.value(schema);
-	const interpret$w = (exclusiveMinimum, instance) => !Instance$p.typeOf(instance, "number") || Instance$p.value(instance) > exclusiveMinimum;
+	const compile$u = async (schema) => Schema$x.value(schema);
+	const interpret$u = (exclusiveMinimum, instance) => !Instance$n.typeOf(instance, "number") || Instance$n.value(instance) > exclusiveMinimum;
 
-	var exclusiveMinimum = { compile: compile$w, interpret: interpret$w };
+	var exclusiveMinimum = { compile: compile$u, interpret: interpret$u };
 
 	const { Core: Core$k } = lib$1;
 
 
-	const compile$v = (schema, ast) => Core$k.compileSchema(schema, ast);
+	const compile$t = (schema, ast) => Core$k.compileSchema(schema, ast);
 
-	const interpret$v = (ifSchema, instance, ast, dynamicAnchors) => {
+	const interpret$t = (ifSchema, instance, ast, dynamicAnchors) => {
 	  Core$k.interpretSchema(ifSchema, instance, ast, dynamicAnchors);
 	  return true;
 	};
@@ -3516,21 +3597,21 @@
 	  return Core$k.collectEvaluatedItems(ifSchema, instance, ast, dynamicAnchors) || new Set();
 	};
 
-	var _if = { compile: compile$v, interpret: interpret$v, collectEvaluatedProperties: collectEvaluatedProperties$8, collectEvaluatedItems: collectEvaluatedItems$9 };
+	var _if = { compile: compile$t, interpret: interpret$t, collectEvaluatedProperties: collectEvaluatedProperties$8, collectEvaluatedItems: collectEvaluatedItems$9 };
 
-	const { Core: Core$j, Schema: Schema$y } = lib$1;
+	const { Core: Core$j, Schema: Schema$w } = lib$1;
 
 
-	const compile$u = async (schema, ast, parentSchema) => {
-	  if (Schema$y.has("if", parentSchema)) {
-	    const ifSchema = await Schema$y.step("if", parentSchema);
+	const compile$s = async (schema, ast, parentSchema) => {
+	  if (Schema$w.has("if", parentSchema)) {
+	    const ifSchema = await Schema$w.step("if", parentSchema);
 	    return [await Core$j.compileSchema(ifSchema, ast), await Core$j.compileSchema(schema, ast)];
 	  } else {
 	    return [];
 	  }
 	};
 
-	const interpret$u = ([guard, block], instance, ast, dynamicAnchors) => {
+	const interpret$s = ([guard, block], instance, ast, dynamicAnchors) => {
 	  return guard === undefined || !quietInterpretSchema$1(guard, instance, ast, dynamicAnchors) || Core$j.interpretSchema(block, instance, ast, dynamicAnchors);
 	};
 
@@ -3560,21 +3641,21 @@
 	  return Core$j.collectEvaluatedItems(block, instance, ast, dynamicAnchors);
 	};
 
-	var then = { compile: compile$u, interpret: interpret$u, collectEvaluatedProperties: collectEvaluatedProperties$7, collectEvaluatedItems: collectEvaluatedItems$8 };
+	var then = { compile: compile$s, interpret: interpret$s, collectEvaluatedProperties: collectEvaluatedProperties$7, collectEvaluatedItems: collectEvaluatedItems$8 };
 
-	const { Core: Core$i, Schema: Schema$x } = lib$1;
+	const { Core: Core$i, Schema: Schema$v } = lib$1;
 
 
-	const compile$t = async (schema, ast, parentSchema) => {
-	  if (Schema$x.has("if", parentSchema)) {
-	    const ifSchema = await Schema$x.step("if", parentSchema);
+	const compile$r = async (schema, ast, parentSchema) => {
+	  if (Schema$v.has("if", parentSchema)) {
+	    const ifSchema = await Schema$v.step("if", parentSchema);
 	    return [await Core$i.compileSchema(ifSchema, ast), await Core$i.compileSchema(schema, ast)];
 	  } else {
 	    return [];
 	  }
 	};
 
-	const interpret$t = ([guard, block], instance, ast, dynamicAnchors) => {
+	const interpret$r = ([guard, block], instance, ast, dynamicAnchors) => {
 	  return guard === undefined || quietInterpretSchema(guard, instance, ast, dynamicAnchors) || Core$i.interpretSchema(block, instance, ast, dynamicAnchors);
 	};
 
@@ -3604,140 +3685,124 @@
 	  return Core$i.collectEvaluatedItems(block, instance, ast, dynamicAnchors);
 	};
 
-	var _else = { compile: compile$t, interpret: interpret$t, collectEvaluatedProperties: collectEvaluatedProperties$6, collectEvaluatedItems: collectEvaluatedItems$7 };
+	var _else = { compile: compile$r, interpret: interpret$r, collectEvaluatedProperties: collectEvaluatedProperties$6, collectEvaluatedItems: collectEvaluatedItems$7 };
 
-	const { Core: Core$h, Schema: Schema$w, Instance: Instance$o } = lib$1;
+	const { Core: Core$h, Schema: Schema$u, Instance: Instance$m } = lib$1;
 
 
-	const compile$s = async (schema, ast) => {
-	  if (Schema$w.typeOf(schema, "array")) {
-	    const tupleItems = await Schema$w.map((itemSchema) => Core$h.compileSchema(itemSchema, ast), schema);
+	const compile$q = async (schema, ast) => {
+	  if (Schema$u.typeOf(schema, "array")) {
+	    const tupleItems = await Schema$u.map((itemSchema) => Core$h.compileSchema(itemSchema, ast), schema);
 	    return Promise.all(tupleItems);
 	  } else {
 	    return Core$h.compileSchema(schema, ast);
 	  }
 	};
 
-	const interpret$s = (items, instance, ast, dynamicAnchors) => {
-	  if (!Instance$o.typeOf(instance, "array")) {
+	const interpret$q = (items, instance, ast, dynamicAnchors) => {
+	  if (!Instance$m.typeOf(instance, "array")) {
 	    return true;
 	  }
 
 	  if (typeof items === "string") {
-	    return Instance$o.every((itemValue) => Core$h.interpretSchema(items, itemValue, ast, dynamicAnchors), instance);
+	    return Instance$m.every((itemValue) => Core$h.interpretSchema(items, itemValue, ast, dynamicAnchors), instance);
 	  } else {
-	    return Instance$o.every((item, ndx) => !(ndx in items) || Core$h.interpretSchema(items[ndx], item, ast, dynamicAnchors), instance);
+	    return Instance$m.every((item, ndx) => !(ndx in items) || Core$h.interpretSchema(items[ndx], item, ast, dynamicAnchors), instance);
 	  }
 	};
 
 	const collectEvaluatedItems$6 = (items, instance, ast, dynamicAnchors) => {
-	  return interpret$s(items, instance, ast, dynamicAnchors) && (typeof items === "string"
-	    ? new Set(Instance$o.map((item, itemIndex) => itemIndex, instance))
+	  return interpret$q(items, instance, ast, dynamicAnchors) && (typeof items === "string"
+	    ? new Set(Instance$m.map((item, itemIndex) => itemIndex, instance))
 	    : new Set(items.map((item, itemIndex) => itemIndex)));
 	};
 
-	var items = { compile: compile$s, interpret: interpret$s, collectEvaluatedItems: collectEvaluatedItems$6 };
+	var items = { compile: compile$q, interpret: interpret$q, collectEvaluatedItems: collectEvaluatedItems$6 };
 
-	const { Core: Core$g, Schema: Schema$v, Instance: Instance$n } = lib$1;
+	const { Core: Core$g, Schema: Schema$t, Instance: Instance$l } = lib$1;
 
 
-	const compile$r = async (schema, ast, parentSchema) => {
-	  const items = await Schema$v.step("prefixItems", parentSchema);
-	  const numberOfPrefixItems = Schema$v.typeOf(items, "array") ? Schema$v.length(items) : 0;
+	const compile$p = async (schema, ast, parentSchema) => {
+	  const items = await Schema$t.step("prefixItems", parentSchema);
+	  const numberOfPrefixItems = Schema$t.typeOf(items, "array") ? Schema$t.length(items) : 0;
 
 	  return [numberOfPrefixItems, await Core$g.compileSchema(schema, ast)];
 	};
 
-	const interpret$r = ([numberOfPrefixItems, items], instance, ast, dynamicAnchors) => {
-	  if (!Instance$n.typeOf(instance, "array")) {
+	const interpret$p = ([numberOfPrefixItems, items], instance, ast, dynamicAnchors) => {
+	  if (!Instance$l.typeOf(instance, "array")) {
 	    return true;
 	  }
 
-	  return Instance$n.every((item, ndx) => ndx < numberOfPrefixItems || Core$g.interpretSchema(items, item, ast, dynamicAnchors), instance);
+	  return Instance$l.every((item, ndx) => ndx < numberOfPrefixItems || Core$g.interpretSchema(items, item, ast, dynamicAnchors), instance);
 	};
 
 	const collectEvaluatedItems$5 = (keywordValue, instance, ast, dynamicAnchors) => {
-	  return interpret$r(keywordValue, instance, ast, dynamicAnchors) && new Set(Instance$n.map((item, ndx) => ndx, instance));
+	  return interpret$p(keywordValue, instance, ast, dynamicAnchors) && new Set(Instance$l.map((item, ndx) => ndx, instance));
 	};
 
-	var items202012 = { compile: compile$r, interpret: interpret$r, collectEvaluatedItems: collectEvaluatedItems$5 };
-
-	const { Schema: Schema$u, Instance: Instance$m } = lib$1;
-
-
-	const compile$q = (schema) => Schema$u.value(schema);
-	const interpret$q = (maxItems, instance) => !Instance$m.typeOf(instance, "array") || Instance$m.length(instance) <= maxItems;
-
-	var maxItems = { compile: compile$q, interpret: interpret$q };
-
-	const { Schema: Schema$t, Instance: Instance$l } = lib$1;
-
-
-	const compile$p = (schema) => Schema$t.value(schema);
-	const interpret$p = (maxLength, instance) => !Instance$l.typeOf(instance, "string") || Instance$l.length(instance) <= maxLength;
-
-	var maxLength = { compile: compile$p, interpret: interpret$p };
+	var items202012 = { compile: compile$p, interpret: interpret$p, collectEvaluatedItems: collectEvaluatedItems$5 };
 
 	const { Schema: Schema$s, Instance: Instance$k } = lib$1;
 
 
 	const compile$o = (schema) => Schema$s.value(schema);
-	const interpret$o = (maxLength, instance) => !Instance$k.typeOf(instance, "string") || [...Instance$k.value(instance)].length <= maxLength;
+	const interpret$o = (maxItems, instance) => !Instance$k.typeOf(instance, "array") || Instance$k.length(instance) <= maxItems;
 
-	var maxLength6 = { compile: compile$o, interpret: interpret$o };
+	var maxItems = { compile: compile$o, interpret: interpret$o };
 
 	const { Schema: Schema$r, Instance: Instance$j } = lib$1;
 
 
 	const compile$n = (schema) => Schema$r.value(schema);
-	const interpret$n = (maxProperties, instance) => !Instance$j.typeOf(instance, "object") || Instance$j.keys(instance).length <= maxProperties;
+	const interpret$n = (maxLength, instance) => !Instance$j.typeOf(instance, "string") || [...Instance$j.value(instance)].length <= maxLength;
 
-	var maxProperties = { compile: compile$n, interpret: interpret$n };
+	var maxLength = { compile: compile$n, interpret: interpret$n };
 
 	const { Schema: Schema$q, Instance: Instance$i } = lib$1;
 
 
-	const compile$m = async (schema, ast, parentSchema) => {
-	  const exclusiveMaximum = await Schema$q.step("exclusiveMaximum", parentSchema);
-	  const isExclusive = Schema$q.value(exclusiveMaximum);
+	const compile$m = (schema) => Schema$q.value(schema);
+	const interpret$m = (maxProperties, instance) => !Instance$i.typeOf(instance, "object") || Instance$i.keys(instance).length <= maxProperties;
+
+	var maxProperties = { compile: compile$m, interpret: interpret$m };
+
+	const { Schema: Schema$p, Instance: Instance$h } = lib$1;
+
+
+	const compile$l = async (schema, ast, parentSchema) => {
+	  const exclusiveMaximum = await Schema$p.step("exclusiveMaximum", parentSchema);
+	  const isExclusive = Schema$p.value(exclusiveMaximum);
 
-	  return [Schema$q.value(schema), isExclusive];
+	  return [Schema$p.value(schema), isExclusive];
 	};
 
-	const interpret$m = ([maximum, isExclusive], instance) => {
-	  if (!Instance$i.typeOf(instance, "number")) {
+	const interpret$l = ([maximum, isExclusive], instance) => {
+	  if (!Instance$h.typeOf(instance, "number")) {
 	    return true;
 	  }
 
-	  const value = Instance$i.value(instance);
+	  const value = Instance$h.value(instance);
 	  return isExclusive ? value < maximum : value <= maximum;
 	};
 
-	var maximumExclusiveMaximum = { compile: compile$m, interpret: interpret$m };
-
-	const { Schema: Schema$p, Instance: Instance$h } = lib$1;
-
-
-	const compile$l = async (schema) => Schema$p.value(schema);
-	const interpret$l = (maximum, instance) => !Instance$h.typeOf(instance, "number") || Instance$h.value(instance) <= maximum;
-
-	var maximum = { compile: compile$l, interpret: interpret$l };
+	var maximumExclusiveMaximum = { compile: compile$l, interpret: interpret$l };
 
 	const { Schema: Schema$o, Instance: Instance$g } = lib$1;
 
 
-	const compile$k = (schema) => Schema$o.value(schema);
-	const interpret$k = (minItems, instance) => !Instance$g.typeOf(instance, "array") || Instance$g.length(instance) >= minItems;
+	const compile$k = async (schema) => Schema$o.value(schema);
+	const interpret$k = (maximum, instance) => !Instance$g.typeOf(instance, "number") || Instance$g.value(instance) <= maximum;
 
-	var minItems = { compile: compile$k, interpret: interpret$k };
+	var maximum = { compile: compile$k, interpret: interpret$k };
 
 	const { Schema: Schema$n, Instance: Instance$f } = lib$1;
 
 
 	const compile$j = (schema) => Schema$n.value(schema);
-	const interpret$j = (minLength, instance) => !Instance$f.typeOf(instance, "string") || Instance$f.length(instance) >= minLength;
+	const interpret$j = (minItems, instance) => !Instance$f.typeOf(instance, "array") || Instance$f.length(instance) >= minItems;
 
-	var minLength = { compile: compile$j, interpret: interpret$j };
+	var minItems = { compile: compile$j, interpret: interpret$j };
 
 	const { Schema: Schema$m, Instance: Instance$e } = lib$1;
 
@@ -3745,7 +3810,7 @@
 	const compile$i = (schema) => Schema$m.value(schema);
 	const interpret$i = (minLength, instance) => !Instance$e.typeOf(instance, "string") || [...Instance$e.value(instance)].length >= minLength;
 
-	var minLength6 = { compile: compile$i, interpret: interpret$i };
+	var minLength = { compile: compile$i, interpret: interpret$i };
 
 	const { Schema: Schema$l, Instance: Instance$d } = lib$1;
 
@@ -4119,14 +4184,12 @@
 	  items202012: items202012,
 	  maxItems: maxItems,
 	  maxLength: maxLength,
-	  maxLength6: maxLength6,
 	  maxProperties: maxProperties,
 	  maximumExclusiveMaximum: maximumExclusiveMaximum,
 	  maximum: maximum,
 	  metaData: Keywords$1.metaData,
 	  minItems: minItems,
 	  minLength: minLength,
-	  minLength6: minLength6,
 	  minProperties: minProperties,
 	  minimumExclusiveMinimum: minimumExclusiveMinimum,
 	  minimum: minimum,
@@ -4532,11 +4595,11 @@
 	  "format": keywords$3.metaData,
 	  "items": keywords$3.items,
 	  "maxItems": keywords$3.maxItems,
-	  "maxLength": keywords$3.maxLength6,
+	  "maxLength": keywords$3.maxLength,
 	  "maxProperties": keywords$3.maxProperties,
 	  "maximum": keywords$3.maximum,
 	  "minItems": keywords$3.minItems,
-	  "minLength": keywords$3.minLength6,
+	  "minLength": keywords$3.minLength,
 	  "minProperties": keywords$3.minProperties,
 	  "minimum": keywords$3.minimum,
 	  "multipleOf": keywords$3.multipleOf,
@@ -4759,11 +4822,11 @@
 	  "else": keywords$2.else,
 	  "items": keywords$2.items,
 	  "maxItems": keywords$2.maxItems,
-	  "maxLength": keywords$2.maxLength6,
+	  "maxLength": keywords$2.maxLength,
 	  "maxProperties": keywords$2.maxProperties,
 	  "maximum": keywords$2.maximum,
 	  "minItems": keywords$2.minItems,
-	  "minLength": keywords$2.minLength6,
+	  "minLength": keywords$2.minLength,
 	  "minProperties": keywords$2.minProperties,
 	  "minimum": keywords$2.minimum,
 	  "multipleOf": keywords$2.multipleOf,
@@ -5167,11 +5230,11 @@
 	  "exclusiveMaximum": keywords$1.exclusiveMaximum,
 	  "exclusiveMinimum": keywords$1.exclusiveMinimum,
 	  "maxItems": keywords$1.maxItems,
-	  "maxLength": keywords$1.maxLength6,
+	  "maxLength": keywords$1.maxLength,
 	  "maxProperties": keywords$1.maxProperties,
 	  "maximum": keywords$1.maximum,
 	  "minItems": keywords$1.minItems,
-	  "minLength": keywords$1.minLength6,
+	  "minLength": keywords$1.minLength,
 	  "minProperties": keywords$1.minProperties,
 	  "minimum": keywords$1.minimum,
 	  "multipleOf": keywords$1.multipleOf,
@@ -5614,11 +5677,11 @@
 	  "exclusiveMaximum": keywords.exclusiveMaximum,
 	  "exclusiveMinimum": keywords.exclusiveMinimum,
 	  "maxItems": keywords.maxItems,
-	  "maxLength": keywords.maxLength6,
+	  "maxLength": keywords.maxLength,
 	  "maxProperties": keywords.maxProperties,
 	  "maximum": keywords.maximum,
 	  "minItems": keywords.minItems,
-	  "minLength": keywords.minLength6,
+	  "minLength": keywords.minLength,
 	  "minProperties": keywords.minProperties,
 	  "minimum": keywords.minimum,
 	  "multipleOf": keywords.multipleOf,