@hyperjump/json-schema 0.18.0

package/dist/json-schema-system.js

@@ -0,0 +1,4698 @@
+System.register('JsonSchema', [], function (exports) {
+  'use strict';
+  return {
+    execute: function () {
+
+      var justCurryIt = curry;
+
+      /*
+        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(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)));
+            };
+          }
+        };
+      }
+
+      var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+      function createCommonjsModule(fn, module) {
+      	return module = { exports: {} }, fn(module, module.exports), module.exports;
+      }
+
+      var pubsub = createCommonjsModule(function (module, exports) {
+      /**
+       * Copyright (c) 2010,2011,2012,2013,2014 Morgan Roderick http://roderick.dk
+       * License: MIT - http://mrgnrdrck.mit-license.org
+       *
+       * https://github.com/mroderick/PubSubJS
+       */
+
+      (function (root, factory){
+
+          var PubSub = {};
+          root.PubSub = PubSub;
+          factory(PubSub);
+          // CommonJS and Node.js module support
+          {
+              if (module !== undefined && module.exports) {
+                  exports = module.exports = PubSub; // Node.js specific `module.exports`
+              }
+              exports.PubSub = PubSub; // CommonJS module 1.1.1 spec
+              module.exports = exports = PubSub; // CommonJS
+          }
+
+      }(( typeof window === 'object' && window ) || commonjsGlobal, function (PubSub){
+
+          var messages = {},
+              lastUid = -1,
+              ALL_SUBSCRIBING_MSG = '*';
+
+          function hasKeys(obj){
+              var key;
+
+              for (key in obj){
+                  if ( Object.prototype.hasOwnProperty.call(obj, key) ){
+                      return true;
+                  }
+              }
+              return false;
+          }
+
+          /**
+           * Returns a function that throws the passed exception, for use as argument for setTimeout
+           * @alias throwException
+           * @function
+           * @param { Object } ex An Error object
+           */
+          function throwException( ex ){
+              return function reThrowException(){
+                  throw ex;
+              };
+          }
+
+          function callSubscriberWithDelayedExceptions( subscriber, message, data ){
+              try {
+                  subscriber( message, data );
+              } catch( ex ){
+                  setTimeout( throwException( ex ), 0);
+              }
+          }
+
+          function callSubscriberWithImmediateExceptions( subscriber, message, data ){
+              subscriber( message, data );
+          }
+
+          function deliverMessage( originalMessage, matchedMessage, data, immediateExceptions ){
+              var subscribers = messages[matchedMessage],
+                  callSubscriber = immediateExceptions ? callSubscriberWithImmediateExceptions : callSubscriberWithDelayedExceptions,
+                  s;
+
+              if ( !Object.prototype.hasOwnProperty.call( messages, matchedMessage ) ) {
+                  return;
+              }
+
+              for (s in subscribers){
+                  if ( Object.prototype.hasOwnProperty.call(subscribers, s)){
+                      callSubscriber( subscribers[s], originalMessage, data );
+                  }
+              }
+          }
+
+          function createDeliveryFunction( message, data, immediateExceptions ){
+              return function deliverNamespaced(){
+                  var topic = String( message ),
+                      position = topic.lastIndexOf( '.' );
+
+                  // deliver the message as it is now
+                  deliverMessage(message, message, data, immediateExceptions);
+
+                  // trim the hierarchy and deliver message to each level
+                  while( position !== -1 ){
+                      topic = topic.substr( 0, position );
+                      position = topic.lastIndexOf('.');
+                      deliverMessage( message, topic, data, immediateExceptions );
+                  }
+
+                  deliverMessage(message, ALL_SUBSCRIBING_MSG, data, immediateExceptions);
+              };
+          }
+
+          function hasDirectSubscribersFor( message ) {
+              var topic = String( message ),
+                  found = Boolean(Object.prototype.hasOwnProperty.call( messages, topic ) && hasKeys(messages[topic]));
+
+              return found;
+          }
+
+          function messageHasSubscribers( message ){
+              var topic = String( message ),
+                  found = hasDirectSubscribersFor(topic) || hasDirectSubscribersFor(ALL_SUBSCRIBING_MSG),
+                  position = topic.lastIndexOf( '.' );
+
+              while ( !found && position !== -1 ){
+                  topic = topic.substr( 0, position );
+                  position = topic.lastIndexOf( '.' );
+                  found = hasDirectSubscribersFor(topic);
+              }
+
+              return found;
+          }
+
+          function publish( message, data, sync, immediateExceptions ){
+              message = (typeof message === 'symbol') ? message.toString() : message;
+
+              var deliver = createDeliveryFunction( message, data, immediateExceptions ),
+                  hasSubscribers = messageHasSubscribers( message );
+
+              if ( !hasSubscribers ){
+                  return false;
+              }
+
+              if ( sync === true ){
+                  deliver();
+              } else {
+                  setTimeout( deliver, 0 );
+              }
+              return true;
+          }
+
+          /**
+           * Publishes the message, passing the data to it's subscribers
+           * @function
+           * @alias publish
+           * @param { String } message The message to publish
+           * @param {} data The data to pass to subscribers
+           * @return { Boolean }
+           */
+          PubSub.publish = function( message, data ){
+              return publish( message, data, false, PubSub.immediateExceptions );
+          };
+
+          /**
+           * Publishes the message synchronously, passing the data to it's subscribers
+           * @function
+           * @alias publishSync
+           * @param { String } message The message to publish
+           * @param {} data The data to pass to subscribers
+           * @return { Boolean }
+           */
+          PubSub.publishSync = function( message, data ){
+              return publish( message, data, true, PubSub.immediateExceptions );
+          };
+
+          /**
+           * Subscribes the passed function to the passed message. Every returned token is unique and should be stored if you need to unsubscribe
+           * @function
+           * @alias subscribe
+           * @param { String } message The message to subscribe to
+           * @param { Function } func The function to call when a new message is published
+           * @return { String }
+           */
+          PubSub.subscribe = function( message, func ){
+              if ( typeof func !== 'function'){
+                  return false;
+              }
+
+              message = (typeof message === 'symbol') ? message.toString() : message;
+
+              // message is not registered yet
+              if ( !Object.prototype.hasOwnProperty.call( messages, message ) ){
+                  messages[message] = {};
+              }
+
+              // forcing token as String, to allow for future expansions without breaking usage
+              // and allow for easy use as key names for the 'messages' object
+              var token = 'uid_' + String(++lastUid);
+              messages[message][token] = func;
+
+              // return token for unsubscribing
+              return token;
+          };
+
+          PubSub.subscribeAll = function( func ){
+              return PubSub.subscribe(ALL_SUBSCRIBING_MSG, func);
+          };
+
+          /**
+           * Subscribes the passed function to the passed message once
+           * @function
+           * @alias subscribeOnce
+           * @param { String } message The message to subscribe to
+           * @param { Function } func The function to call when a new message is published
+           * @return { PubSub }
+           */
+          PubSub.subscribeOnce = function( message, func ){
+              var token = PubSub.subscribe( message, function(){
+                  // before func apply, unsubscribe message
+                  PubSub.unsubscribe( token );
+                  func.apply( this, arguments );
+              });
+              return PubSub;
+          };
+
+          /**
+           * Clears all subscriptions
+           * @function
+           * @public
+           * @alias clearAllSubscriptions
+           */
+          PubSub.clearAllSubscriptions = function clearAllSubscriptions(){
+              messages = {};
+          };
+
+          /**
+           * Clear subscriptions by the topic
+           * @function
+           * @public
+           * @alias clearAllSubscriptions
+           * @return { int }
+           */
+          PubSub.clearSubscriptions = function clearSubscriptions(topic){
+              var m;
+              for (m in messages){
+                  if (Object.prototype.hasOwnProperty.call(messages, m) && m.indexOf(topic) === 0){
+                      delete messages[m];
+                  }
+              }
+          };
+
+          /**
+             Count subscriptions by the topic
+           * @function
+           * @public
+           * @alias countSubscriptions
+           * @return { Array }
+          */
+          PubSub.countSubscriptions = function countSubscriptions(topic){
+              var m;
+              // eslint-disable-next-line no-unused-vars
+              var token;
+              var count = 0;
+              for (m in messages) {
+                  if (Object.prototype.hasOwnProperty.call(messages, m) && m.indexOf(topic) === 0) {
+                      for (token in messages[m]) {
+                          count++;
+                      }
+                      break;
+                  }
+              }
+              return count;
+          };
+
+
+          /**
+             Gets subscriptions by the topic
+           * @function
+           * @public
+           * @alias getSubscriptions
+          */
+          PubSub.getSubscriptions = function getSubscriptions(topic){
+              var m;
+              var list = [];
+              for (m in messages){
+                  if (Object.prototype.hasOwnProperty.call(messages, m) && m.indexOf(topic) === 0){
+                      list.push(m);
+                  }
+              }
+              return list;
+          };
+
+          /**
+           * Removes subscriptions
+           *
+           * - When passed a token, removes a specific subscription.
+           *
+      	 * - When passed a function, removes all subscriptions for that function
+           *
+      	 * - When passed a topic, removes all subscriptions for that topic (hierarchy)
+           * @function
+           * @public
+           * @alias subscribeOnce
+           * @param { String | Function } value A token, function or topic to unsubscribe from
+           * @example // Unsubscribing with a token
+           * var token = PubSub.subscribe('mytopic', myFunc);
+           * PubSub.unsubscribe(token);
+           * @example // Unsubscribing with a function
+           * PubSub.unsubscribe(myFunc);
+           * @example // Unsubscribing from a topic
+           * PubSub.unsubscribe('mytopic');
+           */
+          PubSub.unsubscribe = function(value){
+              var descendantTopicExists = function(topic) {
+                      var m;
+                      for ( m in messages ){
+                          if ( Object.prototype.hasOwnProperty.call(messages, m) && m.indexOf(topic) === 0 ){
+                              // a descendant of the topic exists:
+                              return true;
+                          }
+                      }
+
+                      return false;
+                  },
+                  isTopic    = typeof value === 'string' && ( Object.prototype.hasOwnProperty.call(messages, value) || descendantTopicExists(value) ),
+                  isToken    = !isTopic && typeof value === 'string',
+                  isFunction = typeof value === 'function',
+                  result = false,
+                  m, message, t;
+
+              if (isTopic){
+                  PubSub.clearSubscriptions(value);
+                  return;
+              }
+
+              for ( m in messages ){
+                  if ( Object.prototype.hasOwnProperty.call( messages, m ) ){
+                      message = messages[m];
+
+                      if ( isToken && message[value] ){
+                          delete message[value];
+                          result = value;
+                          // tokens are unique, so we can just stop here
+                          break;
+                      }
+
+                      if (isFunction) {
+                          for ( t in message ){
+                              if (Object.prototype.hasOwnProperty.call(message, t) && message[t] === value){
+                                  delete message[t];
+                                  result = true;
+                              }
+                          }
+                      }
+                  }
+              }
+
+              return result;
+          };
+      }));
+      });
+      pubsub.PubSub;
+
+      var urlResolveBrowser = urlResolve;
+
+      /*
+      The majority of the module is built by following RFC1808
+      url: https://tools.ietf.org/html/rfc1808
+      */
+
+      // adds a slash at end if not present
+      function _addSlash (url) {
+        return url + (url[url.length-1] === '/' ? '' : '/');
+      }
+
+      // resolve the ..'s (directory up) and such
+      function _pathResolve (path) {
+        let pathSplit = path.split('/');
+
+        // happens when path starts with /
+        if (pathSplit[0] === '') {
+          pathSplit = pathSplit.slice(1);
+        }
+
+        // let segmentCount = 0; // number of segments that have been passed
+        let resultArray = [];
+        pathSplit.forEach((current, index) => {
+          // skip occurances of '.'
+          if (current !== '.') {
+            if (current === '..') {
+              resultArray.pop(); // remove previous
+            } else if (current !== '' || index === pathSplit.length - 1) {
+              resultArray.push(current);
+            }
+          }
+        });
+        return '/' + resultArray.join('/');
+      }
+
+      // parses a base url string into an object containing host, path and query
+      function _baseParse (base) {
+        const resultObject = {
+          host: '',
+          path: '',
+          query: '',
+          protocol: ''
+        };
+
+        let path = base;
+        let protocolEndIndex = base.indexOf('//');
+
+        resultObject.protocol = path.substring(0, protocolEndIndex);
+
+        protocolEndIndex += 2; // add two to pass double slash
+
+        const pathIndex = base.indexOf('/', protocolEndIndex);
+        const queryIndex = base.indexOf('?');
+        const hashIndex = base.indexOf('#');
+
+        if (hashIndex !== -1) {
+          path = path.substring(0, hashIndex); // remove hash, not needed for base
+        }
+
+        if (queryIndex !== -1) {
+          const query = path.substring(queryIndex); // remove query, save in return obj
+          resultObject.query = query;
+          path = path.substring(0, queryIndex);
+        }
+
+        if (pathIndex !== -1) {
+          const host = path.substring(0, pathIndex); // separate host & path
+          resultObject.host = host;
+          path = path.substring(pathIndex);
+          resultObject.path = path;
+        } else {
+          resultObject.host = path; // there was no path, therefore path is host
+        }
+
+        return resultObject;
+      }
+
+      // https://tools.ietf.org/html/rfc3986#section-3.1
+      const _scheme = '[a-z][a-z0-9+.-]*'; // ALPHA *( ALPHA / DIGIT / "+" / "-" / "."  )]
+      const _isAbsolute = new RegExp(`^(${_scheme}:)?//`, 'i');
+
+      // parses a relative url string into an object containing the href,
+      // hash, query and whether it is a net path, absolute path or relative path
+      function _relativeParse (relative) {
+        const resultObject = {
+          href: relative, // href is always what was passed through
+          hash: '',
+          query: '',
+          netPath: false,
+          absolutePath: false,
+          relativePath: false
+        };
+        // check for protocol
+        // if protocol exists, is net path (absolute URL)
+        if (_isAbsolute.test(relative)) {
+          resultObject.netPath = true;
+          // return, in this case the relative is the resolved url, no need to parse.
+          return resultObject;
+        }
+
+        // if / is first, this is an absolute path,
+        // I.E. it overwrites the base URL's path
+        if (relative[0] === '/') {
+          resultObject.absolutePath = true;
+          // return resultObject
+        } else if (relative !== '') {
+          resultObject.relativePath = true;
+        }
+
+        let path = relative;
+        const queryIndex = relative.indexOf('?');
+        const hashIndex = relative.indexOf('#');
+
+        if (hashIndex !== -1) {
+          const hash = path.substring(hashIndex);
+          resultObject.hash = hash;
+          path = path.substring(0, hashIndex);
+        }
+
+        if (queryIndex !== -1) {
+          const query = path.substring(queryIndex);
+          resultObject.query = query;
+          path = path.substring(0, queryIndex);
+        }
+
+        resultObject.path = path; // whatever is left is path
+        return resultObject;
+      }
+
+      function _shouldAddSlash (url) {
+        const protocolIndex = url.indexOf('//') + 2;
+        const noPath = !(url.includes('/', protocolIndex));
+        const noQuery = !(url.includes('?', protocolIndex));
+        const noHash = !(url.includes('#', protocolIndex));
+        return (noPath && noQuery && noHash);
+      }
+
+      function _shouldAddProtocol (url) {
+        return url.startsWith('//');
+      }
+
+      /*
+      * PRECONDITION: Base is a fully qualified URL. e.g. http://example.com/
+      * optional: path, query or hash
+      * returns the resolved url
+      */
+      function urlResolve (base, relative) {
+        base = base.trim();
+        relative = relative.trim();
+
+        // about is always absolute
+        if (relative.startsWith('about:')) {
+          return relative;
+        }
+
+        const baseObj = _baseParse(base);
+        const relativeObj = _relativeParse(relative);
+
+        if (!baseObj.protocol && !relativeObj.netPath) {
+          throw new Error('Error, protocol is not specified');
+        }
+
+        if (relativeObj.netPath) { // relative is full qualified URL
+          if (_shouldAddProtocol(relativeObj.href)) {
+            relativeObj.href = baseObj.protocol + relativeObj.href;
+          }
+
+          if (_shouldAddSlash(relativeObj.href)) {
+            return _addSlash(relativeObj.href);
+          }
+
+          return relativeObj.href;
+        } else if (relativeObj.absolutePath) { // relative is an absolute path
+          const {path, query, hash} = relativeObj;
+
+          return baseObj.host + _pathResolve(path) + query + hash;
+        } else if (relativeObj.relativePath) { // relative is a relative path
+          const {path, query, hash} = relativeObj;
+
+          let basePath = baseObj.path;
+          let resultString = baseObj.host;
+
+          let resolvePath;
+
+          if (path.length === 0) {
+            resolvePath = basePath;
+          } else {
+            // remove last segment if no slash at end
+            basePath = basePath.substring(0, basePath.lastIndexOf('/'));
+            resolvePath = _pathResolve(basePath + '/' + path);
+          }
+
+          // if result is just the base host, add /
+          if ((resolvePath === '') && (!query) && (!hash)) {
+            resultString += '/';
+          } else {
+            resultString += resolvePath + query + hash;
+          }
+
+          return resultString;
+        } else {
+          const {host, path, query} = baseObj;
+          // when path and query aren't supplied add slash
+          if ((!path) && (!query)) {
+            return _addSlash(host);
+          }
+          return host + path + query + relativeObj.hash;
+        }
+      }
+
+      const isObject$1 = (value) => typeof value === "object" && !Array.isArray(value) && value !== null;
+      const isType = {
+        null: (value) => value === null,
+        boolean: (value) => typeof value === "boolean",
+        object: isObject$1,
+        array: (value) => Array.isArray(value),
+        number: (value) => typeof value === "number",
+        integer: (value) => Number.isInteger(value),
+        string: (value) => typeof value === "string"
+      };
+      const jsonTypeOf$2 = (value, type) => isType[type](value);
+
+      const splitUrl$4 = (url) => {
+        const indexOfHash = url.indexOf("#");
+        const ndx = indexOfHash === -1 ? url.length : indexOfHash;
+        const urlReference = url.slice(0, ndx);
+        const urlFragment = url.slice(ndx + 1);
+
+        return [decodeURI(urlReference), decodeURI(urlFragment)];
+      };
+
+      const getScheme = (url) => {
+        const matches = RegExp(/^(.+):\/\//).exec(url);
+        return matches ? matches[1] : "";
+      };
+
+      const safeResolveUrl$1 = (contextUrl, url) => {
+        const resolvedUrl = urlResolveBrowser(contextUrl, url);
+        const contextId = splitUrl$4(contextUrl)[0];
+        if (contextId && getScheme(resolvedUrl) === "file" && getScheme(contextId) !== "file") {
+          throw Error(`Can't access file '${resolvedUrl}' resource from network context '${contextUrl}'`);
+        }
+        return resolvedUrl;
+      };
+
+      var common$1 = { jsonTypeOf: jsonTypeOf$2, splitUrl: splitUrl$4, safeResolveUrl: safeResolveUrl$1 };
+
+      const nil$2 = "";
+
+      const compile$P = (pointer) => {
+        if (pointer.length > 0 && pointer[0] !== "/") {
+          throw Error("Invalid JSON Pointer");
+        }
+
+        return pointer.split("/").slice(1).map(unescape);
+      };
+
+      const get$1 = (pointer, value = undefined) => {
+        const ptr = compile$P(pointer);
+
+        const fn = (value) => ptr.reduce(([value, pointer], segment) => {
+          return [applySegment(value, segment, pointer), append(segment, pointer)];
+        }, [value, ""])[0];
+
+        return value === undefined ? fn : fn(value);
+      };
+
+      const set = (pointer, subject = undefined, value = undefined) => {
+        const ptr = compile$P(pointer);
+        const fn = justCurryIt((subject, value) => _set(ptr, subject, value, nil$2));
+        return subject === undefined ? fn : fn(subject, value);
+      };
+
+      const _set = (pointer, subject, value, cursor) => {
+        if (pointer.length === 0) {
+          return value;
+        } else if (pointer.length > 1) {
+          const segment = pointer.shift();
+          return { ...subject, [segment]: _set(pointer, applySegment(subject, segment, cursor), value, append(segment, cursor)) };
+        } else if (Array.isArray(subject)) {
+          const clonedSubject = [...subject];
+          const segment = computeSegment(subject, pointer[0]);
+          clonedSubject[segment] = value;
+          return clonedSubject;
+        } else if (typeof subject === "object" && subject !== null) {
+          return { ...subject, [pointer[0]]: value };
+        } else {
+          return applySegment(subject, pointer[0], cursor);
+        }
+      };
+
+      const assign = (pointer, subject = undefined, value = undefined) => {
+        const ptr = compile$P(pointer);
+        const fn = justCurryIt((subject, value) => _assign(ptr, subject, value, nil$2));
+        return subject === undefined ? fn : fn(subject, value);
+      };
+
+      const _assign = (pointer, subject, value, cursor) => {
+        if (pointer.length === 0) {
+          return;
+        } else if (pointer.length === 1 && !isScalar(subject)) {
+          const segment = computeSegment(subject, pointer[0]);
+          subject[segment] = value;
+        } else {
+          const segment = pointer.shift();
+          _assign(pointer, applySegment(subject, segment, cursor), value, append(segment, cursor));
+        }
+      };
+
+      const unset = (pointer, subject = undefined) => {
+        const ptr = compile$P(pointer);
+        const fn = (subject) => _unset(ptr, subject, nil$2);
+        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$2);
+        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 = justCurryIt((segment, pointer) => pointer + "/" + escape(segment));
+
+      const escape = (segment) => segment.toString().replace(/~/g, "~0").replace(/\//g, "~1");
+      const unescape = (segment) => segment.toString().replace(/~1/g, "/").replace(/~0/g, "~");
+      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$3 = { nil: nil$2, append, get: get$1, set, assign, unset, remove };
+      lib$3.nil;
+      lib$3.append;
+      lib$3.get;
+      lib$3.set;
+      lib$3.assign;
+      lib$3.unset;
+      lib$3.remove;
+
+      const $__value = Symbol("$__value");
+      const $__href = Symbol("$__href");
+
+      const cons$1 = (href, value) => Object.freeze({
+        [$__href]: href,
+        [$__value]: value
+      });
+
+      const isReference = (ref) => ref && ref[$__href] !== undefined;
+      const href = (ref) => ref[$__href];
+      const value$2 = (ref) => ref[$__value];
+
+      var reference = { cons: cons$1, isReference, href, value: value$2 };
+
+      const { jsonTypeOf: jsonTypeOf$1 } = common$1;
+
+
+
+      const nil$1 = Object.freeze({ id: "", pointer: "", instance: undefined, value: undefined });
+      const cons = (instance, id = "") => Object.freeze({ ...nil$1, id, instance, value: instance });
+      const uri$1 = (doc) => `${doc.id}#${encodeURI(doc.pointer)}`;
+      const value$1 = (doc) => reference.isReference(doc.value) ? reference.value(doc.value) : doc.value;
+      const has$1 = (key, doc) => key in value$1(doc);
+      const typeOf$1 = justCurryIt((doc, type) => jsonTypeOf$1(value$1(doc), type));
+
+      const step$1 = (key, doc) => Object.freeze({
+        ...doc,
+        pointer: lib$3.append(key, doc.pointer),
+        value: value$1(doc)[key]
+      });
+
+      const entries$2 = (doc) => Object.keys(value$1(doc))
+        .map((key) => [key, step$1(key, doc)]);
+
+      const keys$1 = (doc) => Object.keys(value$1(doc));
+
+      const map$2 = justCurryIt((fn, doc) => value$1(doc)
+        .map((item, ndx, array, thisArg) => fn(step$1(ndx, doc), ndx, array, thisArg)));
+
+      const filter$1 = justCurryIt((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$1 = justCurryIt((fn, acc, doc) => value$1(doc)
+        .reduce((acc, item, ndx) => fn(acc, step$1(ndx, doc), ndx), acc));
+
+      const every$1 = justCurryIt((fn, doc) => value$1(doc)
+        .every((item, ndx, array, thisArg) => fn(step$1(ndx, doc), ndx, array, thisArg)));
+
+      const some$1 = justCurryIt((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$2, keys: keys$1, map: map$2, filter: filter$1, reduce: reduce$1, every: every$1, some: some$1, length: length$1 };
+      instance.nil;
+      instance.cons;
+      instance.uri;
+      instance.value;
+      instance.has;
+      instance.typeOf;
+      instance.step;
+      instance.entries;
+      instance.keys;
+      instance.map;
+      instance.filter;
+      instance.reduce;
+      instance.every;
+      instance.some;
+      instance.length;
+
+      /*!
+       * 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
+       */
+
+      var format_1 = format$1;
+      var parse_1 = parse;
+
+      /**
+       * 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 (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) {
+          var key;
+          var match;
+          var value;
+
+          PARAM_REGEXP.lastIndex = index;
+
+          while ((match = PARAM_REGEXP.exec(header))) {
+            if (match.index !== index) {
+              throw new TypeError('invalid parameter format')
+            }
+
+            index += match[0].length;
+            key = match[1].toLowerCase();
+            value = match[2];
+
+            if (value[0] === '"') {
+              // remove quotes and escapes
+              value = value
+                .substr(1, value.length - 2)
+                .replace(QESC_REGEXP, '$1');
+            }
+
+            obj.parameters[key] = value;
+          }
+
+          if (index !== header.length) {
+            throw new TypeError('invalid parameter format')
+          }
+        }
+
+        return obj
+      }
+
+      /**
+       * Get content-type from req/res objects.
+       *
+       * @param {object}
+       * @return {Object}
+       * @private
+       */
+
+      function getcontenttype (obj) {
+        var header;
+
+        if (typeof obj.getHeader === 'function') {
+          // res-like
+          header = obj.getHeader('content-type');
+        } else if (typeof obj.headers === 'object') {
+          // req-like
+          header = obj.headers && obj.headers['content-type'];
+        }
+
+        if (typeof header !== 'string') {
+          throw new TypeError('content-type header is missing from object')
+        }
+
+        return header
+      }
+
+      /**
+       * Quote a string if necessary.
+       *
+       * @param {string} val
+       * @return {string}
+       * @private
+       */
+
+      function qstring (val) {
+        var str = String(val);
+
+        // no need to quote tokens
+        if (TOKEN_REGEXP.test(str)) {
+          return str
+        }
+
+        if (str.length > 0 && !TEXT_REGEXP.test(str)) {
+          throw new TypeError('invalid parameter value')
+        }
+
+        return '"' + str.replace(QUOTE_REGEXP, '\\$1') + '"'
+      }
+
+      /**
+       * Class to represent a content type.
+       * @private
+       */
+      function ContentType (type) {
+        this.parameters = Object.create(null);
+        this.type = type;
+      }
+
+      var contentType = {
+      	format: format_1,
+      	parse: parse_1
+      };
+
+      var entries$1 = async (doc) => Object.entries(await doc);
+
+      var map$1 = justCurryIt(async (fn, doc) => (await doc).map(fn));
+
+      var reduce = justCurryIt(async (fn, acc, doc) => {
+        return (await doc).reduce(async (acc, item) => fn(await acc, item), acc);
+      });
+
+      var filter = justCurryIt(async (fn, doc, options = {}) => {
+        return reduce(async (acc, item) => {
+          return (await fn(item)) ? acc.concat([item]) : acc;
+        }, [], doc, options);
+      });
+
+      var some = justCurryIt(async (fn, doc) => {
+        const results = await map$1(fn, doc);
+        return (await Promise.all(results))
+          .some((a) => a);
+      });
+
+      var every = justCurryIt(async (fn, doc) => {
+        const results = await map$1(fn, doc);
+        return (await Promise.all(results))
+          .every((a) => a);
+      });
+
+      var pipeline = justCurryIt((fns, doc) => {
+        return fns.reduce(async (acc, fn) => fn(await acc), doc);
+      });
+
+      var all = (doc) => Promise.all(doc);
+
+      var allValues = (doc) => {
+        return pipeline([
+          entries$1,
+          reduce(async (acc, [propertyName, propertyValue]) => {
+            acc[propertyName] = await propertyValue;
+            return acc;
+          }, {})
+        ], doc);
+      };
+
+      var lib$2 = {
+        entries: entries$1,
+        map: map$1,
+        filter: filter,
+        reduce: reduce,
+        some: some,
+        every: every,
+        pipeline: pipeline,
+        all: all,
+        allValues: allValues
+      };
+      lib$2.entries;
+      lib$2.map;
+      lib$2.filter;
+      lib$2.reduce;
+      lib$2.some;
+      lib$2.every;
+      lib$2.pipeline;
+      lib$2.all;
+      lib$2.allValues;
+
+      var fetch_browser = fetch;
+
+      const { jsonTypeOf, splitUrl: splitUrl$3, safeResolveUrl } = common$1;
+
+
+
+
+      // Config
+      const config = {};
+      const configAlias = {};
+
+      const setConfig = (schemaVersion, key, value) => {
+        if (!config[schemaVersion]) {
+          config[schemaVersion] = {};
+        }
+        config[schemaVersion][key] = value;
+      };
+
+      const getConfig = (schemaVersion, key) => {
+        const configVersion = schemaVersion in configAlias ? configAlias[schemaVersion] : schemaVersion;
+        if (configVersion in config) {
+          return config[configVersion][key];
+        }
+      };
+
+      // Schema Management
+      const schemaStore = {};
+      const schemaStoreAlias = {};
+
+      const add$1 = (schema, url = "", defaultSchemaVersion = "") => {
+        schema = JSON.parse(JSON.stringify(schema));
+
+        // Schema Version
+        const schemaVersion = splitUrl$3(schema["$schema"] || defaultSchemaVersion)[0];
+        if (!schemaVersion) {
+          throw Error("Couldn't determine schema version");
+        }
+        delete schema["$schema"];
+
+        // Identifier
+        const baseToken = getConfig(schemaVersion, "baseToken");
+        const anchorToken = getConfig(schemaVersion, "anchorToken");
+        const externalId = splitUrl$3(url)[0];
+        if (!externalId && !splitUrl$3(schema[baseToken] || "")[0]) {
+          throw Error("Couldn't determine an identifier for the schema");
+        }
+        const internalUrl = safeResolveUrl(externalId, schema[baseToken] || "");
+        const [id, fragment] = splitUrl$3(internalUrl);
+        delete schema[baseToken];
+        if (fragment && baseToken === anchorToken) {
+          schema[anchorToken] = anchorToken !== baseToken ? encodeURI(fragment) : `#${encodeURI(fragment)}`;
+        }
+        if (externalId) {
+          schemaStoreAlias[externalId] = id;
+        }
+
+        // recursiveAnchor
+        const dynamicAnchors = {};
+        const recursiveAnchorToken = getConfig(schemaVersion, "recursiveAnchorToken");
+        if (schema[recursiveAnchorToken] === true) {
+          dynamicAnchors[""] = `${id}#`;
+          schema[anchorToken] = "";
+          delete schema[recursiveAnchorToken];
+        }
+
+        // Vocabulary
+        let vocabulary;
+        const vocabularyToken = getConfig(schemaVersion, "vocabularyToken");
+        if (jsonTypeOf(schema[vocabularyToken], "object")) {
+          configAlias[id] = schemaVersion;
+          vocabulary = schema[vocabularyToken];
+          delete schema[vocabularyToken];
+        } else {
+          configAlias[id] = schemaVersion;
+          vocabulary = { [schemaVersion]: true };
+        }
+
+        // Store Schema
+        const anchors = { "": "" };
+        schemaStore[id] = {
+          id: id,
+          schemaVersion: schemaVersion,
+          schema: processSchema(schema, id, schemaVersion, lib$3.nil, anchors, dynamicAnchors),
+          anchors: anchors,
+          dynamicAnchors: dynamicAnchors,
+          vocabulary: vocabulary,
+          validated: false
+        };
+
+        return schemaStore[id];
+      };
+
+      const processSchema = (subject, id, schemaVersion, pointer, anchors, dynamicAnchors) => {
+        if (jsonTypeOf(subject, "object")) {
+          const embeddedSchemaVersion = typeof subject["$schema"] === "string" ? splitUrl$3(subject["$schema"])[0] : schemaVersion;
+          const embeddedEmbeddedToken = getConfig(embeddedSchemaVersion, "embeddedToken");
+          const embeddedAnchorToken = getConfig(embeddedSchemaVersion, "anchorToken");
+          if (typeof subject[embeddedEmbeddedToken] === "string" && (embeddedEmbeddedToken !== embeddedAnchorToken || subject[embeddedEmbeddedToken][0] !== "#")) {
+            const ref = safeResolveUrl(id, subject[embeddedEmbeddedToken]);
+            subject[embeddedEmbeddedToken] = ref;
+            add$1(subject, ref, schemaVersion);
+            return reference.cons(subject[embeddedEmbeddedToken], subject);
+          }
+
+          const anchorToken = getConfig(schemaVersion, "anchorToken");
+          const dynamicAnchorToken = getConfig(schemaVersion, "dynamicAnchorToken");
+          if (typeof subject[dynamicAnchorToken] === "string") {
+            dynamicAnchors[subject[dynamicAnchorToken]] = `${id}#${encodeURI(pointer)}`;
+            anchors[subject[dynamicAnchorToken]] = pointer;
+            delete subject[dynamicAnchorToken];
+          }
+
+          const embeddedToken = getConfig(schemaVersion, "embeddedToken");
+          if (typeof subject[anchorToken] === "string") {
+            const anchor = anchorToken !== embeddedToken ? subject[anchorToken] : subject[anchorToken].slice(1);
+            anchors[anchor] = pointer;
+            delete subject[anchorToken];
+          }
+
+          const jrefToken = getConfig(schemaVersion, "jrefToken");
+          if (typeof subject[jrefToken] === "string") {
+            return reference.cons(subject[jrefToken], subject);
+          }
+
+          for (const key in subject) {
+            subject[key] = processSchema(subject[key], id, schemaVersion, lib$3.append(key, pointer), anchors, dynamicAnchors);
+          }
+
+          return subject;
+        } else if (Array.isArray(subject)) {
+          return subject.map((item, ndx) => processSchema(item, id, schemaVersion, lib$3.append(ndx, pointer), anchors, dynamicAnchors));
+        } else {
+          return subject;
+        }
+      };
+
+      const hasStoredSchema = (id) => id in schemaStore || id in schemaStoreAlias;
+      const getStoredSchema = (id) => schemaStore[schemaStoreAlias[id]] || schemaStore[id];
+
+      const markValidated = (id) => {
+        schemaStore[id].validated = true;
+      };
+
+      // Schema Retrieval
+      const nil = Object.freeze({
+        id: "",
+        schemaVersion: undefined,
+        vocabulary: {},
+        pointer: lib$3.nil,
+        schema: undefined,
+        value: undefined,
+        anchors: {},
+        dynamicAnchors: {},
+        validated: true
+      });
+
+      const get = async (url, contextDoc = nil) => {
+        const resolvedUrl = safeResolveUrl(uri(contextDoc), url);
+        const [id, fragment] = splitUrl$3(resolvedUrl);
+
+        if (!hasStoredSchema(id)) {
+          const response = await fetch_browser(id, { headers: { Accept: "application/schema+json" } });
+          if (response.status >= 400) {
+            await response.text(); // Sometimes node hangs without this hack
+            throw Error(`Failed to retrieve schema with id: ${id}`);
+          }
+
+          if (response.headers.has("content-type")) {
+            const contentType$1 = contentType.parse(response.headers.get("content-type")).type;
+            if (contentType$1 !== "application/schema+json") {
+              throw Error(`${id} is not a schema. Found a document with media type: ${contentType$1}`);
+            }
+          }
+
+          add$1(await response.json(), id);
+        }
+
+        const storedSchema = getStoredSchema(id);
+        const pointer = fragment[0] !== "/" ? getAnchorPointer(storedSchema, fragment) : fragment;
+        const doc = Object.freeze({
+          ...storedSchema,
+          pointer: pointer,
+          value: lib$3.get(pointer, storedSchema.schema)
+        });
+
+        return followReferences$1(doc);
+      };
+
+      const followReferences$1 = (doc) => reference.isReference(doc.value) ? get(reference.href(doc.value), doc) : doc;
+
+      const getAnchorPointer = (schema, fragment) => {
+        if (!(fragment in schema.anchors)) {
+          throw Error(`No such anchor '${encodeURI(schema.id)}#${encodeURI(fragment)}'`);
+        }
+
+        return schema.anchors[fragment];
+      };
+
+      // Utility Functions
+      const uri = (doc) => `${doc.id}#${encodeURI(doc.pointer)}`;
+      const value = (doc) => reference.isReference(doc.value) ? reference.value(doc.value) : doc.value;
+      const has = (key, doc) => key in value(doc);
+      const typeOf = (doc, type) => jsonTypeOf(value(doc), type);
+
+      const step = (key, doc) => {
+        const storedSchema = getStoredSchema(doc.id);
+        const nextDoc = Object.freeze({
+          ...doc,
+          pointer: lib$3.append(key, doc.pointer),
+          value: value(doc)[key],
+          validated: storedSchema.validated
+        });
+        return followReferences$1(nextDoc);
+      };
+
+      const keys = (doc) => Object.keys(value(doc));
+
+      const entries = (doc) => lib$2.pipeline([
+        value,
+        Object.keys,
+        lib$2.map(async (key) => [key, await step(key, doc)]),
+        lib$2.all
+      ], doc);
+
+      const map = justCurryIt((fn, doc) => lib$2.pipeline([
+        value,
+        lib$2.map(async (item, ndx) => fn(await step(ndx, doc), ndx)),
+        lib$2.all
+      ], doc));
+
+      const length = (doc) => value(doc).length;
+
+      var schema$5 = {
+        setConfig, getConfig,
+        add: add$1, get, markValidated,
+        uri, value, getAnchorPointer, typeOf, has, step, keys, entries, map, length
+      };
+      schema$5.setConfig;
+      schema$5.getConfig;
+      schema$5.add;
+      schema$5.get;
+      schema$5.markValidated;
+      schema$5.uri;
+      schema$5.value;
+      schema$5.getAnchorPointer;
+      schema$5.typeOf;
+      schema$5.has;
+      schema$5.step;
+      schema$5.keys;
+      schema$5.entries;
+      schema$5.map;
+      schema$5.length;
+
+      class InvalidSchemaError$1 extends Error {
+        constructor(output) {
+          super("Invalid Schema");
+          this.name = this.constructor.name;
+          this.output = output;
+        }
+      }
+
+      var invalidSchemaError = InvalidSchemaError$1;
+
+      const { splitUrl: splitUrl$2 } = common$1;
+
+
+
+
+
+      const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED", VERBOSE = "VERBOSE";
+
+      let metaOutputFormat = DETAILED;
+      let shouldMetaValidate = true;
+
+      const validate$1 = async (schema, value = undefined, outputFormat = undefined) => {
+        const compiled = await compile$O(schema);
+        const interpretAst = (value, outputFormat) => interpret$O(compiled, instance.cons(value), outputFormat);
+
+        return value === undefined ? interpretAst : interpretAst(value, outputFormat);
+      };
+
+      const compile$O = async (schema) => {
+        const ast = { metaData: {} };
+        const schemaUri = await compileSchema(schema, ast);
+        return { ast, schemaUri };
+      };
+
+      const interpret$O = justCurryIt(({ ast, schemaUri }, value, outputFormat = FLAG) => {
+        if (![FLAG, BASIC, DETAILED, VERBOSE].includes(outputFormat)) {
+          throw Error(`The '${outputFormat}' error format is not supported`);
+        }
+
+        const output = [];
+        const subscriptionToken = pubsub.subscribe("result", outputHandler(outputFormat, output));
+        interpretSchema(schemaUri, value, ast, {});
+        pubsub.unsubscribe(subscriptionToken);
+
+        return output[0];
+      });
+
+      const outputHandler = (outputFormat, output) => {
+        const resultStack = [];
+
+        return (message, keywordResult) => {
+          if (message === "result") {
+            const { keyword, absoluteKeywordLocation, instanceLocation, valid } = keywordResult;
+            const result = { keyword, absoluteKeywordLocation, instanceLocation, valid, errors: [] };
+            resultStack.push(result);
+          } else if (message === "result.start") {
+            resultStack.push(message);
+          } else if (message === "result.end") {
+            const result = resultStack.pop();
+            while (resultStack[resultStack.length - 1] !== "result.start") {
+              const topResult = resultStack.pop();
+
+              const errors = [topResult];
+              if (outputFormat === BASIC) {
+                errors.push(...topResult.errors);
+                delete topResult.errors;
+              }
+
+              if (outputFormat === VERBOSE || (outputFormat !== FLAG && !topResult.valid)) {
+                result.errors.unshift(...errors);
+              }
+            }
+            resultStack[resultStack.length - 1] = result;
+
+            output[0] = result;
+          }
+        };
+      };
+
+      const setMetaOutputFormat = (format) => {
+        metaOutputFormat = format;
+      };
+
+      const setShouldMetaValidate = (isEnabled) => {
+        shouldMetaValidate = isEnabled;
+      };
+
+      const _keywords = {};
+      const getKeyword = (id) => _keywords[id];
+      const hasKeyword = (id) => id in _keywords;
+      const addKeyword = (id, keywordHandler) => {
+        _keywords[id] = {
+          collectEvaluatedItems: (keywordValue, instance, ast, dynamicAnchors, isTop) => keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, isTop) && new Set(),
+          collectEvaluatedProperties: (keywordValue, instance, ast, dynamicAnchors, isTop) => keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, isTop) && [],
+          ...keywordHandler
+        };
+      };
+
+      const _vocabularies = {};
+      const defineVocabulary = (id, keywords) => {
+        _vocabularies[id] = keywords;
+      };
+
+      const metaValidators = {};
+      const compileSchema = async (schema, ast) => {
+        schema = await followReferences(schema);
+
+        // Vocabularies
+        if (!hasKeyword(`${schema.schemaVersion}#validate`)) {
+          const metaSchema = await schema$5.get(schema.schemaVersion);
+
+          // Check for mandatory vocabularies
+          const mandatoryVocabularies = schema$5.getConfig(metaSchema.id, "mandatoryVocabularies") || [];
+          mandatoryVocabularies.forEach((vocabularyId) => {
+            if (!metaSchema.vocabulary[vocabularyId]) {
+              throw Error(`Vocabulary '${vocabularyId}' must be explicitly declared and required`);
+            }
+          });
+
+          // Load vocabularies
+          Object.entries(metaSchema.vocabulary)
+            .forEach(([vocabularyId, isRequired]) => {
+              if (vocabularyId in _vocabularies) {
+                Object.entries(_vocabularies[vocabularyId])
+                  .forEach(([keyword, keywordHandler]) => {
+                    addKeyword(`${metaSchema.id}#${keyword}`, keywordHandler);
+                  });
+              } else if (isRequired) {
+                throw Error(`Missing required vocabulary: ${vocabularyId}`);
+              }
+            });
+        }
+
+        // Meta validation
+        if (shouldMetaValidate && !schema.validated) {
+          schema$5.markValidated(schema.id);
+
+          // Compile
+          if (!(schema.schemaVersion in metaValidators)) {
+            const metaSchema = await schema$5.get(schema.schemaVersion);
+            const compiledSchema = await compile$O(metaSchema);
+            metaValidators[metaSchema.id] = interpret$O(compiledSchema);
+          }
+
+          // Interpret
+          const schemaInstance = instance.cons(schema.schema, schema.id);
+          const metaResults = metaValidators[schema.schemaVersion](schemaInstance, metaOutputFormat);
+          if (!metaResults.valid) {
+            throw new invalidSchemaError(metaResults);
+          }
+        }
+
+        // Compile
+        if (!(schema.id in ast.metaData)) {
+          ast.metaData[schema.id] = {
+            id: schema.id,
+            dynamicAnchors: schema.dynamicAnchors,
+            anchors: schema.anchors
+          };
+        }
+        return getKeyword(`${schema.schemaVersion}#validate`).compile(schema, ast);
+      };
+
+      const followReferences = async (doc) => {
+        return schema$5.typeOf(doc, "string") ? followReferences(await schema$5.get(schema$5.value(doc), doc)) : doc;
+      };
+
+      const interpretSchema = (schemaUri, instance, ast, dynamicAnchors) => {
+        const keywordId = getKeywordId(schemaUri, ast);
+        const id = splitUrl$2(schemaUri)[0];
+        return getKeyword(keywordId).interpret(schemaUri, instance, ast, { ...ast.metaData[id].dynamicAnchors, ...dynamicAnchors });
+      };
+
+      const collectEvaluatedProperties$e = (schemaUri, instance, ast, dynamicAnchors, isTop) => {
+        const keywordId = getKeywordId(schemaUri, ast);
+        return getKeyword(keywordId).collectEvaluatedProperties(schemaUri, instance, ast, dynamicAnchors, isTop);
+      };
+
+      const collectEvaluatedItems$f = (schemaUri, instance, ast, dynamicAnchors, isTop) => {
+        const keywordId = getKeywordId(schemaUri, ast);
+        return getKeyword(keywordId).collectEvaluatedItems(schemaUri, instance, ast, dynamicAnchors, isTop);
+      };
+
+      const getKeywordId = (schemaUri, ast) => {
+        if (!(schemaUri in ast)) {
+          throw Error(`No schema found at ${schemaUri}`);
+        }
+
+        return ast[schemaUri][0];
+      };
+
+      const add = (schema, url = "", defaultSchemaVersion = "") => {
+        const doc = schema$5.add(schema, url, defaultSchemaVersion);
+        delete metaValidators[doc.id];
+
+        return doc;
+      };
+
+      var core$2 = {
+        validate: validate$1, compile: compile$O, interpret: interpret$O,
+        setMetaOutputFormat, setShouldMetaValidate, FLAG, BASIC, DETAILED, VERBOSE,
+        add, getKeyword, hasKeyword, defineVocabulary,
+        compileSchema, interpretSchema, collectEvaluatedProperties: collectEvaluatedProperties$e, collectEvaluatedItems: collectEvaluatedItems$f
+      };
+      core$2.validate;
+      core$2.compile;
+      core$2.interpret;
+      core$2.setMetaOutputFormat;
+      core$2.setShouldMetaValidate;
+      core$2.FLAG;
+      core$2.BASIC;
+      core$2.DETAILED;
+      core$2.VERBOSE;
+      core$2.add;
+      core$2.getKeyword;
+      core$2.hasKeyword;
+      core$2.defineVocabulary;
+      core$2.compileSchema;
+      core$2.interpretSchema;
+      core$2.collectEvaluatedProperties;
+      core$2.collectEvaluatedItems;
+
+      const compile$N = (schema) => schema$5.value(schema);
+      const interpret$N = () => true;
+
+      var metaData$2 = { compile: compile$N, interpret: interpret$N };
+      metaData$2.compile;
+      metaData$2.interpret;
+
+      const compile$M = async (schema, ast) => {
+        const url = schema$5.uri(schema);
+        if (!(url in ast)) {
+          ast[url] = false; // Place dummy entry in ast to avoid recursive loops
+
+          const schemaValue = schema$5.value(schema);
+          if (!["object", "boolean"].includes(typeof schemaValue)) {
+            throw Error(`No schema found at '${schema$5.uri(schema)}'`);
+          }
+
+          ast[url] = [
+            `${schema.schemaVersion}#validate`,
+            schema$5.uri(schema),
+            typeof schemaValue === "boolean" ? schemaValue : await lib$2.pipeline([
+              schema$5.entries,
+              lib$2.map(([keyword, keywordSchema]) => [`${schema.schemaVersion}#${keyword}`, keywordSchema]),
+              lib$2.filter(([keywordId]) => core$2.hasKeyword(keywordId) && keywordId !== `${schema.schemaVersion}#validate`),
+              lib$2.map(async ([keywordId, keywordSchema]) => {
+                const keywordAst = await core$2.getKeyword(keywordId).compile(keywordSchema, ast, schema);
+                return [keywordId, schema$5.uri(keywordSchema), keywordAst];
+              }),
+              lib$2.all
+            ], schema)
+          ];
+        }
+
+        return url;
+      };
+
+      const interpret$M = (uri, instance$1, ast, dynamicAnchors) => {
+        const [keywordId, schemaUrl, nodes] = ast[uri];
+
+        pubsub.publishSync("result.start");
+        const isValid = typeof nodes === "boolean" ? nodes : nodes
+          .every(([keywordId, schemaUrl, keywordValue]) => {
+            pubsub.publishSync("result.start");
+            const isValid = core$2.getKeyword(keywordId).interpret(keywordValue, instance$1, ast, dynamicAnchors);
+
+            pubsub.publishSync("result", {
+              keyword: keywordId,
+              absoluteKeywordLocation: schemaUrl,
+              instanceLocation: instance.uri(instance$1),
+              valid: isValid,
+              ast: keywordValue
+            });
+            pubsub.publishSync("result.end");
+            return isValid;
+          });
+
+        pubsub.publishSync("result", {
+          keyword: keywordId,
+          absoluteKeywordLocation: schemaUrl,
+          instanceLocation: instance.uri(instance$1),
+          valid: isValid,
+          ast: uri
+        });
+        pubsub.publishSync("result.end");
+        return isValid;
+      };
+
+      const collectEvaluatedProperties$d = (uri, instance, ast, dynamicAnchors, isTop = false) => {
+        const nodes = ast[uri][2];
+
+        if (typeof nodes === "boolean") {
+          return nodes ? [] : false;
+        }
+
+        return nodes
+          .filter(([keywordId]) => !isTop || !keywordId.endsWith("#unevaluatedProperties"))
+          .reduce((acc, [keywordId, , keywordValue]) => {
+            const propertyNames = acc && core$2.getKeyword(keywordId).collectEvaluatedProperties(keywordValue, instance, ast, dynamicAnchors);
+            return propertyNames !== false && [...acc, ...propertyNames];
+          }, []);
+      };
+
+      const collectEvaluatedItems$e = (uri, instance, ast, dynamicAnchors, isTop = false) => {
+        const nodes = ast[uri][2];
+
+        if (typeof nodes === "boolean") {
+          return nodes ? new Set() : false;
+        }
+
+        return nodes
+          .filter(([keywordId]) => !isTop || !keywordId.endsWith("#unevaluatedItems"))
+          .reduce((acc, [keywordId, , keywordValue]) => {
+            const itemIndexes = acc !== false && core$2.getKeyword(keywordId).collectEvaluatedItems(keywordValue, instance, ast, dynamicAnchors);
+            return itemIndexes !== false && new Set([...acc, ...itemIndexes]);
+          }, new Set());
+      };
+
+      var validate = { compile: compile$M, interpret: interpret$M, collectEvaluatedProperties: collectEvaluatedProperties$d, collectEvaluatedItems: collectEvaluatedItems$e };
+      validate.compile;
+      validate.interpret;
+      validate.collectEvaluatedProperties;
+      validate.collectEvaluatedItems;
+
+      var keywords$1 = { metaData: metaData$2, validate };
+      keywords$1.metaData;
+      keywords$1.validate;
+
+      var lib$1 = { Core: core$2, Schema: schema$5, Instance: instance, Keywords: keywords$1 };
+
+      const { Core: Core$v, Schema: Schema$N, Instance: Instance$B } = lib$1;
+
+
+      const compile$L = async (schema, ast, parentSchema) => {
+        const items = await Schema$N.step("items", parentSchema);
+        const numberOfItems = Schema$N.typeOf(items, "array") ? Schema$N.length(items) : Number.MAX_SAFE_INTEGER;
+
+        if (Schema$N.typeOf(schema, "boolean")) {
+          return [numberOfItems, Schema$N.value(schema)];
+        } else {
+          return [numberOfItems, await Core$v.compileSchema(schema, ast)];
+        }
+      };
+
+      const interpret$L = ([numberOfItems, additionalItems], instance, ast, dynamicAnchors) => {
+        if (!Instance$B.typeOf(instance, "array")) {
+          return true;
+        }
+
+        if (typeof additionalItems === "string") {
+          return Instance$B.every((item, ndx) => ndx < numberOfItems || Core$v.interpretSchema(additionalItems, item, ast, dynamicAnchors), instance);
+        } else {
+          return Instance$B.every((item, ndx) => ndx < numberOfItems ? true : additionalItems, instance);
+        }
+      };
+
+      var additionalItems = { compile: compile$L, interpret: interpret$L };
+      additionalItems.compile;
+      additionalItems.interpret;
+
+      const { Core: Core$u, Schema: Schema$M, Instance: Instance$A } = lib$1;
+
+
+      const compile$K = async (schema, ast, parentSchema) => {
+        const items = await Schema$M.step("items", parentSchema);
+        const numberOfItems = Schema$M.typeOf(items, "array") ? Schema$M.length(items) : Number.MAX_SAFE_INTEGER;
+
+        return [numberOfItems, await Core$u.compileSchema(schema, ast)];
+      };
+
+      const interpret$K = ([numberOfItems, additionalItems], instance, ast, dynamicAnchors) => {
+        if (!Instance$A.typeOf(instance, "array")) {
+          return true;
+        }
+
+        return Instance$A.every((item, ndx) => ndx < numberOfItems || Core$u.interpretSchema(additionalItems, item, ast, dynamicAnchors), instance);
+      };
+
+      const collectEvaluatedItems$d = (keywordValue, instance, ast, dynamicAnchors) => {
+        return interpret$K(keywordValue, instance, ast, dynamicAnchors) && new Set(Instance$A.map((item, ndx) => ndx, instance));
+      };
+
+      var additionalItems6 = { compile: compile$K, interpret: interpret$K, collectEvaluatedItems: collectEvaluatedItems$d };
+      additionalItems6.compile;
+      additionalItems6.interpret;
+      additionalItems6.collectEvaluatedItems;
+
+      const { Core: Core$t, Schema: Schema$L, Instance: Instance$z } = lib$1;
+
+
+      const compile$J = async (schema, ast, parentSchema) => {
+        const properties = await Schema$L.step("properties", parentSchema);
+        const propertyNames = Schema$L.typeOf(properties, "object") ? Schema$L.keys(properties) : [];
+
+        const patternProperties = await Schema$L.step("patternProperties", parentSchema);
+        const propertyNamePatterns = Schema$L.typeOf(patternProperties, "object") ? Schema$L.keys(patternProperties).map((pattern) => new RegExp(pattern)) : [];
+
+        if (Schema$L.typeOf(schema, "boolean")) {
+          return [propertyNames, propertyNamePatterns, Schema$L.value(schema)];
+        } else {
+          return [propertyNames, propertyNamePatterns, await Core$t.compileSchema(schema, ast)];
+        }
+      };
+
+      const interpret$J = ([propertyNames, propertyNamePatterns, additionalProperties], instance, ast, dynamicAnchors) => {
+        if (!Instance$z.typeOf(instance, "object")) {
+          return true;
+        }
+
+        const properties = Instance$z.entries(instance)
+          .filter(([propertyName]) => !propertyNames.includes(propertyName) && !propertyNamePatterns.some((pattern) => pattern.test(propertyName)));
+
+        if (typeof additionalProperties === "string") {
+          return properties.every(([, property]) => Core$t.interpretSchema(additionalProperties, property, ast, dynamicAnchors));
+        } else {
+          return properties.length === 0 || additionalProperties;
+        }
+      };
+
+      var additionalProperties = { compile: compile$J, interpret: interpret$J };
+      additionalProperties.compile;
+      additionalProperties.interpret;
+
+      const { Core: Core$s, Schema: Schema$K, Instance: Instance$y } = lib$1;
+
+
+      const compile$I = async (schema, ast, parentSchema) => {
+        const propertiesSchema = await Schema$K.step("properties", parentSchema);
+        const propertyNames = Schema$K.typeOf(propertiesSchema, "object") ? Schema$K.keys(propertiesSchema) : [];
+
+        const patternProperties = await Schema$K.step("patternProperties", parentSchema);
+        const propertyNamePatterns = Schema$K.typeOf(patternProperties, "object") ? Schema$K.keys(patternProperties).map((pattern) => new RegExp(pattern)) : [];
+
+        return [propertyNames, propertyNamePatterns, await Core$s.compileSchema(schema, ast)];
+      };
+
+      const interpret$I = ([propertyNames, propertyNamePatterns, additionalProperties], instance, ast, dynamicAnchors) => {
+        if (!Instance$y.typeOf(instance, "object")) {
+          return true;
+        }
+
+        return Instance$y.entries(instance)
+          .filter(([propertyName]) => !propertyNames.includes(propertyName) && !propertyNamePatterns.some((pattern) => pattern.test(propertyName)))
+          .every(([, property]) => Core$s.interpretSchema(additionalProperties, property, ast, dynamicAnchors));
+      };
+
+      const collectEvaluatedProperties$c = (keywordValue, instance, ast, dynamicAnchors) => {
+        return interpret$I(keywordValue, instance, ast, dynamicAnchors) && [new RegExp("")];
+      };
+
+      var additionalProperties6 = { compile: compile$I, interpret: interpret$I, collectEvaluatedProperties: collectEvaluatedProperties$c };
+      additionalProperties6.compile;
+      additionalProperties6.interpret;
+      additionalProperties6.collectEvaluatedProperties;
+
+      const { Core: Core$r, Schema: Schema$J } = lib$1;
+
+
+
+      const compile$H = (schema, ast) => lib$2.pipeline([
+        Schema$J.map(async (itemSchema) => Core$r.compileSchema(await itemSchema, ast)),
+        lib$2.all
+      ], schema);
+
+      const interpret$H = (allOf, instance, ast, dynamicAnchors) => {
+        return allOf.every((schemaUrl) => Core$r.interpretSchema(schemaUrl, instance, ast, dynamicAnchors));
+      };
+
+      const collectEvaluatedProperties$b = (allOf, instance, ast, dynamicAnchors) => {
+        return allOf.reduce((acc, schemaUrl) => {
+          const propertyNames = acc && Core$r.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
+          return propertyNames !== false && [...acc, ...propertyNames];
+        }, []);
+      };
+
+      const collectEvaluatedItems$c = (allOf, instance, ast, dynamicAnchors) => {
+        return allOf.reduce((acc, schemaUrl) => {
+          const itemIndexes = acc !== false && Core$r.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
+          return itemIndexes !== false && new Set([...acc, ...itemIndexes]);
+        }, new Set());
+      };
+
+      var allOf = { compile: compile$H, interpret: interpret$H, collectEvaluatedProperties: collectEvaluatedProperties$b, collectEvaluatedItems: collectEvaluatedItems$c };
+      allOf.compile;
+      allOf.interpret;
+      allOf.collectEvaluatedProperties;
+      allOf.collectEvaluatedItems;
+
+      const { Core: Core$q, Schema: Schema$I } = lib$1;
+
+
+
+      const compile$G = (schema, ast) => lib$2.pipeline([
+        Schema$I.map(async (itemSchema) => Core$q.compileSchema(await itemSchema, ast)),
+        lib$2.all
+      ], schema);
+
+      const interpret$G = (anyOf, instance, ast, dynamicAnchors) => {
+        const matches = anyOf.filter((schemaUrl) => Core$q.interpretSchema(schemaUrl, instance, ast, dynamicAnchors));
+        return matches.length > 0;
+      };
+
+      const collectEvaluatedProperties$a = (anyOf, instance, ast, dynamicAnchors) => {
+        return anyOf.reduce((acc, schemaUrl) => {
+          const propertyNames = Core$q.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
+          return propertyNames !== false ? [...acc || [], ...propertyNames] : acc;
+        }, false);
+      };
+
+      const collectEvaluatedItems$b = (anyOf, instance, ast, dynamicAnchors) => {
+        return anyOf.reduce((acc, schemaUrl) => {
+          const itemIndexes = Core$q.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
+          return itemIndexes !== false ? new Set([...acc || [], ...itemIndexes]) : acc;
+        }, false);
+      };
+
+      var anyOf = { compile: compile$G, interpret: interpret$G, collectEvaluatedProperties: collectEvaluatedProperties$a, collectEvaluatedItems: collectEvaluatedItems$b };
+      anyOf.compile;
+      anyOf.interpret;
+      anyOf.collectEvaluatedProperties;
+      anyOf.collectEvaluatedItems;
+
+      var keyList = Object.keys;
+      var native_stringify = JSON.stringify;
+
+      function stringify(val, allowUndefined) {
+          var i, max, str, keys, key, propVal, tipeof;
+
+          tipeof = typeof val;
+
+          if (tipeof === 'string') return native_stringify(val);
+          if (val === true) return 'true';
+          if (val === false) return 'false';
+          if (val === null) return 'null';
+
+          if (val instanceof Array) {
+              str = '[';
+              max = val.length - 1;
+              for(i = 0; i < max; i++)
+                  str += stringify(val[i], false) + ',';
+              if (max > -1) {
+                  str += stringify(val[i], false);
+              }
+
+              return str + ']';
+          }
+
+          if (val instanceof Object) {
+              if (typeof val.toJSON === 'function')
+                  return stringify(val.toJSON(), allowUndefined);
+
+              // only object is left
+              keys = keyList(val).sort();
+              max = keys.length;
+              str = '';
+              i = 0;
+              while (i < max) {
+                  key = keys[i];
+                  propVal = stringify(val[key], true);
+                  if (propVal !== undefined) {
+                      if (i && str !== '') { //if the string is empty, don't add comma to avoid the json to become invalid.
+                          str += ',';
+                      }
+                      str += native_stringify(key) + ':' + propVal;
+                  }
+                  i++;
+              }
+              return '{' + str + '}';
+          }
+
+          switch (tipeof) {
+          case 'function':
+          case 'undefined':
+              return allowUndefined ? undefined : null;
+          default:
+              return isFinite(val) ? val : null;
+          }
+      }
+
+      var fastestStableStringify = function(obj) { return '' + stringify(obj, false); };
+
+      const { Schema: Schema$H, Instance: Instance$x } = lib$1;
+
+
+
+      const compile$F = (schema) => fastestStableStringify(Schema$H.value(schema));
+      const interpret$F = (const_, instance) => fastestStableStringify(Instance$x.value(instance)) === const_;
+
+      var _const = { compile: compile$F, interpret: interpret$F };
+      _const.compile;
+      _const.interpret;
+
+      const { Core: Core$p, Instance: Instance$w } = lib$1;
+
+
+      const compile$E = (schema, ast) => Core$p.compileSchema(schema, ast);
+
+      const interpret$E = (contains, instance, ast, dynamicAnchors) => {
+        return !Instance$w.typeOf(instance, "array") || Instance$w.some((item) => Core$p.interpretSchema(contains, item, ast, dynamicAnchors), instance);
+      };
+
+      var contains = { compile: compile$E, interpret: interpret$E };
+      contains.compile;
+      contains.interpret;
+
+      const { Core: Core$o, Schema: Schema$G, Instance: Instance$v } = lib$1;
+
+
+      const compile$D = async (schema, ast, parentSchema) => {
+        const contains = await Core$o.compileSchema(schema, ast);
+
+        const minContainsSchema = await Schema$G.step("minContains", parentSchema);
+        const minContains = Schema$G.typeOf(minContainsSchema, "number") ? Schema$G.value(minContainsSchema) : 1;
+
+        const maxContainsSchema = await Schema$G.step("maxContains", parentSchema);
+        const maxContains = Schema$G.typeOf(maxContainsSchema, "number") ? Schema$G.value(maxContainsSchema) : Number.MAX_SAFE_INTEGER;
+
+        return { contains, minContains, maxContains };
+      };
+
+      const interpret$D = ({ contains, minContains, maxContains }, instance, ast, dynamicAnchors) => {
+        if (!Instance$v.typeOf(instance, "array")) {
+          return true;
+        }
+
+        const matches = Instance$v.reduce((matches, item) => {
+          return Core$o.interpretSchema(contains, item, ast, dynamicAnchors) ? matches + 1 : matches;
+        }, 0, instance);
+        return matches >= minContains && matches <= maxContains;
+      };
+
+      const collectEvaluatedItems$a = (keywordValue, instance, ast, dynamicAnchors) => {
+        return interpret$D(keywordValue, instance, ast, dynamicAnchors) && Instance$v.reduce((matchedIndexes, item, itemIndex) => {
+          return Core$o.interpretSchema(keywordValue.contains, item, ast, dynamicAnchors) ? matchedIndexes.add(itemIndex) : matchedIndexes;
+        }, new Set(), instance);
+      };
+
+      var containsMinContainsMaxContains = { compile: compile$D, interpret: interpret$D, collectEvaluatedItems: collectEvaluatedItems$a };
+      containsMinContainsMaxContains.compile;
+      containsMinContainsMaxContains.interpret;
+      containsMinContainsMaxContains.collectEvaluatedItems;
+
+      const { Core: Core$n, Schema: Schema$F } = lib$1;
+
+
+
+      const compile$C = async (schema, ast) => {
+        await lib$2.pipeline([
+          Schema$F.entries,
+          lib$2.map(([, definitionSchema]) => Core$n.compileSchema(definitionSchema, ast)),
+          lib$2.all
+        ], schema);
+      };
+
+      const interpret$C = () => true;
+
+      var definitions = { compile: compile$C, interpret: interpret$C };
+      definitions.compile;
+      definitions.interpret;
+
+      const { Core: Core$m, Schema: Schema$E, Instance: Instance$u } = lib$1;
+
+
+
+      const compile$B = (schema, ast) => lib$2.pipeline([
+        Schema$E.entries,
+        lib$2.map(async ([key, dependency]) => {
+          return [key, Schema$E.typeOf(dependency, "array") ? Schema$E.value(dependency) : await Core$m.compileSchema(dependency, ast)];
+        }),
+        lib$2.all
+      ], schema);
+
+      const interpret$B = (dependencies, instance, ast, dynamicAnchors) => {
+        const value = Instance$u.value(instance);
+
+        return !Instance$u.typeOf(instance, "object") || dependencies.every(([propertyName, dependency]) => {
+          if (!(propertyName in value)) {
+            return true;
+          }
+
+          if (Array.isArray(dependency)) {
+            return dependency.every((key) => key in value);
+          } else {
+            return Core$m.interpretSchema(dependency, instance, ast, dynamicAnchors);
+          }
+        });
+      };
+
+      var dependencies = { compile: compile$B, interpret: interpret$B };
+      dependencies.compile;
+      dependencies.interpret;
+
+      const { Schema: Schema$D, Instance: Instance$t } = lib$1;
+
+
+
+      const compile$A = (schema) => lib$2.pipeline([
+        Schema$D.entries,
+        lib$2.map(([key, dependentRequired]) => [key, Schema$D.value(dependentRequired)]),
+        lib$2.all
+      ], schema);
+
+      const interpret$A = (dependentRequired, instance) => {
+        const value = Instance$t.value(instance);
+
+        return !Instance$t.typeOf(instance, "object") || dependentRequired.every(([propertyName, required]) => {
+          return !(propertyName in value) || required.every((key) => key in value);
+        });
+      };
+
+      var dependentRequired = { compile: compile$A, interpret: interpret$A };
+      dependentRequired.compile;
+      dependentRequired.interpret;
+
+      const { Core: Core$l, Schema: Schema$C, Instance: Instance$s } = lib$1;
+
+
+
+      const compile$z = (schema, ast) => lib$2.pipeline([
+        Schema$C.entries,
+        lib$2.map(async ([key, dependentSchema]) => [key, await Core$l.compileSchema(dependentSchema, ast)]),
+        lib$2.all
+      ], schema);
+
+      const interpret$z = (dependentSchemas, instance, ast, dynamicAnchors) => {
+        const value = Instance$s.value(instance);
+
+        return !Instance$s.typeOf(instance, "object") || dependentSchemas.every(([propertyName, dependentSchema]) => {
+          return !(propertyName in value) || Core$l.interpretSchema(dependentSchema, instance, ast, dynamicAnchors);
+        });
+      };
+
+      const collectEvaluatedProperties$9 = (dependentSchemas, instance, ast, dynamicAnchors) => {
+        return dependentSchemas.reduce((acc, [propertyName, dependentSchema]) => {
+          if (!acc || !Instance$s.has(propertyName, instance)) {
+            return acc;
+          }
+
+          const propertyNames = Core$l.collectEvaluatedProperties(dependentSchema, instance, ast, dynamicAnchors);
+          return propertyNames !== false && acc.concat(propertyNames);
+        }, []);
+      };
+
+      var dependentSchemas = { compile: compile$z, interpret: interpret$z, collectEvaluatedProperties: collectEvaluatedProperties$9 };
+      dependentSchemas.compile;
+      dependentSchemas.interpret;
+      dependentSchemas.collectEvaluatedProperties;
+
+      const { Schema: Schema$B, Instance: Instance$r } = lib$1;
+
+
+
+      const compile$y = (schema) => Schema$B.value(schema).map(fastestStableStringify);
+      const interpret$y = (enum_, instance) => enum_.some((enumValue) => fastestStableStringify(Instance$r.value(instance)) === enumValue);
+
+      var _enum = { compile: compile$y, interpret: interpret$y };
+      _enum.compile;
+      _enum.interpret;
+
+      const { Schema: Schema$A, Instance: Instance$q } = lib$1;
+
+
+      const compile$x = async (schema) => Schema$A.value(schema);
+      const interpret$x = (exclusiveMaximum, instance) => !Instance$q.typeOf(instance, "number") || Instance$q.value(instance) < exclusiveMaximum;
+
+      var exclusiveMaximum = { compile: compile$x, interpret: interpret$x };
+      exclusiveMaximum.compile;
+      exclusiveMaximum.interpret;
+
+      const { Schema: Schema$z, Instance: Instance$p } = lib$1;
+
+
+      const compile$w = async (schema) => Schema$z.value(schema);
+      const interpret$w = (exclusiveMinimum, instance) => !Instance$p.typeOf(instance, "number") || Instance$p.value(instance) > exclusiveMinimum;
+
+      var exclusiveMinimum = { compile: compile$w, interpret: interpret$w };
+      exclusiveMinimum.compile;
+      exclusiveMinimum.interpret;
+
+      const { Core: Core$k } = lib$1;
+
+
+      const compile$v = (schema, ast) => Core$k.compileSchema(schema, ast);
+
+      const interpret$v = (ifSchema, instance, ast, dynamicAnchors) => {
+        Core$k.interpretSchema(ifSchema, instance, ast, dynamicAnchors);
+        return true;
+      };
+
+      const collectEvaluatedProperties$8 = (ifSchema, instance, ast, dynamicAnchors) => {
+        return Core$k.collectEvaluatedProperties(ifSchema, instance, ast, dynamicAnchors) || [];
+      };
+
+      const collectEvaluatedItems$9 = (ifSchema, instance, ast, dynamicAnchors) => {
+        return Core$k.collectEvaluatedItems(ifSchema, instance, ast, dynamicAnchors) || new Set();
+      };
+
+      var _if = { compile: compile$v, interpret: interpret$v, collectEvaluatedProperties: collectEvaluatedProperties$8, collectEvaluatedItems: collectEvaluatedItems$9 };
+      _if.compile;
+      _if.interpret;
+      _if.collectEvaluatedProperties;
+      _if.collectEvaluatedItems;
+
+      const { Core: Core$j, Schema: Schema$y } = lib$1;
+
+
+      const compile$u = async (schema, ast, parentSchema) => {
+        if (Schema$y.has("if", parentSchema)) {
+          const ifSchema = await Schema$y.step("if", parentSchema);
+          return [await Core$j.compileSchema(ifSchema, ast), await Core$j.compileSchema(schema, ast)];
+        } else {
+          return [];
+        }
+      };
+
+      const interpret$u = ([guard, block], instance, ast, dynamicAnchors) => {
+        return guard === undefined || !quietInterpretSchema$1(guard, instance, ast, dynamicAnchors) || Core$j.interpretSchema(block, instance, ast, dynamicAnchors);
+      };
+
+      // Interpret a schema without events being emitted
+      const quietInterpretSchema$1 = (uri, instance, ast, dynamicAnchors) => {
+        const nodes = ast[uri][2];
+
+        return typeof nodes === "boolean" ? nodes : nodes
+          .every(([keywordId, , keywordValue]) => {
+            return Core$j.getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
+          });
+      };
+
+      const collectEvaluatedProperties$7 = ([guard, block], instance, ast, dynamicAnchors) => {
+        if (guard === undefined || !quietInterpretSchema$1(guard, instance, ast, dynamicAnchors)) {
+          return [];
+        }
+
+        return Core$j.collectEvaluatedProperties(block, instance, ast, dynamicAnchors);
+      };
+
+      const collectEvaluatedItems$8 = ([guard, block], instance, ast, dynamicAnchors) => {
+        if (guard === undefined || !quietInterpretSchema$1(guard, instance, ast, dynamicAnchors)) {
+          return new Set();
+        }
+
+        return Core$j.collectEvaluatedItems(block, instance, ast, dynamicAnchors);
+      };
+
+      var then = { compile: compile$u, interpret: interpret$u, collectEvaluatedProperties: collectEvaluatedProperties$7, collectEvaluatedItems: collectEvaluatedItems$8 };
+      then.compile;
+      then.interpret;
+      then.collectEvaluatedProperties;
+      then.collectEvaluatedItems;
+
+      const { Core: Core$i, Schema: Schema$x } = lib$1;
+
+
+      const compile$t = async (schema, ast, parentSchema) => {
+        if (Schema$x.has("if", parentSchema)) {
+          const ifSchema = await Schema$x.step("if", parentSchema);
+          return [await Core$i.compileSchema(ifSchema, ast), await Core$i.compileSchema(schema, ast)];
+        } else {
+          return [];
+        }
+      };
+
+      const interpret$t = ([guard, block], instance, ast, dynamicAnchors) => {
+        return guard === undefined || quietInterpretSchema(guard, instance, ast, dynamicAnchors) || Core$i.interpretSchema(block, instance, ast, dynamicAnchors);
+      };
+
+      // Interpret a schema without events being emitted
+      const quietInterpretSchema = (uri, instance, ast, dynamicAnchors) => {
+        const nodes = ast[uri][2];
+
+        return typeof nodes === "boolean" ? nodes : nodes
+          .every(([keywordId, , keywordValue]) => {
+            return Core$i.getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
+          });
+      };
+
+      const collectEvaluatedProperties$6 = ([guard, block], instance, ast, dynamicAnchors) => {
+        if (guard === undefined || quietInterpretSchema(guard, instance, ast, dynamicAnchors)) {
+          return [];
+        }
+
+        return Core$i.collectEvaluatedProperties(block, instance, ast, dynamicAnchors);
+      };
+
+      const collectEvaluatedItems$7 = ([guard, block], instance, ast, dynamicAnchors) => {
+        if (guard === undefined || quietInterpretSchema(guard, instance, ast, dynamicAnchors)) {
+          return new Set();
+        }
+
+        return Core$i.collectEvaluatedItems(block, instance, ast, dynamicAnchors);
+      };
+
+      var _else = { compile: compile$t, interpret: interpret$t, collectEvaluatedProperties: collectEvaluatedProperties$6, collectEvaluatedItems: collectEvaluatedItems$7 };
+      _else.compile;
+      _else.interpret;
+      _else.collectEvaluatedProperties;
+      _else.collectEvaluatedItems;
+
+      const { Core: Core$h, Schema: Schema$w, Instance: Instance$o } = lib$1;
+
+
+      const compile$s = async (schema, ast) => {
+        if (Schema$w.typeOf(schema, "array")) {
+          const tupleItems = await Schema$w.map((itemSchema) => Core$h.compileSchema(itemSchema, ast), schema);
+          return Promise.all(tupleItems);
+        } else {
+          return Core$h.compileSchema(schema, ast);
+        }
+      };
+
+      const interpret$s = (items, instance, ast, dynamicAnchors) => {
+        if (!Instance$o.typeOf(instance, "array")) {
+          return true;
+        }
+
+        if (typeof items === "string") {
+          return Instance$o.every((itemValue) => Core$h.interpretSchema(items, itemValue, ast, dynamicAnchors), instance);
+        } else {
+          return Instance$o.every((item, ndx) => !(ndx in items) || Core$h.interpretSchema(items[ndx], item, ast, dynamicAnchors), instance);
+        }
+      };
+
+      const collectEvaluatedItems$6 = (items, instance, ast, dynamicAnchors) => {
+        return interpret$s(items, instance, ast, dynamicAnchors) && (typeof items === "string"
+          ? new Set(Instance$o.map((item, itemIndex) => itemIndex, instance))
+          : new Set(items.map((item, itemIndex) => itemIndex)));
+      };
+
+      var items = { compile: compile$s, interpret: interpret$s, collectEvaluatedItems: collectEvaluatedItems$6 };
+      items.compile;
+      items.interpret;
+      items.collectEvaluatedItems;
+
+      const { Core: Core$g, Schema: Schema$v, Instance: Instance$n } = lib$1;
+
+
+      const compile$r = async (schema, ast, parentSchema) => {
+        const items = await Schema$v.step("prefixItems", parentSchema);
+        const numberOfPrefixItems = Schema$v.typeOf(items, "array") ? Schema$v.length(items) : 0;
+
+        return [numberOfPrefixItems, await Core$g.compileSchema(schema, ast)];
+      };
+
+      const interpret$r = ([numberOfPrefixItems, items], instance, ast, dynamicAnchors) => {
+        if (!Instance$n.typeOf(instance, "array")) {
+          return true;
+        }
+
+        return Instance$n.every((item, ndx) => ndx < numberOfPrefixItems || Core$g.interpretSchema(items, item, ast, dynamicAnchors), instance);
+      };
+
+      const collectEvaluatedItems$5 = (keywordValue, instance, ast, dynamicAnchors) => {
+        return interpret$r(keywordValue, instance, ast, dynamicAnchors) && new Set(Instance$n.map((item, ndx) => ndx, instance));
+      };
+
+      var items202012 = { compile: compile$r, interpret: interpret$r, collectEvaluatedItems: collectEvaluatedItems$5 };
+      items202012.compile;
+      items202012.interpret;
+      items202012.collectEvaluatedItems;
+
+      const { Schema: Schema$u, Instance: Instance$m } = lib$1;
+
+
+      const compile$q = (schema) => Schema$u.value(schema);
+      const interpret$q = (maxItems, instance) => !Instance$m.typeOf(instance, "array") || Instance$m.length(instance) <= maxItems;
+
+      var maxItems = { compile: compile$q, interpret: interpret$q };
+      maxItems.compile;
+      maxItems.interpret;
+
+      const { Schema: Schema$t, Instance: Instance$l } = lib$1;
+
+
+      const compile$p = (schema) => Schema$t.value(schema);
+      const interpret$p = (maxLength, instance) => !Instance$l.typeOf(instance, "string") || Instance$l.length(instance) <= maxLength;
+
+      var maxLength = { compile: compile$p, interpret: interpret$p };
+      maxLength.compile;
+      maxLength.interpret;
+
+      const { Schema: Schema$s, Instance: Instance$k } = lib$1;
+
+
+      const compile$o = (schema) => Schema$s.value(schema);
+      const interpret$o = (maxLength, instance) => !Instance$k.typeOf(instance, "string") || [...Instance$k.value(instance)].length <= maxLength;
+
+      var maxLength6 = { compile: compile$o, interpret: interpret$o };
+      maxLength6.compile;
+      maxLength6.interpret;
+
+      const { Schema: Schema$r, Instance: Instance$j } = lib$1;
+
+
+      const compile$n = (schema) => Schema$r.value(schema);
+      const interpret$n = (maxProperties, instance) => !Instance$j.typeOf(instance, "object") || Instance$j.keys(instance).length <= maxProperties;
+
+      var maxProperties = { compile: compile$n, interpret: interpret$n };
+      maxProperties.compile;
+      maxProperties.interpret;
+
+      const { Schema: Schema$q, Instance: Instance$i } = lib$1;
+
+
+      const compile$m = async (schema, ast, parentSchema) => {
+        const exclusiveMaximum = await Schema$q.step("exclusiveMaximum", parentSchema);
+        const isExclusive = Schema$q.value(exclusiveMaximum);
+
+        return [Schema$q.value(schema), isExclusive];
+      };
+
+      const interpret$m = ([maximum, isExclusive], instance) => {
+        if (!Instance$i.typeOf(instance, "number")) {
+          return true;
+        }
+
+        const value = Instance$i.value(instance);
+        return isExclusive ? value < maximum : value <= maximum;
+      };
+
+      var maximumExclusiveMaximum = { compile: compile$m, interpret: interpret$m };
+      maximumExclusiveMaximum.compile;
+      maximumExclusiveMaximum.interpret;
+
+      const { Schema: Schema$p, Instance: Instance$h } = lib$1;
+
+
+      const compile$l = async (schema) => Schema$p.value(schema);
+      const interpret$l = (maximum, instance) => !Instance$h.typeOf(instance, "number") || Instance$h.value(instance) <= maximum;
+
+      var maximum = { compile: compile$l, interpret: interpret$l };
+      maximum.compile;
+      maximum.interpret;
+
+      const { Schema: Schema$o, Instance: Instance$g } = lib$1;
+
+
+      const compile$k = (schema) => Schema$o.value(schema);
+      const interpret$k = (minItems, instance) => !Instance$g.typeOf(instance, "array") || Instance$g.length(instance) >= minItems;
+
+      var minItems = { compile: compile$k, interpret: interpret$k };
+      minItems.compile;
+      minItems.interpret;
+
+      const { Schema: Schema$n, Instance: Instance$f } = lib$1;
+
+
+      const compile$j = (schema) => Schema$n.value(schema);
+      const interpret$j = (minLength, instance) => !Instance$f.typeOf(instance, "string") || Instance$f.length(instance) >= minLength;
+
+      var minLength = { compile: compile$j, interpret: interpret$j };
+      minLength.compile;
+      minLength.interpret;
+
+      const { Schema: Schema$m, Instance: Instance$e } = lib$1;
+
+
+      const compile$i = (schema) => Schema$m.value(schema);
+      const interpret$i = (minLength, instance) => !Instance$e.typeOf(instance, "string") || [...Instance$e.value(instance)].length >= minLength;
+
+      var minLength6 = { compile: compile$i, interpret: interpret$i };
+      minLength6.compile;
+      minLength6.interpret;
+
+      const { Schema: Schema$l, Instance: Instance$d } = lib$1;
+
+
+      const compile$h = (schema) => Schema$l.value(schema);
+      const interpret$h = (minProperties, instance) => !Instance$d.typeOf(instance, "object") || Instance$d.keys(instance).length >= minProperties;
+
+      var minProperties = { compile: compile$h, interpret: interpret$h };
+      minProperties.compile;
+      minProperties.interpret;
+
+      const { Schema: Schema$k, Instance: Instance$c } = lib$1;
+
+
+      const compile$g = async (schema, ast, parentSchema) => {
+        const exclusiveMinimum = await Schema$k.step("exclusiveMinimum", parentSchema);
+        const isExclusive = Schema$k.value(exclusiveMinimum);
+
+        return [Schema$k.value(schema), isExclusive];
+      };
+
+      const interpret$g = ([minimum, isExclusive], instance) => {
+        if (!Instance$c.typeOf(instance, "number")) {
+          return true;
+        }
+
+        const value = Instance$c.value(instance);
+        return isExclusive ? value > minimum : value >= minimum;
+      };
+
+      var minimumExclusiveMinimum = { compile: compile$g, interpret: interpret$g };
+      minimumExclusiveMinimum.compile;
+      minimumExclusiveMinimum.interpret;
+
+      const { Schema: Schema$j, Instance: Instance$b } = lib$1;
+
+
+      const compile$f = async (schema) => Schema$j.value(schema);
+      const interpret$f = (minimum, instance) => !Instance$b.typeOf(instance, "number") || Instance$b.value(instance) >= minimum;
+
+      var minimum = { compile: compile$f, interpret: interpret$f };
+      minimum.compile;
+      minimum.interpret;
+
+      const { Schema: Schema$i, Instance: Instance$a } = lib$1;
+
+
+      const compile$e = (schema) => Schema$i.value(schema);
+
+      const interpret$e = (multipleOf, instance) => {
+        if (!Instance$a.typeOf(instance, "number")) {
+          return true;
+        }
+
+        const remainder = Instance$a.value(instance) % multipleOf;
+        return numberEqual(0, remainder) || numberEqual(multipleOf, remainder);
+      };
+
+      const numberEqual = (a, b) => Math.abs(a - b) < 1.19209290e-7;
+
+      var multipleOf = { compile: compile$e, interpret: interpret$e };
+      multipleOf.compile;
+      multipleOf.interpret;
+
+      const { Core: Core$f } = lib$1;
+
+
+      const compile$d = Core$f.compileSchema;
+      const interpret$d = (not, instance, ast, dynamicAnchors) => !Core$f.interpretSchema(not, instance, ast, dynamicAnchors);
+
+      var not = { compile: compile$d, interpret: interpret$d };
+      not.compile;
+      not.interpret;
+
+      const { Core: Core$e, Schema: Schema$h } = lib$1;
+
+
+      const compile$c = async (schema, ast) => {
+        const oneOf = await Schema$h.map((itemSchema) => Core$e.compileSchema(itemSchema, ast), schema);
+        return Promise.all(oneOf);
+      };
+
+      const interpret$c = (oneOf, instance, ast, dynamicAnchors) => {
+        let validCount = 0;
+        for (const schemaUrl of oneOf) {
+          if (Core$e.interpretSchema(schemaUrl, instance, ast, dynamicAnchors)) {
+            validCount++;
+          }
+
+          if (validCount > 1) {
+            break;
+          }
+        }
+
+        return validCount === 1;
+      };
+
+      const collectEvaluatedProperties$5 = (oneOf, instance, ast, dynamicAnchors) => {
+        let validCount = 0;
+        return oneOf.reduce((acc, schemaUrl) => {
+          if (validCount > 1) {
+            return false;
+          }
+
+          const propertyNames = Core$e.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
+          return propertyNames ? validCount++ === 0 && propertyNames : acc;
+        }, false);
+      };
+
+      const collectEvaluatedItems$4 = (oneOf, instance, ast, dynamicAnchors) => {
+        let validCount = 0;
+        return oneOf.reduce((acc, schemaUrl) => {
+          if (validCount > 1) {
+            return false;
+          }
+
+          const itemIndexes = Core$e.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
+          return itemIndexes ? validCount++ === 0 && itemIndexes : acc;
+        }, false);
+      };
+
+      var oneOf = { compile: compile$c, interpret: interpret$c, collectEvaluatedProperties: collectEvaluatedProperties$5, collectEvaluatedItems: collectEvaluatedItems$4 };
+      oneOf.compile;
+      oneOf.interpret;
+      oneOf.collectEvaluatedProperties;
+      oneOf.collectEvaluatedItems;
+
+      const { Schema: Schema$g, Instance: Instance$9 } = lib$1;
+
+
+      const compile$b = (schema) => new RegExp(Schema$g.value(schema), "u");
+      const interpret$b = (pattern, instance) => !Instance$9.typeOf(instance, "string") || pattern.test(Instance$9.value(instance));
+
+      var pattern = { compile: compile$b, interpret: interpret$b };
+      pattern.compile;
+      pattern.interpret;
+
+      const { Core: Core$d, Schema: Schema$f, Instance: Instance$8 } = lib$1;
+
+
+
+      const compile$a = (schema, ast) => lib$2.pipeline([
+        Schema$f.entries,
+        lib$2.map(async ([pattern, propertySchema]) => [new RegExp(pattern, "u"), await Core$d.compileSchema(propertySchema, ast)]),
+        lib$2.all
+      ], schema);
+
+      const interpret$a = (patternProperties, instance, ast, dynamicAnchors) => {
+        return !Instance$8.typeOf(instance, "object") || patternProperties.every(([pattern, schemaUrl]) => {
+          return Instance$8.entries(instance)
+            .filter(([propertyName]) => pattern.test(propertyName))
+            .every(([, propertyValue]) => Core$d.interpretSchema(schemaUrl, propertyValue, ast, dynamicAnchors));
+        });
+      };
+
+      const collectEvaluatedProperties$4 = (patternProperties, instance, ast, dynamicAnchors) => {
+        return interpret$a(patternProperties, instance, ast, dynamicAnchors) && patternProperties.map(([pattern]) => pattern);
+      };
+
+      var patternProperties = { compile: compile$a, interpret: interpret$a, collectEvaluatedProperties: collectEvaluatedProperties$4 };
+      patternProperties.compile;
+      patternProperties.interpret;
+      patternProperties.collectEvaluatedProperties;
+
+      const isObject = (value) => typeof value === "object" && !Array.isArray(value) && value !== null;
+      const escapeRegExp$1 = (string) => string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
+
+      const splitUrl$1 = (url) => {
+        const indexOfHash = url.indexOf("#");
+        const ndx = indexOfHash === -1 ? url.length : indexOfHash;
+        const urlReference = url.slice(0, ndx);
+        const urlFragment = url.slice(ndx + 1);
+
+        return [decodeURI(urlReference), decodeURI(urlFragment)];
+      };
+
+      var common = { isObject, escapeRegExp: escapeRegExp$1, splitUrl: splitUrl$1 };
+
+      const { Core: Core$c, Schema: Schema$e, Instance: Instance$7 } = lib$1;
+
+      const { escapeRegExp } = common;
+
+
+      const compile$9 = (schema, ast) => lib$2.pipeline([
+        Schema$e.entries,
+        lib$2.reduce(async (acc, [propertyName, propertySchema]) => {
+          acc[propertyName] = await Core$c.compileSchema(propertySchema, ast);
+          return acc;
+        }, Object.create(null))
+      ], schema);
+
+      const interpret$9 = (properties, instance, ast, dynamicAnchors) => {
+        return !Instance$7.typeOf(instance, "object") || Instance$7.entries(instance)
+          .filter(([propertyName]) => propertyName in properties)
+          .every(([propertyName, schemaUrl]) => Core$c.interpretSchema(properties[propertyName], schemaUrl, ast, dynamicAnchors));
+      };
+
+      const collectEvaluatedProperties$3 = (properties, instance, ast, dynamicAnchors) => {
+        return interpret$9(properties, instance, ast, dynamicAnchors) && Object.keys(properties)
+          .map((propertyName) => new RegExp(`^${escapeRegExp(propertyName)}$`));
+      };
+
+      var properties = { compile: compile$9, interpret: interpret$9, collectEvaluatedProperties: collectEvaluatedProperties$3 };
+      properties.compile;
+      properties.interpret;
+      properties.collectEvaluatedProperties;
+
+      const { Core: Core$b, Instance: Instance$6 } = lib$1;
+
+
+      const compile$8 = (schema, ast) => Core$b.compileSchema(schema, ast);
+
+      const interpret$8 = (propertyNames, instance, ast, dynamicAnchors) => {
+        return !Instance$6.typeOf(instance, "object") || Instance$6.keys(instance)
+          .every((key) => Core$b.interpretSchema(propertyNames, Instance$6.cons(key), ast, dynamicAnchors));
+      };
+
+      var propertyNames = { compile: compile$8, interpret: interpret$8 };
+      propertyNames.compile;
+      propertyNames.interpret;
+
+      const { Core: Core$a, Schema: Schema$d } = lib$1;
+      const { splitUrl } = common;
+
+
+      const compile$7 = async (dynamicRef, ast) => {
+        const [, fragment] = splitUrl(Schema$d.value(dynamicRef));
+        const referencedSchema = await Schema$d.get(Schema$d.value(dynamicRef), dynamicRef);
+        await Core$a.compileSchema(referencedSchema, ast);
+        return [referencedSchema.id, fragment];
+      };
+
+      const interpret$7 = ([id, fragment], instance, ast, dynamicAnchors) => {
+        if (fragment in ast.metaData[id].dynamicAnchors) {
+          return Core$a.interpretSchema(dynamicAnchors[fragment], instance, ast, dynamicAnchors);
+        } else {
+          const pointer = Schema$d.getAnchorPointer(ast.metaData[id], fragment);
+          return Core$a.interpretSchema(`${id}#${encodeURI(pointer)}`, instance, ast, dynamicAnchors);
+        }
+      };
+
+      const collectEvaluatedProperties$2 = Core$a.collectEvaluatedProperties;
+      const collectEvaluatedItems$3 = Core$a.collectEvaluatedItems;
+
+      var dynamicRef = { compile: compile$7, interpret: interpret$7, collectEvaluatedProperties: collectEvaluatedProperties$2, collectEvaluatedItems: collectEvaluatedItems$3 };
+      dynamicRef.compile;
+      dynamicRef.interpret;
+      dynamicRef.collectEvaluatedProperties;
+      dynamicRef.collectEvaluatedItems;
+
+      const { Core: Core$9, Schema: Schema$c } = lib$1;
+
+
+      const compile$6 = async (ref, ast) => {
+        const referencedSchema = await Schema$c.get(Schema$c.value(ref), ref);
+        return Core$9.compileSchema(referencedSchema, ast);
+      };
+
+      const interpret$6 = Core$9.interpretSchema;
+      const collectEvaluatedProperties$1 = Core$9.collectEvaluatedProperties;
+      const collectEvaluatedItems$2 = Core$9.collectEvaluatedItems;
+
+      var ref = { compile: compile$6, interpret: interpret$6, collectEvaluatedProperties: collectEvaluatedProperties$1, collectEvaluatedItems: collectEvaluatedItems$2 };
+      ref.compile;
+      ref.interpret;
+      ref.collectEvaluatedProperties;
+      ref.collectEvaluatedItems;
+
+      const { Schema: Schema$b, Instance: Instance$5 } = lib$1;
+
+
+      const compile$5 = (schema) => Schema$b.value(schema);
+
+      const interpret$5 = (required, instance) => {
+        return !Instance$5.typeOf(instance, "object") || required.every((propertyName) => Object.prototype.hasOwnProperty.call(Instance$5.value(instance), propertyName));
+      };
+
+      var required = { compile: compile$5, interpret: interpret$5 };
+      required.compile;
+      required.interpret;
+
+      const { Core: Core$8, Schema: Schema$a, Instance: Instance$4 } = lib$1;
+
+
+
+      const compile$4 = (schema, ast) => {
+        return lib$2.pipeline([
+          Schema$a.map((itemSchema) => Core$8.compileSchema(itemSchema, ast)),
+          lib$2.all
+        ], schema);
+      };
+
+      const interpret$4 = (items, instance, ast, dynamicAnchors) => {
+        if (!Instance$4.typeOf(instance, "array")) {
+          return true;
+        }
+
+        return Instance$4.every((item, ndx) => !(ndx in items) || Core$8.interpretSchema(items[ndx], item, ast, dynamicAnchors), instance);
+      };
+
+      const collectEvaluatedItems$1 = (items, instance, ast, dynamicAnchors) => {
+        return interpret$4(items, instance, ast, dynamicAnchors) && new Set(items.map((item, ndx) => ndx));
+      };
+
+      var tupleItems = { compile: compile$4, interpret: interpret$4, collectEvaluatedItems: collectEvaluatedItems$1 };
+      tupleItems.compile;
+      tupleItems.interpret;
+      tupleItems.collectEvaluatedItems;
+
+      const { Schema: Schema$9, Instance: Instance$3 } = lib$1;
+
+
+      const compile$3 = (schema) => Schema$9.value(schema);
+      const interpret$3 = (type, instance) => typeof type === "string" ? Instance$3.typeOf(instance, type) : type.some(Instance$3.typeOf(instance));
+
+      var type = { compile: compile$3, interpret: interpret$3 };
+      type.compile;
+      type.interpret;
+
+      const { Core: Core$7, Schema: Schema$8, Instance: Instance$2 } = lib$1;
+
+
+      const compile$2 = async (schema, ast, parentSchema) => {
+        return [Schema$8.uri(parentSchema), await Core$7.compileSchema(schema, ast)];
+      };
+
+      const interpret$2 = ([schemaUrl, unevaluatedItems], instance, ast, dynamicAnchors) => {
+        if (!Instance$2.typeOf(instance, "array")) {
+          return true;
+        }
+
+        const itemIndexes = Core$7.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors, true);
+        return itemIndexes === false || Instance$2.every((item, itemIndex) => {
+          return itemIndexes.has(itemIndex) || Core$7.interpretSchema(unevaluatedItems, Instance$2.step(itemIndex, instance), ast, dynamicAnchors);
+        }, instance);
+      };
+
+      const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
+        return interpret$2(keywordValue, instance, ast, dynamicAnchors) && new Set(Instance$2.map((item, ndx) => ndx, instance));
+      };
+
+      var unevaluatedItems = { compile: compile$2, interpret: interpret$2, collectEvaluatedItems };
+      unevaluatedItems.compile;
+      unevaluatedItems.interpret;
+      unevaluatedItems.collectEvaluatedItems;
+
+      const { Core: Core$6, Schema: Schema$7, Instance: Instance$1 } = lib$1;
+
+
+      const compile$1 = async (schema, ast, parentSchema) => {
+        return [Schema$7.uri(parentSchema), await Core$6.compileSchema(schema, ast)];
+      };
+
+      const interpret$1 = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnchors) => {
+        if (!Instance$1.typeOf(instance, "object")) {
+          return true;
+        }
+
+        const evaluatedPropertyNames = Core$6.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors, true);
+
+        return !evaluatedPropertyNames || Instance$1.entries(instance)
+          .filter(([propertyName]) => !evaluatedPropertyNames.some((pattern) => propertyName.match(pattern)))
+          .every(([, property]) => Core$6.interpretSchema(unevaluatedProperties, property, ast, dynamicAnchors));
+      };
+
+      const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors) =>{
+        return interpret$1(keywordValue, instance, ast, dynamicAnchors) && [new RegExp("")];
+      };
+
+      var unevaluatedProperties = { compile: compile$1, interpret: interpret$1, collectEvaluatedProperties };
+      unevaluatedProperties.compile;
+      unevaluatedProperties.interpret;
+      unevaluatedProperties.collectEvaluatedProperties;
+
+      const { Schema: Schema$6, Instance } = lib$1;
+
+
+
+      const compile = (schema) => Schema$6.value(schema);
+
+      const interpret = (uniqueItems, instance) => {
+        if (!Instance.typeOf(instance, "array") || uniqueItems === false) {
+          return true;
+        }
+
+        const normalizedItems = Instance.map((item) => fastestStableStringify(Instance.value(item)), instance);
+        return new Set(normalizedItems).size === normalizedItems.length;
+      };
+
+      var uniqueItems = { compile, interpret };
+      uniqueItems.compile;
+      uniqueItems.interpret;
+
+      const { Keywords } = lib$1;
+
+
+      var keywords = {
+        additionalItems: additionalItems,
+        additionalItems6: additionalItems6,
+        additionalProperties: additionalProperties,
+        additionalProperties6: additionalProperties6,
+        allOf: allOf,
+        anyOf: anyOf,
+        const: _const,
+        contains: contains,
+        containsMinContainsMaxContains: containsMinContainsMaxContains,
+        definitions: definitions,
+        dependencies: dependencies,
+        dependentRequired: dependentRequired,
+        dependentSchemas: dependentSchemas,
+        enum: _enum,
+        exclusiveMaximum: exclusiveMaximum,
+        exclusiveMinimum: exclusiveMinimum,
+        if: _if,
+        then: then,
+        else: _else,
+        items: items,
+        items202012: items202012,
+        maxItems: maxItems,
+        maxLength: maxLength,
+        maxLength6: maxLength6,
+        maxProperties: maxProperties,
+        maximumExclusiveMaximum: maximumExclusiveMaximum,
+        maximum: maximum,
+        metaData: Keywords.metaData,
+        minItems: minItems,
+        minLength: minLength,
+        minLength6: minLength6,
+        minProperties: minProperties,
+        minimumExclusiveMinimum: minimumExclusiveMinimum,
+        minimum: minimum,
+        multipleOf: multipleOf,
+        not: not,
+        oneOf: oneOf,
+        pattern: pattern,
+        patternProperties: patternProperties,
+        properties: properties,
+        propertyNames: propertyNames,
+        dynamicRef: dynamicRef,
+        ref: ref,
+        required: required,
+        tupleItems: tupleItems,
+        type: type,
+        unevaluatedItems: unevaluatedItems,
+        unevaluatedProperties: unevaluatedProperties,
+        uniqueItems: uniqueItems,
+        validate: Keywords.validate
+      };
+      keywords.additionalItems;
+      keywords.additionalItems6;
+      keywords.additionalProperties;
+      keywords.additionalProperties6;
+      keywords.allOf;
+      keywords.anyOf;
+      keywords.contains;
+      keywords.containsMinContainsMaxContains;
+      keywords.definitions;
+      keywords.dependencies;
+      keywords.dependentRequired;
+      keywords.dependentSchemas;
+      keywords.exclusiveMaximum;
+      keywords.exclusiveMinimum;
+      keywords.then;
+      keywords.items;
+      keywords.items202012;
+      keywords.maxItems;
+      keywords.maxLength;
+      keywords.maxLength6;
+      keywords.maxProperties;
+      keywords.maximumExclusiveMaximum;
+      keywords.maximum;
+      keywords.metaData;
+      keywords.minItems;
+      keywords.minLength;
+      keywords.minLength6;
+      keywords.minProperties;
+      keywords.minimumExclusiveMinimum;
+      keywords.minimum;
+      keywords.multipleOf;
+      keywords.not;
+      keywords.oneOf;
+      keywords.pattern;
+      keywords.patternProperties;
+      keywords.properties;
+      keywords.propertyNames;
+      keywords.dynamicRef;
+      keywords.ref;
+      keywords.required;
+      keywords.tupleItems;
+      keywords.type;
+      keywords.unevaluatedItems;
+      keywords.unevaluatedProperties;
+      keywords.uniqueItems;
+      keywords.validate;
+
+      var schema$4 = `{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string"
+        },
+        "$schema": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}`;
+
+      var hyperSchema = `{
+    "$schema": "http://json-schema.org/draft-04/hyper-schema#",
+    "id": "http://json-schema.org/draft-04/hyper-schema#",
+    "title": "JSON Hyper-Schema",
+    "allOf": [
+        {"$ref": "http://json-schema.org/draft-04/schema#"}
+    ],
+    "properties": {
+        "additionalItems": {
+            "anyOf": [
+                {"type": "boolean"},
+                {"$ref": "#"}
+            ]
+        },
+        "additionalProperties": {
+            "anyOf": [
+                {"type": "boolean"},
+                {"$ref": "#"}
+            ]
+        },
+        "dependencies": {
+            "additionalProperties": {
+                "anyOf": [
+                    {"$ref": "#"},
+                    {"type": "array"}
+                ]
+            }
+        },
+        "items": {
+            "anyOf": [
+                {"$ref": "#"},
+                {"$ref": "#/definitions/schemaArray"}
+            ]
+        },
+        "definitions": {
+            "additionalProperties": {"$ref": "#"}
+        },
+        "patternProperties": {
+            "additionalProperties": {"$ref": "#"}
+        },
+        "properties": {
+            "additionalProperties": {"$ref": "#"}
+        },
+        "allOf": {"$ref": "#/definitions/schemaArray"},
+        "anyOf": {"$ref": "#/definitions/schemaArray"},
+        "oneOf": {"$ref": "#/definitions/schemaArray"},
+        "not": { "$ref": "#" },
+
+        "links": {
+            "type": "array",
+            "items": {"$ref": "#/definitions/linkDescription"}
+        },
+        "fragmentResolution": {
+            "type": "string"
+        },
+        "media": {
+            "type": "object",
+            "properties": {
+                "type": {
+                    "description": "A media type, as described in RFC 2046",
+                    "type": "string"
+                },
+                "binaryEncoding": {
+                    "description": "A content encoding scheme, as described in RFC 2045",
+                    "type": "string"
+                }
+            }
+        },
+        "pathStart": {
+            "description": "Instances' URIs must start with this value for this schema to apply to them",
+            "type": "string",
+            "format": "uri"
+        }
+    },
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "items": {"$ref": "#"}
+        },
+        "linkDescription": {
+            "title": "Link Description Object",
+            "type": "object",
+            "required": ["href", "rel"],
+            "properties": {
+                "href": {
+                    "description": "a URI template, as defined by RFC 6570, with the addition of the $, ( and ) characters for pre-processing",
+                    "type": "string"
+                },
+                "rel": {
+                    "description": "relation to the target resource of the link",
+                    "type": "string"
+                },
+                "title": {
+                    "description": "a title for the link",
+                    "type": "string"
+                },
+                "targetSchema": {
+                    "description": "JSON Schema describing the link target",
+                    "$ref": "#"
+                },
+                "mediaType": {
+                    "description": "media type (as defined by RFC 2046) describing the link target",
+                    "type": "string"
+                },
+                "method": {
+                    "description": "method for requesting the target of the link (e.g. for HTTP this might be \\"GET\\" or \\"DELETE\\")",
+                    "type": "string"
+                },
+                "encType": {
+                    "description": "The media type in which to submit data along with the request",
+                    "type": "string",
+                    "default": "application/json"
+                },
+                "schema": {
+                    "description": "Schema describing the data to submit along with the request",
+                    "$ref": "#"
+                }
+            }
+        },
+        "readOnly": {
+            "description": "If true, indicates that the value of this property is controlled by the server.",
+            "type": "boolean",
+            "default": false
+        }
+    },
+    "links": [
+        {
+            "rel": "self",
+            "href": "{+id}"
+        },
+        {
+            "rel": "full",
+            "href": "{+($ref)}"
+        }
+    ]
+}`;
+
+      const { Core: Core$5, Schema: Schema$5 } = lib$1;
+
+
+
+
+
+      // JSON Schema Draft-04
+      const schemaVersion$4 = "http://json-schema.org/draft-04/schema";
+
+      Schema$5.setConfig(schemaVersion$4, "baseToken", "id");
+      Schema$5.setConfig(schemaVersion$4, "embeddedToken", "id");
+      Schema$5.setConfig(schemaVersion$4, "anchorToken", "id");
+      Schema$5.setConfig(schemaVersion$4, "jrefToken", "$ref");
+
+      Schema$5.add(JSON.parse(schema$4));
+      Core$5.defineVocabulary(schemaVersion$4, {
+        "validate": keywords.validate,
+        "additionalItems": keywords.additionalItems,
+        "additionalProperties": keywords.additionalProperties,
+        "allOf": keywords.allOf,
+        "anyOf": keywords.anyOf,
+        "default": keywords.metaData,
+        "definitions": keywords.definitions,
+        "dependencies": keywords.dependencies,
+        "description": keywords.metaData,
+        "enum": keywords.enum,
+        "format": keywords.metaData,
+        "items": keywords.items,
+        "maxItems": keywords.maxItems,
+        "maxLength": keywords.maxLength,
+        "maxProperties": keywords.maxProperties,
+        "maximum": keywords.maximumExclusiveMaximum,
+        "minItems": keywords.minItems,
+        "minLength": keywords.minLength,
+        "minProperties": keywords.minProperties,
+        "minimum": keywords.minimumExclusiveMinimum,
+        "multipleOf": keywords.multipleOf,
+        "not": keywords.not,
+        "oneOf": keywords.oneOf,
+        "pattern": keywords.pattern,
+        "patternProperties": keywords.patternProperties,
+        "properties": keywords.properties,
+        "required": keywords.required,
+        "title": keywords.metaData,
+        "type": keywords.type,
+        "uniqueItems": keywords.uniqueItems
+      });
+
+      // JSON Hyper-Schema Draft-04
+      const hyperSchemaVersion = "http://json-schema.org/draft-04/hyper-schema";
+
+      Schema$5.setConfig(hyperSchemaVersion, "baseToken", "id");
+      Schema$5.setConfig(hyperSchemaVersion, "embeddedToken", "id");
+      Schema$5.setConfig(hyperSchemaVersion, "anchorToken", "id");
+      Schema$5.setConfig(hyperSchemaVersion, "jrefToken", "$ref");
+
+      Schema$5.add(JSON.parse(hyperSchema));
+      Core$5.defineVocabulary(hyperSchemaVersion, {
+        "validate": keywords.validate,
+        "additionalItems": keywords.additionalItems,
+        "additionalProperties": keywords.additionalProperties,
+        "allOf": keywords.allOf,
+        "anyOf": keywords.anyOf,
+        "default": keywords.metaData,
+        "definitions": keywords.definitions,
+        "dependencies": keywords.dependencies,
+        "description": keywords.metaData,
+        "enum": keywords.enum,
+        "format": keywords.metaData,
+        "fragmentResolution": keywords.metaData,
+        "items": keywords.items,
+        "maxItems": keywords.maxItems,
+        "minProperties": keywords.minProperties,
+        "maxProperties": keywords.maxProperties,
+        "maximum": keywords.maximumExclusiveMaximum,
+        "media": keywords.metaData,
+        "minItems": keywords.minItems,
+        "minLength": keywords.minLength,
+        "maxLength": keywords.maxLength,
+        "minimum": keywords.minimumExclusiveMinimum,
+        "multipleOf": keywords.multipleOf,
+        "links": keywords.metaData,
+        "not": keywords.not,
+        "oneOf": keywords.oneOf,
+        "pathStart": keywords.metaData,
+        "pattern": keywords.pattern,
+        "patternProperties": keywords.patternProperties,
+        "properties": keywords.properties,
+        "readOnly": keywords.metaData,
+        "required": keywords.required,
+        "title": keywords.metaData,
+        "type": keywords.type,
+        "uniqueItems": keywords.uniqueItems
+      });
+
+      var schema$3 = `{
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "$id": "http://json-schema.org/draft-06/schema#",
+    "title": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "allOf": [
+                { "$ref": "#/definitions/nonNegativeInteger" },
+                { "default": 0 }
+            ]
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    },
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "examples": {
+            "type": "array",
+            "items": {}
+        },
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": { "$ref": "#" },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "contains": { "$ref": "#" },
+        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": { "$ref": "#" },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "propertyNames": { "$ref": "#" },
+        "const": {},
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "default": {}
+}`;
+
+      const { Core: Core$4, Schema: Schema$4 } = lib$1;
+
+
+
+
+      const schemaVersion$3 = "http://json-schema.org/draft-06/schema";
+
+      Schema$4.setConfig(schemaVersion$3, "baseToken", "$id");
+      Schema$4.setConfig(schemaVersion$3, "embeddedToken", "$id");
+      Schema$4.setConfig(schemaVersion$3, "anchorToken", "$id");
+      Schema$4.setConfig(schemaVersion$3, "jrefToken", "$ref");
+
+      Schema$4.add(JSON.parse(schema$3));
+      Core$4.defineVocabulary(schemaVersion$3, {
+        "validate": keywords.validate,
+        "additionalItems": keywords.additionalItems6,
+        "additionalProperties": keywords.additionalProperties6,
+        "allOf": keywords.allOf,
+        "anyOf": keywords.anyOf,
+        "const": keywords.const,
+        "contains": keywords.contains,
+        "default": keywords.metaData,
+        "definitions": keywords.definitions,
+        "dependencies": keywords.dependencies,
+        "description": keywords.metaData,
+        "enum": keywords.enum,
+        "examples": keywords.metaData,
+        "exclusiveMaximum": keywords.exclusiveMaximum,
+        "exclusiveMinimum": keywords.exclusiveMinimum,
+        "format": keywords.metaData,
+        "items": keywords.items,
+        "maxItems": keywords.maxItems,
+        "maxLength": keywords.maxLength6,
+        "maxProperties": keywords.maxProperties,
+        "maximum": keywords.maximum,
+        "minItems": keywords.minItems,
+        "minLength": keywords.minLength6,
+        "minProperties": keywords.minProperties,
+        "minimum": keywords.minimum,
+        "multipleOf": keywords.multipleOf,
+        "not": keywords.not,
+        "oneOf": keywords.oneOf,
+        "pattern": keywords.pattern,
+        "patternProperties": keywords.patternProperties,
+        "properties": keywords.properties,
+        "propertyNames": keywords.propertyNames,
+        "required": keywords.required,
+        "title": keywords.metaData,
+        "type": keywords.type,
+        "uniqueItems": keywords.uniqueItems
+      });
+
+      var schema$2 = `{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$id": "http://json-schema.org/draft-07/schema#",
+    "title": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "allOf": [
+                { "$ref": "#/definitions/nonNegativeInteger" },
+                { "default": 0 }
+            ]
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    },
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": true,
+        "readOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "writeOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "examples": {
+            "type": "array",
+            "items": true
+        },
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": { "$ref": "#" },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": true
+        },
+        "maxItems": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "contains": { "$ref": "#" },
+        "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": { "$ref": "#" },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "propertyNames": { "$ref": "#" },
+        "const": true,
+        "enum": {
+            "type": "array",
+            "items": true,
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "format": { "type": "string" },
+        "contentMediaType": { "type": "string" },
+        "contentEncoding": { "type": "string" },
+        "if": { "$ref": "#" },
+        "then": { "$ref": "#" },
+        "else": { "$ref": "#" },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "default": true
+}`;
+
+      const { Core: Core$3, Schema: Schema$3 } = lib$1;
+
+
+
+
+      const schemaVersion$2 = "http://json-schema.org/draft-07/schema";
+
+      Schema$3.setConfig(schemaVersion$2, "baseToken", "$id");
+      Schema$3.setConfig(schemaVersion$2, "embeddedToken", "$id");
+      Schema$3.setConfig(schemaVersion$2, "anchorToken", "$id");
+      Schema$3.setConfig(schemaVersion$2, "jrefToken", "$ref");
+
+      Schema$3.add(JSON.parse(schema$2));
+      Core$3.defineVocabulary(schemaVersion$2, {
+        "validate": keywords.validate,
+        "additionalItems": keywords.additionalItems6,
+        "additionalProperties": keywords.additionalProperties6,
+        "allOf": keywords.allOf,
+        "anyOf": keywords.anyOf,
+        "const": keywords.const,
+        "contains": keywords.contains,
+        "default": keywords.metaData,
+        "definitions": keywords.definitions,
+        "dependencies": keywords.dependencies,
+        "description": keywords.metaData,
+        "enum": keywords.enum,
+        "exclusiveMaximum": keywords.exclusiveMaximum,
+        "exclusiveMinimum": keywords.exclusiveMinimum,
+        "format": keywords.metaData,
+        "if": keywords.if,
+        "then": keywords.then,
+        "else": keywords.else,
+        "items": keywords.items,
+        "maxItems": keywords.maxItems,
+        "maxLength": keywords.maxLength6,
+        "maxProperties": keywords.maxProperties,
+        "maximum": keywords.maximum,
+        "minItems": keywords.minItems,
+        "minLength": keywords.minLength6,
+        "minProperties": keywords.minProperties,
+        "minimum": keywords.minimum,
+        "multipleOf": keywords.multipleOf,
+        "not": keywords.not,
+        "oneOf": keywords.oneOf,
+        "pattern": keywords.pattern,
+        "patternProperties": keywords.patternProperties,
+        "properties": keywords.properties,
+        "propertyNames": keywords.propertyNames,
+        "readOnly": keywords.metaData,
+        "required": keywords.required,
+        "title": keywords.metaData,
+        "type": keywords.type,
+        "uniqueItems": keywords.uniqueItems,
+        "writeOnly": keywords.metaData
+      });
+
+      var schema$1 = `{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/core": true,
+        "https://json-schema.org/draft/2019-09/vocab/applicator": true,
+        "https://json-schema.org/draft/2019-09/vocab/validation": true,
+        "https://json-schema.org/draft/2019-09/vocab/meta-data": true,
+        "https://json-schema.org/draft/2019-09/vocab/format": false,
+        "https://json-schema.org/draft/2019-09/vocab/content": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Core and Validation specifications meta-schema",
+    "allOf": [
+        {"$ref": "meta/core"},
+        {"$ref": "meta/applicator"},
+        {"$ref": "meta/validation"},
+        {"$ref": "meta/meta-data"},
+        {"$ref": "meta/format"},
+        {"$ref": "meta/content"}
+    ],
+    "type": ["object", "boolean"],
+    "properties": {
+        "definitions": {
+            "$comment": "While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.",
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "$comment": "\\"dependencies\\" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to \\"dependentSchemas\\" and \\"dependentRequired\\"",
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$recursiveRef": "#" },
+                    { "$ref": "meta/validation#/$defs/stringArray" }
+                ]
+            }
+        }
+    }
+}`;
+
+      var core$1 = `{
+    "$id": "https://json-schema.org/draft/2019-09/meta/core",
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$vocabulary": {
+      "https://json-schema.org/draft/2019-09/vocab/core": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Core vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference",
+            "$comment": "Non-empty fragments not allowed.",
+            "pattern": "^[^#]*#?$"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$anchor": {
+            "type": "string",
+            "pattern": "^[A-Za-z][-A-Za-z0-9.:_]*$"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$recursiveRef": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$recursiveAnchor": {
+            "type": "boolean",
+            "default": false
+        },
+        "$vocabulary": {
+            "type": "object",
+            "propertyNames": {
+                "type": "string",
+                "format": "uri"
+            },
+            "additionalProperties": {
+                "type": "boolean"
+            }
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "$defs": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "default": {}
+        }
+    }
+}`;
+
+      var applicator$1 = `{
+    "$id": "https://json-schema.org/draft/2019-09/meta/applicator",
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/applicator": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Applicator vocabulary meta-schema",
+    "properties": {
+        "additionalItems": { "$recursiveRef": "#" },
+        "unevaluatedItems": { "$recursiveRef": "#" },
+        "items": {
+            "anyOf": [
+                { "$recursiveRef": "#" },
+                { "$ref": "#/$defs/schemaArray" }
+            ]
+        },
+        "contains": { "$recursiveRef": "#" },
+        "additionalProperties": { "$recursiveRef": "#" },
+        "unevaluatedProperties": { "$recursiveRef": "#" },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependentSchemas": {
+            "type": "object",
+            "additionalProperties": {
+                "$recursiveRef": "#"
+            }
+        },
+        "propertyNames": { "$recursiveRef": "#" },
+        "if": { "$recursiveRef": "#" },
+        "then": { "$recursiveRef": "#" },
+        "else": { "$recursiveRef": "#" },
+        "allOf": { "$ref": "#/$defs/schemaArray" },
+        "anyOf": { "$ref": "#/$defs/schemaArray" },
+        "oneOf": { "$ref": "#/$defs/schemaArray" },
+        "not": { "$recursiveRef": "#" }
+    },
+    "$defs": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$recursiveRef": "#" }
+        }
+    }
+}`;
+
+      var validation$1 = `{
+    "$id": "https://json-schema.org/draft/2019-09/meta/validation",
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$vocabulary": {
+      "https://json-schema.org/draft/2019-09/vocab/validation": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Validation vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minContains": {
+            "$ref": "#/$defs/nonNegativeInteger",
+            "default": 1
+        },
+        "maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/$defs/stringArray" },
+        "dependentRequired": {
+            "type": "object",
+            "additionalProperties": {
+                "$ref": "#/$defs/stringArray"
+            }
+        },
+        "const": true,
+        "enum": {
+            "type": "array",
+            "items": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/$defs/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/$defs/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        }
+    },
+    "$defs": {
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "$ref": "#/$defs/nonNegativeInteger",
+            "default": 0
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    }
+}`;
+
+      var metaData$1 = `{
+    "$id": "https://json-schema.org/draft/2019-09/meta/meta-data",
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$vocabulary": {
+      "https://json-schema.org/draft/2019-09/vocab/meta-data": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Meta-data vocabulary meta-schema",
+
+    "type": ["object", "boolean"],
+    "properties": {
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": true,
+        "deprecated": {
+            "type": "boolean",
+            "default": false
+        },
+        "readOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "writeOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "examples": {
+            "type": "array",
+            "items": true
+        }
+    }
+}`;
+
+      var format = `{
+    "$id": "https://json-schema.org/draft/2019-09/meta/format",
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$vocabulary": {
+      "https://json-schema.org/draft/2019-09/vocab/format": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Format vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "format": { "type": "string" }
+    }
+}`;
+
+      var content$1 = `{
+    "$id": "https://json-schema.org/draft/2019-09/meta/content",
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$vocabulary": {
+      "https://json-schema.org/draft/2019-09/vocab/content": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Content vocabulary meta-schema",
+
+    "type": ["object", "boolean"],
+    "properties": {
+        "contentMediaType": { "type": "string" },
+        "contentEncoding": { "type": "string" },
+        "contentSchema": { "$recursiveRef": "#" }
+    }
+}`;
+
+      const { Core: Core$2, Schema: Schema$2 } = lib$1;
+
+
+
+
+
+
+
+
+
+
+      const schemaVersion$1 = "https://json-schema.org/draft/2019-09/schema";
+
+      Schema$2.setConfig(schemaVersion$1, "baseToken", "$id");
+      Schema$2.setConfig(schemaVersion$1, "embeddedToken", "$id");
+      Schema$2.setConfig(schemaVersion$1, "anchorToken", "$anchor");
+      Schema$2.setConfig(schemaVersion$1, "recursiveAnchorToken", "$recursiveAnchor");
+      Schema$2.setConfig(schemaVersion$1, "vocabularyToken", "$vocabulary");
+      Schema$2.setConfig(schemaVersion$1, "mandatoryVocabularies", ["https://json-schema.org/draft/2019-09/vocab/core"]);
+
+      Schema$2.add(JSON.parse(schema$1));
+
+      Schema$2.add(JSON.parse(core$1));
+      Core$2.defineVocabulary("https://json-schema.org/draft/2019-09/vocab/core", {
+        "validate": keywords.validate,
+        "$defs": keywords.definitions,
+        "$recursiveRef": keywords.dynamicRef,
+        "$ref": keywords.ref
+      });
+
+      Schema$2.add(JSON.parse(applicator$1));
+      Core$2.defineVocabulary("https://json-schema.org/draft/2019-09/vocab/applicator", {
+        "additionalItems": keywords.additionalItems6,
+        "additionalProperties": keywords.additionalProperties6,
+        "allOf": keywords.allOf,
+        "anyOf": keywords.anyOf,
+        "contains": keywords.containsMinContainsMaxContains,
+        "dependentSchemas": keywords.dependentSchemas,
+        "if": keywords.if,
+        "then": keywords.then,
+        "else": keywords.else,
+        "items": keywords.items,
+        "not": keywords.not,
+        "oneOf": keywords.oneOf,
+        "patternProperties": keywords.patternProperties,
+        "properties": keywords.properties,
+        "propertyNames": keywords.propertyNames,
+        "unevaluatedItems": keywords.unevaluatedItems,
+        "unevaluatedProperties": keywords.unevaluatedProperties
+      });
+
+      Schema$2.add(JSON.parse(validation$1));
+      Core$2.defineVocabulary("https://json-schema.org/draft/2019-09/vocab/validation", {
+        "const": keywords.const,
+        "dependentRequired": keywords.dependentRequired,
+        "enum": keywords.enum,
+        "exclusiveMaximum": keywords.exclusiveMaximum,
+        "exclusiveMinimum": keywords.exclusiveMinimum,
+        "maxItems": keywords.maxItems,
+        "maxLength": keywords.maxLength6,
+        "maxProperties": keywords.maxProperties,
+        "maximum": keywords.maximum,
+        "minItems": keywords.minItems,
+        "minLength": keywords.minLength6,
+        "minProperties": keywords.minProperties,
+        "minimum": keywords.minimum,
+        "multipleOf": keywords.multipleOf,
+        "pattern": keywords.pattern,
+        "required": keywords.required,
+        "type": keywords.type,
+        "uniqueItems": keywords.uniqueItems
+      });
+
+      Schema$2.add(JSON.parse(metaData$1));
+      Core$2.defineVocabulary("https://json-schema.org/draft/2019-09/vocab/meta-data", {
+        "default": keywords.metaData,
+        "deprecated": keywords.metaData,
+        "description": keywords.metaData,
+        "examples": keywords.metaData,
+        "readOnly": keywords.metaData,
+        "title": keywords.metaData,
+        "writeOnly": keywords.metaData
+      });
+
+      Schema$2.add(JSON.parse(format));
+
+      Schema$2.add(JSON.parse(content$1));
+      Core$2.defineVocabulary("https://json-schema.org/draft/2019-09/vocab/content", {
+        "contentEncoding": keywords.metaData,
+        "contentMediaType": keywords.metaData,
+        "contentSchema": keywords.metaData
+      });
+
+      var schema = `{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/core": true,
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+        "https://json-schema.org/draft/2020-12/vocab/validation": true,
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Core and Validation specifications meta-schema",
+    "allOf": [
+        {"$ref": "meta/core"},
+        {"$ref": "meta/applicator"},
+        {"$ref": "meta/unevaluated"},
+        {"$ref": "meta/validation"},
+        {"$ref": "meta/meta-data"},
+        {"$ref": "meta/format-annotation"},
+        {"$ref": "meta/content"}
+    ],
+    "type": ["object", "boolean"],
+    "properties": {
+        "definitions": {
+            "$comment": "While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.",
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" },
+            "default": {}
+        },
+        "dependencies": {
+            "$comment": "\\"dependencies\\" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to \\"dependentSchemas\\" and \\"dependentRequired\\"",
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$dynamicRef": "#meta" },
+                    { "$ref": "meta/validation#/$defs/stringArray" }
+                ]
+            }
+        }
+    }
+}`;
+
+      var core = `{
+    "$id": "https://json-schema.org/draft/2020-12/meta/core",
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/core": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Core vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference",
+            "$comment": "Non-empty fragments not allowed.",
+            "pattern": "^[^#]*#?$"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$anchor": {
+            "type": "string",
+            "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$dynamicRef": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$dynamicAnchor": {
+            "type": "string",
+            "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
+        },
+        "$vocabulary": {
+            "type": "object",
+            "propertyNames": {
+                "type": "string",
+                "format": "uri"
+            },
+            "additionalProperties": {
+                "type": "boolean"
+            }
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "$defs": {
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" },
+            "default": {}
+        }
+    }
+}`;
+
+      var applicator = `{
+    "$id": "https://json-schema.org/draft/2020-12/meta/applicator",
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Applicator vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "prefixItems": { "$ref": "#/$defs/schemaArray" },
+        "items": { "$dynamicRef": "#meta" },
+        "contains": { "$dynamicRef": "#meta" },
+        "additionalProperties": { "$dynamicRef": "#meta" },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependentSchemas": {
+            "type": "object",
+            "additionalProperties": {
+                "$dynamicRef": "#meta"
+            }
+        },
+        "propertyNames": { "$dynamicRef": "#meta" },
+        "if": { "$dynamicRef": "#meta" },
+        "then": { "$dynamicRef": "#meta" },
+        "else": { "$dynamicRef": "#meta" },
+        "allOf": { "$ref": "#/$defs/schemaArray" },
+        "anyOf": { "$ref": "#/$defs/schemaArray" },
+        "oneOf": { "$ref": "#/$defs/schemaArray" },
+        "not": { "$dynamicRef": "#meta" }
+    },
+    "$defs": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$dynamicRef": "#meta" }
+        }
+    }
+}`;
+
+      var validation = `{
+    "$id": "https://json-schema.org/draft/2020-12/meta/validation",
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/validation": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Validation vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "multipleOf": {
+            "type": "number",
+            "exclusiveMinimum": 0
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "number"
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "number"
+        },
+        "maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minContains": {
+            "$ref": "#/$defs/nonNegativeInteger",
+            "default": 1
+        },
+        "maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
+        "minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+        "required": { "$ref": "#/$defs/stringArray" },
+        "dependentRequired": {
+            "type": "object",
+            "additionalProperties": {
+                "$ref": "#/$defs/stringArray"
+            }
+        },
+        "const": true,
+        "enum": {
+            "type": "array",
+            "items": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/$defs/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/$defs/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        }
+    },
+    "$defs": {
+        "nonNegativeInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "nonNegativeIntegerDefault0": {
+            "$ref": "#/$defs/nonNegativeInteger",
+            "default": 0
+        },
+        "simpleTypes": {
+            "enum": [
+                "array",
+                "boolean",
+                "integer",
+                "null",
+                "number",
+                "object",
+                "string"
+            ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "uniqueItems": true,
+            "default": []
+        }
+    }
+}`;
+
+      var metaData = `{
+    "$id": "https://json-schema.org/draft/2020-12/meta/meta-data",
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Meta-data vocabulary meta-schema",
+
+    "type": ["object", "boolean"],
+    "properties": {
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": true,
+        "deprecated": {
+            "type": "boolean",
+            "default": false
+        },
+        "readOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "writeOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "examples": {
+            "type": "array",
+            "items": true
+        }
+    }
+}`;
+
+      var formatAnnotation = `{
+    "$id": "https://json-schema.org/draft/2020-12/meta/format-annotation",
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Format vocabulary meta-schema for annotation results",
+    "type": ["object", "boolean"],
+    "properties": {
+        "format": { "type": "string" }
+    }
+}`;
+
+      var formatAssertion = `{
+    "$id": "https://json-schema.org/draft/2020-12/meta/format-assertion",
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/format-assertion": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Format vocabulary meta-schema for assertion results",
+    "type": ["object", "boolean"],
+    "properties": {
+        "format": { "type": "string" }
+    }
+}`;
+
+      var content = `{
+    "$id": "https://json-schema.org/draft/2020-12/meta/content",
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Content vocabulary meta-schema",
+
+    "type": ["object", "boolean"],
+    "properties": {
+        "contentMediaType": { "type": "string" },
+        "contentEncoding": { "type": "string" },
+        "contentSchema": { "$dynamicRef": "#meta" }
+    }
+}`;
+
+      var unevaluated = `{
+    "$id": "https://json-schema.org/draft/2020-12/meta/unevaluated",
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Unevaluated applicator vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "unevaluatedItems": { "$dynamicRef": "#meta" },
+        "unevaluatedProperties": { "$dynamicRef": "#meta" }
+    }
+}`;
+
+      const { Core: Core$1, Schema: Schema$1 } = lib$1;
+
+
+
+
+
+
+
+
+
+
+
+
+      const schemaVersion = "https://json-schema.org/draft/2020-12/schema";
+
+      Schema$1.setConfig(schemaVersion, "baseToken", "$id");
+      Schema$1.setConfig(schemaVersion, "embeddedToken", "$id");
+      Schema$1.setConfig(schemaVersion, "anchorToken", "$anchor");
+      Schema$1.setConfig(schemaVersion, "dynamicAnchorToken", "$dynamicAnchor");
+      Schema$1.setConfig(schemaVersion, "vocabularyToken", "$vocabulary");
+      Schema$1.setConfig(schemaVersion, "mandatoryVocabularies", ["https://json-schema.org/draft/2020-12/vocab/core"]);
+
+      Schema$1.add(JSON.parse(schema));
+
+      Schema$1.add(JSON.parse(core));
+      Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/core", {
+        "validate": keywords.validate,
+        "$defs": keywords.definitions,
+        "$dynamicRef": keywords.dynamicRef,
+        "$ref": keywords.ref
+      });
+
+      Schema$1.add(JSON.parse(applicator));
+      Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/applicator", {
+        "additionalProperties": keywords.additionalProperties6,
+        "allOf": keywords.allOf,
+        "anyOf": keywords.anyOf,
+        "contains": keywords.containsMinContainsMaxContains,
+        "dependentSchemas": keywords.dependentSchemas,
+        "if": keywords.if,
+        "then": keywords.then,
+        "else": keywords.else,
+        "items": keywords.items202012,
+        "not": keywords.not,
+        "oneOf": keywords.oneOf,
+        "patternProperties": keywords.patternProperties,
+        "prefixItems": keywords.tupleItems,
+        "properties": keywords.properties,
+        "propertyNames": keywords.propertyNames
+      });
+
+      Schema$1.add(JSON.parse(validation));
+      Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/validation", {
+        "const": keywords.const,
+        "dependentRequired": keywords.dependentRequired,
+        "enum": keywords.enum,
+        "exclusiveMaximum": keywords.exclusiveMaximum,
+        "exclusiveMinimum": keywords.exclusiveMinimum,
+        "maxItems": keywords.maxItems,
+        "maxLength": keywords.maxLength6,
+        "maxProperties": keywords.maxProperties,
+        "maximum": keywords.maximum,
+        "minItems": keywords.minItems,
+        "minLength": keywords.minLength6,
+        "minProperties": keywords.minProperties,
+        "minimum": keywords.minimum,
+        "multipleOf": keywords.multipleOf,
+        "pattern": keywords.pattern,
+        "required": keywords.required,
+        "type": keywords.type,
+        "uniqueItems": keywords.uniqueItems
+      });
+
+      Schema$1.add(JSON.parse(metaData));
+      Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/meta-data", {
+        "default": keywords.metaData,
+        "deprecated": keywords.metaData,
+        "description": keywords.metaData,
+        "examples": keywords.metaData,
+        "readOnly": keywords.metaData,
+        "title": keywords.metaData,
+        "writeOnly": keywords.metaData
+      });
+
+      Schema$1.add(JSON.parse(formatAnnotation));
+      Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/format-annotation", {
+        "format": keywords.metaData
+      });
+
+      Schema$1.add(JSON.parse(formatAssertion));
+
+      Schema$1.add(JSON.parse(content));
+      Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/content", {
+        "contentEncoding": keywords.metaData,
+        "contentMediaType": keywords.metaData,
+        "contentSchema": keywords.metaData
+      });
+
+      Schema$1.add(JSON.parse(unevaluated));
+      Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/unevaluated", {
+        "unevaluatedItems": keywords.unevaluatedItems,
+        "unevaluatedProperties": keywords.unevaluatedProperties
+      });
+
+      const { Core, Schema, InvalidSchemaError } = lib$1;
+
+
+
+
+
+
+
+
+
+      var lib = exports('default', {
+        add: Core.add,
+        get: Schema.get,
+        validate: Core.validate,
+        compile: Core.compile,
+        interpret: Core.interpret,
+        setMetaOutputFormat: Core.setMetaOutputFormat,
+        setShouldMetaValidate: Core.setShouldMetaValidate,
+        FLAG: Core.FLAG,
+        BASIC: Core.BASIC,
+        DETAILED: Core.DETAILED,
+        VERBOSE: Core.VERBOSE,
+        Keywords: keywords,
+        InvalidSchemaError: InvalidSchemaError
+      });
+      var lib_1 = exports('add', lib.add);
+      var lib_2 = exports('get', lib.get);
+      var lib_3 = exports('validate', lib.validate);
+      var lib_4 = exports('compile', lib.compile);
+      var lib_5 = exports('interpret', lib.interpret);
+      var lib_6 = exports('setMetaOutputFormat', lib.setMetaOutputFormat);
+      var lib_7 = exports('setShouldMetaValidate', lib.setShouldMetaValidate);
+      var lib_8 = exports('FLAG', lib.FLAG);
+      var lib_9 = exports('BASIC', lib.BASIC);
+      var lib_10 = exports('DETAILED', lib.DETAILED);
+      var lib_11 = exports('VERBOSE', lib.VERBOSE);
+      var lib_12 = exports('Keywords', lib.Keywords);
+      var lib_13 = exports('InvalidSchemaError', lib.InvalidSchemaError);
+
+    }
+  };
+});
+//# sourceMappingURL=json-schema-system.js.map