@hyperjump/json-schema 0.23.1 → 0.23.2

package/dist/json-schema-cjs.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-var justCurryIt$2 = curry$j;
+var justCurryIt$1 = curry$b;
 
 /*
   function add(a, b, c) {
@@ -29,7 +29,7 @@ var justCurryIt$2 = curry$j;
   milesToKm(10); // 16.2
 */
 
-function curry$j(fn, arity) {
+function curry$b(fn, arity) {
   return function curried() {
     if (arity == null) {
       arity = fn.length;
@@ -1900,84 +1900,91 @@ const pathRelative$1 = (from, to) => {
 
 var common$1 = { jsonTypeOf: jsonTypeOf$2, resolveUrl: resolveUrl$3, urlFragment: urlFragment$1, pathRelative: pathRelative$1 };
 
-const curry$i = justCurryIt$2;
+const curry$a = justCurryIt$1;
 
 
-const nil$3 = "";
+const nil$2 = "";
 
-const compile$Q = (pointer) => {
+const compile$N = (pointer) => {
   if (pointer.length > 0 && pointer[0] !== "/") {
     throw Error("Invalid JSON Pointer");
   }
 
-  return pointer.split("/").slice(1).map(unescape$1);
+  return pointer.split("/").slice(1).map(unescape);
 };
 
-const get$3 = (pointer, value = undefined) => {
-  const ptr = compile$Q(pointer);
+const get$2 = (pointer, value = undefined) => {
+  const ptr = compile$N(pointer);
 
   const fn = (value) => ptr.reduce(([value, pointer], segment) => {
-    return [applySegment$1(value, segment, pointer), append$1(segment, pointer)];
+    return [applySegment(value, segment, pointer), append(segment, pointer)];
   }, [value, ""])[0];
 
   return value === undefined ? fn : fn(value);
 };
 
-const set$1 = (pointer, subject = undefined, value = undefined) => {
-  const ptr = compile$Q(pointer);
-  const fn = curry$i((subject, value) => _set$1(ptr, subject, value, nil$3));
+const set = (pointer, subject = undefined, value = undefined) => {
+  const ptr = compile$N(pointer);
+  const fn = curry$a((subject, value) => _set(ptr, subject, value, nil$2));
   return subject === undefined ? fn : fn(subject, value);
 };
 
-const _set$1 = (pointer, subject, value, cursor) => {
+const _set = (pointer, subject, value, cursor) => {
   if (pointer.length === 0) {
     return value;
   } else if (pointer.length > 1) {
-    const segment = pointer.shift();
-    return { ...subject, [segment]: _set$1(pointer, applySegment$1(subject, segment, cursor), value, append$1(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$1(subject, pointer[0]);
+    const segment = computeSegment(subject, pointer[0]);
     clonedSubject[segment] = value;
     return clonedSubject;
   } else if (typeof subject === "object" && subject !== null) {
     return { ...subject, [pointer[0]]: value };
   } else {
-    return applySegment$1(subject, pointer[0], cursor);
+    return applySegment(subject, pointer[0], cursor);
   }
 };
 
-const assign$1 = (pointer, subject = undefined, value = undefined) => {
-  const ptr = compile$Q(pointer);
-  const fn = curry$i((subject, value) => _assign$1(ptr, subject, value, nil$3));
+const assign = (pointer, subject = undefined, value = undefined) => {
+  const ptr = compile$N(pointer);
+  const fn = curry$a((subject, value) => _assign(ptr, subject, value, nil$2));
   return subject === undefined ? fn : fn(subject, value);
 };
 
-const _assign$1 = (pointer, subject, value, cursor) => {
+const _assign = (pointer, subject, value, cursor) => {
   if (pointer.length === 0) {
     return;
-  } else if (pointer.length === 1 && !isScalar$1(subject)) {
-    const segment = computeSegment$1(subject, pointer[0]);
+  } else if (pointer.length === 1 && !isScalar(subject)) {
+    const segment = computeSegment(subject, pointer[0]);
     subject[segment] = value;
   } else {
     const segment = pointer.shift();
-    _assign$1(pointer, applySegment$1(subject, segment, cursor), value, append$1(segment, cursor));
+    _assign(pointer, applySegment(subject, segment, cursor), value, append(segment, cursor));
   }
 };
 
-const unset$1 = (pointer, subject = undefined) => {
-  const ptr = compile$Q(pointer);
-  const fn = (subject) => _unset$1(ptr, subject, nil$3);
+const unset = (pointer, subject = undefined) => {
+  const ptr = compile$N(pointer);
+  const fn = (subject) => _unset(ptr, subject, nil$2);
   return subject === undefined ? fn : fn(subject);
 };
 
-const _unset$1 = (pointer, subject, cursor) => {
+const _unset = (pointer, subject, cursor) => {
   if (pointer.length == 0) {
     return undefined;
   } else if (pointer.length > 1) {
     const segment = pointer.shift();
-    const value = applySegment$1(subject, segment, cursor);
-    return { ...subject, [segment]: _unset$1(pointer, value, append$1(segment, cursor)) };
+    const value = applySegment(subject, segment, cursor);
+    return { ...subject, [segment]: _unset(pointer, value, append(segment, cursor)) };
   } else if (Array.isArray(subject)) {
     return subject.filter((_, ndx) => ndx != pointer[0]);
   } else if (typeof subject === "object" && subject !== null) {
@@ -1985,54 +1992,54 @@ const _unset$1 = (pointer, subject, cursor) => {
     const { [pointer[0]]: _, ...result } = subject;
     return result;
   } else {
-    return applySegment$1(subject, pointer[0], cursor);
+    return applySegment(subject, pointer[0], cursor);
   }
 };
 
-const remove$1 = (pointer, subject = undefined) => {
-  const ptr = compile$Q(pointer);
-  const fn = (subject) => _remove$1(ptr, subject, nil$3);
+const remove = (pointer, subject = undefined) => {
+  const ptr = compile$N(pointer);
+  const fn = (subject) => _remove(ptr, subject, nil$2);
   return subject === undefined ? fn : fn(subject);
 };
 
-const _remove$1 = (pointer, subject, cursor) => {
+const _remove = (pointer, subject, cursor) => {
   if (pointer.length === 0) {
     return;
   } else if (pointer.length > 1) {
     const segment = pointer.shift();
-    const value = applySegment$1(subject, segment, cursor);
-    _remove$1(pointer, value, append$1(segment, cursor));
+    const value = applySegment(subject, segment, cursor);
+    _remove(pointer, value, append(segment, cursor));
   } else if (Array.isArray(subject)) {
     subject.splice(pointer[0], 1);
   } else if (typeof subject === "object" && subject !== null) {
     delete subject[pointer[0]];
   } else {
-    applySegment$1(subject, pointer[0], cursor);
+    applySegment(subject, pointer[0], cursor);
   }
 };
 
-const append$1 = curry$i((segment, pointer) => pointer + "/" + escape$2(segment));
+const append = curry$a((segment, pointer) => pointer + "/" + escape(segment));
 
-const escape$2 = (segment) => segment.toString().replace(/~/g, "~0").replace(/\//g, "~1");
-const unescape$1 = (segment) => segment.toString().replace(/~1/g, "/").replace(/~0/g, "~");
-const computeSegment$1 = (value, segment) => Array.isArray(value) && segment === "-" ? value.length : segment;
+const escape = (segment) => segment.toString().replace(/~/g, "~0").replace(/\//g, "~1");
+const unescape = (segment) => segment.toString().replace(/~1/g, "/").replace(/~0/g, "~");
+const computeSegment = (value, segment) => Array.isArray(value) && segment === "-" ? value.length : segment;
 
-const applySegment$1 = (value, segment, cursor = "") => {
+const applySegment = (value, segment, cursor = "") => {
   if (value === undefined) {
     throw TypeError(`Value at '${cursor}' is undefined and does not have property '${segment}'`);
   } else if (value === null) {
     throw TypeError(`Value at '${cursor}' is null and does not have property '${segment}'`);
-  } else if (isScalar$1(value)) {
+  } else if (isScalar(value)) {
     throw TypeError(`Value at '${cursor}' is a ${typeof value} and does not have property '${segment}'`);
   } else {
-    const computedSegment = computeSegment$1(value, segment);
+    const computedSegment = computeSegment(value, segment);
     return value[computedSegment];
   }
 };
 
-const isScalar$1 = (value) => value === null || typeof value !== "object";
+const isScalar = (value) => value === null || typeof value !== "object";
 
-var lib$6 = { nil: nil$3, append: append$1, get: get$3, set: set$1, assign: assign$1, unset: unset$1, remove: remove$1 };
+var lib$3 = { nil: nil$2, append, get: get$2, set, assign, unset, remove };
 
 const $__value = Symbol("$__value");
 const $__href = Symbol("$__href");
@@ -2048,16 +2055,16 @@ const value$2 = (ref) => ref[$__value];
 
 var reference = { cons: cons$1, isReference, href, value: value$2 };
 
-const JsonPointer$3 = lib$6;
-const curry$h = justCurryIt$2;
+const JsonPointer$1 = lib$3;
+const curry$9 = justCurryIt$1;
 const { resolveUrl: resolveUrl$2, jsonTypeOf: jsonTypeOf$1 } = common$1;
 const Reference$2 = reference;
 
 
-const nil$2 = Object.freeze({ id: "", pointer: "", instance: undefined, value: undefined });
-const cons = (instance, id = "") => Object.freeze({ ...nil$2, id: resolveUrl$2(id, ""), instance, value: instance });
+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$2 = (url, instance = nil$2) => {
+const get$1 = (url, instance = nil$1) => {
   if (!url.startsWith("#")) {
     throw Error(`No JSON document found at '${url.split("#")[0]}'`);
   }
@@ -2068,126 +2075,48 @@ const get$2 = (url, instance = nil$2) => {
 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$h((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,
-  pointer: JsonPointer$3.append(key, doc.pointer),
+  pointer: JsonPointer$1.append(key, doc.pointer),
   value: value$1(doc)[key]
 });
 
-const entries$5 = (doc) => Object.keys(value$1(doc))
+const entries$3 = (doc) => Object.keys(value$1(doc))
   .map((key) => [key, step$1(key, doc)]);
 
 const keys$1 = (doc) => Object.keys(value$1(doc));
 
-const map$7 = curry$h((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 forEach = curry$h((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$2 = curry$h((fn, doc) => value$1(doc)
+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$6 = curry$h((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$2 = curry$h((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$2 = curry$h((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$2, cons, get: get$2, uri: uri$1, value: value$1, has: has$1, typeOf: typeOf$1, length: length$1,
-  step: step$1, entries: entries$5, keys: keys$1, map: map$7, forEach, filter: filter$2, reduce: reduce$6, every: every$2, some: some$2
-};
-
-var entries$4 = async (doc) => Object.entries(await doc);
-
-const curry$g = justCurryIt$2;
-
-
-var map$6 = curry$g(async (fn, doc) => (await doc).map(fn));
-
-const curry$f = justCurryIt$2;
-
-
-var reduce$5 = curry$f(async (fn, acc, doc) => {
-  return (await doc).reduce(async (acc, item) => fn(await acc, item), acc);
-});
-
-const curry$e = justCurryIt$2;
-const reduce$4 = reduce$5;
-
-
-var filter$1 = curry$e(async (fn, doc, options = {}) => {
-  return reduce$4(async (acc, item) => {
-    return (await fn(item)) ? acc.concat([item]) : acc;
-  }, [], doc, options);
-});
-
-const curry$d = justCurryIt$2;
-const map$5 = map$6;
-
-
-var some$1 = curry$d(async (fn, doc) => {
-  const results = await map$5(fn, doc);
-  return (await Promise.all(results))
-    .some((a) => a);
-});
-
-const curry$c = justCurryIt$2;
-const map$4 = map$6;
-
-
-var every$1 = curry$c(async (fn, doc) => {
-  const results = await map$4(fn, doc);
-  return (await Promise.all(results))
-    .every((a) => a);
-});
-
-const curry$b = justCurryIt$2;
-
-
-var pipeline$3 = curry$b((fns, doc) => {
-  return fns.reduce(async (acc, fn) => fn(await acc), doc);
-});
-
-var all$1 = (doc) => Promise.all(doc);
-
-const pipeline$2 = pipeline$3;
-const entries$3 = entries$4;
-const reduce$3 = reduce$5;
-
-
-var allValues$1 = (doc) => {
-  return pipeline$2([
-    entries$3,
-    reduce$3(async (acc, [propertyName, propertyValue]) => {
-      acc[propertyName] = await propertyValue;
-      return acc;
-    }, {})
-  ], doc);
+  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 lib$5 = {
-  entries: entries$4,
-  map: map$6,
-  filter: filter$1,
-  reduce: reduce$5,
-  some: some$1,
-  every: every$1,
-  pipeline: pipeline$3,
-  all: all$1,
-  allValues: allValues$1
-};
+var entries$2 = async (doc) => Object.entries(await doc);
 
-var justCurryIt$1 = curry$a;
+var justCurryIt = curry$8;
 
 /*
   function add(a, b, c) {
@@ -2212,7 +2141,7 @@ var justCurryIt$1 = curry$a;
   milesToKm(10); // 16.2
 */
 
-function curry$a(fn, arity) {
+function curry$8(fn, arity) {
   return function curried() {
     if (arity == null) {
       arity = fn.length;
@@ -2228,987 +2157,83 @@ function curry$a(fn, arity) {
   };
 }
 
-const curry$9 = justCurryIt$1;
-
-
-const nil$1 = "";
-
-const compile$P = (pointer) => {
-  if (pointer.length > 0 && pointer[0] !== "/") {
-    throw Error("Invalid JSON Pointer");
-  }
-
-  return pointer.split("/").slice(1).map(unescape);
-};
-
-const get$1 = (pointer, value = undefined) => {
-  const ptr = compile$P(pointer);
-
-  const fn = (value) => ptr.reduce(([value, pointer], segment) => {
-    return [applySegment(value, segment, pointer), append(segment, pointer)];
-  }, [value, ""])[0];
-
-  return value === undefined ? fn : fn(value);
-};
-
-const set = (pointer, subject = undefined, value = undefined) => {
-  const ptr = compile$P(pointer);
-  const fn = curry$9((subject, value) => _set(ptr, subject, value, nil$1));
-  return subject === undefined ? fn : fn(subject, value);
-};
-
-const _set = (pointer, subject, value, cursor) => {
-  if (pointer.length === 0) {
-    return value;
-  } else if (pointer.length > 1) {
-    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]);
-    clonedSubject[segment] = value;
-    return clonedSubject;
-  } else if (typeof subject === "object" && subject !== null) {
-    return { ...subject, [pointer[0]]: value };
-  } else {
-    return applySegment(subject, pointer[0], cursor);
-  }
-};
-
-const assign = (pointer, subject = undefined, value = undefined) => {
-  const ptr = compile$P(pointer);
-  const fn = curry$9((subject, value) => _assign(ptr, subject, value, nil$1));
-  return subject === undefined ? fn : fn(subject, value);
-};
-
-const _assign = (pointer, subject, value, cursor) => {
-  if (pointer.length === 0) {
-    return;
-  } else if (pointer.length === 1 && !isScalar(subject)) {
-    const segment = computeSegment(subject, pointer[0]);
-    subject[segment] = value;
-  } else {
-    const segment = pointer.shift();
-    _assign(pointer, applySegment(subject, segment, cursor), value, append(segment, cursor));
-  }
-};
-
-const unset = (pointer, subject = undefined) => {
-  const ptr = compile$P(pointer);
-  const fn = (subject) => _unset(ptr, subject, nil$1);
-  return subject === undefined ? fn : fn(subject);
-};
-
-const _unset = (pointer, subject, cursor) => {
-  if (pointer.length == 0) {
-    return undefined;
-  } else if (pointer.length > 1) {
-    const segment = pointer.shift();
-    const value = applySegment(subject, segment, cursor);
-    return { ...subject, [segment]: _unset(pointer, value, append(segment, cursor)) };
-  } else if (Array.isArray(subject)) {
-    return subject.filter((_, ndx) => ndx != pointer[0]);
-  } else if (typeof subject === "object" && subject !== null) {
-    // eslint-disable-next-line no-unused-vars
-    const { [pointer[0]]: _, ...result } = subject;
-    return result;
-  } else {
-    return applySegment(subject, pointer[0], cursor);
-  }
-};
-
-const remove = (pointer, subject = undefined) => {
-  const ptr = compile$P(pointer);
-  const fn = (subject) => _remove(ptr, subject, nil$1);
-  return subject === undefined ? fn : fn(subject);
-};
-
-const _remove = (pointer, subject, cursor) => {
-  if (pointer.length === 0) {
-    return;
-  } else if (pointer.length > 1) {
-    const segment = pointer.shift();
-    const value = applySegment(subject, segment, cursor);
-    _remove(pointer, value, append(segment, cursor));
-  } else if (Array.isArray(subject)) {
-    subject.splice(pointer[0], 1);
-  } else if (typeof subject === "object" && subject !== null) {
-    delete subject[pointer[0]];
-  } else {
-    applySegment(subject, pointer[0], cursor);
-  }
-};
-
-const append = curry$9((segment, pointer) => pointer + "/" + escape$1(segment));
-
-const escape$1 = (segment) => segment.toString().replace(/~/g, "~0").replace(/\//g, "~1");
-const unescape = (segment) => segment.toString().replace(/~1/g, "/").replace(/~0/g, "~");
-const computeSegment = (value, segment) => Array.isArray(value) && segment === "-" ? value.length : segment;
-
-const applySegment = (value, segment, cursor = "") => {
-  if (value === undefined) {
-    throw TypeError(`Value at '${cursor}' is undefined and does not have property '${segment}'`);
-  } else if (value === null) {
-    throw TypeError(`Value at '${cursor}' is null and does not have property '${segment}'`);
-  } else if (isScalar(value)) {
-    throw TypeError(`Value at '${cursor}' is a ${typeof value} and does not have property '${segment}'`);
-  } else {
-    const computedSegment = computeSegment(value, segment);
-    return value[computedSegment];
-  }
-};
-
-const isScalar = (value) => value === null || typeof value !== "object";
-
-var lib$4 = { nil: nil$1, append, get: get$1, set, assign, unset, remove };
-
-var moo$1 = {exports: {}};
-
-(function (module) {
-	(function(root, factory) {
-	  if (module.exports) {
-	    module.exports = factory();
-	  } else {
-	    root.moo = factory();
-	  }
-	}(commonjsGlobal, function() {
-
-	  var hasOwnProperty = Object.prototype.hasOwnProperty;
-	  var toString = Object.prototype.toString;
-	  var hasSticky = typeof new RegExp().sticky === 'boolean';
-
-	  /***************************************************************************/
-
-	  function isRegExp(o) { return o && toString.call(o) === '[object RegExp]' }
-	  function isObject(o) { return o && typeof o === 'object' && !isRegExp(o) && !Array.isArray(o) }
-
-	  function reEscape(s) {
-	    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&')
-	  }
-	  function reGroups(s) {
-	    var re = new RegExp('|' + s);
-	    return re.exec('').length - 1
-	  }
-	  function reCapture(s) {
-	    return '(' + s + ')'
-	  }
-	  function reUnion(regexps) {
-	    if (!regexps.length) return '(?!)'
-	    var source =  regexps.map(function(s) {
-	      return "(?:" + s + ")"
-	    }).join('|');
-	    return "(?:" + source + ")"
-	  }
-
-	  function regexpOrLiteral(obj) {
-	    if (typeof obj === 'string') {
-	      return '(?:' + reEscape(obj) + ')'
-
-	    } else if (isRegExp(obj)) {
-	      // TODO: consider /u support
-	      if (obj.ignoreCase) throw new Error('RegExp /i flag not allowed')
-	      if (obj.global) throw new Error('RegExp /g flag is implied')
-	      if (obj.sticky) throw new Error('RegExp /y flag is implied')
-	      if (obj.multiline) throw new Error('RegExp /m flag is implied')
-	      return obj.source
-
-	    } else {
-	      throw new Error('Not a pattern: ' + obj)
-	    }
-	  }
-
-	  function objectToRules(object) {
-	    var keys = Object.getOwnPropertyNames(object);
-	    var result = [];
-	    for (var i = 0; i < keys.length; i++) {
-	      var key = keys[i];
-	      var thing = object[key];
-	      var rules = [].concat(thing);
-	      if (key === 'include') {
-	        for (var j = 0; j < rules.length; j++) {
-	          result.push({include: rules[j]});
-	        }
-	        continue
-	      }
-	      var match = [];
-	      rules.forEach(function(rule) {
-	        if (isObject(rule)) {
-	          if (match.length) result.push(ruleOptions(key, match));
-	          result.push(ruleOptions(key, rule));
-	          match = [];
-	        } else {
-	          match.push(rule);
-	        }
-	      });
-	      if (match.length) result.push(ruleOptions(key, match));
-	    }
-	    return result
-	  }
-
-	  function arrayToRules(array) {
-	    var result = [];
-	    for (var i = 0; i < array.length; i++) {
-	      var obj = array[i];
-	      if (obj.include) {
-	        var include = [].concat(obj.include);
-	        for (var j = 0; j < include.length; j++) {
-	          result.push({include: include[j]});
-	        }
-	        continue
-	      }
-	      if (!obj.type) {
-	        throw new Error('Rule has no type: ' + JSON.stringify(obj))
-	      }
-	      result.push(ruleOptions(obj.type, obj));
-	    }
-	    return result
-	  }
-
-	  function ruleOptions(type, obj) {
-	    if (!isObject(obj)) {
-	      obj = { match: obj };
-	    }
-	    if (obj.include) {
-	      throw new Error('Matching rules cannot also include states')
-	    }
-
-	    // nb. error and fallback imply lineBreaks
-	    var options = {
-	      defaultType: type,
-	      lineBreaks: !!obj.error || !!obj.fallback,
-	      pop: false,
-	      next: null,
-	      push: null,
-	      error: false,
-	      fallback: false,
-	      value: null,
-	      type: null,
-	      shouldThrow: false,
-	    };
-
-	    // Avoid Object.assign(), so we support IE9+
-	    for (var key in obj) {
-	      if (hasOwnProperty.call(obj, key)) {
-	        options[key] = obj[key];
-	      }
-	    }
-
-	    // type transform cannot be a string
-	    if (typeof options.type === 'string' && type !== options.type) {
-	      throw new Error("Type transform cannot be a string (type '" + options.type + "' for token '" + type + "')")
-	    }
-
-	    // convert to array
-	    var match = options.match;
-	    options.match = Array.isArray(match) ? match : match ? [match] : [];
-	    options.match.sort(function(a, b) {
-	      return isRegExp(a) && isRegExp(b) ? 0
-	           : isRegExp(b) ? -1 : isRegExp(a) ? +1 : b.length - a.length
-	    });
-	    return options
-	  }
-
-	  function toRules(spec) {
-	    return Array.isArray(spec) ? arrayToRules(spec) : objectToRules(spec)
-	  }
-
-	  var defaultErrorRule = ruleOptions('error', {lineBreaks: true, shouldThrow: true});
-	  function compileRules(rules, hasStates) {
-	    var errorRule = null;
-	    var fast = Object.create(null);
-	    var fastAllowed = true;
-	    var unicodeFlag = null;
-	    var groups = [];
-	    var parts = [];
-
-	    // If there is a fallback rule, then disable fast matching
-	    for (var i = 0; i < rules.length; i++) {
-	      if (rules[i].fallback) {
-	        fastAllowed = false;
-	      }
-	    }
-
-	    for (var i = 0; i < rules.length; i++) {
-	      var options = rules[i];
-
-	      if (options.include) {
-	        // all valid inclusions are removed by states() preprocessor
-	        throw new Error('Inheritance is not allowed in stateless lexers')
-	      }
-
-	      if (options.error || options.fallback) {
-	        // errorRule can only be set once
-	        if (errorRule) {
-	          if (!options.fallback === !errorRule.fallback) {
-	            throw new Error("Multiple " + (options.fallback ? "fallback" : "error") + " rules not allowed (for token '" + options.defaultType + "')")
-	          } else {
-	            throw new Error("fallback and error are mutually exclusive (for token '" + options.defaultType + "')")
-	          }
-	        }
-	        errorRule = options;
-	      }
-
-	      var match = options.match.slice();
-	      if (fastAllowed) {
-	        while (match.length && typeof match[0] === 'string' && match[0].length === 1) {
-	          var word = match.shift();
-	          fast[word.charCodeAt(0)] = options;
-	        }
-	      }
-
-	      // Warn about inappropriate state-switching options
-	      if (options.pop || options.push || options.next) {
-	        if (!hasStates) {
-	          throw new Error("State-switching options are not allowed in stateless lexers (for token '" + options.defaultType + "')")
-	        }
-	        if (options.fallback) {
-	          throw new Error("State-switching options are not allowed on fallback tokens (for token '" + options.defaultType + "')")
-	        }
-	      }
-
-	      // Only rules with a .match are included in the RegExp
-	      if (match.length === 0) {
-	        continue
-	      }
-	      fastAllowed = false;
-
-	      groups.push(options);
-
-	      // Check unicode flag is used everywhere or nowhere
-	      for (var j = 0; j < match.length; j++) {
-	        var obj = match[j];
-	        if (!isRegExp(obj)) {
-	          continue
-	        }
-
-	        if (unicodeFlag === null) {
-	          unicodeFlag = obj.unicode;
-	        } else if (unicodeFlag !== obj.unicode && options.fallback === false) {
-	          throw new Error('If one rule is /u then all must be')
-	        }
-	      }
-
-	      // convert to RegExp
-	      var pat = reUnion(match.map(regexpOrLiteral));
-
-	      // validate
-	      var regexp = new RegExp(pat);
-	      if (regexp.test("")) {
-	        throw new Error("RegExp matches empty string: " + regexp)
-	      }
-	      var groupCount = reGroups(pat);
-	      if (groupCount > 0) {
-	        throw new Error("RegExp has capture groups: " + regexp + "\nUse (?: … ) instead")
-	      }
-
-	      // try and detect rules matching newlines
-	      if (!options.lineBreaks && regexp.test('\n')) {
-	        throw new Error('Rule should declare lineBreaks: ' + regexp)
-	      }
-
-	      // store regex
-	      parts.push(reCapture(pat));
-	    }
-
-
-	    // If there's no fallback rule, use the sticky flag so we only look for
-	    // matches at the current index.
-	    //
-	    // If we don't support the sticky flag, then fake it using an irrefutable
-	    // match (i.e. an empty pattern).
-	    var fallbackRule = errorRule && errorRule.fallback;
-	    var flags = hasSticky && !fallbackRule ? 'ym' : 'gm';
-	    var suffix = hasSticky || fallbackRule ? '' : '|';
-
-	    if (unicodeFlag === true) flags += "u";
-	    var combined = new RegExp(reUnion(parts) + suffix, flags);
-	    return {regexp: combined, groups: groups, fast: fast, error: errorRule || defaultErrorRule}
-	  }
-
-	  function compile(rules) {
-	    var result = compileRules(toRules(rules));
-	    return new Lexer({start: result}, 'start')
-	  }
-
-	  function checkStateGroup(g, name, map) {
-	    var state = g && (g.push || g.next);
-	    if (state && !map[state]) {
-	      throw new Error("Missing state '" + state + "' (in token '" + g.defaultType + "' of state '" + name + "')")
-	    }
-	    if (g && g.pop && +g.pop !== 1) {
-	      throw new Error("pop must be 1 (in token '" + g.defaultType + "' of state '" + name + "')")
-	    }
-	  }
-	  function compileStates(states, start) {
-	    var all = states.$all ? toRules(states.$all) : [];
-	    delete states.$all;
-
-	    var keys = Object.getOwnPropertyNames(states);
-	    if (!start) start = keys[0];
-
-	    var ruleMap = Object.create(null);
-	    for (var i = 0; i < keys.length; i++) {
-	      var key = keys[i];
-	      ruleMap[key] = toRules(states[key]).concat(all);
-	    }
-	    for (var i = 0; i < keys.length; i++) {
-	      var key = keys[i];
-	      var rules = ruleMap[key];
-	      var included = Object.create(null);
-	      for (var j = 0; j < rules.length; j++) {
-	        var rule = rules[j];
-	        if (!rule.include) continue
-	        var splice = [j, 1];
-	        if (rule.include !== key && !included[rule.include]) {
-	          included[rule.include] = true;
-	          var newRules = ruleMap[rule.include];
-	          if (!newRules) {
-	            throw new Error("Cannot include nonexistent state '" + rule.include + "' (in state '" + key + "')")
-	          }
-	          for (var k = 0; k < newRules.length; k++) {
-	            var newRule = newRules[k];
-	            if (rules.indexOf(newRule) !== -1) continue
-	            splice.push(newRule);
-	          }
-	        }
-	        rules.splice.apply(rules, splice);
-	        j--;
-	      }
-	    }
-
-	    var map = Object.create(null);
-	    for (var i = 0; i < keys.length; i++) {
-	      var key = keys[i];
-	      map[key] = compileRules(ruleMap[key], true);
-	    }
-
-	    for (var i = 0; i < keys.length; i++) {
-	      var name = keys[i];
-	      var state = map[name];
-	      var groups = state.groups;
-	      for (var j = 0; j < groups.length; j++) {
-	        checkStateGroup(groups[j], name, map);
-	      }
-	      var fastKeys = Object.getOwnPropertyNames(state.fast);
-	      for (var j = 0; j < fastKeys.length; j++) {
-	        checkStateGroup(state.fast[fastKeys[j]], name, map);
-	      }
-	    }
-
-	    return new Lexer(map, start)
-	  }
-
-	  function keywordTransform(map) {
-	    var reverseMap = Object.create(null);
-	    var byLength = Object.create(null);
-	    var types = Object.getOwnPropertyNames(map);
-	    for (var i = 0; i < types.length; i++) {
-	      var tokenType = types[i];
-	      var item = map[tokenType];
-	      var keywordList = Array.isArray(item) ? item : [item];
-	      keywordList.forEach(function(keyword) {
-	        (byLength[keyword.length] = byLength[keyword.length] || []).push(keyword);
-	        if (typeof keyword !== 'string') {
-	          throw new Error("keyword must be string (in keyword '" + tokenType + "')")
-	        }
-	        reverseMap[keyword] = tokenType;
-	      });
-	    }
-
-	    // fast string lookup
-	    // https://jsperf.com/string-lookups
-	    function str(x) { return JSON.stringify(x) }
-	    var source = '';
-	    source += 'switch (value.length) {\n';
-	    for (var length in byLength) {
-	      var keywords = byLength[length];
-	      source += 'case ' + length + ':\n';
-	      source += 'switch (value) {\n';
-	      keywords.forEach(function(keyword) {
-	        var tokenType = reverseMap[keyword];
-	        source += 'case ' + str(keyword) + ': return ' + str(tokenType) + '\n';
-	      });
-	      source += '}\n';
-	    }
-	    source += '}\n';
-	    return Function('value', source) // type
-	  }
-
-	  /***************************************************************************/
-
-	  var Lexer = function(states, state) {
-	    this.startState = state;
-	    this.states = states;
-	    this.buffer = '';
-	    this.stack = [];
-	    this.reset();
-	  };
-
-	  Lexer.prototype.reset = function(data, info) {
-	    this.buffer = data || '';
-	    this.index = 0;
-	    this.line = info ? info.line : 1;
-	    this.col = info ? info.col : 1;
-	    this.queuedToken = info ? info.queuedToken : null;
-	    this.queuedThrow = info ? info.queuedThrow : null;
-	    this.setState(info ? info.state : this.startState);
-	    this.stack = info && info.stack ? info.stack.slice() : [];
-	    return this
-	  };
-
-	  Lexer.prototype.save = function() {
-	    return {
-	      line: this.line,
-	      col: this.col,
-	      state: this.state,
-	      stack: this.stack.slice(),
-	      queuedToken: this.queuedToken,
-	      queuedThrow: this.queuedThrow,
-	    }
-	  };
-
-	  Lexer.prototype.setState = function(state) {
-	    if (!state || this.state === state) return
-	    this.state = state;
-	    var info = this.states[state];
-	    this.groups = info.groups;
-	    this.error = info.error;
-	    this.re = info.regexp;
-	    this.fast = info.fast;
-	  };
-
-	  Lexer.prototype.popState = function() {
-	    this.setState(this.stack.pop());
-	  };
-
-	  Lexer.prototype.pushState = function(state) {
-	    this.stack.push(this.state);
-	    this.setState(state);
-	  };
-
-	  var eat = hasSticky ? function(re, buffer) { // assume re is /y
-	    return re.exec(buffer)
-	  } : function(re, buffer) { // assume re is /g
-	    var match = re.exec(buffer);
-	    // will always match, since we used the |(?:) trick
-	    if (match[0].length === 0) {
-	      return null
-	    }
-	    return match
-	  };
-
-	  Lexer.prototype._getGroup = function(match) {
-	    var groupCount = this.groups.length;
-	    for (var i = 0; i < groupCount; i++) {
-	      if (match[i + 1] !== undefined) {
-	        return this.groups[i]
-	      }
-	    }
-	    throw new Error('Cannot find token type for matched text')
-	  };
-
-	  function tokenToString() {
-	    return this.value
-	  }
+const curry$7 = justCurryIt;
 
-	  Lexer.prototype.next = function() {
-	    var index = this.index;
 
-	    // If a fallback token matched, we don't need to re-run the RegExp
-	    if (this.queuedGroup) {
-	      var token = this._token(this.queuedGroup, this.queuedText, index);
-	      this.queuedGroup = null;
-	      this.queuedText = "";
-	      return token
-	    }
-
-	    var buffer = this.buffer;
-	    if (index === buffer.length) {
-	      return // EOF
-	    }
-
-	    // Fast matching for single characters
-	    var group = this.fast[buffer.charCodeAt(index)];
-	    if (group) {
-	      return this._token(group, buffer.charAt(index), index)
-	    }
-
-	    // Execute RegExp
-	    var re = this.re;
-	    re.lastIndex = index;
-	    var match = eat(re, buffer);
-
-	    // Error tokens match the remaining buffer
-	    var error = this.error;
-	    if (match == null) {
-	      return this._token(error, buffer.slice(index, buffer.length), index)
-	    }
-
-	    var group = this._getGroup(match);
-	    var text = match[0];
-
-	    if (error.fallback && match.index !== index) {
-	      this.queuedGroup = group;
-	      this.queuedText = text;
-
-	      // Fallback tokens contain the unmatched portion of the buffer
-	      return this._token(error, buffer.slice(index, match.index), index)
-	    }
-
-	    return this._token(group, text, index)
-	  };
-
-	  Lexer.prototype._token = function(group, text, offset) {
-	    // count line breaks
-	    var lineBreaks = 0;
-	    if (group.lineBreaks) {
-	      var matchNL = /\n/g;
-	      var nl = 1;
-	      if (text === '\n') {
-	        lineBreaks = 1;
-	      } else {
-	        while (matchNL.exec(text)) { lineBreaks++; nl = matchNL.lastIndex; }
-	      }
-	    }
-
-	    var token = {
-	      type: (typeof group.type === 'function' && group.type(text)) || group.defaultType,
-	      value: typeof group.value === 'function' ? group.value(text) : text,
-	      text: text,
-	      toString: tokenToString,
-	      offset: offset,
-	      lineBreaks: lineBreaks,
-	      line: this.line,
-	      col: this.col,
-	    };
-	    // nb. adding more props to token object will make V8 sad!
-
-	    var size = text.length;
-	    this.index += size;
-	    this.line += lineBreaks;
-	    if (lineBreaks !== 0) {
-	      this.col = size - nl + 1;
-	    } else {
-	      this.col += size;
-	    }
-
-	    // throw, if no rule with {error: true}
-	    if (group.shouldThrow) {
-	      throw new Error(this.formatError(token, "invalid syntax"))
-	    }
-
-	    if (group.pop) this.popState();
-	    else if (group.push) this.pushState(group.push);
-	    else if (group.next) this.setState(group.next);
-
-	    return token
-	  };
-
-	  if (typeof Symbol !== 'undefined' && Symbol.iterator) {
-	    var LexerIterator = function(lexer) {
-	      this.lexer = lexer;
-	    };
-
-	    LexerIterator.prototype.next = function() {
-	      var token = this.lexer.next();
-	      return {value: token, done: !token}
-	    };
-
-	    LexerIterator.prototype[Symbol.iterator] = function() {
-	      return this
-	    };
-
-	    Lexer.prototype[Symbol.iterator] = function() {
-	      return new LexerIterator(this)
-	    };
-	  }
-
-	  Lexer.prototype.formatError = function(token, message) {
-	    if (token == null) {
-	      // An undefined token indicates EOF
-	      var text = this.buffer.slice(this.index);
-	      var token = {
-	        text: text,
-	        offset: this.index,
-	        lineBreaks: text.indexOf('\n') === -1 ? 0 : 1,
-	        line: this.line,
-	        col: this.col,
-	      };
-	    }
-	    var start = Math.max(0, token.offset - token.col + 1);
-	    var eol = token.lineBreaks ? token.text.indexOf('\n') : token.text.length;
-	    var firstLine = this.buffer.substring(start, token.offset + eol);
-	    message += " at line " + token.line + " col " + token.col + ":\n\n";
-	    message += "  " + firstLine + "\n";
-	    message += "  " + Array(token.col).join(" ") + "^";
-	    return message
-	  };
-
-	  Lexer.prototype.clone = function() {
-	    return new Lexer(this.states, this.state)
-	  };
-
-	  Lexer.prototype.has = function(tokenType) {
-	    return true
-	  };
-
-
-	  return {
-	    compile: compile,
-	    states: compileStates,
-	    error: Object.freeze({error: true}),
-	    fallback: Object.freeze({fallback: true}),
-	    keywords: keywordTransform,
-	  }
-
-	}));
-} (moo$1));
-
-const moo = moo$1.exports;
-
-
-const digit = `[0-9]`;
-const digit19 = `[1-9]`;
-const hexdig = `[0-9a-fA-F]`;
-
-// String
-const unescaped = `[\\x20-\\x21\\x23-\\x5b\\x5d-\\u{10ffff}]`;
-const escape = `\\\\`;
-const escaped = `${escape}(?:["\\/\\\\brfnt]|u${hexdig}{4})`;
-const char = `(?:${unescaped}|${escaped})`;
-const string = `"${char}*"`;
-
-// Number
-const int = `(?:0|${digit19}${digit}*)`;
-const frac = `\\.${digit}+`;
-const e = `[eE]`;
-const exp = `${e}[-+]?${digit}+`;
-const number = `-?${int}(?:${frac})?(?:${exp})?`;
-
-// Whitespace
-const whitespace = `(?:(?:\\r?\\n)|[ \\t])+`;
-
-var lexer = (json) => {
-  const lexer = moo.states({
-    main: {
-      WS: { match: new RegExp(whitespace, "u"), lineBreaks: true },
-      true: { match: "true", value: () => true },
-      false: { match: "false", value: () => false },
-      null: { match: "null", value: () => null },
-      number: { match: new RegExp(number, "u"), value: parseFloat },
-      string: { match: new RegExp(string, "u"), value: JSON.parse },
-      "{": "{",
-      "}": "}",
-      "[": "[",
-      "]": "]",
-      ":": ":",
-      ",": ",",
-      error: moo.error
-    }
-  });
-  lexer.reset(json);
-
-  const _next = () => {
-    let token;
-    do {
-      token = lexer.next();
-      if (token?.type === "error") {
-        throw SyntaxError(lexer.formatError(token, "Unrecognized token"));
-      }
-    } while (token?.type === "WS");
-
-    return token;
-  };
-
-  let previous;
-  let nextToken = _next();
-
-  const next = (expectedType = undefined) => {
-    previous = nextToken;
-    nextToken = _next();
-    if (expectedType && previous?.type !== expectedType) {
-      throw SyntaxError(lexer.formatError(previous, `Expected a '${expectedType}'`));
-    }
-    return previous;
-  };
-
-  const peek = () => nextToken;
-
-  const defaultErrorToken = { offset: 0, line: 1, col: 0, text: "" };
-  const syntaxError = (message) => {
-    const referenceToken = previous || defaultErrorToken;
-    const errorToken = {
-      ...referenceToken,
-      offset: referenceToken.offset + referenceToken.text.length,
-      col: referenceToken.col + referenceToken.text.length
-    };
-    throw new SyntaxError(lexer.formatError(errorToken, message));
-  };
-
-  return { next, peek, syntaxError };
-};
-
-const JsonPointer$2 = lib$4;
-const jsonLexer = lexer;
-
-
-const defaultReviver = (key, value) => value;
-const parse$3 = (json, reviver = defaultReviver) => {
-  const lexer = jsonLexer(json);
-  const value =  parseValue(lexer, "", JsonPointer$2.nil, reviver);
-
-  const token = lexer.peek();
-  if (token) {
-    lexer.syntaxError("A value has been parsed, but more tokens were found");
-  }
-  return value;
-};
-
-const parseValue = (lexer, key, pointer, reviver) => {
-  let value;
-  const token = lexer.next();
-  switch (token?.type) {
-    case "true":
-    case "false":
-    case "null":
-    case "number":
-    case "string":
-      value = token.value;
-      break;
-    case "{":
-      value = parseObject(lexer, key, pointer, reviver);
-      break;
-    case "[":
-      value = parseArray(lexer, key, pointer, reviver);
-      break;
-    default:
-      lexer.syntaxError("Expected a JSON value");
-  }
-
-  return reviver(key, value, pointer);
-};
-
-const parseObject = (lexer, key, pointer, reviver) => {
-  const value = {};
-
-  if (lexer.peek()?.type !== "}") {
-    parseProperties(lexer, key, pointer, reviver, value);
-  }
-
-  lexer.next("}");
+var map$3 = curry$7(async (fn, doc) => (await doc).map(fn));
 
-  return value;
-};
+const curry$6 = justCurryIt;
 
-const parseProperties = (lexer, key, pointer, reviver, value) => {
-  const propertyName = lexer.next("string").value;
-  lexer.next(":");
-  if (!isValueToken(lexer.peek())) {
-    lexer.syntaxError("Expected a JSON value");
-  }
-  value[propertyName] = parseValue(lexer, propertyName, JsonPointer$2.append(propertyName, pointer), reviver);
 
-  if (lexer.peek()?.type === ",") {
-    lexer.next(); // burn comma
-    parseProperties(lexer, propertyName, pointer, reviver, value);
-  } else if (isValueToken(lexer.peek())) {
-    lexer.next(",");
-  }
-};
+var reduce$2 = curry$6(async (fn, acc, doc) => {
+  return (await doc).reduce(async (acc, item) => fn(await acc, item), acc);
+});
 
-const parseArray = (lexer, key, pointer, reviver) => {
-  const value = [];
+const curry$5 = justCurryIt;
+const reduce$1 = reduce$2;
 
-  if (lexer.peek()?.type !== "]") {
-    parseItems(lexer, 0, pointer, reviver, value);
-  }
 
-  lexer.next("]");
+var filter = curry$5(async (fn, doc, options = {}) => {
+  return reduce$1(async (acc, item) => {
+    return (await fn(item)) ? acc.concat([item]) : acc;
+  }, [], doc, options);
+});
 
-  return value;
-};
+const curry$4 = justCurryIt;
+const map$2 = map$3;
 
-const parseItems = (lexer, key, pointer, reviver, value) => {
-  if (!isValueToken(lexer.peek())) {
-    lexer.syntaxError("Expected a JSON value");
-  }
-  value[key] = parseValue(lexer, key, JsonPointer$2.append(key, pointer), reviver);
-  if (lexer.peek()?.type === ",") {
-    lexer.next(); // burn comma
-    parseItems(lexer, key + 1, pointer, reviver, value);
-  } else if (isValueToken(lexer.peek())) {
-    lexer.next(",");
-  }
-};
 
-const valueType = new Set(["string", "number", "true", "false", "null", "[", "{"]);
-const isValueToken = (token) => valueType.has(token?.type);
+var some = curry$4(async (fn, doc) => {
+  const results = await map$2(fn, doc);
+  return (await Promise.all(results))
+    .some((a) => a);
+});
 
-var parse_1 = parse$3;
+const curry$3 = justCurryIt;
+const map$1 = map$3;
 
-const JsonPointer$1 = lib$4;
 
+var every = curry$3(async (fn, doc) => {
+  const results = await map$1(fn, doc);
+  return (await Promise.all(results))
+    .every((a) => a);
+});
 
-const defaultReplacer = (key, value) => value;
-const stringify$2 = (value, replacer = defaultReplacer, space = "") => {
-  return stringifyValue(value, replacer, space, "", JsonPointer$1.nil, 1);
-};
+const curry$2 = justCurryIt;
 
-const stringifyValue = (value, replacer, space, key, pointer, depth) => {
-  value = replacer(key, value, pointer);
-  let result;
-  if (Array.isArray(value)) {
-    result = stringifyArray(value, replacer, space, pointer, depth);
-  } else if (typeof value === "object" && value !== null) {
-    result = stringifyObject(value, replacer, space, pointer, depth);
-  } else {
-    result = JSON.stringify(value);
-  }
 
-  return result;
-};
+var pipeline$1 = curry$2((fns, doc) => {
+  return fns.reduce(async (acc, fn) => fn(await acc), doc);
+});
 
-const stringifyArray = (value, replacer, space, pointer, depth) => {
-  if (value.length === 0) {
-    space = "";
-  }
-  const padding = space ? `\n${space.repeat(depth - 1)}` : "";
-  return "[" + padding + space + value
-    .map((item, index) => {
-      const indexPointer = JsonPointer$1.append(index, pointer);
-      return stringifyValue(item, replacer, space, index, indexPointer, depth + 1);
-    })
-    .join(`,${padding}${space}`) + padding + "]";
-};
-
-const stringifyObject = (value, replacer, space, pointer, depth) => {
-  if (Object.keys(value).length === 0) {
-    space = "";
-  }
-  const padding = space ? `\n${space.repeat(depth - 1)}` : "";
-  const spacing = space ? " " : "";
-  return "{" + padding + space + Object.entries(value)
-    .map(([key, value]) => {
-      const keyPointer = JsonPointer$1.append(key, pointer);
-      return JSON.stringify(key) + ":" + spacing + stringifyValue(value, replacer, space, key, keyPointer, depth + 1);
-    })
-    .join(`,${padding}${space}`) + padding + "}";
-};
+var all = (doc) => Promise.all(doc);
 
-var stringify_1 = stringify$2;
+const pipeline = pipeline$1;
+const entries$1 = entries$2;
+const reduce = reduce$2;
 
-const parse$2 = parse_1;
-const stringify$1 = stringify_1;
 
+var allValues = (doc) => {
+  return pipeline([
+    entries$1,
+    reduce(async (acc, [propertyName, propertyValue]) => {
+      acc[propertyName] = await propertyValue;
+      return acc;
+    }, {})
+  ], doc);
+};
 
-var lib$3 = { parse: parse$2, stringify: stringify$1 };
+var lib$2 = {
+  entries: entries$2,
+  map: map$3,
+  filter: filter,
+  reduce: reduce$2,
+  some: some,
+  every: every,
+  pipeline: pipeline$1,
+  all: all,
+  allValues: allValues
+};
 
 var fetch_browser = fetch;
 
@@ -3464,10 +2489,9 @@ const getContentType = (path) => {
 
 var mediaTypes = { addPlugin, parse, getContentType };
 
-const curry$8 = justCurryIt$2;
-const Pact$a = lib$5;
-const Json = lib$3;
-const JsonPointer = lib$6;
+const curry$1 = justCurryIt$1;
+const Pact$a = lib$2;
+const JsonPointer = lib$3;
 const { jsonTypeOf, resolveUrl: resolveUrl$1, urlFragment, pathRelative } = common$1;
 const fetch$1 = fetch_browser;
 const Reference$1 = reference;
@@ -3498,61 +2522,64 @@ const getConfig = (dialectId, key) => {
 // Schema Management
 const schemaStore = {};
 const schemaStoreAlias = {};
-const add$1 = (schema, retrievalUri = "", defaultDialectId = "") => {
-  const dialectId = getDialectId(schema, retrievalUri, defaultDialectId);
-
-  const id = getBaseUri(schema, retrievalUri, dialectJsonSchemaVersion[dialectId]);
-
-  // Extract embedded schemas and collect anchors
-  const embeddedToken = getConfig(dialectId, "embeddedToken");
-  const baseToken = getConfig(dialectId, "baseToken");
-  const anchorToken = getConfig(dialectId, "anchorToken");
-  const dynamicAnchorToken = getConfig(dialectId, "dynamicAnchorToken");
-  const jrefToken = getConfig(dialectId, "jrefToken");
-
-  const dynamicAnchors = {};
-  const anchors = { "": "" };
-
-  schema = Json.parse(JSON.stringify(schema), (key, value, pointer) => {
-    if (jsonTypeOf(value, "object")) {
-      // Embedded Schema
-      const embeddedSchemaDialectId = typeof value.$schema === "string" ? resolveUrl$1(value.$schema, "") : dialectId;
-      const embeddedEmbeddedToken = getConfig(embeddedSchemaDialectId, "embeddedToken");
-      const embeddedAnchorToken = getConfig(embeddedSchemaDialectId, "anchorToken");
-      if (typeof value[embeddedEmbeddedToken] === "string" && (embeddedEmbeddedToken !== embeddedAnchorToken || value[embeddedEmbeddedToken][0] !== "#") && pointer !== "") {
-        const embeddedRetrievalUri = resolveUrl$1(id, value[embeddedEmbeddedToken]);
-        add$1(value, embeddedRetrievalUri, dialectId);
-        return Reference$1.cons(value[embeddedEmbeddedToken], value);
-      }
 
-      if (typeof value[jrefToken] === "string") {
-        return Reference$1.cons(value[jrefToken], value);
-      }
+const add$1 = (schema, url = "", defaultSchemaVersion = "") => {
+  schema = JSON.parse(JSON.stringify(schema));
+  const externalId = resolveUrl$1(url, "");
 
-      if (typeof value[anchorToken] === "string" && pointer !== JsonPointer.nil) {
-        const anchor = anchorToken !== embeddedToken ? value[anchorToken] : value[anchorToken].slice(1);
-        anchors[anchor] = pointer;
-        delete value[anchorToken];
-      }
+  // Dialect / JSON Schema Version
+  const dialectId = resolveUrl$1(schema["$schema"] || defaultSchemaVersion, "");
+  if (!dialectId) {
+    throw Error("Couldn't determine schema dialect");
+  }
+  delete schema["$schema"];
 
-      if (typeof value[dynamicAnchorToken] === "string") {
-        dynamicAnchors[value[dynamicAnchorToken]] = `${id}#${pointer}`;
-        anchors[value[dynamicAnchorToken]] = pointer;
-        delete value[dynamicAnchorToken];
+  // 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 {
+      // Need to look at meta-schema to determine version
+      const metaSchema = schemaStore[dialectId];
+      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];
       }
     }
+  }
 
-    return value;
-  });
-  console.log(embeddedIds);
-
-  delete schema.$schema;
+  // Internal Identifier
+  const [id, fragment] = getSchemaIdentifier(schema, externalId, dialectJsonSchemaVersion[dialectId]);
+  if (!id) {
+    throw Error("Couldn't determine an identifier for the schema");
+  }
+  const baseToken = getConfig(dialectId, "baseToken");
   delete schema[baseToken];
+  if (externalId) {
+    schemaStoreAlias[externalId] = id;
+  }
+
+  const anchorToken = getConfig(dialectId, "anchorToken");
+  if (fragment && baseToken === anchorToken) {
+    schema[anchorToken] = anchorToken !== baseToken ? encodeURI(fragment) : `#${encodeURI(fragment)}`;
+  }
 
   // recursiveAnchor
+  const dynamicAnchors = {};
   const recursiveAnchorToken = getConfig(dialectId, "recursiveAnchorToken");
   if (schema[recursiveAnchorToken] === true) {
     dynamicAnchors[""] = `${id}#`;
+    schema[anchorToken] = "";
     delete schema[recursiveAnchorToken];
   }
 
@@ -3567,66 +2594,69 @@ const add$1 = (schema, retrievalUri = "", defaultDialectId = "") => {
   }
 
   // Store Schema
+  const anchors = { "": "" };
   schemaStore[id] = {
-    id,
-    dialectId,
-    schema,
-    anchors,
-    dynamicAnchors,
-    vocabulary,
+    id: id,
+    dialectId: dialectId,
+    schema: processSchema(schema, id, dialectId, JsonPointer.nil, anchors, dynamicAnchors),
+    anchors: anchors,
+    dynamicAnchors: dynamicAnchors,
+    vocabulary: vocabulary,
     validated: false
   };
-  if (id === "https://example.com/schema/root") {
-    console.log(Object.keys(schemaStore).filter((id) => !/json-schema\.org/.test(id)));
-  }
 
-  if (retrievalUri) {
-    schemaStoreAlias[resolveUrl$1(retrievalUri, "")] = id;
-  }
+  return id;
 };
 
-const getDialectId = (schema, retrievalUri, defaultDialectId) => {
-  const dialectId = resolveUrl$1(schema.$schema || defaultDialectId, "");
-  if (!dialectId) {
-    throw Error("Couldn't determine schema dialect");
-  }
+const getSchemaIdentifier = (schema, externalId, jsonSchemaVersion) => {
+  const baseToken = config[jsonSchemaVersion]?.["baseToken"];
+  const internalUrl = resolveUrl$1(externalId, schema[baseToken] || "");
+  return [resolveUrl$1(internalUrl, ""), urlFragment(internalUrl)];
+};
+
+const processSchema = (subject, id, dialectId, pointer, anchors, dynamicAnchors) => {
+  if (jsonTypeOf(subject, "object")) {
+    const embeddedSchemaDialectId = typeof subject.$schema === "string" ? resolveUrl$1(subject.$schema, "") : dialectId;
+    const embeddedEmbeddedToken = getConfig(embeddedSchemaDialectId, "embeddedToken");
+    const embeddedAnchorToken = getConfig(embeddedSchemaDialectId, "anchorToken");
+    if (typeof subject[embeddedEmbeddedToken] === "string" && (embeddedEmbeddedToken !== embeddedAnchorToken || subject[embeddedEmbeddedToken][0] !== "#")) {
+      const ref = resolveUrl$1(id, subject[embeddedEmbeddedToken]);
+      const embeddedBaseToken = getConfig(embeddedSchemaDialectId, "baseToken");
+      subject[embeddedBaseToken] = ref;
+      add$1(subject, ref, dialectId);
+      return Reference$1.cons(subject[embeddedEmbeddedToken], subject);
+    }
 
-  // Determine JSON Schema version
-  if (!(dialectId in dialectJsonSchemaVersion)) {
-    if (schema?.$vocabulary?.[core201909Id] === true && dialectId === getBaseUri(schema, retrievalUri, core201909Id)) {
-      // Self describing 2019-09 meta-schema
-      dialectJsonSchemaVersion[dialectId] = core201909Id;
-    } else if (schema?.$vocabulary?.[core202012Id] === true && dialectId === getBaseUri(schema, retrievalUri, core202012Id)) {
-      // Self describing 2020-12 meta-schema
-      dialectJsonSchemaVersion[dialectId] = core202012Id;
-    } else {
-      // Need to look at meta-schema to determine version
-      const metaSchema = schemaStore[dialectId];
-      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];
-      }
+    const anchorToken = getConfig(dialectId, "anchorToken");
+    const dynamicAnchorToken = getConfig(dialectId, "dynamicAnchorToken");
+    if (typeof subject[dynamicAnchorToken] === "string") {
+      dynamicAnchors[subject[dynamicAnchorToken]] = `${id}#${encodeURI(pointer)}`;
+      anchors[subject[dynamicAnchorToken]] = pointer;
+      delete subject[dynamicAnchorToken];
     }
-  }
 
-  return dialectId;
-};
+    const embeddedToken = getConfig(dialectId, "embeddedToken");
+    if (typeof subject[anchorToken] === "string") {
+      const anchor = anchorToken !== embeddedToken ? subject[anchorToken] : subject[anchorToken].slice(1);
+      anchors[anchor] = pointer;
+      delete subject[anchorToken];
+    }
 
-const getBaseUri = (schema, retrievalUri, jsonSchemaVersion) => {
-  const baseToken = config[jsonSchemaVersion]?.["baseToken"];
-  const relativeBaseUri = typeof schema[baseToken] === "string" ? schema[baseToken] : "";
-  const baseUri = resolveUrl$1(resolveUrl$1(retrievalUri, relativeBaseUri), "");
-  if (!baseUri) {
-    throw Error("Couldn't determine an identifier for the schema");
-  }
+    const jrefToken = getConfig(dialectId, "jrefToken");
+    if (typeof subject[jrefToken] === "string") {
+      return Reference$1.cons(subject[jrefToken], subject);
+    }
 
-  return baseUri;
+    for (const key in subject) {
+      subject[key] = processSchema(subject[key], id, dialectId, JsonPointer.append(key, pointer), anchors, dynamicAnchors);
+    }
+
+    return subject;
+  } else if (Array.isArray(subject)) {
+    return subject.map((item, ndx) => processSchema(item, id, dialectId, JsonPointer.append(ndx, pointer), anchors, dynamicAnchors));
+  } else {
+    return subject;
+  }
 };
 
 const hasStoredSchema = (id) => id in schemaStore || id in schemaStoreAlias;
@@ -3720,14 +2750,14 @@ const step = (key, doc) => {
 
 const keys = (doc) => Object.keys(value(doc));
 
-const entries$2 = (doc) => Pact$a.pipeline([
+const entries = (doc) => Pact$a.pipeline([
   value,
   Object.keys,
   Pact$a.map(async (key) => [key, await step(key, doc)]),
   Pact$a.all
 ], doc);
 
-const map$3 = curry$8((fn, doc) => Pact$a.pipeline([
+const map = curry$1((fn, doc) => Pact$a.pipeline([
   value,
   Pact$a.map(async (item, ndx) => fn(await step(ndx, doc), ndx)),
   Pact$a.all
@@ -3743,43 +2773,36 @@ const toSchemaDefaultOptions = {
 const toSchema = (schemaDoc, options = {}) => {
   const fullOptions = { ...toSchemaDefaultOptions, ...options };
 
-  const anchorToken = getConfig(schemaDoc.dialectId, "anchorToken");
-  const dynamicAnchorToken = getConfig(schemaDoc.dialectId, "dynamicAnchorToken");
-
-  const anchors = {};
-  for (const anchor in schemaDoc.anchors) {
-    if (anchor !== "" && !schemaDoc.dynamicAnchors[anchor]) {
-      anchors[schemaDoc.anchors[anchor]] = anchor;
+  const schema = JSON.parse(JSON.stringify(schemaDoc.schema, (key, value) => {
+    if (!Reference$1.isReference(value)) {
+      return value;
     }
-  }
-
-  const dynamicAnchors = {};
-  for (const anchor in schemaDoc.dynamicAnchors) {
-    const pointer = urlFragment(schemaDoc.dynamicAnchors[anchor]);
-    dynamicAnchors[pointer] = anchor;
-  }
 
-  const schema = JSON.parse(Json.stringify(schemaDoc.schema, (key, value, pointer) => {
-    if (Reference$1.isReference(value)) {
-      const refValue = Reference$1.value(value);
-      const embeddedDialect = typeof refValue.$schema === "string" ? resolveUrl$1(refValue.$schema, "") : schemaDoc.dialectId;
-      const embeddedToken = getConfig(embeddedDialect, "embeddedToken");
-      if (!fullOptions.includeEmbedded && embeddedToken in refValue) {
-        return;
-      } else {
-        return Reference$1.value(value);
-      }
+    const refValue = Reference$1.value(value);
+    const embeddedDialect = typeof refValue.$schema === "string" ? resolveUrl$1(refValue.$schema, "") : schemaDoc.dialectId;
+    const embeddedToken = getConfig(embeddedDialect, "embeddedToken");
+    if (!fullOptions.includeEmbedded && embeddedToken in refValue) {
+      return;
     } else {
-      if (pointer in anchors) {
-        value = { [anchorToken]: anchors[pointer], ...value };
-      }
-      if (pointer in dynamicAnchors) {
-        value = { [dynamicAnchorToken]: dynamicAnchors[pointer], ...value };
-      }
-      return value;
+      return Reference$1.value(value);
     }
   }));
 
+  const dynamicAnchorToken = getConfig(schemaDoc.dialectId, "dynamicAnchorToken");
+  Object.entries(schemaDoc.dynamicAnchors)
+    .forEach(([anchor, uri]) => {
+      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 !== "" && !(anchor in schemaDoc.dynamicAnchors))
+    .forEach(([anchor, pointer]) => {
+      const anchorPointer = JsonPointer.append(anchorToken, pointer);
+      JsonPointer.assign(anchorPointer, schema, anchor);
+    });
+
   const baseToken = getConfig(schemaDoc.dialectId, "baseToken");
   const id = relativeUri(fullOptions.parentId, schemaDoc.id);
   const dialect = fullOptions.parentDialect === schemaDoc.dialectId ? "" : schemaDoc.dialectId;
@@ -3802,7 +2825,7 @@ const relativeUri = (from, to) => {
 var schema$5 = {
   setConfig, getConfig,
   add: add$1, get, markValidated,
-  uri, value, getAnchorPointer, typeOf, has, step, keys, entries: entries$2, map: map$3, length,
+  uri, value, getAnchorPointer, typeOf, has, step, keys, entries, map, length,
   toSchema
 };
 
@@ -3816,19 +2839,19 @@ class InvalidSchemaError$3 extends Error {
 
 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$7 = justCurryIt$2;
+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;
@@ -3848,19 +2871,19 @@ MediaTypes.addPlugin("application/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$7(({ 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`);
   }
@@ -3935,10 +2958,10 @@ const compileSchema = async (schema, ast) => {
 
   // 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`);
@@ -3961,17 +2984,17 @@ const compileSchema = async (schema, ast) => {
 
   // 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);
@@ -3990,7 +3013,7 @@ const compileSchema = async (schema, ast) => {
 };
 
 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) => {
@@ -4018,45 +3041,45 @@ const getKeywordId = (schemaUri, ast) => {
 };
 
 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,
   addMediaTypePlugin: MediaTypes.addPlugin
 };
 
-const Pact$9 = lib$5;
+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)
@@ -4066,7 +3089,7 @@ const compile$M = async (schema, ast) => {
   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");
@@ -4078,7 +3101,7 @@ const interpret$M = (uri, instance, ast, dynamicAnchors) => {
       PubSub.publishSync("result", {
         keyword: keywordId,
         absoluteKeywordLocation: schemaUrl,
-        instanceLocation: Instance$D.uri(instance),
+        instanceLocation: Instance$B.uri(instance),
         valid: isValid,
         ast: keywordValue
       });
@@ -4089,7 +3112,7 @@ const interpret$M = (uri, instance, ast, dynamicAnchors) => {
   PubSub.publishSync("result", {
     keyword: keywordId,
     absoluteKeywordLocation: schemaUrl,
-    instanceLocation: Instance$D.uri(instance),
+    instanceLocation: Instance$B.uri(instance),
     valid: isValid,
     ast: uri
   });
@@ -4127,7 +3150,7 @@ const collectEvaluatedItems$e = (uri, instance, ast, dynamicAnchors, isTop = fal
     }, 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;
@@ -4136,90 +3159,90 @@ const validate = validate$1;
 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$2 = { 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$2;
+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$2;
+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$2;
+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") {
@@ -4229,168 +3252,47 @@ const interpret$J = ([propertyNames, propertyNamePatterns, additionalProperties]
   }
 };
 
-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$2;
+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("")];
-};
-
-var additionalProperties6 = { compile: compile$I, interpret: interpret$I, collectEvaluatedProperties: collectEvaluatedProperties$c };
-
-var entries$1 = async (doc) => Object.entries(await doc);
-
-var justCurryIt = curry$6;
-
-/*
-  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$6(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$5 = justCurryIt;
-
-
-var map$2 = curry$5(async (fn, doc) => (await doc).map(fn));
-
-const curry$4 = justCurryIt;
-
-
-var reduce$2 = curry$4(async (fn, acc, doc) => {
-  return (await doc).reduce(async (acc, item) => fn(await acc, item), acc);
-});
-
-const curry$3 = justCurryIt;
-const reduce$1 = reduce$2;
-
-
-var filter = curry$3(async (fn, doc, options = {}) => {
-  return reduce$1(async (acc, item) => {
-    return (await fn(item)) ? acc.concat([item]) : acc;
-  }, [], doc, options);
-});
-
-const curry$2 = justCurryIt;
-const map$1 = map$2;
-
-
-var some = curry$2(async (fn, doc) => {
-  const results = await map$1(fn, doc);
-  return (await Promise.all(results))
-    .some((a) => a);
-});
-
-const curry$1 = justCurryIt;
-const map = map$2;
-
-
-var every = curry$1(async (fn, doc) => {
-  const results = await map(fn, doc);
-  return (await Promise.all(results))
-    .every((a) => a);
-});
-
-const curry = justCurryIt;
-
-
-var pipeline$1 = curry((fns, doc) => {
-  return fns.reduce(async (acc, fn) => fn(await acc), doc);
-});
-
-var all = (doc) => Promise.all(doc);
-
-const pipeline = pipeline$1;
-const entries = entries$1;
-const reduce = reduce$2;
-
-
-var allValues = (doc) => {
-  return pipeline([
-    entries,
-    reduce(async (acc, [propertyName, propertyValue]) => {
-      acc[propertyName] = await propertyValue;
-      return acc;
-    }, {})
-  ], doc);
+  return interpret$G(keywordValue, instance, ast, dynamicAnchors) && [new RegExp("")];
 };
 
-var lib$1 = {
-  entries: entries$1,
-  map: map$2,
-  filter: filter,
-  reduce: reduce$2,
-  some: some,
-  every: every,
-  pipeline: pipeline$1,
-  all: all,
-  allValues: allValues
-};
+var additionalProperties6 = { compile: compile$G, interpret: interpret$G, collectEvaluatedProperties: collectEvaluatedProperties$c };
 
-const { Core: Core$r, Schema: Schema$J } = lib$2;
-const Pact$8 = 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));
 };
 
@@ -4408,18 +3310,18 @@ const collectEvaluatedItems$c = (allOf, instance, ast, dynamicAnchors) => {
   }, 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$2;
-const Pact$7 = 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;
 };
@@ -4438,7 +3340,7 @@ const collectEvaluatedItems$b = (anyOf, instance, ast, dynamicAnchors) => {
   }, 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;
@@ -4499,92 +3401,92 @@ function stringify(val, allowUndefined) {
 
 var fastestStableStringify = function(obj) { return '' + stringify(obj, false); };
 
-const { Schema: Schema$H, Instance: Instance$x } = lib$2;
+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$2;
+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$2;
+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$2;
-const Pact$6 = 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$2;
-const Pact$5 = 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;
     }
@@ -4597,49 +3499,49 @@ const interpret$B = (dependencies, instance, ast, dynamicAnchors) => {
   });
 };
 
-var dependencies = { compile: compile$B, interpret: interpret$B };
+var dependencies = { compile: compile$z, interpret: interpret$z };
 
-const { Schema: Schema$D, Instance: Instance$t } = lib$2;
-const Pact$4 = 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$2;
-const Pact$3 = 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;
     }
 
@@ -4648,39 +3550,39 @@ const collectEvaluatedProperties$9 = (dependentSchemas, instance, ast, dynamicAn
   }, []);
 };
 
-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$2;
+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$2;
+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$2;
+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$2;
+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;
 };
@@ -4693,21 +3595,21 @@ const collectEvaluatedItems$9 = (ifSchema, instance, ast, dynamicAnchors) => {
   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$2;
+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);
 };
 
@@ -4737,21 +3639,21 @@ const collectEvaluatedItems$8 = ([guard, block], instance, ast, dynamicAnchors)
   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$2;
+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);
 };
 
@@ -4781,150 +3683,134 @@ const collectEvaluatedItems$7 = ([guard, block], instance, ast, dynamicAnchors)
   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$2;
+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$2;
+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$2;
-
-
-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 };
+var items202012 = { compile: compile$p, interpret: interpret$p, collectEvaluatedItems: collectEvaluatedItems$5 };
 
-const { Schema: Schema$t, Instance: Instance$l } = lib$2;
+const { Schema: Schema$s, Instance: Instance$k } = 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;
+const compile$o = (schema) => Schema$s.value(schema);
+const interpret$o = (maxItems, instance) => !Instance$k.typeOf(instance, "array") || Instance$k.length(instance) <= maxItems;
 
-var maxLength = { compile: compile$p, interpret: interpret$p };
+var maxItems = { compile: compile$o, interpret: interpret$o };
 
-const { Schema: Schema$s, Instance: Instance$k } = lib$2;
+const { Schema: Schema$r, Instance: Instance$j } = 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 compile$n = (schema) => Schema$r.value(schema);
+const interpret$n = (maxLength, instance) => !Instance$j.typeOf(instance, "string") || [...Instance$j.value(instance)].length <= maxLength;
 
-var maxLength6 = { compile: compile$o, interpret: interpret$o };
+var maxLength = { compile: compile$n, interpret: interpret$n };
 
-const { Schema: Schema$r, Instance: Instance$j } = lib$2;
+const { Schema: Schema$q, Instance: Instance$i } = 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 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$n, interpret: interpret$n };
+var maxProperties = { compile: compile$m, interpret: interpret$m };
 
-const { Schema: Schema$q, Instance: Instance$i } = lib$2;
+const { Schema: Schema$p, Instance: Instance$h } = 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$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$2;
-
-
-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$2;
+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$2;
+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$2;
+const { Schema: Schema$m, Instance: Instance$e } = lib$1;
 
 
 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$2;
+const { Schema: Schema$l, Instance: Instance$d } = lib$1;
 
 
 const compile$h = (schema) => Schema$l.value(schema);
@@ -4932,7 +3818,7 @@ const interpret$h = (minProperties, instance) => !Instance$d.typeOf(instance, "o
 
 var minProperties = { compile: compile$h, interpret: interpret$h };
 
-const { Schema: Schema$k, Instance: Instance$c } = lib$2;
+const { Schema: Schema$k, Instance: Instance$c } = lib$1;
 
 
 const compile$g = async (schema, ast, parentSchema) => {
@@ -4953,7 +3839,7 @@ const interpret$g = ([minimum, isExclusive], instance) => {
 
 var minimumExclusiveMinimum = { compile: compile$g, interpret: interpret$g };
 
-const { Schema: Schema$j, Instance: Instance$b } = lib$2;
+const { Schema: Schema$j, Instance: Instance$b } = lib$1;
 
 
 const compile$f = async (schema) => Schema$j.value(schema);
@@ -4961,7 +3847,7 @@ const interpret$f = (minimum, instance) => !Instance$b.typeOf(instance, "number"
 
 var minimum = { compile: compile$f, interpret: interpret$f };
 
-const { Schema: Schema$i, Instance: Instance$a } = lib$2;
+const { Schema: Schema$i, Instance: Instance$a } = lib$1;
 
 
 const compile$e = (schema) => Schema$i.value(schema);
@@ -4979,7 +3865,7 @@ const numberEqual = (a, b) => Math.abs(a - b) < 1.19209290e-7;
 
 var multipleOf = { compile: compile$e, interpret: interpret$e };
 
-const { Core: Core$f } = lib$2;
+const { Core: Core$f } = lib$1;
 
 
 const compile$d = Core$f.compileSchema;
@@ -4987,7 +3873,7 @@ const interpret$d = (not, instance, ast, dynamicAnchors) => !Core$f.interpretSch
 
 var not = { compile: compile$d, interpret: interpret$d };
 
-const { Core: Core$e, Schema: Schema$h } = lib$2;
+const { Core: Core$e, Schema: Schema$h } = lib$1;
 
 
 const compile$c = async (schema, ast) => {
@@ -5036,7 +3922,7 @@ const collectEvaluatedItems$4 = (oneOf, instance, ast, dynamicAnchors) => {
 
 var oneOf = { compile: compile$c, interpret: interpret$c, collectEvaluatedProperties: collectEvaluatedProperties$5, collectEvaluatedItems: collectEvaluatedItems$4 };
 
-const { Schema: Schema$g, Instance: Instance$9 } = lib$2;
+const { Schema: Schema$g, Instance: Instance$9 } = lib$1;
 
 
 const compile$b = (schema) => new RegExp(Schema$g.value(schema), "u");
@@ -5044,8 +3930,8 @@ const interpret$b = (pattern, instance) => !Instance$9.typeOf(instance, "string"
 
 var pattern = { compile: compile$b, interpret: interpret$b };
 
-const { Core: Core$d, Schema: Schema$f, Instance: Instance$8 } = lib$2;
-const Pact$2 = lib$1;
+const { Core: Core$d, Schema: Schema$f, Instance: Instance$8 } = lib$1;
+const Pact$2 = lib$2;
 
 
 const compile$a = (schema, ast) => Pact$2.pipeline([
@@ -5082,8 +3968,8 @@ const splitUrl$1 = (url) => {
 
 var common = { isObject, escapeRegExp: escapeRegExp$1, splitUrl: splitUrl$1 };
 
-const { Core: Core$c, Schema: Schema$e, Instance: Instance$7 } = lib$2;
-const Pact$1 = lib$1;
+const { Core: Core$c, Schema: Schema$e, Instance: Instance$7 } = lib$1;
+const Pact$1 = lib$2;
 const { escapeRegExp } = common;
 
 
@@ -5108,7 +3994,7 @@ const collectEvaluatedProperties$3 = (properties, instance, ast, dynamicAnchors)
 
 var properties = { compile: compile$9, interpret: interpret$9, collectEvaluatedProperties: collectEvaluatedProperties$3 };
 
-const { Core: Core$b, Instance: Instance$6 } = lib$2;
+const { Core: Core$b, Instance: Instance$6 } = lib$1;
 
 
 const compile$8 = (schema, ast) => Core$b.compileSchema(schema, ast);
@@ -5120,7 +4006,7 @@ const interpret$8 = (propertyNames, instance, ast, dynamicAnchors) => {
 
 var propertyNames = { compile: compile$8, interpret: interpret$8 };
 
-const { Core: Core$a, Schema: Schema$d } = lib$2;
+const { Core: Core$a, Schema: Schema$d } = lib$1;
 const { splitUrl } = common;
 
 
@@ -5145,7 +4031,7 @@ const collectEvaluatedItems$3 = Core$a.collectEvaluatedItems;
 
 var dynamicRef = { compile: compile$7, interpret: interpret$7, collectEvaluatedProperties: collectEvaluatedProperties$2, collectEvaluatedItems: collectEvaluatedItems$3 };
 
-const { Core: Core$9, Schema: Schema$c } = lib$2;
+const { Core: Core$9, Schema: Schema$c } = lib$1;
 
 
 const compile$6 = async (ref, ast) => {
@@ -5159,7 +4045,7 @@ const collectEvaluatedItems$2 = Core$9.collectEvaluatedItems;
 
 var ref = { compile: compile$6, interpret: interpret$6, collectEvaluatedProperties: collectEvaluatedProperties$1, collectEvaluatedItems: collectEvaluatedItems$2 };
 
-const { Schema: Schema$b, Instance: Instance$5 } = lib$2;
+const { Schema: Schema$b, Instance: Instance$5 } = lib$1;
 
 
 const compile$5 = (schema) => Schema$b.value(schema);
@@ -5170,8 +4056,8 @@ const interpret$5 = (required, instance) => {
 
 var required = { compile: compile$5, interpret: interpret$5 };
 
-const { Core: Core$8, Schema: Schema$a, Instance: Instance$4 } = lib$2;
-const Pact = lib$1;
+const { Core: Core$8, Schema: Schema$a, Instance: Instance$4 } = lib$1;
+const Pact = lib$2;
 
 
 const compile$4 = (schema, ast) => {
@@ -5195,7 +4081,7 @@ const collectEvaluatedItems$1 = (items, instance, ast, dynamicAnchors) => {
 
 var tupleItems = { compile: compile$4, interpret: interpret$4, collectEvaluatedItems: collectEvaluatedItems$1 };
 
-const { Schema: Schema$9, Instance: Instance$3 } = lib$2;
+const { Schema: Schema$9, Instance: Instance$3 } = lib$1;
 
 
 const compile$3 = (schema) => Schema$9.value(schema);
@@ -5203,7 +4089,7 @@ const interpret$3 = (type, instance) => typeof type === "string" ? Instance$3.ty
 
 var type = { compile: compile$3, interpret: interpret$3 };
 
-const { Core: Core$7, Schema: Schema$8, Instance: Instance$2 } = lib$2;
+const { Core: Core$7, Schema: Schema$8, Instance: Instance$2 } = lib$1;
 
 
 const compile$2 = async (schema, ast, parentSchema) => {
@@ -5227,7 +4113,7 @@ const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
 
 var unevaluatedItems = { compile: compile$2, interpret: interpret$2, collectEvaluatedItems };
 
-const { Core: Core$6, Schema: Schema$7, Instance: Instance$1 } = lib$2;
+const { Core: Core$6, Schema: Schema$7, Instance: Instance$1 } = lib$1;
 
 
 const compile$1 = async (schema, ast, parentSchema) => {
@@ -5252,7 +4138,7 @@ const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors)
 
 var unevaluatedProperties = { compile: compile$1, interpret: interpret$1, collectEvaluatedProperties };
 
-const { Schema: Schema$6, Instance } = lib$2;
+const { Schema: Schema$6, Instance } = lib$1;
 const jsonStringify = fastestStableStringify;
 
 
@@ -5269,7 +4155,7 @@ const interpret = (uniqueItems, instance) => {
 
 var uniqueItems = { compile, interpret };
 
-const { Keywords: Keywords$1 } = lib$2;
+const { Keywords: Keywords$1 } = lib$1;
 
 
 var keywords$5 = {
@@ -5296,14 +4182,12 @@ var keywords$5 = {
   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,
@@ -5475,7 +4359,7 @@ var schema$4 = `{
     "default": {}
 }`;
 
-const { Core: Core$5, Schema: Schema$5 } = lib$2;
+const { Core: Core$5, Schema: Schema$5 } = lib$1;
 const keywords$4 = keywords$5;
 const metaSchema$4 = schema$4;
 
@@ -5677,7 +4561,7 @@ var schema$3 = `{
     "default": {}
 }`;
 
-const { Core: Core$4, Schema: Schema$4 } = lib$2;
+const { Core: Core$4, Schema: Schema$4 } = lib$1;
 const keywords$3 = keywords$5;
 const metaSchema$3 = schema$3;
 
@@ -5709,11 +4593,11 @@ Core$4.defineVocabulary(jsonSchemaVersion$3, {
   "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,
@@ -5902,7 +4786,7 @@ var schema$2 = `{
     "default": true
 }`;
 
-const { Core: Core$3, Schema: Schema$3 } = lib$2;
+const { Core: Core$3, Schema: Schema$3 } = lib$1;
 const keywords$2 = keywords$5;
 const metaSchema$2 = schema$2;
 
@@ -5936,11 +4820,11 @@ Core$3.defineVocabulary(jsonSchemaVersion$2, {
   "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,
@@ -6285,7 +5169,7 @@ var content$1 = `{
     }
 }`;
 
-const { Core: Core$2, Schema: Schema$2 } = lib$2;
+const { Core: Core$2, Schema: Schema$2 } = lib$1;
 const keywords$1 = keywords$5;
 const metaSchema$1 = schema$1;
 const coreMetaSchema$1 = core$1;
@@ -6344,11 +5228,11 @@ Core$2.defineVocabulary("https://json-schema.org/draft/2019-09/vocab/validation"
   "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,
@@ -6732,7 +5616,7 @@ var unevaluated = `{
     }
 }`;
 
-const { Core: Core$1, Schema: Schema$1 } = lib$2;
+const { Core: Core$1, Schema: Schema$1 } = lib$1;
 const keywords = keywords$5;
 const metaSchema = schema;
 const coreMetaSchema = core;
@@ -6791,11 +5675,11 @@ Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/validation"
   "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,
@@ -6836,7 +5720,7 @@ Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/unevaluated
   "unevaluatedProperties": keywords.unevaluatedProperties
 });
 
-const { Core, Schema, InvalidSchemaError } = lib$2;
+const { Core, Schema, InvalidSchemaError } = lib$1;
 const Keywords = keywords$5;