@hyperjump/json-schema 0.23.1 → 0.23.3

package/dist/json-schema-system.js

@@ -5,7 +5,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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) {
@@ -30,7 +30,7 @@ System.register('JsonSchema', [], (function (exports) {
 			  milesToKm(10); // 16.2
 			*/
 
-			function curry$j(fn, arity) {
+			function curry$b(fn, arity) {
 			  return function curried() {
 			    if (arity == null) {
 			      arity = fn.length;
@@ -1901,84 +1901,91 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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) {
@@ -1986,54 +1993,54 @@ System.register('JsonSchema', [], (function (exports) {
 			    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$1(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$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$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$4 = { nil: nil$2, append, get: get$2, set, assign, unset, remove };
 
 			const $__value = Symbol("$__value");
 			const $__href = Symbol("$__href");
@@ -2049,16 +2056,16 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var reference = { cons: cons$1, isReference, href, value: value$2 };
 
-			const JsonPointer$3 = lib$6;
-			const curry$h = justCurryIt$2;
+			const JsonPointer$3 = lib$4;
+			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]}'`);
 			  }
@@ -2069,7 +2076,7 @@ System.register('JsonSchema', [], (function (exports) {
 			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,
@@ -2077,118 +2084,40 @@ System.register('JsonSchema', [], (function (exports) {
 			  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
+			  nil: nil$1, cons, get: get$1, uri: uri$1, value: value$1, has: has$1, typeOf: typeOf$1, length: length$1,
+			  step: step$1, entries: entries$3, keys: keys$1, map: map$4, forEach, filter: filter$1, reduce: reduce$3, every: every$1, some: some$1
 			};
 
-			var entries$4 = async (doc) => Object.entries(await doc);
-
-			const curry$g = justCurryIt$2;
-
-
-			var map$6 = curry$g(async (fn, doc) => (await doc).map(fn));
+			var entries$2 = async (doc) => Object.entries(await doc);
 
-			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);
-			};
-
-			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 justCurryIt$1 = curry$a;
+			var justCurryIt = curry$8;
 
 			/*
 			  function add(a, b, c) {
@@ -2213,7 +2142,7 @@ System.register('JsonSchema', [], (function (exports) {
 			  milesToKm(10); // 16.2
 			*/
 
-			function curry$a(fn, arity) {
+			function curry$8(fn, arity) {
 			  return function curried() {
 			    if (arity == null) {
 			      arity = fn.length;
@@ -2229,146 +2158,83 @@ System.register('JsonSchema', [], (function (exports) {
 			  };
 			}
 
-			const curry$9 = justCurryIt$1;
+			const curry$7 = justCurryIt;
 
 
-			const nil$1 = "";
+			var map$3 = curry$7(async (fn, doc) => (await doc).map(fn));
 
-			const compile$P = (pointer) => {
-			  if (pointer.length > 0 && pointer[0] !== "/") {
-			    throw Error("Invalid JSON Pointer");
-			  }
+			const curry$6 = justCurryIt;
 
-			  return pointer.split("/").slice(1).map(unescape);
-			};
 
-			const get$1 = (pointer, value = undefined) => {
-			  const ptr = compile$P(pointer);
+			var reduce$2 = curry$6(async (fn, acc, doc) => {
+			  return (await doc).reduce(async (acc, item) => fn(await acc, item), acc);
+			});
 
-			  const fn = (value) => ptr.reduce(([value, pointer], segment) => {
-			    return [applySegment(value, segment, pointer), append(segment, pointer)];
-			  }, [value, ""])[0];
+			const curry$5 = justCurryIt;
+			const reduce$1 = reduce$2;
 
-			  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);
-			};
+			var filter = curry$5(async (fn, doc, options = {}) => {
+			  return reduce$1(async (acc, item) => {
+			    return (await fn(item)) ? acc.concat([item]) : acc;
+			  }, [], doc, options);
+			});
 
-			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 curry$4 = justCurryIt;
+			const map$2 = map$3;
 
-			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));
-			  }
-			};
+			var some = curry$4(async (fn, doc) => {
+			  const results = await map$2(fn, doc);
+			  return (await Promise.all(results))
+			    .some((a) => a);
+			});
 
-			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 curry$3 = justCurryIt;
+			const map$1 = map$3;
 
-			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);
-			};
+			var every = curry$3(async (fn, doc) => {
+			  const results = await map$1(fn, doc);
+			  return (await Promise.all(results))
+			    .every((a) => a);
+			});
 
-			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 curry$2 = justCurryIt;
 
-			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;
+			var pipeline$1 = curry$2((fns, doc) => {
+			  return fns.reduce(async (acc, fn) => fn(await acc), doc);
+			});
 
-			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];
-			  }
-			};
+			var all = (doc) => Promise.all(doc);
 
-			const isScalar = (value) => value === null || typeof value !== "object";
+			const pipeline = pipeline$1;
+			const entries$1 = entries$2;
+			const reduce = reduce$2;
 
-			var lib$4 = { nil: nil$1, append, get: get$1, set, assign, unset, remove };
+
+			var allValues = (doc) => {
+			  return pipeline([
+			    entries$1,
+			    reduce(async (acc, [propertyName, propertyValue]) => {
+			      acc[propertyName] = await propertyValue;
+			      return acc;
+			    }, {})
+			  ], doc);
+			};
+
+			var lib$3 = {
+			  entries: entries$2,
+			  map: map$3,
+			  filter: filter,
+			  reduce: reduce$2,
+			  some: some,
+			  every: every,
+			  pipeline: pipeline$1,
+			  all: all,
+			  allValues: allValues
+			};
 
 			var moo$1 = {exports: {}};
 
@@ -3209,7 +3075,7 @@ System.register('JsonSchema', [], (function (exports) {
 			const stringify$1 = stringify_1;
 
 
-			var lib$3 = { parse: parse$2, stringify: stringify$1 };
+			var lib$2 = { parse: parse$2, stringify: stringify$1 };
 
 			var fetch_browser = fetch;
 
@@ -3465,10 +3331,10 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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$3;
+			const Json = lib$2;
+			const JsonPointer = lib$4;
 			const { jsonTypeOf, resolveUrl: resolveUrl$1, urlFragment, pathRelative } = common$1;
 			const fetch$1 = fetch_browser;
 			const Reference$1 = reference;
@@ -3499,61 +3365,64 @@ System.register('JsonSchema', [], (function (exports) {
 			// 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];
 			  }
 
@@ -3568,66 +3437,69 @@ System.register('JsonSchema', [], (function (exports) {
 			  }
 
 			  // 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;
@@ -3721,14 +3593,14 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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
@@ -3803,7 +3675,7 @@ System.register('JsonSchema', [], (function (exports) {
 			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
 			};
 
@@ -3817,19 +3689,19 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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;
@@ -3849,19 +3721,19 @@ System.register('JsonSchema', [], (function (exports) {
 			});
 
 			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`);
 			  }
@@ -3936,10 +3808,10 @@ System.register('JsonSchema', [], (function (exports) {
 
 			  // 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`);
@@ -3962,17 +3834,17 @@ System.register('JsonSchema', [], (function (exports) {
 
 			  // 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);
@@ -3991,7 +3863,7 @@ System.register('JsonSchema', [], (function (exports) {
 			};
 
 			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) => {
@@ -4019,45 +3891,45 @@ System.register('JsonSchema', [], (function (exports) {
 			};
 
 			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$3;
 			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)
@@ -4067,7 +3939,7 @@ System.register('JsonSchema', [], (function (exports) {
 			  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");
@@ -4079,7 +3951,7 @@ System.register('JsonSchema', [], (function (exports) {
 			      PubSub.publishSync("result", {
 			        keyword: keywordId,
 			        absoluteKeywordLocation: schemaUrl,
-			        instanceLocation: Instance$D.uri(instance),
+			        instanceLocation: Instance$B.uri(instance),
 			        valid: isValid,
 			        ast: keywordValue
 			      });
@@ -4090,7 +3962,7 @@ System.register('JsonSchema', [], (function (exports) {
 			  PubSub.publishSync("result", {
 			    keyword: keywordId,
 			    absoluteKeywordLocation: schemaUrl,
-			    instanceLocation: Instance$D.uri(instance),
+			    instanceLocation: Instance$B.uri(instance),
 			    valid: isValid,
 			    ast: uri
 			  });
@@ -4128,7 +4000,7 @@ System.register('JsonSchema', [], (function (exports) {
 			    }, 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;
@@ -4137,90 +4009,90 @@ System.register('JsonSchema', [], (function (exports) {
 			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") {
@@ -4230,168 +4102,47 @@ System.register('JsonSchema', [], (function (exports) {
 			  }
 			};
 
-			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("")];
+			  return interpret$G(keywordValue, instance, ast, dynamicAnchors) && [new RegExp("")];
 			};
 
-			var additionalProperties6 = { compile: compile$I, interpret: interpret$I, collectEvaluatedProperties: collectEvaluatedProperties$c };
+			var additionalProperties6 = { compile: compile$G, interpret: interpret$G, collectEvaluatedProperties: collectEvaluatedProperties$c };
 
-			var entries$1 = async (doc) => Object.entries(await doc);
+			const { Core: Core$r, Schema: Schema$H } = lib$1;
+			const Pact$8 = lib$3;
 
-			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);
-			};
-
-			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
-			};
-
-			const { Core: Core$r, Schema: Schema$J } = lib$2;
-			const Pact$8 = lib$1;
-
-
-			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));
 			};
 
@@ -4409,18 +4160,18 @@ System.register('JsonSchema', [], (function (exports) {
 			  }, 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$3;
 
 
-			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;
 			};
@@ -4439,7 +4190,7 @@ System.register('JsonSchema', [], (function (exports) {
 			  }, 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;
@@ -4500,92 +4251,92 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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$3;
 
 
-			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$3;
 
 
-			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;
 			    }
@@ -4598,49 +4349,49 @@ System.register('JsonSchema', [], (function (exports) {
 			  });
 			};
 
-			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$3;
 
 
-			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$3;
 
 
-			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;
 			    }
 
@@ -4649,39 +4400,39 @@ System.register('JsonSchema', [], (function (exports) {
 			  }, []);
 			};
 
-			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;
 			};
@@ -4694,21 +4445,21 @@ System.register('JsonSchema', [], (function (exports) {
 			  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);
 			};
 
@@ -4738,21 +4489,21 @@ System.register('JsonSchema', [], (function (exports) {
 			  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);
 			};
 
@@ -4782,150 +4533,134 @@ System.register('JsonSchema', [], (function (exports) {
 			  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 items202012 = { compile: compile$p, interpret: interpret$p, collectEvaluatedItems: collectEvaluatedItems$5 };
 
-			var maxItems = { compile: compile$q, interpret: interpret$q };
+			const { Schema: Schema$s, Instance: Instance$k } = lib$1;
 
-			const { Schema: Schema$t, Instance: Instance$l } = lib$2;
 
+			const compile$o = (schema) => Schema$s.value(schema);
+			const interpret$o = (maxItems, instance) => !Instance$k.typeOf(instance, "array") || Instance$k.length(instance) <= maxItems;
 
-			const compile$p = (schema) => Schema$t.value(schema);
-			const interpret$p = (maxLength, instance) => !Instance$l.typeOf(instance, "string") || Instance$l.length(instance) <= maxLength;
-
-			var maxLength = { compile: compile$p, interpret: interpret$p };
+			var 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);
@@ -4933,7 +4668,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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) => {
@@ -4954,7 +4689,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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);
@@ -4962,7 +4697,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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);
@@ -4980,7 +4715,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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;
@@ -4988,7 +4723,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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) => {
@@ -5037,7 +4772,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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");
@@ -5045,8 +4780,8 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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$3;
 
 
 			const compile$a = (schema, ast) => Pact$2.pipeline([
@@ -5083,8 +4818,8 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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$3;
 			const { escapeRegExp } = common;
 
 
@@ -5109,7 +4844,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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);
@@ -5121,7 +4856,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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;
 
 
@@ -5146,7 +4881,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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) => {
@@ -5160,7 +4895,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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);
@@ -5171,8 +4906,8 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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$3;
 
 
 			const compile$4 = (schema, ast) => {
@@ -5196,7 +4931,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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);
@@ -5204,7 +4939,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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) => {
@@ -5228,7 +4963,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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) => {
@@ -5253,7 +4988,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			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;
 
 
@@ -5270,7 +5005,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var uniqueItems = { compile, interpret };
 
-			const { Keywords: Keywords$1 } = lib$2;
+			const { Keywords: Keywords$1 } = lib$1;
 
 
 			var keywords$5 = {
@@ -5297,14 +5032,12 @@ System.register('JsonSchema', [], (function (exports) {
 			  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,
@@ -5476,7 +5209,7 @@ System.register('JsonSchema', [], (function (exports) {
     "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;
 
@@ -5678,7 +5411,7 @@ System.register('JsonSchema', [], (function (exports) {
     "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;
 
@@ -5710,11 +5443,11 @@ System.register('JsonSchema', [], (function (exports) {
 			  "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,
@@ -5903,7 +5636,7 @@ System.register('JsonSchema', [], (function (exports) {
     "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;
 
@@ -5937,11 +5670,11 @@ System.register('JsonSchema', [], (function (exports) {
 			  "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,
@@ -6286,7 +6019,7 @@ System.register('JsonSchema', [], (function (exports) {
     }
 }`;
 
-			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;
@@ -6345,11 +6078,11 @@ System.register('JsonSchema', [], (function (exports) {
 			  "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,
@@ -6733,7 +6466,7 @@ System.register('JsonSchema', [], (function (exports) {
     }
 }`;
 
-			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;
@@ -6792,11 +6525,11 @@ System.register('JsonSchema', [], (function (exports) {
 			  "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,
@@ -6837,7 +6570,7 @@ System.register('JsonSchema', [], (function (exports) {
 			  "unevaluatedProperties": keywords.unevaluatedProperties
 			});
 
-			const { Core, Schema, InvalidSchemaError } = lib$2;
+			const { Core, Schema, InvalidSchemaError } = lib$1;
 			const Keywords = keywords$5;