@hyperjump/json-schema 0.18.0

package/dist/json-schema-cjs.js

@@ -0,0 +1,4708 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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 = {
+  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 = lib.add;
+var lib_2 = lib.get;
+var lib_3 = lib.validate;
+var lib_4 = lib.compile;
+var lib_5 = lib.interpret;
+var lib_6 = lib.setMetaOutputFormat;
+var lib_7 = lib.setShouldMetaValidate;
+var lib_8 = lib.FLAG;
+var lib_9 = lib.BASIC;
+var lib_10 = lib.DETAILED;
+var lib_11 = lib.VERBOSE;
+var lib_12 = lib.Keywords;
+var lib_13 = lib.InvalidSchemaError;
+
+exports.BASIC = lib_9;
+exports.DETAILED = lib_10;
+exports.FLAG = lib_8;
+exports.InvalidSchemaError = lib_13;
+exports.Keywords = lib_12;
+exports.VERBOSE = lib_11;
+exports.add = lib_1;
+exports.compile = lib_4;
+exports['default'] = lib;
+exports.get = lib_2;
+exports.interpret = lib_5;
+exports.setMetaOutputFormat = lib_6;
+exports.setShouldMetaValidate = lib_7;
+exports.validate = lib_3;
+//# sourceMappingURL=json-schema-cjs.js.map