@hyperjump/json-schema 0.21.0 → 0.23.1

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 = curry$a;
+			var justCurryIt$2 = curry$j;
 
 			/*
 			  function add(a, b, c) {
@@ -30,7 +30,7 @@ System.register('JsonSchema', [], (function (exports) {
 			  milesToKm(10); // 16.2
 			*/
 
-			function curry$a(fn, arity) {
+			function curry$j(fn, arity) {
 			  return function curried() {
 			    if (arity == null) {
 			      arity = fn.length;
@@ -1901,84 +1901,84 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var common$1 = { jsonTypeOf: jsonTypeOf$2, resolveUrl: resolveUrl$3, urlFragment: urlFragment$1, pathRelative: pathRelative$1 };
 
-			const curry$9 = justCurryIt;
+			const curry$i = justCurryIt$2;
 
 
-			const nil$2 = "";
+			const nil$3 = "";
 
-			const compile$P = (pointer) => {
+			const compile$Q = (pointer) => {
 			  if (pointer.length > 0 && pointer[0] !== "/") {
 			    throw Error("Invalid JSON Pointer");
 			  }
 
-			  return pointer.split("/").slice(1).map(unescape);
+			  return pointer.split("/").slice(1).map(unescape$1);
 			};
 
-			const get$1 = (pointer, value = undefined) => {
-			  const ptr = compile$P(pointer);
+			const get$3 = (pointer, value = undefined) => {
+			  const ptr = compile$Q(pointer);
 
 			  const fn = (value) => ptr.reduce(([value, pointer], segment) => {
-			    return [applySegment(value, segment, pointer), append(segment, pointer)];
+			    return [applySegment$1(value, segment, pointer), append$1(segment, pointer)];
 			  }, [value, ""])[0];
 
 			  return value === undefined ? fn : fn(value);
 			};
 
-			const set = (pointer, subject = undefined, value = undefined) => {
-			  const ptr = compile$P(pointer);
-			  const fn = curry$9((subject, value) => _set(ptr, subject, value, nil$2));
+			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));
 			  return subject === undefined ? fn : fn(subject, value);
 			};
 
-			const _set = (pointer, subject, value, cursor) => {
+			const _set$1 = (pointer, subject, value, cursor) => {
 			  if (pointer.length === 0) {
 			    return value;
 			  } else if (pointer.length > 1) {
 			    const segment = pointer.shift();
-			    return { ...subject, [segment]: _set(pointer, applySegment(subject, segment, cursor), value, append(segment, cursor)) };
+			    return { ...subject, [segment]: _set$1(pointer, applySegment$1(subject, segment, cursor), value, append$1(segment, cursor)) };
 			  } else if (Array.isArray(subject)) {
 			    const clonedSubject = [...subject];
-			    const segment = computeSegment(subject, pointer[0]);
+			    const segment = computeSegment$1(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);
+			    return applySegment$1(subject, pointer[0], cursor);
 			  }
 			};
 
-			const assign = (pointer, subject = undefined, value = undefined) => {
-			  const ptr = compile$P(pointer);
-			  const fn = curry$9((subject, value) => _assign(ptr, subject, value, nil$2));
+			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));
 			  return subject === undefined ? fn : fn(subject, value);
 			};
 
-			const _assign = (pointer, subject, value, cursor) => {
+			const _assign$1 = (pointer, subject, value, cursor) => {
 			  if (pointer.length === 0) {
 			    return;
-			  } else if (pointer.length === 1 && !isScalar(subject)) {
-			    const segment = computeSegment(subject, pointer[0]);
+			  } else if (pointer.length === 1 && !isScalar$1(subject)) {
+			    const segment = computeSegment$1(subject, pointer[0]);
 			    subject[segment] = value;
 			  } else {
 			    const segment = pointer.shift();
-			    _assign(pointer, applySegment(subject, segment, cursor), value, append(segment, cursor));
+			    _assign$1(pointer, applySegment$1(subject, segment, cursor), value, append$1(segment, cursor));
 			  }
 			};
 
-			const unset = (pointer, subject = undefined) => {
-			  const ptr = compile$P(pointer);
-			  const fn = (subject) => _unset(ptr, subject, nil$2);
+			const unset$1 = (pointer, subject = undefined) => {
+			  const ptr = compile$Q(pointer);
+			  const fn = (subject) => _unset$1(ptr, subject, nil$3);
 			  return subject === undefined ? fn : fn(subject);
 			};
 
-			const _unset = (pointer, subject, cursor) => {
+			const _unset$1 = (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)) };
+			    const value = applySegment$1(subject, segment, cursor);
+			    return { ...subject, [segment]: _unset$1(pointer, value, append$1(segment, cursor)) };
 			  } else if (Array.isArray(subject)) {
 			    return subject.filter((_, ndx) => ndx != pointer[0]);
 			  } else if (typeof subject === "object" && subject !== null) {
@@ -1986,54 +1986,54 @@ System.register('JsonSchema', [], (function (exports) {
 			    const { [pointer[0]]: _, ...result } = subject;
 			    return result;
 			  } else {
-			    return applySegment(subject, pointer[0], cursor);
+			    return applySegment$1(subject, pointer[0], cursor);
 			  }
 			};
 
-			const remove = (pointer, subject = undefined) => {
-			  const ptr = compile$P(pointer);
-			  const fn = (subject) => _remove(ptr, subject, nil$2);
+			const remove$1 = (pointer, subject = undefined) => {
+			  const ptr = compile$Q(pointer);
+			  const fn = (subject) => _remove$1(ptr, subject, nil$3);
 			  return subject === undefined ? fn : fn(subject);
 			};
 
-			const _remove = (pointer, subject, cursor) => {
+			const _remove$1 = (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));
+			    const value = applySegment$1(subject, segment, cursor);
+			    _remove$1(pointer, value, append$1(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);
+			    applySegment$1(subject, pointer[0], cursor);
 			  }
 			};
 
-			const append = curry$9((segment, pointer) => pointer + "/" + escape(segment));
+			const append$1 = curry$i((segment, pointer) => pointer + "/" + escape$2(segment));
 
-			const escape = (segment) => segment.toString().replace(/~/g, "~0").replace(/\//g, "~1");
-			const unescape = (segment) => segment.toString().replace(/~1/g, "/").replace(/~0/g, "~");
-			const computeSegment = (value, segment) => Array.isArray(value) && segment === "-" ? value.length : segment;
+			const 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 applySegment = (value, segment, cursor = "") => {
+			const applySegment$1 = (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)) {
+			  } else if (isScalar$1(value)) {
 			    throw TypeError(`Value at '${cursor}' is a ${typeof value} and does not have property '${segment}'`);
 			  } else {
-			    const computedSegment = computeSegment(value, segment);
+			    const computedSegment = computeSegment$1(value, segment);
 			    return value[computedSegment];
 			  }
 			};
 
-			const isScalar = (value) => value === null || typeof value !== "object";
+			const isScalar$1 = (value) => value === null || typeof value !== "object";
 
-			var lib$3 = { nil: nil$2, append, get: get$1, set, assign, unset, remove };
+			var lib$6 = { nil: nil$3, append: append$1, get: get$3, set: set$1, assign: assign$1, unset: unset$1, remove: remove$1 };
 
 			const $__value = Symbol("$__value");
 			const $__href = Symbol("$__href");
@@ -2049,261 +2049,1299 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var reference = { cons: cons$1, isReference, href, value: value$2 };
 
-			const JsonPointer$1 = lib$3;
-			const curry$8 = justCurryIt;
+			const JsonPointer$3 = lib$6;
+			const curry$h = justCurryIt$2;
 			const { resolveUrl: resolveUrl$2, jsonTypeOf: jsonTypeOf$1 } = common$1;
 			const Reference$2 = reference;
 
 
-			const nil$1 = Object.freeze({ id: "", pointer: "", instance: undefined, value: undefined });
-			const cons = (instance, id = "") => Object.freeze({ ...nil$1, id: resolveUrl$2(id, ""), instance, value: instance });
+			const 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 get$2 = (url, instance = nil$2) => {
+			  if (!url.startsWith("#")) {
+			    throw Error(`No JSON document found at '${url.split("#")[0]}'`);
+			  }
+
+			  return Object.freeze({ ...instance, pointer: url.substr(1) });
+			};
+
 			const uri$1 = (doc) => `${doc.id}#${encodeURI(doc.pointer)}`;
 			const value$1 = (doc) => Reference$2.isReference(doc.value) ? Reference$2.value(doc.value) : doc.value;
 			const has$1 = (key, doc) => key in value$1(doc);
-			const typeOf$1 = curry$8((doc, type) => jsonTypeOf$1(value$1(doc), type));
+			const typeOf$1 = curry$h((doc, type) => jsonTypeOf$1(value$1(doc), type));
 
 			const step$1 = (key, doc) => Object.freeze({
 			  ...doc,
-			  pointer: JsonPointer$1.append(key, doc.pointer),
+			  pointer: JsonPointer$3.append(key, doc.pointer),
 			  value: value$1(doc)[key]
 			});
 
-			const entries$3 = (doc) => Object.keys(value$1(doc))
+			const entries$5 = (doc) => Object.keys(value$1(doc))
 			  .map((key) => [key, step$1(key, doc)]);
 
 			const keys$1 = (doc) => Object.keys(value$1(doc));
 
-			const map$4 = curry$8((fn, doc) => value$1(doc)
+			const map$7 = curry$h((fn, doc) => value$1(doc)
 			  .map((item, ndx, array, thisArg) => fn(step$1(ndx, doc), ndx, array, thisArg)));
 
-			const filter$1 = curry$8((fn, doc) => value$1(doc)
+			const forEach = curry$h((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)
 			  .map((item, ndx, array, thisArg) => step$1(ndx, doc))
 			  .filter((item, ndx, array, thisArg) => fn(item, ndx, array, thisArg)));
 
-			const reduce$3 = curry$8((fn, acc, doc) => value$1(doc)
+			const reduce$6 = curry$h((fn, acc, doc) => value$1(doc)
 			  .reduce((acc, item, ndx) => fn(acc, step$1(ndx, doc), ndx), acc));
 
-			const every$1 = curry$8((fn, doc) => value$1(doc)
+			const every$2 = curry$h((fn, doc) => value$1(doc)
 			  .every((item, ndx, array, thisArg) => fn(step$1(ndx, doc), ndx, array, thisArg)));
 
-			const some$1 = curry$8((fn, doc) => value$1(doc)
+			const some$2 = curry$h((fn, doc) => value$1(doc)
 			  .some((item, ndx, array, thisArg) => fn(step$1(ndx, doc), ndx, array, thisArg)));
 
 			const length$1 = (doc) => value$1(doc).length;
 
-			var instance = { nil: nil$1, cons, uri: uri$1, value: value$1, has: has$1, typeOf: typeOf$1, step: step$1, entries: entries$3, keys: keys$1, map: map$4, filter: filter$1, reduce: reduce$3, every: every$1, some: some$1, length: length$1 };
+			var instance = {
+			  nil: nil$2, cons, get: get$2, uri: uri$1, value: value$1, has: has$1, typeOf: typeOf$1, length: length$1,
+			  step: step$1, entries: entries$5, keys: keys$1, map: map$7, forEach, filter: filter$2, reduce: reduce$6, every: every$2, some: some$2
+			};
 
-			var entries$2 = async (doc) => Object.entries(await doc);
+			var entries$4 = async (doc) => Object.entries(await doc);
 
-			const curry$7 = justCurryIt;
+			const curry$g = justCurryIt$2;
 
 
-			var map$3 = curry$7(async (fn, doc) => (await doc).map(fn));
+			var map$6 = curry$g(async (fn, doc) => (await doc).map(fn));
 
-			const curry$6 = justCurryIt;
+			const curry$f = justCurryIt$2;
 
 
-			var reduce$2 = curry$6(async (fn, acc, doc) => {
+			var reduce$5 = curry$f(async (fn, acc, doc) => {
 			  return (await doc).reduce(async (acc, item) => fn(await acc, item), acc);
 			});
 
-			const curry$5 = justCurryIt;
-			const reduce$1 = reduce$2;
+			const curry$e = justCurryIt$2;
+			const reduce$4 = reduce$5;
 
 
-			var filter = curry$5(async (fn, doc, options = {}) => {
-			  return reduce$1(async (acc, item) => {
+			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$4 = justCurryIt;
-			const map$2 = map$3;
+			const curry$d = justCurryIt$2;
+			const map$5 = map$6;
 
 
-			var some = curry$4(async (fn, doc) => {
-			  const results = await map$2(fn, doc);
+			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$3 = justCurryIt;
-			const map$1 = map$3;
+			const curry$c = justCurryIt$2;
+			const map$4 = map$6;
 
 
-			var every = curry$3(async (fn, doc) => {
-			  const results = await map$1(fn, doc);
+			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$2 = justCurryIt;
+			const curry$b = justCurryIt$2;
 
 
-			var pipeline$1 = curry$2((fns, doc) => {
+			var pipeline$3 = curry$b((fns, doc) => {
 			  return fns.reduce(async (acc, fn) => fn(await acc), doc);
 			});
 
-			var all = (doc) => Promise.all(doc);
+			var all$1 = (doc) => Promise.all(doc);
 
-			const pipeline = pipeline$1;
-			const entries$1 = entries$2;
-			const reduce = reduce$2;
+			const pipeline$2 = pipeline$3;
+			const entries$3 = entries$4;
+			const reduce$3 = reduce$5;
 
 
-			var allValues = (doc) => {
-			  return pipeline([
-			    entries$1,
-			    reduce(async (acc, [propertyName, propertyValue]) => {
+			var allValues$1 = (doc) => {
+			  return pipeline$2([
+			    entries$3,
+			    reduce$3(async (acc, [propertyName, propertyValue]) => {
 			      acc[propertyName] = await propertyValue;
 			      return acc;
 			    }, {})
 			  ], doc);
 			};
 
-			var lib$2 = {
-			  entries: entries$2,
-			  map: map$3,
-			  filter: filter,
-			  reduce: reduce$2,
-			  some: some,
-			  every: every,
-			  pipeline: pipeline$1,
-			  all: all,
-			  allValues: allValues
+			var 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 fetch_browser = fetch;
-
-			var contentType = {};
-
-			/*!
-			 * content-type
-			 * Copyright(c) 2015 Douglas Christopher Wilson
-			 * MIT Licensed
-			 */
-
-			/**
-			 * RegExp to match *( ";" parameter ) in RFC 7231 sec 3.1.1.1
-			 *
-			 * parameter     = token "=" ( token / quoted-string )
-			 * token         = 1*tchar
-			 * tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
-			 *               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
-			 *               / DIGIT / ALPHA
-			 *               ; any VCHAR, except delimiters
-			 * quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE
-			 * qdtext        = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text
-			 * obs-text      = %x80-FF
-			 * quoted-pair   = "\" ( HTAB / SP / VCHAR / obs-text )
-			 */
-			var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;
-			var TEXT_REGEXP = /^[\u000b\u0020-\u007e\u0080-\u00ff]+$/;
-			var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
-
-			/**
-			 * RegExp to match quoted-pair in RFC 7230 sec 3.2.6
-			 *
-			 * quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
-			 * obs-text    = %x80-FF
-			 */
-			var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g;
-
-			/**
-			 * RegExp to match chars that must be quoted-pair in RFC 7230 sec 3.2.6
-			 */
-			var QUOTE_REGEXP = /([\\"])/g;
-
-			/**
-			 * RegExp to match type in RFC 7231 sec 3.1.1.1
-			 *
-			 * media-type = type "/" subtype
-			 * type       = token
-			 * subtype    = token
-			 */
-			var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
-
-			/**
-			 * Module exports.
-			 * @public
-			 */
-
-			contentType.format = format$1;
-			contentType.parse = parse$1;
-
-			/**
-			 * Format object to media type.
-			 *
-			 * @param {object} obj
-			 * @return {string}
-			 * @public
-			 */
+			var justCurryIt$1 = curry$a;
 
-			function format$1 (obj) {
-			  if (!obj || typeof obj !== 'object') {
-			    throw new TypeError('argument obj is required')
+			/*
+			  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
 
-			  var parameters = obj.parameters;
-			  var type = obj.type;
+			  function add(...args) {
+			    return args.reduce((sum, n) => sum + n, 0)
+			  }
+			  var curryAdd4 = curry(add, 4)
+			  curryAdd4(1)(2, 3)(4); // 10
 
-			  if (!type || !TYPE_REGEXP.test(type)) {
-			    throw new TypeError('invalid type')
+			  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
+			*/
 
-			  var string = type;
+			function curry$a(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)));
+			      };
+			    }
+			  };
+			}
 
-			  // append parameters
-			  if (parameters && typeof parameters === 'object') {
-			    var param;
-			    var params = Object.keys(parameters).sort();
+			const curry$9 = justCurryIt$1;
 
-			    for (var i = 0; i < params.length; i++) {
-			      param = params[i];
 
-			      if (!TOKEN_REGEXP.test(param)) {
-			        throw new TypeError('invalid parameter name')
-			      }
+			const nil$1 = "";
 
-			      string += '; ' + param + '=' + qstring(parameters[param]);
-			    }
+			const compile$P = (pointer) => {
+			  if (pointer.length > 0 && pointer[0] !== "/") {
+			    throw Error("Invalid JSON Pointer");
 			  }
 
-			  return string
-			}
+			  return pointer.split("/").slice(1).map(unescape);
+			};
 
-			/**
-			 * Parse media type to object.
-			 *
-			 * @param {string|object} string
-			 * @return {Object}
-			 * @public
-			 */
+			const get$1 = (pointer, value = undefined) => {
+			  const ptr = compile$P(pointer);
 
-			function parse$1 (string) {
-			  if (!string) {
-			    throw new TypeError('argument string is required')
-			  }
+			  const fn = (value) => ptr.reduce(([value, pointer], segment) => {
+			    return [applySegment(value, segment, pointer), append(segment, pointer)];
+			  }, [value, ""])[0];
 
-			  // support req/res-like objects as argument
-			  var header = typeof string === 'object'
-			    ? getcontenttype(string)
-			    : string;
+			  return value === undefined ? fn : fn(value);
+			};
 
-			  if (typeof header !== 'string') {
-			    throw new TypeError('argument string is required to be a string')
+			const set = (pointer, subject = undefined, value = undefined) => {
+			  const ptr = compile$P(pointer);
+			  const fn = curry$9((subject, value) => _set(ptr, subject, value, nil$1));
+			  return subject === undefined ? fn : fn(subject, value);
+			};
+
+			const _set = (pointer, subject, value, cursor) => {
+			  if (pointer.length === 0) {
+			    return value;
+			  } else if (pointer.length > 1) {
+			    if (Array.isArray(subject)) {
+			      const index = pointer.shift();
+			      const clonedSubject = [...subject];
+			      clonedSubject[index] = _set(pointer, applySegment(subject, index, cursor), value, append(index, cursor));
+			      return clonedSubject;
+			    } else {
+			      const segment = pointer.shift();
+			      return { ...subject, [segment]: _set(pointer, applySegment(subject, segment, cursor), value, append(segment, cursor)) };
+			    }
+			  } else if (Array.isArray(subject)) {
+			    const clonedSubject = [...subject];
+			    const segment = computeSegment(subject, pointer[0]);
+			    clonedSubject[segment] = value;
+			    return clonedSubject;
+			  } else if (typeof subject === "object" && subject !== null) {
+			    return { ...subject, [pointer[0]]: value };
+			  } else {
+			    return applySegment(subject, pointer[0], cursor);
 			  }
+			};
 
-			  var index = header.indexOf(';');
-			  var type = index !== -1
-			    ? header.substr(0, index).trim()
-			    : header.trim();
+			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);
+			};
 
-			  if (!TYPE_REGEXP.test(type)) {
-			    throw new TypeError('invalid media type')
+			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 obj = new ContentType(type.toLowerCase());
+			const unset = (pointer, subject = undefined) => {
+			  const ptr = compile$P(pointer);
+			  const fn = (subject) => _unset(ptr, subject, nil$1);
+			  return subject === undefined ? fn : fn(subject);
+			};
+
+			const _unset = (pointer, subject, cursor) => {
+			  if (pointer.length == 0) {
+			    return undefined;
+			  } else if (pointer.length > 1) {
+			    const segment = pointer.shift();
+			    const value = applySegment(subject, segment, cursor);
+			    return { ...subject, [segment]: _unset(pointer, value, append(segment, cursor)) };
+			  } else if (Array.isArray(subject)) {
+			    return subject.filter((_, ndx) => ndx != pointer[0]);
+			  } else if (typeof subject === "object" && subject !== null) {
+			    // eslint-disable-next-line no-unused-vars
+			    const { [pointer[0]]: _, ...result } = subject;
+			    return result;
+			  } else {
+			    return applySegment(subject, pointer[0], cursor);
+			  }
+			};
+
+			const remove = (pointer, subject = undefined) => {
+			  const ptr = compile$P(pointer);
+			  const fn = (subject) => _remove(ptr, subject, nil$1);
+			  return subject === undefined ? fn : fn(subject);
+			};
+
+			const _remove = (pointer, subject, cursor) => {
+			  if (pointer.length === 0) {
+			    return;
+			  } else if (pointer.length > 1) {
+			    const segment = pointer.shift();
+			    const value = applySegment(subject, segment, cursor);
+			    _remove(pointer, value, append(segment, cursor));
+			  } else if (Array.isArray(subject)) {
+			    subject.splice(pointer[0], 1);
+			  } else if (typeof subject === "object" && subject !== null) {
+			    delete subject[pointer[0]];
+			  } else {
+			    applySegment(subject, pointer[0], cursor);
+			  }
+			};
+
+			const append = curry$9((segment, pointer) => pointer + "/" + escape$1(segment));
+
+			const escape$1 = (segment) => segment.toString().replace(/~/g, "~0").replace(/\//g, "~1");
+			const unescape = (segment) => segment.toString().replace(/~1/g, "/").replace(/~0/g, "~");
+			const computeSegment = (value, segment) => Array.isArray(value) && segment === "-" ? value.length : segment;
+
+			const applySegment = (value, segment, cursor = "") => {
+			  if (value === undefined) {
+			    throw TypeError(`Value at '${cursor}' is undefined and does not have property '${segment}'`);
+			  } else if (value === null) {
+			    throw TypeError(`Value at '${cursor}' is null and does not have property '${segment}'`);
+			  } else if (isScalar(value)) {
+			    throw TypeError(`Value at '${cursor}' is a ${typeof value} and does not have property '${segment}'`);
+			  } else {
+			    const computedSegment = computeSegment(value, segment);
+			    return value[computedSegment];
+			  }
+			};
+
+			const isScalar = (value) => value === null || typeof value !== "object";
+
+			var lib$4 = { nil: nil$1, append, get: get$1, set, assign, unset, remove };
+
+			var moo$1 = {exports: {}};
+
+			(function (module) {
+				(function(root, factory) {
+				  if (module.exports) {
+				    module.exports = factory();
+				  } else {
+				    root.moo = factory();
+				  }
+				}(commonjsGlobal, function() {
+
+				  var hasOwnProperty = Object.prototype.hasOwnProperty;
+				  var toString = Object.prototype.toString;
+				  var hasSticky = typeof new RegExp().sticky === 'boolean';
+
+				  /***************************************************************************/
+
+				  function isRegExp(o) { return o && toString.call(o) === '[object RegExp]' }
+				  function isObject(o) { return o && typeof o === 'object' && !isRegExp(o) && !Array.isArray(o) }
+
+				  function reEscape(s) {
+				    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&')
+				  }
+				  function reGroups(s) {
+				    var re = new RegExp('|' + s);
+				    return re.exec('').length - 1
+				  }
+				  function reCapture(s) {
+				    return '(' + s + ')'
+				  }
+				  function reUnion(regexps) {
+				    if (!regexps.length) return '(?!)'
+				    var source =  regexps.map(function(s) {
+				      return "(?:" + s + ")"
+				    }).join('|');
+				    return "(?:" + source + ")"
+				  }
+
+				  function regexpOrLiteral(obj) {
+				    if (typeof obj === 'string') {
+				      return '(?:' + reEscape(obj) + ')'
+
+				    } else if (isRegExp(obj)) {
+				      // TODO: consider /u support
+				      if (obj.ignoreCase) throw new Error('RegExp /i flag not allowed')
+				      if (obj.global) throw new Error('RegExp /g flag is implied')
+				      if (obj.sticky) throw new Error('RegExp /y flag is implied')
+				      if (obj.multiline) throw new Error('RegExp /m flag is implied')
+				      return obj.source
+
+				    } else {
+				      throw new Error('Not a pattern: ' + obj)
+				    }
+				  }
+
+				  function objectToRules(object) {
+				    var keys = Object.getOwnPropertyNames(object);
+				    var result = [];
+				    for (var i = 0; i < keys.length; i++) {
+				      var key = keys[i];
+				      var thing = object[key];
+				      var rules = [].concat(thing);
+				      if (key === 'include') {
+				        for (var j = 0; j < rules.length; j++) {
+				          result.push({include: rules[j]});
+				        }
+				        continue
+				      }
+				      var match = [];
+				      rules.forEach(function(rule) {
+				        if (isObject(rule)) {
+				          if (match.length) result.push(ruleOptions(key, match));
+				          result.push(ruleOptions(key, rule));
+				          match = [];
+				        } else {
+				          match.push(rule);
+				        }
+				      });
+				      if (match.length) result.push(ruleOptions(key, match));
+				    }
+				    return result
+				  }
+
+				  function arrayToRules(array) {
+				    var result = [];
+				    for (var i = 0; i < array.length; i++) {
+				      var obj = array[i];
+				      if (obj.include) {
+				        var include = [].concat(obj.include);
+				        for (var j = 0; j < include.length; j++) {
+				          result.push({include: include[j]});
+				        }
+				        continue
+				      }
+				      if (!obj.type) {
+				        throw new Error('Rule has no type: ' + JSON.stringify(obj))
+				      }
+				      result.push(ruleOptions(obj.type, obj));
+				    }
+				    return result
+				  }
+
+				  function ruleOptions(type, obj) {
+				    if (!isObject(obj)) {
+				      obj = { match: obj };
+				    }
+				    if (obj.include) {
+				      throw new Error('Matching rules cannot also include states')
+				    }
+
+				    // nb. error and fallback imply lineBreaks
+				    var options = {
+				      defaultType: type,
+				      lineBreaks: !!obj.error || !!obj.fallback,
+				      pop: false,
+				      next: null,
+				      push: null,
+				      error: false,
+				      fallback: false,
+				      value: null,
+				      type: null,
+				      shouldThrow: false,
+				    };
+
+				    // Avoid Object.assign(), so we support IE9+
+				    for (var key in obj) {
+				      if (hasOwnProperty.call(obj, key)) {
+				        options[key] = obj[key];
+				      }
+				    }
+
+				    // type transform cannot be a string
+				    if (typeof options.type === 'string' && type !== options.type) {
+				      throw new Error("Type transform cannot be a string (type '" + options.type + "' for token '" + type + "')")
+				    }
+
+				    // convert to array
+				    var match = options.match;
+				    options.match = Array.isArray(match) ? match : match ? [match] : [];
+				    options.match.sort(function(a, b) {
+				      return isRegExp(a) && isRegExp(b) ? 0
+				           : isRegExp(b) ? -1 : isRegExp(a) ? +1 : b.length - a.length
+				    });
+				    return options
+				  }
+
+				  function toRules(spec) {
+				    return Array.isArray(spec) ? arrayToRules(spec) : objectToRules(spec)
+				  }
+
+				  var defaultErrorRule = ruleOptions('error', {lineBreaks: true, shouldThrow: true});
+				  function compileRules(rules, hasStates) {
+				    var errorRule = null;
+				    var fast = Object.create(null);
+				    var fastAllowed = true;
+				    var unicodeFlag = null;
+				    var groups = [];
+				    var parts = [];
+
+				    // If there is a fallback rule, then disable fast matching
+				    for (var i = 0; i < rules.length; i++) {
+				      if (rules[i].fallback) {
+				        fastAllowed = false;
+				      }
+				    }
+
+				    for (var i = 0; i < rules.length; i++) {
+				      var options = rules[i];
+
+				      if (options.include) {
+				        // all valid inclusions are removed by states() preprocessor
+				        throw new Error('Inheritance is not allowed in stateless lexers')
+				      }
+
+				      if (options.error || options.fallback) {
+				        // errorRule can only be set once
+				        if (errorRule) {
+				          if (!options.fallback === !errorRule.fallback) {
+				            throw new Error("Multiple " + (options.fallback ? "fallback" : "error") + " rules not allowed (for token '" + options.defaultType + "')")
+				          } else {
+				            throw new Error("fallback and error are mutually exclusive (for token '" + options.defaultType + "')")
+				          }
+				        }
+				        errorRule = options;
+				      }
+
+				      var match = options.match.slice();
+				      if (fastAllowed) {
+				        while (match.length && typeof match[0] === 'string' && match[0].length === 1) {
+				          var word = match.shift();
+				          fast[word.charCodeAt(0)] = options;
+				        }
+				      }
+
+				      // Warn about inappropriate state-switching options
+				      if (options.pop || options.push || options.next) {
+				        if (!hasStates) {
+				          throw new Error("State-switching options are not allowed in stateless lexers (for token '" + options.defaultType + "')")
+				        }
+				        if (options.fallback) {
+				          throw new Error("State-switching options are not allowed on fallback tokens (for token '" + options.defaultType + "')")
+				        }
+				      }
+
+				      // Only rules with a .match are included in the RegExp
+				      if (match.length === 0) {
+				        continue
+				      }
+				      fastAllowed = false;
+
+				      groups.push(options);
+
+				      // Check unicode flag is used everywhere or nowhere
+				      for (var j = 0; j < match.length; j++) {
+				        var obj = match[j];
+				        if (!isRegExp(obj)) {
+				          continue
+				        }
+
+				        if (unicodeFlag === null) {
+				          unicodeFlag = obj.unicode;
+				        } else if (unicodeFlag !== obj.unicode && options.fallback === false) {
+				          throw new Error('If one rule is /u then all must be')
+				        }
+				      }
+
+				      // convert to RegExp
+				      var pat = reUnion(match.map(regexpOrLiteral));
+
+				      // validate
+				      var regexp = new RegExp(pat);
+				      if (regexp.test("")) {
+				        throw new Error("RegExp matches empty string: " + regexp)
+				      }
+				      var groupCount = reGroups(pat);
+				      if (groupCount > 0) {
+				        throw new Error("RegExp has capture groups: " + regexp + "\nUse (?: … ) instead")
+				      }
+
+				      // try and detect rules matching newlines
+				      if (!options.lineBreaks && regexp.test('\n')) {
+				        throw new Error('Rule should declare lineBreaks: ' + regexp)
+				      }
+
+				      // store regex
+				      parts.push(reCapture(pat));
+				    }
+
+
+				    // If there's no fallback rule, use the sticky flag so we only look for
+				    // matches at the current index.
+				    //
+				    // If we don't support the sticky flag, then fake it using an irrefutable
+				    // match (i.e. an empty pattern).
+				    var fallbackRule = errorRule && errorRule.fallback;
+				    var flags = hasSticky && !fallbackRule ? 'ym' : 'gm';
+				    var suffix = hasSticky || fallbackRule ? '' : '|';
+
+				    if (unicodeFlag === true) flags += "u";
+				    var combined = new RegExp(reUnion(parts) + suffix, flags);
+				    return {regexp: combined, groups: groups, fast: fast, error: errorRule || defaultErrorRule}
+				  }
+
+				  function compile(rules) {
+				    var result = compileRules(toRules(rules));
+				    return new Lexer({start: result}, 'start')
+				  }
+
+				  function checkStateGroup(g, name, map) {
+				    var state = g && (g.push || g.next);
+				    if (state && !map[state]) {
+				      throw new Error("Missing state '" + state + "' (in token '" + g.defaultType + "' of state '" + name + "')")
+				    }
+				    if (g && g.pop && +g.pop !== 1) {
+				      throw new Error("pop must be 1 (in token '" + g.defaultType + "' of state '" + name + "')")
+				    }
+				  }
+				  function compileStates(states, start) {
+				    var all = states.$all ? toRules(states.$all) : [];
+				    delete states.$all;
+
+				    var keys = Object.getOwnPropertyNames(states);
+				    if (!start) start = keys[0];
+
+				    var ruleMap = Object.create(null);
+				    for (var i = 0; i < keys.length; i++) {
+				      var key = keys[i];
+				      ruleMap[key] = toRules(states[key]).concat(all);
+				    }
+				    for (var i = 0; i < keys.length; i++) {
+				      var key = keys[i];
+				      var rules = ruleMap[key];
+				      var included = Object.create(null);
+				      for (var j = 0; j < rules.length; j++) {
+				        var rule = rules[j];
+				        if (!rule.include) continue
+				        var splice = [j, 1];
+				        if (rule.include !== key && !included[rule.include]) {
+				          included[rule.include] = true;
+				          var newRules = ruleMap[rule.include];
+				          if (!newRules) {
+				            throw new Error("Cannot include nonexistent state '" + rule.include + "' (in state '" + key + "')")
+				          }
+				          for (var k = 0; k < newRules.length; k++) {
+				            var newRule = newRules[k];
+				            if (rules.indexOf(newRule) !== -1) continue
+				            splice.push(newRule);
+				          }
+				        }
+				        rules.splice.apply(rules, splice);
+				        j--;
+				      }
+				    }
+
+				    var map = Object.create(null);
+				    for (var i = 0; i < keys.length; i++) {
+				      var key = keys[i];
+				      map[key] = compileRules(ruleMap[key], true);
+				    }
+
+				    for (var i = 0; i < keys.length; i++) {
+				      var name = keys[i];
+				      var state = map[name];
+				      var groups = state.groups;
+				      for (var j = 0; j < groups.length; j++) {
+				        checkStateGroup(groups[j], name, map);
+				      }
+				      var fastKeys = Object.getOwnPropertyNames(state.fast);
+				      for (var j = 0; j < fastKeys.length; j++) {
+				        checkStateGroup(state.fast[fastKeys[j]], name, map);
+				      }
+				    }
+
+				    return new Lexer(map, start)
+				  }
+
+				  function keywordTransform(map) {
+				    var reverseMap = Object.create(null);
+				    var byLength = Object.create(null);
+				    var types = Object.getOwnPropertyNames(map);
+				    for (var i = 0; i < types.length; i++) {
+				      var tokenType = types[i];
+				      var item = map[tokenType];
+				      var keywordList = Array.isArray(item) ? item : [item];
+				      keywordList.forEach(function(keyword) {
+				        (byLength[keyword.length] = byLength[keyword.length] || []).push(keyword);
+				        if (typeof keyword !== 'string') {
+				          throw new Error("keyword must be string (in keyword '" + tokenType + "')")
+				        }
+				        reverseMap[keyword] = tokenType;
+				      });
+				    }
+
+				    // fast string lookup
+				    // https://jsperf.com/string-lookups
+				    function str(x) { return JSON.stringify(x) }
+				    var source = '';
+				    source += 'switch (value.length) {\n';
+				    for (var length in byLength) {
+				      var keywords = byLength[length];
+				      source += 'case ' + length + ':\n';
+				      source += 'switch (value) {\n';
+				      keywords.forEach(function(keyword) {
+				        var tokenType = reverseMap[keyword];
+				        source += 'case ' + str(keyword) + ': return ' + str(tokenType) + '\n';
+				      });
+				      source += '}\n';
+				    }
+				    source += '}\n';
+				    return Function('value', source) // type
+				  }
+
+				  /***************************************************************************/
+
+				  var Lexer = function(states, state) {
+				    this.startState = state;
+				    this.states = states;
+				    this.buffer = '';
+				    this.stack = [];
+				    this.reset();
+				  };
+
+				  Lexer.prototype.reset = function(data, info) {
+				    this.buffer = data || '';
+				    this.index = 0;
+				    this.line = info ? info.line : 1;
+				    this.col = info ? info.col : 1;
+				    this.queuedToken = info ? info.queuedToken : null;
+				    this.queuedThrow = info ? info.queuedThrow : null;
+				    this.setState(info ? info.state : this.startState);
+				    this.stack = info && info.stack ? info.stack.slice() : [];
+				    return this
+				  };
+
+				  Lexer.prototype.save = function() {
+				    return {
+				      line: this.line,
+				      col: this.col,
+				      state: this.state,
+				      stack: this.stack.slice(),
+				      queuedToken: this.queuedToken,
+				      queuedThrow: this.queuedThrow,
+				    }
+				  };
+
+				  Lexer.prototype.setState = function(state) {
+				    if (!state || this.state === state) return
+				    this.state = state;
+				    var info = this.states[state];
+				    this.groups = info.groups;
+				    this.error = info.error;
+				    this.re = info.regexp;
+				    this.fast = info.fast;
+				  };
+
+				  Lexer.prototype.popState = function() {
+				    this.setState(this.stack.pop());
+				  };
+
+				  Lexer.prototype.pushState = function(state) {
+				    this.stack.push(this.state);
+				    this.setState(state);
+				  };
+
+				  var eat = hasSticky ? function(re, buffer) { // assume re is /y
+				    return re.exec(buffer)
+				  } : function(re, buffer) { // assume re is /g
+				    var match = re.exec(buffer);
+				    // will always match, since we used the |(?:) trick
+				    if (match[0].length === 0) {
+				      return null
+				    }
+				    return match
+				  };
+
+				  Lexer.prototype._getGroup = function(match) {
+				    var groupCount = this.groups.length;
+				    for (var i = 0; i < groupCount; i++) {
+				      if (match[i + 1] !== undefined) {
+				        return this.groups[i]
+				      }
+				    }
+				    throw new Error('Cannot find token type for matched text')
+				  };
+
+				  function tokenToString() {
+				    return this.value
+				  }
+
+				  Lexer.prototype.next = function() {
+				    var index = this.index;
+
+				    // If a fallback token matched, we don't need to re-run the RegExp
+				    if (this.queuedGroup) {
+				      var token = this._token(this.queuedGroup, this.queuedText, index);
+				      this.queuedGroup = null;
+				      this.queuedText = "";
+				      return token
+				    }
+
+				    var buffer = this.buffer;
+				    if (index === buffer.length) {
+				      return // EOF
+				    }
+
+				    // Fast matching for single characters
+				    var group = this.fast[buffer.charCodeAt(index)];
+				    if (group) {
+				      return this._token(group, buffer.charAt(index), index)
+				    }
+
+				    // Execute RegExp
+				    var re = this.re;
+				    re.lastIndex = index;
+				    var match = eat(re, buffer);
+
+				    // Error tokens match the remaining buffer
+				    var error = this.error;
+				    if (match == null) {
+				      return this._token(error, buffer.slice(index, buffer.length), index)
+				    }
+
+				    var group = this._getGroup(match);
+				    var text = match[0];
+
+				    if (error.fallback && match.index !== index) {
+				      this.queuedGroup = group;
+				      this.queuedText = text;
+
+				      // Fallback tokens contain the unmatched portion of the buffer
+				      return this._token(error, buffer.slice(index, match.index), index)
+				    }
+
+				    return this._token(group, text, index)
+				  };
+
+				  Lexer.prototype._token = function(group, text, offset) {
+				    // count line breaks
+				    var lineBreaks = 0;
+				    if (group.lineBreaks) {
+				      var matchNL = /\n/g;
+				      var nl = 1;
+				      if (text === '\n') {
+				        lineBreaks = 1;
+				      } else {
+				        while (matchNL.exec(text)) { lineBreaks++; nl = matchNL.lastIndex; }
+				      }
+				    }
+
+				    var token = {
+				      type: (typeof group.type === 'function' && group.type(text)) || group.defaultType,
+				      value: typeof group.value === 'function' ? group.value(text) : text,
+				      text: text,
+				      toString: tokenToString,
+				      offset: offset,
+				      lineBreaks: lineBreaks,
+				      line: this.line,
+				      col: this.col,
+				    };
+				    // nb. adding more props to token object will make V8 sad!
+
+				    var size = text.length;
+				    this.index += size;
+				    this.line += lineBreaks;
+				    if (lineBreaks !== 0) {
+				      this.col = size - nl + 1;
+				    } else {
+				      this.col += size;
+				    }
+
+				    // throw, if no rule with {error: true}
+				    if (group.shouldThrow) {
+				      throw new Error(this.formatError(token, "invalid syntax"))
+				    }
+
+				    if (group.pop) this.popState();
+				    else if (group.push) this.pushState(group.push);
+				    else if (group.next) this.setState(group.next);
+
+				    return token
+				  };
+
+				  if (typeof Symbol !== 'undefined' && Symbol.iterator) {
+				    var LexerIterator = function(lexer) {
+				      this.lexer = lexer;
+				    };
+
+				    LexerIterator.prototype.next = function() {
+				      var token = this.lexer.next();
+				      return {value: token, done: !token}
+				    };
+
+				    LexerIterator.prototype[Symbol.iterator] = function() {
+				      return this
+				    };
+
+				    Lexer.prototype[Symbol.iterator] = function() {
+				      return new LexerIterator(this)
+				    };
+				  }
+
+				  Lexer.prototype.formatError = function(token, message) {
+				    if (token == null) {
+				      // An undefined token indicates EOF
+				      var text = this.buffer.slice(this.index);
+				      var token = {
+				        text: text,
+				        offset: this.index,
+				        lineBreaks: text.indexOf('\n') === -1 ? 0 : 1,
+				        line: this.line,
+				        col: this.col,
+				      };
+				    }
+				    var start = Math.max(0, token.offset - token.col + 1);
+				    var eol = token.lineBreaks ? token.text.indexOf('\n') : token.text.length;
+				    var firstLine = this.buffer.substring(start, token.offset + eol);
+				    message += " at line " + token.line + " col " + token.col + ":\n\n";
+				    message += "  " + firstLine + "\n";
+				    message += "  " + Array(token.col).join(" ") + "^";
+				    return message
+				  };
+
+				  Lexer.prototype.clone = function() {
+				    return new Lexer(this.states, this.state)
+				  };
+
+				  Lexer.prototype.has = function(tokenType) {
+				    return true
+				  };
+
+
+				  return {
+				    compile: compile,
+				    states: compileStates,
+				    error: Object.freeze({error: true}),
+				    fallback: Object.freeze({fallback: true}),
+				    keywords: keywordTransform,
+				  }
+
+				}));
+			} (moo$1));
+
+			const moo = moo$1.exports;
+
+
+			const digit = `[0-9]`;
+			const digit19 = `[1-9]`;
+			const hexdig = `[0-9a-fA-F]`;
+
+			// String
+			const unescaped = `[\\x20-\\x21\\x23-\\x5b\\x5d-\\u{10ffff}]`;
+			const escape = `\\\\`;
+			const escaped = `${escape}(?:["\\/\\\\brfnt]|u${hexdig}{4})`;
+			const char = `(?:${unescaped}|${escaped})`;
+			const string = `"${char}*"`;
+
+			// Number
+			const int = `(?:0|${digit19}${digit}*)`;
+			const frac = `\\.${digit}+`;
+			const e = `[eE]`;
+			const exp = `${e}[-+]?${digit}+`;
+			const number = `-?${int}(?:${frac})?(?:${exp})?`;
+
+			// Whitespace
+			const whitespace = `(?:(?:\\r?\\n)|[ \\t])+`;
+
+			var lexer = (json) => {
+			  const lexer = moo.states({
+			    main: {
+			      WS: { match: new RegExp(whitespace, "u"), lineBreaks: true },
+			      true: { match: "true", value: () => true },
+			      false: { match: "false", value: () => false },
+			      null: { match: "null", value: () => null },
+			      number: { match: new RegExp(number, "u"), value: parseFloat },
+			      string: { match: new RegExp(string, "u"), value: JSON.parse },
+			      "{": "{",
+			      "}": "}",
+			      "[": "[",
+			      "]": "]",
+			      ":": ":",
+			      ",": ",",
+			      error: moo.error
+			    }
+			  });
+			  lexer.reset(json);
+
+			  const _next = () => {
+			    let token;
+			    do {
+			      token = lexer.next();
+			      if (token?.type === "error") {
+			        throw SyntaxError(lexer.formatError(token, "Unrecognized token"));
+			      }
+			    } while (token?.type === "WS");
+
+			    return token;
+			  };
+
+			  let previous;
+			  let nextToken = _next();
+
+			  const next = (expectedType = undefined) => {
+			    previous = nextToken;
+			    nextToken = _next();
+			    if (expectedType && previous?.type !== expectedType) {
+			      throw SyntaxError(lexer.formatError(previous, `Expected a '${expectedType}'`));
+			    }
+			    return previous;
+			  };
+
+			  const peek = () => nextToken;
+
+			  const defaultErrorToken = { offset: 0, line: 1, col: 0, text: "" };
+			  const syntaxError = (message) => {
+			    const referenceToken = previous || defaultErrorToken;
+			    const errorToken = {
+			      ...referenceToken,
+			      offset: referenceToken.offset + referenceToken.text.length,
+			      col: referenceToken.col + referenceToken.text.length
+			    };
+			    throw new SyntaxError(lexer.formatError(errorToken, message));
+			  };
+
+			  return { next, peek, syntaxError };
+			};
+
+			const JsonPointer$2 = lib$4;
+			const jsonLexer = lexer;
+
+
+			const defaultReviver = (key, value) => value;
+			const parse$3 = (json, reviver = defaultReviver) => {
+			  const lexer = jsonLexer(json);
+			  const value =  parseValue(lexer, "", JsonPointer$2.nil, reviver);
+
+			  const token = lexer.peek();
+			  if (token) {
+			    lexer.syntaxError("A value has been parsed, but more tokens were found");
+			  }
+			  return value;
+			};
+
+			const parseValue = (lexer, key, pointer, reviver) => {
+			  let value;
+			  const token = lexer.next();
+			  switch (token?.type) {
+			    case "true":
+			    case "false":
+			    case "null":
+			    case "number":
+			    case "string":
+			      value = token.value;
+			      break;
+			    case "{":
+			      value = parseObject(lexer, key, pointer, reviver);
+			      break;
+			    case "[":
+			      value = parseArray(lexer, key, pointer, reviver);
+			      break;
+			    default:
+			      lexer.syntaxError("Expected a JSON value");
+			  }
+
+			  return reviver(key, value, pointer);
+			};
+
+			const parseObject = (lexer, key, pointer, reviver) => {
+			  const value = {};
+
+			  if (lexer.peek()?.type !== "}") {
+			    parseProperties(lexer, key, pointer, reviver, value);
+			  }
+
+			  lexer.next("}");
+
+			  return value;
+			};
+
+			const parseProperties = (lexer, key, pointer, reviver, value) => {
+			  const propertyName = lexer.next("string").value;
+			  lexer.next(":");
+			  if (!isValueToken(lexer.peek())) {
+			    lexer.syntaxError("Expected a JSON value");
+			  }
+			  value[propertyName] = parseValue(lexer, propertyName, JsonPointer$2.append(propertyName, pointer), reviver);
+
+			  if (lexer.peek()?.type === ",") {
+			    lexer.next(); // burn comma
+			    parseProperties(lexer, propertyName, pointer, reviver, value);
+			  } else if (isValueToken(lexer.peek())) {
+			    lexer.next(",");
+			  }
+			};
+
+			const parseArray = (lexer, key, pointer, reviver) => {
+			  const value = [];
+
+			  if (lexer.peek()?.type !== "]") {
+			    parseItems(lexer, 0, pointer, reviver, value);
+			  }
+
+			  lexer.next("]");
+
+			  return value;
+			};
+
+			const parseItems = (lexer, key, pointer, reviver, value) => {
+			  if (!isValueToken(lexer.peek())) {
+			    lexer.syntaxError("Expected a JSON value");
+			  }
+			  value[key] = parseValue(lexer, key, JsonPointer$2.append(key, pointer), reviver);
+			  if (lexer.peek()?.type === ",") {
+			    lexer.next(); // burn comma
+			    parseItems(lexer, key + 1, pointer, reviver, value);
+			  } else if (isValueToken(lexer.peek())) {
+			    lexer.next(",");
+			  }
+			};
+
+			const valueType = new Set(["string", "number", "true", "false", "null", "[", "{"]);
+			const isValueToken = (token) => valueType.has(token?.type);
+
+			var parse_1 = parse$3;
+
+			const JsonPointer$1 = lib$4;
+
+
+			const defaultReplacer = (key, value) => value;
+			const stringify$2 = (value, replacer = defaultReplacer, space = "") => {
+			  return stringifyValue(value, replacer, space, "", JsonPointer$1.nil, 1);
+			};
+
+			const stringifyValue = (value, replacer, space, key, pointer, depth) => {
+			  value = replacer(key, value, pointer);
+			  let result;
+			  if (Array.isArray(value)) {
+			    result = stringifyArray(value, replacer, space, pointer, depth);
+			  } else if (typeof value === "object" && value !== null) {
+			    result = stringifyObject(value, replacer, space, pointer, depth);
+			  } else {
+			    result = JSON.stringify(value);
+			  }
+
+			  return result;
+			};
+
+			const stringifyArray = (value, replacer, space, pointer, depth) => {
+			  if (value.length === 0) {
+			    space = "";
+			  }
+			  const padding = space ? `\n${space.repeat(depth - 1)}` : "";
+			  return "[" + padding + space + value
+			    .map((item, index) => {
+			      const indexPointer = JsonPointer$1.append(index, pointer);
+			      return stringifyValue(item, replacer, space, index, indexPointer, depth + 1);
+			    })
+			    .join(`,${padding}${space}`) + padding + "]";
+			};
+
+			const stringifyObject = (value, replacer, space, pointer, depth) => {
+			  if (Object.keys(value).length === 0) {
+			    space = "";
+			  }
+			  const padding = space ? `\n${space.repeat(depth - 1)}` : "";
+			  const spacing = space ? " " : "";
+			  return "{" + padding + space + Object.entries(value)
+			    .map(([key, value]) => {
+			      const keyPointer = JsonPointer$1.append(key, pointer);
+			      return JSON.stringify(key) + ":" + spacing + stringifyValue(value, replacer, space, key, keyPointer, depth + 1);
+			    })
+			    .join(`,${padding}${space}`) + padding + "}";
+			};
+
+			var stringify_1 = stringify$2;
+
+			const parse$2 = parse_1;
+			const stringify$1 = stringify_1;
+
+
+			var lib$3 = { parse: parse$2, stringify: stringify$1 };
+
+			var fetch_browser = fetch;
+
+			var contentType = {};
+
+			/*!
+			 * content-type
+			 * Copyright(c) 2015 Douglas Christopher Wilson
+			 * MIT Licensed
+			 */
+
+			/**
+			 * RegExp to match *( ";" parameter ) in RFC 7231 sec 3.1.1.1
+			 *
+			 * parameter     = token "=" ( token / quoted-string )
+			 * token         = 1*tchar
+			 * tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+			 *               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+			 *               / DIGIT / ALPHA
+			 *               ; any VCHAR, except delimiters
+			 * quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE
+			 * qdtext        = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text
+			 * obs-text      = %x80-FF
+			 * quoted-pair   = "\" ( HTAB / SP / VCHAR / obs-text )
+			 */
+			var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;
+			var TEXT_REGEXP = /^[\u000b\u0020-\u007e\u0080-\u00ff]+$/;
+			var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+
+			/**
+			 * RegExp to match quoted-pair in RFC 7230 sec 3.2.6
+			 *
+			 * quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
+			 * obs-text    = %x80-FF
+			 */
+			var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g;
+
+			/**
+			 * RegExp to match chars that must be quoted-pair in RFC 7230 sec 3.2.6
+			 */
+			var QUOTE_REGEXP = /([\\"])/g;
+
+			/**
+			 * RegExp to match type in RFC 7231 sec 3.1.1.1
+			 *
+			 * media-type = type "/" subtype
+			 * type       = token
+			 * subtype    = token
+			 */
+			var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+
+			/**
+			 * Module exports.
+			 * @public
+			 */
+
+			contentType.format = format$1;
+			contentType.parse = parse$1;
+
+			/**
+			 * Format object to media type.
+			 *
+			 * @param {object} obj
+			 * @return {string}
+			 * @public
+			 */
+
+			function format$1 (obj) {
+			  if (!obj || typeof obj !== 'object') {
+			    throw new TypeError('argument obj is required')
+			  }
+
+			  var parameters = obj.parameters;
+			  var type = obj.type;
+
+			  if (!type || !TYPE_REGEXP.test(type)) {
+			    throw new TypeError('invalid type')
+			  }
+
+			  var string = type;
+
+			  // append parameters
+			  if (parameters && typeof parameters === 'object') {
+			    var param;
+			    var params = Object.keys(parameters).sort();
+
+			    for (var i = 0; i < params.length; i++) {
+			      param = params[i];
+
+			      if (!TOKEN_REGEXP.test(param)) {
+			        throw new TypeError('invalid parameter name')
+			      }
+
+			      string += '; ' + param + '=' + qstring(parameters[param]);
+			    }
+			  }
+
+			  return string
+			}
+
+			/**
+			 * Parse media type to object.
+			 *
+			 * @param {string|object} string
+			 * @return {Object}
+			 * @public
+			 */
+
+			function parse$1 (string) {
+			  if (!string) {
+			    throw new TypeError('argument string is required')
+			  }
+
+			  // support req/res-like objects as argument
+			  var header = typeof string === 'object'
+			    ? getcontenttype(string)
+			    : string;
+
+			  if (typeof header !== 'string') {
+			    throw new TypeError('argument string is required to be a string')
+			  }
+
+			  var index = header.indexOf(';');
+			  var type = index !== -1
+			    ? header.substr(0, index).trim()
+			    : header.trim();
+
+			  if (!TYPE_REGEXP.test(type)) {
+			    throw new TypeError('invalid media type')
+			  }
+
+			  var obj = new ContentType(type.toLowerCase());
 
 			  // parse parameters
 			  if (index !== -1) {
@@ -2408,11 +3446,11 @@ System.register('JsonSchema', [], (function (exports) {
 			};
 
 			const parse = (response) => {
-			  const contentType = contentTypeParser.parse(response.headers.get("content-type")).type;
-			  if (!(contentType in mediaTypePlugins)) {
-			    throw Error(`${response.url} is not a schema. Found a document with media type: ${contentType}`);
+			  const contentType = contentTypeParser.parse(response.headers.get("content-type"));
+			  if (!(contentType.type in mediaTypePlugins)) {
+			    throw Error(`${response.url} is not a schema. Found a document with media type: ${contentType.type}`);
 			  }
-			  return mediaTypePlugins[contentType].parse(response);
+			  return mediaTypePlugins[contentType.type].parse(response, contentType.parameters);
 			};
 
 			const getContentType = (path) => {
@@ -2427,9 +3465,10 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var mediaTypes = { addPlugin, parse, getContentType };
 
-			const curry$1 = justCurryIt;
-			const Pact$a = lib$2;
-			const JsonPointer = lib$3;
+			const curry$8 = justCurryIt$2;
+			const Pact$a = lib$5;
+			const Json = lib$3;
+			const JsonPointer = lib$6;
 			const { jsonTypeOf, resolveUrl: resolveUrl$1, urlFragment, pathRelative } = common$1;
 			const fetch$1 = fetch_browser;
 			const Reference$1 = reference;
@@ -2444,6 +3483,8 @@ System.register('JsonSchema', [], (function (exports) {
 			const dialectJsonSchemaVersion = {};
 
 			const setConfig = (jsonSchemaVersion, key, value) => {
+			  dialectJsonSchemaVersion[jsonSchemaVersion] = jsonSchemaVersion;
+
 			  if (!config[jsonSchemaVersion]) {
 			    config[jsonSchemaVersion] = {};
 			  }
@@ -2458,62 +3499,61 @@ System.register('JsonSchema', [], (function (exports) {
 			// Schema Management
 			const schemaStore = {};
 			const schemaStoreAlias = {};
+			const add$1 = (schema, retrievalUri = "", defaultDialectId = "") => {
+			  const dialectId = getDialectId(schema, retrievalUri, defaultDialectId);
 
-			const add$1 = (schema, url = "", defaultSchemaVersion = "") => {
-			  schema = JSON.parse(JSON.stringify(schema));
-			  const externalId = resolveUrl$1(url, "");
+			  const id = getBaseUri(schema, retrievalUri, dialectJsonSchemaVersion[dialectId]);
 
-			  // Dialect / JSON Schema Version
-			  const dialectId = resolveUrl$1(schema["$schema"] || defaultSchemaVersion, "");
-			  if (!dialectId) {
-			    throw Error("Couldn't determine schema dialect");
-			  }
-			  delete schema["$schema"];
+			  // 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");
 
-			  // JSON Schema version
-			  if (!(dialectId in dialectJsonSchemaVersion)) {
-			    if (schema?.$vocabulary?.[core201909Id] === true && dialectId === getSchemaIdentifier(schema, externalId, core201909Id)[0]) {
-			      dialectJsonSchemaVersion[dialectId] = core201909Id;
-			    } else if (schema?.$vocabulary?.[core202012Id] === true && dialectId === getSchemaIdentifier(schema, externalId, core202012Id)[0]) {
-			      dialectJsonSchemaVersion[dialectId] = core202012Id;
-			    } else if (dialectId === getSchemaIdentifier(schema, externalId, dialectId)[0]) {
-			      dialectJsonSchemaVersion[dialectId] = dialectId;
-			    } else if (!(dialectId in schemaStore)) {
-			      throw Error(`Couldn't determine JSON Schema version for dialect: '${dialectId}'`);
-			    } else {
-			      const metaSchema = schemaStore[dialectId];
-			      if (metaSchema.vocabulary[core201909Id] === true) {
-			        dialectJsonSchemaVersion[dialectId] = core201909Id;
-			      } else if (metaSchema.vocabulary[core202012Id] === true) {
-			        dialectJsonSchemaVersion[dialectId] = core202012Id;
-			      } else {
-			        dialectJsonSchemaVersion[dialectId] = dialectJsonSchemaVersion[metaSchema.dialectId];
+			  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);
+			      }
+
+			      if (typeof value[anchorToken] === "string" && pointer !== JsonPointer.nil) {
+			        const anchor = anchorToken !== embeddedToken ? value[anchorToken] : value[anchorToken].slice(1);
+			        anchors[anchor] = pointer;
+			        delete value[anchorToken];
+			      }
+
+			      if (typeof value[dynamicAnchorToken] === "string") {
+			        dynamicAnchors[value[dynamicAnchorToken]] = `${id}#${pointer}`;
+			        anchors[value[dynamicAnchorToken]] = pointer;
+			        delete value[dynamicAnchorToken];
 			      }
 			    }
-			  }
 
-			  // 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;
-			  }
+			    return value;
+			  });
+			  console.log(embeddedIds);
 
-			  const anchorToken = getConfig(dialectId, "anchorToken");
-			  if (fragment && baseToken === anchorToken) {
-			    schema[anchorToken] = anchorToken !== baseToken ? encodeURI(fragment) : `#${encodeURI(fragment)}`;
-			  }
+			  delete schema.$schema;
+			  delete schema[baseToken];
 
 			  // recursiveAnchor
-			  const dynamicAnchors = {};
 			  const recursiveAnchorToken = getConfig(dialectId, "recursiveAnchorToken");
 			  if (schema[recursiveAnchorToken] === true) {
 			    dynamicAnchors[""] = `${id}#`;
-			    schema[anchorToken] = "";
 			    delete schema[recursiveAnchorToken];
 			  }
 
@@ -2528,69 +3568,66 @@ System.register('JsonSchema', [], (function (exports) {
 			  }
 
 			  // Store Schema
-			  const anchors = { "": "" };
 			  schemaStore[id] = {
-			    id: id,
-			    dialectId: dialectId,
-			    schema: processSchema(schema, id, dialectId, JsonPointer.nil, anchors, dynamicAnchors),
-			    anchors: anchors,
-			    dynamicAnchors: dynamicAnchors,
-			    vocabulary: vocabulary,
+			    id,
+			    dialectId,
+			    schema,
+			    anchors,
+			    dynamicAnchors,
+			    vocabulary,
 			    validated: false
 			  };
+			  if (id === "https://example.com/schema/root") {
+			    console.log(Object.keys(schemaStore).filter((id) => !/json-schema\.org/.test(id)));
+			  }
 
-			  return id;
+			  if (retrievalUri) {
+			    schemaStoreAlias[resolveUrl$1(retrievalUri, "")] = id;
+			  }
 			};
 
-			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);
-			    }
-
-			    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];
-			    }
-
-			    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 getDialectId = (schema, retrievalUri, defaultDialectId) => {
+			  const dialectId = resolveUrl$1(schema.$schema || defaultDialectId, "");
+			  if (!dialectId) {
+			    throw Error("Couldn't determine schema dialect");
+			  }
 
-			    const jrefToken = getConfig(dialectId, "jrefToken");
-			    if (typeof subject[jrefToken] === "string") {
-			      return Reference$1.cons(subject[jrefToken], 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];
+			      }
 			    }
+			  }
 
-			    for (const key in subject) {
-			      subject[key] = processSchema(subject[key], id, dialectId, JsonPointer.append(key, pointer), anchors, dynamicAnchors);
-			    }
+			  return dialectId;
+			};
 
-			    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 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");
 			  }
+
+			  return baseUri;
 			};
 
 			const hasStoredSchema = (id) => id in schemaStore || id in schemaStoreAlias;
@@ -2625,7 +3662,23 @@ System.register('JsonSchema', [], (function (exports) {
 			      throw Error(`Failed to retrieve schema with id: ${id}`);
 			    }
 
-			    add$1(await MediaTypes$1.parse(response), id);
+			    const [schema, defaultDialectId] = await MediaTypes$1.parse(response);
+
+			    let dialectId;
+			    if (schema.$schema) {
+			      dialectId = resolveUrl$1(schema.$schema, "");
+			    } else if (defaultDialectId) {
+			      dialectId = resolveUrl$1(id, defaultDialectId);
+			    } else {
+			      dialectId = "";
+			    }
+
+			    // Make sure the meta-schema is loaded if this isn't a known dialect
+			    if (dialectId && id !== dialectId && !(dialectId in dialectJsonSchemaVersion)) {
+			      await get(dialectId);
+			    }
+
+			    add$1(schema, id, dialectId);
 			  }
 
 			  const storedSchema = getStoredSchema(id);
@@ -2668,14 +3721,14 @@ System.register('JsonSchema', [], (function (exports) {
 
 			const keys = (doc) => Object.keys(value(doc));
 
-			const entries = (doc) => Pact$a.pipeline([
+			const entries$2 = (doc) => Pact$a.pipeline([
 			  value,
 			  Object.keys,
 			  Pact$a.map(async (key) => [key, await step(key, doc)]),
 			  Pact$a.all
 			], doc);
 
-			const map = curry$1((fn, doc) => Pact$a.pipeline([
+			const map$3 = curry$8((fn, doc) => Pact$a.pipeline([
 			  value,
 			  Pact$a.map(async (item, ndx) => fn(await step(ndx, doc), ndx)),
 			  Pact$a.all
@@ -2691,41 +3744,43 @@ System.register('JsonSchema', [], (function (exports) {
 			const toSchema = (schemaDoc, options = {}) => {
 			  const fullOptions = { ...toSchemaDefaultOptions, ...options };
 
-			  const schema = JSON.parse(JSON.stringify(schemaDoc.schema, (key, value) => {
-			    if (!Reference$1.isReference(value)) {
-			      return value;
+			  const anchorToken = getConfig(schemaDoc.dialectId, "anchorToken");
+			  const dynamicAnchorToken = getConfig(schemaDoc.dialectId, "dynamicAnchorToken");
+
+			  const anchors = {};
+			  for (const anchor in schemaDoc.anchors) {
+			    if (anchor !== "" && !schemaDoc.dynamicAnchors[anchor]) {
+			      anchors[schemaDoc.anchors[anchor]] = anchor;
 			    }
+			  }
+
+			  const dynamicAnchors = {};
+			  for (const anchor in schemaDoc.dynamicAnchors) {
+			    const pointer = urlFragment(schemaDoc.dynamicAnchors[anchor]);
+			    dynamicAnchors[pointer] = anchor;
+			  }
 
-			    const refValue = Reference$1.value(value);
-			    const embeddedDialect = typeof refValue.$schema === "string" ? resolveUrl$1(refValue.$schema, "") : schemaDoc.dialectId;
-			    const embeddedToken = getConfig(embeddedDialect, "embeddedToken");
-			    if (!fullOptions.includeEmbedded && embeddedToken in refValue) {
-			      return;
+			  const schema = JSON.parse(Json.stringify(schemaDoc.schema, (key, value, pointer) => {
+			    if (Reference$1.isReference(value)) {
+			      const refValue = Reference$1.value(value);
+			      const embeddedDialect = typeof refValue.$schema === "string" ? resolveUrl$1(refValue.$schema, "") : schemaDoc.dialectId;
+			      const embeddedToken = getConfig(embeddedDialect, "embeddedToken");
+			      if (!fullOptions.includeEmbedded && embeddedToken in refValue) {
+			        return;
+			      } else {
+			        return Reference$1.value(value);
+			      }
 			    } else {
-			      return Reference$1.value(value);
+			      if (pointer in anchors) {
+			        value = { [anchorToken]: anchors[pointer], ...value };
+			      }
+			      if (pointer in dynamicAnchors) {
+			        value = { [dynamicAnchorToken]: dynamicAnchors[pointer], ...value };
+			      }
+			      return value;
 			    }
 			  }));
 
-			  const dynamicAnchorToken = getConfig(schemaDoc.dialectId, "dynamicAnchorToken");
-			  Object.entries(schemaDoc.dynamicAnchors)
-			    .forEach(([anchor, uri]) => {
-			      const pointer = urlFragment(uri);
-			      JsonPointer.assign(pointer, schema, {
-			        [dynamicAnchorToken]: anchor,
-			        ...JsonPointer.get(pointer, schema)
-			      });
-			    });
-
-			  const anchorToken = getConfig(schemaDoc.dialectId, "anchorToken");
-			  Object.entries(schemaDoc.anchors)
-			    .filter(([anchor]) => anchor !== "")
-			    .forEach(([anchor, pointer]) => {
-			      JsonPointer.assign(pointer, schema, {
-			        [anchorToken]: anchor,
-			        ...JsonPointer.get(pointer, schema)
-			      });
-			    });
-
 			  const baseToken = getConfig(schemaDoc.dialectId, "baseToken");
 			  const id = relativeUri(fullOptions.parentId, schemaDoc.id);
 			  const dialect = fullOptions.parentDialect === schemaDoc.dialectId ? "" : schemaDoc.dialectId;
@@ -2748,7 +3803,7 @@ System.register('JsonSchema', [], (function (exports) {
 			var schema$5 = {
 			  setConfig, getConfig,
 			  add: add$1, get, markValidated,
-			  uri, value, getAnchorPointer, typeOf, has, step, keys, entries, map, length,
+			  uri, value, getAnchorPointer, typeOf, has, step, keys, entries: entries$2, map: map$3, length,
 			  toSchema
 			};
 
@@ -2762,13 +3817,22 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var invalidSchemaError = InvalidSchemaError$3;
 
-			const curry = justCurryIt;
+			const Schema$R = schema$5;
+
+
+			const compile$O = (schema) => Schema$R.value(schema);
+			const interpret$O = () => true;
+
+			var metaData$4 = { compile: compile$O, interpret: interpret$O };
+
+			const curry$7 = justCurryIt$2;
 			const PubSub$1 = pubsub.exports;
 			const { resolveUrl } = common$1;
 			const Instance$E = instance;
-			const Schema$R = schema$5;
+			const Schema$Q = schema$5;
 			const InvalidSchemaError$2 = invalidSchemaError;
 			const MediaTypes = mediaTypes;
+			const metaData$3 = metaData$4;
 
 
 			const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED", VERBOSE = "VERBOSE";
@@ -2777,24 +3841,27 @@ System.register('JsonSchema', [], (function (exports) {
 			let shouldMetaValidate = true;
 
 			MediaTypes.addPlugin("application/schema+json", {
-			  parse: async (response) => await response.json(),
+			  parse: async (response, contentTypeParameters) => [
+			    await response.json(),
+			    contentTypeParameters.schema || contentTypeParameters.profile
+			  ],
 			  matcher: (path) => path.endsWith(".schema.json")
 			});
 
 			const validate$2 = async (schema, value = undefined, outputFormat = undefined) => {
-			  const compiled = await compile$O(schema);
-			  const interpretAst = (value, outputFormat) => interpret$O(compiled, Instance$E.cons(value), outputFormat);
+			  const compiled = await compile$N(schema);
+			  const interpretAst = (value, outputFormat) => interpret$N(compiled, Instance$E.cons(value), outputFormat);
 
 			  return value === undefined ? interpretAst : interpretAst(value, outputFormat);
 			};
 
-			const compile$O = async (schema) => {
+			const compile$N = async (schema) => {
 			  const ast = { metaData: {} };
 			  const schemaUri = await compileSchema(schema, ast);
 			  return { ast, schemaUri };
 			};
 
-			const interpret$O = curry(({ ast, schemaUri }, value, outputFormat = FLAG) => {
+			const interpret$N = curry$7(({ ast, schemaUri }, value, outputFormat = FLAG) => {
 			  if (![FLAG, BASIC, DETAILED, VERBOSE].includes(outputFormat)) {
 			    throw Error(`The '${outputFormat}' error format is not supported`);
 			  }
@@ -2848,7 +3915,7 @@ System.register('JsonSchema', [], (function (exports) {
 			};
 
 			const _keywords = {};
-			const getKeyword = (id) => _keywords[id];
+			const getKeyword = (id) => _keywords[id] || metaData$3;
 			const hasKeyword = (id) => id in _keywords;
 			const addKeyword = (id, keywordHandler) => {
 			  _keywords[id] = {
@@ -2869,10 +3936,10 @@ System.register('JsonSchema', [], (function (exports) {
 
 			  // Vocabularies
 			  if (!hasKeyword(`${schema.dialectId}#validate`)) {
-			    const metaSchema = await Schema$R.get(schema.dialectId);
+			    const metaSchema = await Schema$Q.get(schema.dialectId);
 
 			    // Check for mandatory vocabularies
-			    const mandatoryVocabularies = Schema$R.getConfig(metaSchema.id, "mandatoryVocabularies") || [];
+			    const mandatoryVocabularies = Schema$Q.getConfig(metaSchema.id, "mandatoryVocabularies") || [];
 			    mandatoryVocabularies.forEach((vocabularyId) => {
 			      if (!metaSchema.vocabulary[vocabularyId]) {
 			        throw Error(`Vocabulary '${vocabularyId}' must be explicitly declared and required`);
@@ -2895,13 +3962,13 @@ System.register('JsonSchema', [], (function (exports) {
 
 			  // Meta validation
 			  if (shouldMetaValidate && !schema.validated) {
-			    Schema$R.markValidated(schema.id);
+			    Schema$Q.markValidated(schema.id);
 
 			    // Compile
 			    if (!(schema.dialectId in metaValidators)) {
-			      const metaSchema = await Schema$R.get(schema.dialectId);
-			      const compiledSchema = await compile$O(metaSchema);
-			      metaValidators[metaSchema.id] = interpret$O(compiledSchema);
+			      const metaSchema = await Schema$Q.get(schema.dialectId);
+			      const compiledSchema = await compile$N(metaSchema);
+			      metaValidators[metaSchema.id] = interpret$N(compiledSchema);
 			    }
 
 			    // Interpret
@@ -2924,7 +3991,7 @@ System.register('JsonSchema', [], (function (exports) {
 			};
 
 			const followReferences = async (doc) => {
-			  return Schema$R.typeOf(doc, "string") ? followReferences(await Schema$R.get(Schema$R.value(doc), doc)) : doc;
+			  return Schema$Q.typeOf(doc, "string") ? followReferences(await Schema$Q.get(Schema$Q.value(doc), doc)) : doc;
 			};
 
 			const interpretSchema = (schemaUri, instance, ast, dynamicAnchors) => {
@@ -2952,27 +4019,19 @@ System.register('JsonSchema', [], (function (exports) {
 			};
 
 			const add = (schema, url = "", defaultSchemaVersion = "") => {
-			  const id = Schema$R.add(schema, url, defaultSchemaVersion);
+			  const id = Schema$Q.add(schema, url, defaultSchemaVersion);
 			  delete metaValidators[id];
 			};
 
 			var core$2 = {
-			  validate: validate$2, compile: compile$O, interpret: interpret$O,
+			  validate: validate$2, compile: compile$N, interpret: interpret$N,
 			  setMetaOutputFormat, setShouldMetaValidate, FLAG, BASIC, DETAILED, VERBOSE,
 			  add, getKeyword, hasKeyword, defineVocabulary,
 			  compileSchema, interpretSchema, collectEvaluatedProperties: collectEvaluatedProperties$e, collectEvaluatedItems: collectEvaluatedItems$f,
 			  addMediaTypePlugin: MediaTypes.addPlugin
 			};
 
-			const Schema$Q = schema$5;
-
-
-			const compile$N = (schema) => Schema$Q.value(schema);
-			const interpret$N = () => true;
-
-			var metaData$3 = { compile: compile$N, interpret: interpret$N };
-
-			const Pact$9 = lib$2;
+			const Pact$9 = lib$5;
 			const PubSub = pubsub.exports;
 			const Core$x = core$2;
 			const Instance$D = instance;
@@ -2995,7 +4054,7 @@ System.register('JsonSchema', [], (function (exports) {
 			      typeof schemaValue === "boolean" ? schemaValue : await Pact$9.pipeline([
 			        Schema$P.entries,
 			        Pact$9.map(([keyword, keywordSchema]) => [`${schema.dialectId}#${keyword}`, keywordSchema]),
-			        Pact$9.filter(([keywordId]) => Core$x.hasKeyword(keywordId) && keywordId !== `${schema.dialectId}#validate`),
+			        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];
@@ -3071,7 +4130,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var validate$1 = { compile: compile$M, interpret: interpret$M, collectEvaluatedProperties: collectEvaluatedProperties$d, collectEvaluatedItems: collectEvaluatedItems$e };
 
-			const metaData$2 = metaData$3;
+			const metaData$2 = metaData$4;
 			const validate = validate$1;
 
 
@@ -3085,9 +4144,9 @@ System.register('JsonSchema', [], (function (exports) {
 			const InvalidSchemaError$1 = invalidSchemaError;
 
 
-			var lib$1 = { Core: Core$w, Schema: Schema$O, Instance: Instance$C, Reference, Keywords: Keywords$2, InvalidSchemaError: InvalidSchemaError$1 };
+			var lib$2 = { Core: Core$w, Schema: Schema$O, Instance: Instance$C, Reference, Keywords: Keywords$2, InvalidSchemaError: InvalidSchemaError$1 };
 
-			const { Core: Core$v, Schema: Schema$N, Instance: Instance$B } = lib$1;
+			const { Core: Core$v, Schema: Schema$N, Instance: Instance$B } = lib$2;
 
 
 			const compile$L = async (schema, ast, parentSchema) => {
@@ -3115,7 +4174,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var additionalItems = { compile: compile$L, interpret: interpret$L };
 
-			const { Core: Core$u, Schema: Schema$M, Instance: Instance$A } = lib$1;
+			const { Core: Core$u, Schema: Schema$M, Instance: Instance$A } = lib$2;
 
 
 			const compile$K = async (schema, ast, parentSchema) => {
@@ -3139,7 +4198,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var additionalItems6 = { compile: compile$K, interpret: interpret$K, collectEvaluatedItems: collectEvaluatedItems$d };
 
-			const { Core: Core$t, Schema: Schema$L, Instance: Instance$z } = lib$1;
+			const { Core: Core$t, Schema: Schema$L, Instance: Instance$z } = lib$2;
 
 
 			const compile$J = async (schema, ast, parentSchema) => {
@@ -3173,7 +4232,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var additionalProperties = { compile: compile$J, interpret: interpret$J };
 
-			const { Core: Core$s, Schema: Schema$K, Instance: Instance$y } = lib$1;
+			const { Core: Core$s, Schema: Schema$K, Instance: Instance$y } = lib$2;
 
 
 			const compile$I = async (schema, ast, parentSchema) => {
@@ -3202,8 +4261,129 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var additionalProperties6 = { compile: compile$I, interpret: interpret$I, collectEvaluatedProperties: collectEvaluatedProperties$c };
 
-			const { Core: Core$r, Schema: Schema$J } = lib$1;
-			const Pact$8 = lib$2;
+			var entries$1 = async (doc) => Object.entries(await doc);
+
+			var justCurryIt = curry$6;
+
+			/*
+			  function add(a, b, c) {
+			    return a + b + c;
+			  }
+			  curry(add)(1)(2)(3); // 6
+			  curry(add)(1)(2)(2); // 5
+			  curry(add)(2)(4, 3); // 9
+
+			  function add(...args) {
+			    return args.reduce((sum, n) => sum + n, 0)
+			  }
+			  var curryAdd4 = curry(add, 4)
+			  curryAdd4(1)(2, 3)(4); // 10
+
+			  function converter(ratio, input) {
+			    return (input*ratio).toFixed(1);
+			  }
+			  const curriedConverter = curry(converter)
+			  const milesToKm = curriedConverter(1.62);
+			  milesToKm(35); // 56.7
+			  milesToKm(10); // 16.2
+			*/
+
+			function curry$6(fn, arity) {
+			  return function curried() {
+			    if (arity == null) {
+			      arity = fn.length;
+			    }
+			    var args = [].slice.call(arguments);
+			    if (args.length >= arity) {
+			      return fn.apply(this, args);
+			    } else {
+			      return function() {
+			        return curried.apply(this, args.concat([].slice.call(arguments)));
+			      };
+			    }
+			  };
+			}
+
+			const curry$5 = justCurryIt;
+
+
+			var map$2 = curry$5(async (fn, doc) => (await doc).map(fn));
+
+			const curry$4 = justCurryIt;
+
+
+			var reduce$2 = curry$4(async (fn, acc, doc) => {
+			  return (await doc).reduce(async (acc, item) => fn(await acc, item), acc);
+			});
+
+			const curry$3 = justCurryIt;
+			const reduce$1 = reduce$2;
+
+
+			var filter = curry$3(async (fn, doc, options = {}) => {
+			  return reduce$1(async (acc, item) => {
+			    return (await fn(item)) ? acc.concat([item]) : acc;
+			  }, [], doc, options);
+			});
+
+			const curry$2 = justCurryIt;
+			const map$1 = map$2;
+
+
+			var some = curry$2(async (fn, doc) => {
+			  const results = await map$1(fn, doc);
+			  return (await Promise.all(results))
+			    .some((a) => a);
+			});
+
+			const curry$1 = justCurryIt;
+			const map = map$2;
+
+
+			var every = curry$1(async (fn, doc) => {
+			  const results = await map(fn, doc);
+			  return (await Promise.all(results))
+			    .every((a) => a);
+			});
+
+			const curry = justCurryIt;
+
+
+			var pipeline$1 = curry((fns, doc) => {
+			  return fns.reduce(async (acc, fn) => fn(await acc), doc);
+			});
+
+			var all = (doc) => Promise.all(doc);
+
+			const pipeline = pipeline$1;
+			const entries = entries$1;
+			const reduce = reduce$2;
+
+
+			var allValues = (doc) => {
+			  return pipeline([
+			    entries,
+			    reduce(async (acc, [propertyName, propertyValue]) => {
+			      acc[propertyName] = await propertyValue;
+			      return acc;
+			    }, {})
+			  ], doc);
+			};
+
+			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([
@@ -3231,8 +4411,8 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var allOf = { compile: compile$H, interpret: interpret$H, collectEvaluatedProperties: collectEvaluatedProperties$b, collectEvaluatedItems: collectEvaluatedItems$c };
 
-			const { Core: Core$q, Schema: Schema$I } = lib$1;
-			const Pact$7 = lib$2;
+			const { Core: Core$q, Schema: Schema$I } = lib$2;
+			const Pact$7 = lib$1;
 
 
 			const compile$G = (schema, ast) => Pact$7.pipeline([
@@ -3320,7 +4500,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var fastestStableStringify = function(obj) { return '' + stringify(obj, false); };
 
-			const { Schema: Schema$H, Instance: Instance$x } = lib$1;
+			const { Schema: Schema$H, Instance: Instance$x } = lib$2;
 			const jsonStringify$2 = fastestStableStringify;
 
 
@@ -3329,7 +4509,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var _const = { compile: compile$F, interpret: interpret$F };
 
-			const { Core: Core$p, Instance: Instance$w } = lib$1;
+			const { Core: Core$p, Instance: Instance$w } = lib$2;
 
 
 			const compile$E = (schema, ast) => Core$p.compileSchema(schema, ast);
@@ -3340,7 +4520,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var contains = { compile: compile$E, interpret: interpret$E };
 
-			const { Core: Core$o, Schema: Schema$G, Instance: Instance$v } = lib$1;
+			const { Core: Core$o, Schema: Schema$G, Instance: Instance$v } = lib$2;
 
 
 			const compile$D = async (schema, ast, parentSchema) => {
@@ -3374,8 +4554,8 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var containsMinContainsMaxContains = { compile: compile$D, interpret: interpret$D, collectEvaluatedItems: collectEvaluatedItems$a };
 
-			const { Core: Core$n, Schema: Schema$F } = lib$1;
-			const Pact$6 = lib$2;
+			const { Core: Core$n, Schema: Schema$F } = lib$2;
+			const Pact$6 = lib$1;
 
 
 			const compile$C = async (schema, ast) => {
@@ -3390,8 +4570,8 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var definitions = { compile: compile$C, interpret: interpret$C };
 
-			const { Core: Core$m, Schema: Schema$E, Instance: Instance$u } = lib$1;
-			const Pact$5 = lib$2;
+			const { Core: Core$m, Schema: Schema$E, Instance: Instance$u } = lib$2;
+			const Pact$5 = lib$1;
 
 
 			const compile$B = (schema, ast) => Pact$5.pipeline([
@@ -3420,8 +4600,8 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var dependencies = { compile: compile$B, interpret: interpret$B };
 
-			const { Schema: Schema$D, Instance: Instance$t } = lib$1;
-			const Pact$4 = lib$2;
+			const { Schema: Schema$D, Instance: Instance$t } = lib$2;
+			const Pact$4 = lib$1;
 
 
 			const compile$A = (schema) => Pact$4.pipeline([
@@ -3440,8 +4620,8 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var dependentRequired = { compile: compile$A, interpret: interpret$A };
 
-			const { Core: Core$l, Schema: Schema$C, Instance: Instance$s } = lib$1;
-			const Pact$3 = lib$2;
+			const { Core: Core$l, Schema: Schema$C, Instance: Instance$s } = lib$2;
+			const Pact$3 = lib$1;
 
 
 			const compile$z = (schema, ast) => Pact$3.pipeline([
@@ -3471,7 +4651,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var dependentSchemas = { compile: compile$z, interpret: interpret$z, collectEvaluatedProperties: collectEvaluatedProperties$9 };
 
-			const { Schema: Schema$B, Instance: Instance$r } = lib$1;
+			const { Schema: Schema$B, Instance: Instance$r } = lib$2;
 			const jsonStringify$1 = fastestStableStringify;
 
 
@@ -3480,7 +4660,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var _enum = { compile: compile$y, interpret: interpret$y };
 
-			const { Schema: Schema$A, Instance: Instance$q } = lib$1;
+			const { Schema: Schema$A, Instance: Instance$q } = lib$2;
 
 
 			const compile$x = async (schema) => Schema$A.value(schema);
@@ -3488,7 +4668,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var exclusiveMaximum = { compile: compile$x, interpret: interpret$x };
 
-			const { Schema: Schema$z, Instance: Instance$p } = lib$1;
+			const { Schema: Schema$z, Instance: Instance$p } = lib$2;
 
 
 			const compile$w = async (schema) => Schema$z.value(schema);
@@ -3496,7 +4676,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var exclusiveMinimum = { compile: compile$w, interpret: interpret$w };
 
-			const { Core: Core$k } = lib$1;
+			const { Core: Core$k } = lib$2;
 
 
 			const compile$v = (schema, ast) => Core$k.compileSchema(schema, ast);
@@ -3516,7 +4696,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var _if = { compile: compile$v, interpret: interpret$v, collectEvaluatedProperties: collectEvaluatedProperties$8, collectEvaluatedItems: collectEvaluatedItems$9 };
 
-			const { Core: Core$j, Schema: Schema$y } = lib$1;
+			const { Core: Core$j, Schema: Schema$y } = lib$2;
 
 
 			const compile$u = async (schema, ast, parentSchema) => {
@@ -3560,7 +4740,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var then = { compile: compile$u, interpret: interpret$u, collectEvaluatedProperties: collectEvaluatedProperties$7, collectEvaluatedItems: collectEvaluatedItems$8 };
 
-			const { Core: Core$i, Schema: Schema$x } = lib$1;
+			const { Core: Core$i, Schema: Schema$x } = lib$2;
 
 
 			const compile$t = async (schema, ast, parentSchema) => {
@@ -3604,7 +4784,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var _else = { compile: compile$t, interpret: interpret$t, collectEvaluatedProperties: collectEvaluatedProperties$6, collectEvaluatedItems: collectEvaluatedItems$7 };
 
-			const { Core: Core$h, Schema: Schema$w, Instance: Instance$o } = lib$1;
+			const { Core: Core$h, Schema: Schema$w, Instance: Instance$o } = lib$2;
 
 
 			const compile$s = async (schema, ast) => {
@@ -3636,7 +4816,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var items = { compile: compile$s, interpret: interpret$s, collectEvaluatedItems: collectEvaluatedItems$6 };
 
-			const { Core: Core$g, Schema: Schema$v, Instance: Instance$n } = lib$1;
+			const { Core: Core$g, Schema: Schema$v, Instance: Instance$n } = lib$2;
 
 
 			const compile$r = async (schema, ast, parentSchema) => {
@@ -3660,7 +4840,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var items202012 = { compile: compile$r, interpret: interpret$r, collectEvaluatedItems: collectEvaluatedItems$5 };
 
-			const { Schema: Schema$u, Instance: Instance$m } = lib$1;
+			const { Schema: Schema$u, Instance: Instance$m } = lib$2;
 
 
 			const compile$q = (schema) => Schema$u.value(schema);
@@ -3668,7 +4848,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var maxItems = { compile: compile$q, interpret: interpret$q };
 
-			const { Schema: Schema$t, Instance: Instance$l } = lib$1;
+			const { Schema: Schema$t, Instance: Instance$l } = lib$2;
 
 
 			const compile$p = (schema) => Schema$t.value(schema);
@@ -3676,7 +4856,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var maxLength = { compile: compile$p, interpret: interpret$p };
 
-			const { Schema: Schema$s, Instance: Instance$k } = lib$1;
+			const { Schema: Schema$s, Instance: Instance$k } = lib$2;
 
 
 			const compile$o = (schema) => Schema$s.value(schema);
@@ -3684,7 +4864,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var maxLength6 = { compile: compile$o, interpret: interpret$o };
 
-			const { Schema: Schema$r, Instance: Instance$j } = lib$1;
+			const { Schema: Schema$r, Instance: Instance$j } = lib$2;
 
 
 			const compile$n = (schema) => Schema$r.value(schema);
@@ -3692,7 +4872,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var maxProperties = { compile: compile$n, interpret: interpret$n };
 
-			const { Schema: Schema$q, Instance: Instance$i } = lib$1;
+			const { Schema: Schema$q, Instance: Instance$i } = lib$2;
 
 
 			const compile$m = async (schema, ast, parentSchema) => {
@@ -3713,7 +4893,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var maximumExclusiveMaximum = { compile: compile$m, interpret: interpret$m };
 
-			const { Schema: Schema$p, Instance: Instance$h } = lib$1;
+			const { Schema: Schema$p, Instance: Instance$h } = lib$2;
 
 
 			const compile$l = async (schema) => Schema$p.value(schema);
@@ -3721,7 +4901,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var maximum = { compile: compile$l, interpret: interpret$l };
 
-			const { Schema: Schema$o, Instance: Instance$g } = lib$1;
+			const { Schema: Schema$o, Instance: Instance$g } = lib$2;
 
 
 			const compile$k = (schema) => Schema$o.value(schema);
@@ -3729,7 +4909,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var minItems = { compile: compile$k, interpret: interpret$k };
 
-			const { Schema: Schema$n, Instance: Instance$f } = lib$1;
+			const { Schema: Schema$n, Instance: Instance$f } = lib$2;
 
 
 			const compile$j = (schema) => Schema$n.value(schema);
@@ -3737,7 +4917,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var minLength = { compile: compile$j, interpret: interpret$j };
 
-			const { Schema: Schema$m, Instance: Instance$e } = lib$1;
+			const { Schema: Schema$m, Instance: Instance$e } = lib$2;
 
 
 			const compile$i = (schema) => Schema$m.value(schema);
@@ -3745,7 +4925,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var minLength6 = { compile: compile$i, interpret: interpret$i };
 
-			const { Schema: Schema$l, Instance: Instance$d } = lib$1;
+			const { Schema: Schema$l, Instance: Instance$d } = lib$2;
 
 
 			const compile$h = (schema) => Schema$l.value(schema);
@@ -3753,7 +4933,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var minProperties = { compile: compile$h, interpret: interpret$h };
 
-			const { Schema: Schema$k, Instance: Instance$c } = lib$1;
+			const { Schema: Schema$k, Instance: Instance$c } = lib$2;
 
 
 			const compile$g = async (schema, ast, parentSchema) => {
@@ -3774,7 +4954,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var minimumExclusiveMinimum = { compile: compile$g, interpret: interpret$g };
 
-			const { Schema: Schema$j, Instance: Instance$b } = lib$1;
+			const { Schema: Schema$j, Instance: Instance$b } = lib$2;
 
 
 			const compile$f = async (schema) => Schema$j.value(schema);
@@ -3782,7 +4962,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var minimum = { compile: compile$f, interpret: interpret$f };
 
-			const { Schema: Schema$i, Instance: Instance$a } = lib$1;
+			const { Schema: Schema$i, Instance: Instance$a } = lib$2;
 
 
 			const compile$e = (schema) => Schema$i.value(schema);
@@ -3800,7 +4980,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var multipleOf = { compile: compile$e, interpret: interpret$e };
 
-			const { Core: Core$f } = lib$1;
+			const { Core: Core$f } = lib$2;
 
 
 			const compile$d = Core$f.compileSchema;
@@ -3808,7 +4988,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var not = { compile: compile$d, interpret: interpret$d };
 
-			const { Core: Core$e, Schema: Schema$h } = lib$1;
+			const { Core: Core$e, Schema: Schema$h } = lib$2;
 
 
 			const compile$c = async (schema, ast) => {
@@ -3857,7 +5037,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$1;
+			const { Schema: Schema$g, Instance: Instance$9 } = lib$2;
 
 
 			const compile$b = (schema) => new RegExp(Schema$g.value(schema), "u");
@@ -3865,8 +5045,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$1;
-			const Pact$2 = lib$2;
+			const { Core: Core$d, Schema: Schema$f, Instance: Instance$8 } = lib$2;
+			const Pact$2 = lib$1;
 
 
 			const compile$a = (schema, ast) => Pact$2.pipeline([
@@ -3903,8 +5083,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$1;
-			const Pact$1 = lib$2;
+			const { Core: Core$c, Schema: Schema$e, Instance: Instance$7 } = lib$2;
+			const Pact$1 = lib$1;
 			const { escapeRegExp } = common;
 
 
@@ -3929,7 +5109,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$1;
+			const { Core: Core$b, Instance: Instance$6 } = lib$2;
 
 
 			const compile$8 = (schema, ast) => Core$b.compileSchema(schema, ast);
@@ -3941,7 +5121,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var propertyNames = { compile: compile$8, interpret: interpret$8 };
 
-			const { Core: Core$a, Schema: Schema$d } = lib$1;
+			const { Core: Core$a, Schema: Schema$d } = lib$2;
 			const { splitUrl } = common;
 
 
@@ -3966,7 +5146,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$1;
+			const { Core: Core$9, Schema: Schema$c } = lib$2;
 
 
 			const compile$6 = async (ref, ast) => {
@@ -3980,7 +5160,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$1;
+			const { Schema: Schema$b, Instance: Instance$5 } = lib$2;
 
 
 			const compile$5 = (schema) => Schema$b.value(schema);
@@ -3991,8 +5171,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$1;
-			const Pact = lib$2;
+			const { Core: Core$8, Schema: Schema$a, Instance: Instance$4 } = lib$2;
+			const Pact = lib$1;
 
 
 			const compile$4 = (schema, ast) => {
@@ -4016,7 +5196,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$1;
+			const { Schema: Schema$9, Instance: Instance$3 } = lib$2;
 
 
 			const compile$3 = (schema) => Schema$9.value(schema);
@@ -4024,7 +5204,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$1;
+			const { Core: Core$7, Schema: Schema$8, Instance: Instance$2 } = lib$2;
 
 
 			const compile$2 = async (schema, ast, parentSchema) => {
@@ -4048,7 +5228,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$1;
+			const { Core: Core$6, Schema: Schema$7, Instance: Instance$1 } = lib$2;
 
 
 			const compile$1 = async (schema, ast, parentSchema) => {
@@ -4073,7 +5253,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var unevaluatedProperties = { compile: compile$1, interpret: interpret$1, collectEvaluatedProperties };
 
-			const { Schema: Schema$6, Instance } = lib$1;
+			const { Schema: Schema$6, Instance } = lib$2;
 			const jsonStringify = fastestStableStringify;
 
 
@@ -4090,7 +5270,7 @@ System.register('JsonSchema', [], (function (exports) {
 
 			var uniqueItems = { compile, interpret };
 
-			const { Keywords: Keywords$1 } = lib$1;
+			const { Keywords: Keywords$1 } = lib$2;
 
 
 			var keywords$5 = {
@@ -4296,7 +5476,7 @@ System.register('JsonSchema', [], (function (exports) {
     "default": {}
 }`;
 
-			const { Core: Core$5, Schema: Schema$5 } = lib$1;
+			const { Core: Core$5, Schema: Schema$5 } = lib$2;
 			const keywords$4 = keywords$5;
 			const metaSchema$4 = schema$4;
 
@@ -4498,7 +5678,7 @@ System.register('JsonSchema', [], (function (exports) {
     "default": {}
 }`;
 
-			const { Core: Core$4, Schema: Schema$4 } = lib$1;
+			const { Core: Core$4, Schema: Schema$4 } = lib$2;
 			const keywords$3 = keywords$5;
 			const metaSchema$3 = schema$3;
 
@@ -4723,7 +5903,7 @@ System.register('JsonSchema', [], (function (exports) {
     "default": true
 }`;
 
-			const { Core: Core$3, Schema: Schema$3 } = lib$1;
+			const { Core: Core$3, Schema: Schema$3 } = lib$2;
 			const keywords$2 = keywords$5;
 			const metaSchema$2 = schema$2;
 
@@ -5106,7 +6286,7 @@ System.register('JsonSchema', [], (function (exports) {
     }
 }`;
 
-			const { Core: Core$2, Schema: Schema$2 } = lib$1;
+			const { Core: Core$2, Schema: Schema$2 } = lib$2;
 			const keywords$1 = keywords$5;
 			const metaSchema$1 = schema$1;
 			const coreMetaSchema$1 = core$1;
@@ -5553,7 +6733,7 @@ System.register('JsonSchema', [], (function (exports) {
     }
 }`;
 
-			const { Core: Core$1, Schema: Schema$1 } = lib$1;
+			const { Core: Core$1, Schema: Schema$1 } = lib$2;
 			const keywords = keywords$5;
 			const metaSchema = schema;
 			const coreMetaSchema = core;
@@ -5657,7 +6837,7 @@ System.register('JsonSchema', [], (function (exports) {
 			  "unevaluatedProperties": keywords.unevaluatedProperties
 			});
 
-			const { Core, Schema, InvalidSchemaError } = lib$1;
+			const { Core, Schema, InvalidSchemaError } = lib$2;
 			const Keywords = keywords$5;