@hyperjump/json-schema 0.18.4 → 0.20.0

package/dist/json-schema-cjs.js

@@ -2,7 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var justCurryIt = curry;
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var justCurryIt = curry$a;
 
 /*
   function add(a, b, c) {
@@ -27,7 +29,7 @@ var justCurryIt = curry;
   milesToKm(10); // 16.2
 */
 
-function curry(fn, arity) {
+function curry$a(fn, arity) {
   return function curried() {
     if (arity == null) {
       arity = fn.length;
@@ -43,13 +45,8 @@ function curry(fn, arity) {
   };
 }
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+var pubsub = {exports: {}};
 
-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
@@ -57,600 +54,1854 @@ var pubsub = createCommonjsModule(function (module, exports) {
  * https://github.com/mroderick/PubSubJS
  */
 
-(function (root, factory){
-
-    var PubSub = {};
-
-    if (root.PubSub) {
-        PubSub = root.PubSub;
-        console.warn("PubSub already loaded, using existing version");
-    } else {
-        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
-    }
+(function (module, exports) {
+	(function (root, factory){
+
+	    var PubSub = {};
+
+	    if (root.PubSub) {
+	        PubSub = root.PubSub;
+	        console.warn("PubSub already loaded, using existing version");
+	    } else {
+	        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.exports));
+
+var uri_all = {exports: {}};
+
+/** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js */
+
+(function (module, exports) {
+	(function (global, factory) {
+		factory(exports) ;
+	}(commonjsGlobal, (function (exports) {
+	function merge() {
+	    for (var _len = arguments.length, sets = Array(_len), _key = 0; _key < _len; _key++) {
+	        sets[_key] = arguments[_key];
+	    }
+
+	    if (sets.length > 1) {
+	        sets[0] = sets[0].slice(0, -1);
+	        var xl = sets.length - 1;
+	        for (var x = 1; x < xl; ++x) {
+	            sets[x] = sets[x].slice(1, -1);
+	        }
+	        sets[xl] = sets[xl].slice(1);
+	        return sets.join('');
+	    } else {
+	        return sets[0];
+	    }
+	}
+	function subexp(str) {
+	    return "(?:" + str + ")";
+	}
+	function typeOf(o) {
+	    return o === undefined ? "undefined" : o === null ? "null" : Object.prototype.toString.call(o).split(" ").pop().split("]").shift().toLowerCase();
+	}
+	function toUpperCase(str) {
+	    return str.toUpperCase();
+	}
+	function toArray(obj) {
+	    return obj !== undefined && obj !== null ? obj instanceof Array ? obj : typeof obj.length !== "number" || obj.split || obj.setInterval || obj.call ? [obj] : Array.prototype.slice.call(obj) : [];
+	}
+	function assign(target, source) {
+	    var obj = target;
+	    if (source) {
+	        for (var key in source) {
+	            obj[key] = source[key];
+	        }
+	    }
+	    return obj;
+	}
+
+	function buildExps(isIRI) {
+	    var ALPHA$$ = "[A-Za-z]",
+	        DIGIT$$ = "[0-9]",
+	        HEXDIG$$ = merge(DIGIT$$, "[A-Fa-f]"),
+	        PCT_ENCODED$ = subexp(subexp("%[EFef]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + HEXDIG$$)),
+	        //expanded
+	    GEN_DELIMS$$ = "[\\:\\/\\?\\#\\[\\]\\@]",
+	        SUB_DELIMS$$ = "[\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\=]",
+	        RESERVED$$ = merge(GEN_DELIMS$$, SUB_DELIMS$$),
+	        UCSCHAR$$ = isIRI ? "[\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]" : "[]",
+	        //subset, excludes bidi control characters
+	    IPRIVATE$$ = isIRI ? "[\\uE000-\\uF8FF]" : "[]",
+	        //subset
+	    UNRESERVED$$ = merge(ALPHA$$, DIGIT$$, "[\\-\\.\\_\\~]", UCSCHAR$$);
+	        subexp(ALPHA$$ + merge(ALPHA$$, DIGIT$$, "[\\+\\-\\.]") + "*");
+	        subexp(subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\:]")) + "*");
+	        var DEC_OCTET_RELAXED$ = subexp(subexp("25[0-5]") + "|" + subexp("2[0-4]" + DIGIT$$) + "|" + subexp("1" + DIGIT$$ + DIGIT$$) + "|" + subexp("0?[1-9]" + DIGIT$$) + "|0?0?" + DIGIT$$),
+	        //relaxed parsing rules
+	    IPV4ADDRESS$ = subexp(DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$),
+	        H16$ = subexp(HEXDIG$$ + "{1,4}"),
+	        LS32$ = subexp(subexp(H16$ + "\\:" + H16$) + "|" + IPV4ADDRESS$),
+	        IPV6ADDRESS1$ = subexp(subexp(H16$ + "\\:") + "{6}" + LS32$),
+	        //                           6( h16 ":" ) ls32
+	    IPV6ADDRESS2$ = subexp("\\:\\:" + subexp(H16$ + "\\:") + "{5}" + LS32$),
+	        //                      "::" 5( h16 ":" ) ls32
+	    IPV6ADDRESS3$ = subexp(subexp(H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{4}" + LS32$),
+	        //[               h16 ] "::" 4( h16 ":" ) ls32
+	    IPV6ADDRESS4$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,1}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{3}" + LS32$),
+	        //[ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
+	    IPV6ADDRESS5$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,2}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{2}" + LS32$),
+	        //[ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
+	    IPV6ADDRESS6$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,3}" + H16$) + "?\\:\\:" + H16$ + "\\:" + LS32$),
+	        //[ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32
+	    IPV6ADDRESS7$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,4}" + H16$) + "?\\:\\:" + LS32$),
+	        //[ *4( h16 ":" ) h16 ] "::"              ls32
+	    IPV6ADDRESS8$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,5}" + H16$) + "?\\:\\:" + H16$),
+	        //[ *5( h16 ":" ) h16 ] "::"              h16
+	    IPV6ADDRESS9$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,6}" + H16$) + "?\\:\\:"),
+	        //[ *6( h16 ":" ) h16 ] "::"
+	    IPV6ADDRESS$ = subexp([IPV6ADDRESS1$, IPV6ADDRESS2$, IPV6ADDRESS3$, IPV6ADDRESS4$, IPV6ADDRESS5$, IPV6ADDRESS6$, IPV6ADDRESS7$, IPV6ADDRESS8$, IPV6ADDRESS9$].join("|")),
+	        ZONEID$ = subexp(subexp(UNRESERVED$$ + "|" + PCT_ENCODED$) + "+");
+	        //RFC 6874, with relaxed parsing rules
+	    subexp("[vV]" + HEXDIG$$ + "+\\." + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\:]") + "+");
+	        //RFC 6874
+	    subexp(subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$)) + "*");
+	        var PCHAR$ = subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@]"));
+	        subexp(subexp(PCT_ENCODED$ + "|" + merge(UNRESERVED$$, SUB_DELIMS$$, "[\\@]")) + "+");
+	        subexp(subexp(PCHAR$ + "|" + merge("[\\/\\?]", IPRIVATE$$)) + "*");
+	    return {
+	        NOT_SCHEME: new RegExp(merge("[^]", ALPHA$$, DIGIT$$, "[\\+\\-\\.]"), "g"),
+	        NOT_USERINFO: new RegExp(merge("[^\\%\\:]", UNRESERVED$$, SUB_DELIMS$$), "g"),
+	        NOT_HOST: new RegExp(merge("[^\\%\\[\\]\\:]", UNRESERVED$$, SUB_DELIMS$$), "g"),
+	        NOT_PATH: new RegExp(merge("[^\\%\\/\\:\\@]", UNRESERVED$$, SUB_DELIMS$$), "g"),
+	        NOT_PATH_NOSCHEME: new RegExp(merge("[^\\%\\/\\@]", UNRESERVED$$, SUB_DELIMS$$), "g"),
+	        NOT_QUERY: new RegExp(merge("[^\\%]", UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@\\/\\?]", IPRIVATE$$), "g"),
+	        NOT_FRAGMENT: new RegExp(merge("[^\\%]", UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@\\/\\?]"), "g"),
+	        ESCAPE: new RegExp(merge("[^]", UNRESERVED$$, SUB_DELIMS$$), "g"),
+	        UNRESERVED: new RegExp(UNRESERVED$$, "g"),
+	        OTHER_CHARS: new RegExp(merge("[^\\%]", UNRESERVED$$, RESERVED$$), "g"),
+	        PCT_ENCODED: new RegExp(PCT_ENCODED$, "g"),
+	        IPV4ADDRESS: new RegExp("^(" + IPV4ADDRESS$ + ")$"),
+	        IPV6ADDRESS: new RegExp("^\\[?(" + IPV6ADDRESS$ + ")" + subexp(subexp("\\%25|\\%(?!" + HEXDIG$$ + "{2})") + "(" + ZONEID$ + ")") + "?\\]?$") //RFC 6874, with relaxed parsing rules
+	    };
+	}
+	var URI_PROTOCOL = buildExps(false);
+
+	var IRI_PROTOCOL = buildExps(true);
+
+	var slicedToArray = function () {
+	  function sliceIterator(arr, i) {
+	    var _arr = [];
+	    var _n = true;
+	    var _d = false;
+	    var _e = undefined;
+
+	    try {
+	      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+	        _arr.push(_s.value);
+
+	        if (i && _arr.length === i) break;
+	      }
+	    } catch (err) {
+	      _d = true;
+	      _e = err;
+	    } finally {
+	      try {
+	        if (!_n && _i["return"]) _i["return"]();
+	      } finally {
+	        if (_d) throw _e;
+	      }
+	    }
+
+	    return _arr;
+	  }
+
+	  return function (arr, i) {
+	    if (Array.isArray(arr)) {
+	      return arr;
+	    } else if (Symbol.iterator in Object(arr)) {
+	      return sliceIterator(arr, i);
+	    } else {
+	      throw new TypeError("Invalid attempt to destructure non-iterable instance");
+	    }
+	  };
+	}();
+
+
+
+
+
+
+
+
+
+
+
+
+
+	var toConsumableArray = function (arr) {
+	  if (Array.isArray(arr)) {
+	    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+
+	    return arr2;
+	  } else {
+	    return Array.from(arr);
+	  }
+	};
+
+	/** Highest positive signed 32-bit float value */
+
+	var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
+
+	/** Bootstring parameters */
+	var base = 36;
+	var tMin = 1;
+	var tMax = 26;
+	var skew = 38;
+	var damp = 700;
+	var initialBias = 72;
+	var initialN = 128; // 0x80
+	var delimiter = '-'; // '\x2D'
+
+	/** Regular expressions */
+	var regexPunycode = /^xn--/;
+	var regexNonASCII = /[^\0-\x7E]/; // non-ASCII chars
+	var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
+
+	/** Error messages */
+	var errors = {
+		'overflow': 'Overflow: input needs wider integers to process',
+		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
+		'invalid-input': 'Invalid input'
+	};
+
+	/** Convenience shortcuts */
+	var baseMinusTMin = base - tMin;
+	var floor = Math.floor;
+	var stringFromCharCode = String.fromCharCode;
+
+	/*--------------------------------------------------------------------------*/
+
+	/**
+	 * A generic error utility function.
+	 * @private
+	 * @param {String} type The error type.
+	 * @returns {Error} Throws a `RangeError` with the applicable error message.
+	 */
+	function error$1(type) {
+		throw new RangeError(errors[type]);
+	}
+
+	/**
+	 * A generic `Array#map` utility function.
+	 * @private
+	 * @param {Array} array The array to iterate over.
+	 * @param {Function} callback The function that gets called for every array
+	 * item.
+	 * @returns {Array} A new array of values returned by the callback function.
+	 */
+	function map(array, fn) {
+		var result = [];
+		var length = array.length;
+		while (length--) {
+			result[length] = fn(array[length]);
+		}
+		return result;
+	}
+
+	/**
+	 * A simple `Array#map`-like wrapper to work with domain name strings or email
+	 * addresses.
+	 * @private
+	 * @param {String} domain The domain name or email address.
+	 * @param {Function} callback The function that gets called for every
+	 * character.
+	 * @returns {Array} A new string of characters returned by the callback
+	 * function.
+	 */
+	function mapDomain(string, fn) {
+		var parts = string.split('@');
+		var result = '';
+		if (parts.length > 1) {
+			// In email addresses, only the domain name should be punycoded. Leave
+			// the local part (i.e. everything up to `@`) intact.
+			result = parts[0] + '@';
+			string = parts[1];
+		}
+		// Avoid `split(regex)` for IE8 compatibility. See #17.
+		string = string.replace(regexSeparators, '\x2E');
+		var labels = string.split('.');
+		var encoded = map(labels, fn).join('.');
+		return result + encoded;
+	}
+
+	/**
+	 * Creates an array containing the numeric code points of each Unicode
+	 * character in the string. While JavaScript uses UCS-2 internally,
+	 * this function will convert a pair of surrogate halves (each of which
+	 * UCS-2 exposes as separate characters) into a single code point,
+	 * matching UTF-16.
+	 * @see `punycode.ucs2.encode`
+	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
+	 * @memberOf punycode.ucs2
+	 * @name decode
+	 * @param {String} string The Unicode input string (UCS-2).
+	 * @returns {Array} The new array of code points.
+	 */
+	function ucs2decode(string) {
+		var output = [];
+		var counter = 0;
+		var length = string.length;
+		while (counter < length) {
+			var value = string.charCodeAt(counter++);
+			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+				// It's a high surrogate, and there is a next character.
+				var extra = string.charCodeAt(counter++);
+				if ((extra & 0xFC00) == 0xDC00) {
+					// Low surrogate.
+					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+				} else {
+					// It's an unmatched surrogate; only append this code unit, in case the
+					// next code unit is the high surrogate of a surrogate pair.
+					output.push(value);
+					counter--;
+				}
+			} else {
+				output.push(value);
+			}
+		}
+		return output;
+	}
+
+	/**
+	 * Creates a string based on an array of numeric code points.
+	 * @see `punycode.ucs2.decode`
+	 * @memberOf punycode.ucs2
+	 * @name encode
+	 * @param {Array} codePoints The array of numeric code points.
+	 * @returns {String} The new Unicode string (UCS-2).
+	 */
+	var ucs2encode = function ucs2encode(array) {
+		return String.fromCodePoint.apply(String, toConsumableArray(array));
+	};
+
+	/**
+	 * Converts a basic code point into a digit/integer.
+	 * @see `digitToBasic()`
+	 * @private
+	 * @param {Number} codePoint The basic numeric code point value.
+	 * @returns {Number} The numeric value of a basic code point (for use in
+	 * representing integers) in the range `0` to `base - 1`, or `base` if
+	 * the code point does not represent a value.
+	 */
+	var basicToDigit = function basicToDigit(codePoint) {
+		if (codePoint - 0x30 < 0x0A) {
+			return codePoint - 0x16;
+		}
+		if (codePoint - 0x41 < 0x1A) {
+			return codePoint - 0x41;
+		}
+		if (codePoint - 0x61 < 0x1A) {
+			return codePoint - 0x61;
+		}
+		return base;
+	};
+
+	/**
+	 * Converts a digit/integer into a basic code point.
+	 * @see `basicToDigit()`
+	 * @private
+	 * @param {Number} digit The numeric value of a basic code point.
+	 * @returns {Number} The basic code point whose value (when used for
+	 * representing integers) is `digit`, which needs to be in the range
+	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
+	 * used; else, the lowercase form is used. The behavior is undefined
+	 * if `flag` is non-zero and `digit` has no uppercase form.
+	 */
+	var digitToBasic = function digitToBasic(digit, flag) {
+		//  0..25 map to ASCII a..z or A..Z
+		// 26..35 map to ASCII 0..9
+		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+	};
+
+	/**
+	 * Bias adaptation function as per section 3.4 of RFC 3492.
+	 * https://tools.ietf.org/html/rfc3492#section-3.4
+	 * @private
+	 */
+	var adapt = function adapt(delta, numPoints, firstTime) {
+		var k = 0;
+		delta = firstTime ? floor(delta / damp) : delta >> 1;
+		delta += floor(delta / numPoints);
+		for (; /* no initialization */delta > baseMinusTMin * tMax >> 1; k += base) {
+			delta = floor(delta / baseMinusTMin);
+		}
+		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+	};
+
+	/**
+	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
+	 * symbols.
+	 * @memberOf punycode
+	 * @param {String} input The Punycode string of ASCII-only symbols.
+	 * @returns {String} The resulting string of Unicode symbols.
+	 */
+	var decode = function decode(input) {
+		// Don't use UCS-2.
+		var output = [];
+		var inputLength = input.length;
+		var i = 0;
+		var n = initialN;
+		var bias = initialBias;
+
+		// Handle the basic code points: let `basic` be the number of input code
+		// points before the last delimiter, or `0` if there is none, then copy
+		// the first basic code points to the output.
+
+		var basic = input.lastIndexOf(delimiter);
+		if (basic < 0) {
+			basic = 0;
+		}
+
+		for (var j = 0; j < basic; ++j) {
+			// if it's not a basic code point
+			if (input.charCodeAt(j) >= 0x80) {
+				error$1('not-basic');
+			}
+			output.push(input.charCodeAt(j));
+		}
+
+		// Main decoding loop: start just after the last delimiter if any basic code
+		// points were copied; start at the beginning otherwise.
+
+		for (var index = basic > 0 ? basic + 1 : 0; index < inputLength;) /* no final expression */{
+
+			// `index` is the index of the next character to be consumed.
+			// Decode a generalized variable-length integer into `delta`,
+			// which gets added to `i`. The overflow checking is easier
+			// if we increase `i` as we go, then subtract off its starting
+			// value at the end to obtain `delta`.
+			var oldi = i;
+			for (var w = 1, k = base;; /* no condition */k += base) {
+
+				if (index >= inputLength) {
+					error$1('invalid-input');
+				}
+
+				var digit = basicToDigit(input.charCodeAt(index++));
+
+				if (digit >= base || digit > floor((maxInt - i) / w)) {
+					error$1('overflow');
+				}
+
+				i += digit * w;
+				var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+
+				if (digit < t) {
+					break;
+				}
+
+				var baseMinusT = base - t;
+				if (w > floor(maxInt / baseMinusT)) {
+					error$1('overflow');
+				}
+
+				w *= baseMinusT;
+			}
+
+			var out = output.length + 1;
+			bias = adapt(i - oldi, out, oldi == 0);
+
+			// `i` was supposed to wrap around from `out` to `0`,
+			// incrementing `n` each time, so we'll fix that now:
+			if (floor(i / out) > maxInt - n) {
+				error$1('overflow');
+			}
+
+			n += floor(i / out);
+			i %= out;
+
+			// Insert `n` at position `i` of the output.
+			output.splice(i++, 0, n);
+		}
+
+		return String.fromCodePoint.apply(String, output);
+	};
+
+	/**
+	 * Converts a string of Unicode symbols (e.g. a domain name label) to a
+	 * Punycode string of ASCII-only symbols.
+	 * @memberOf punycode
+	 * @param {String} input The string of Unicode symbols.
+	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
+	 */
+	var encode = function encode(input) {
+		var output = [];
+
+		// Convert the input in UCS-2 to an array of Unicode code points.
+		input = ucs2decode(input);
+
+		// Cache the length.
+		var inputLength = input.length;
+
+		// Initialize the state.
+		var n = initialN;
+		var delta = 0;
+		var bias = initialBias;
+
+		// Handle the basic code points.
+		var _iteratorNormalCompletion = true;
+		var _didIteratorError = false;
+		var _iteratorError = undefined;
+
+		try {
+			for (var _iterator = input[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+				var _currentValue2 = _step.value;
+
+				if (_currentValue2 < 0x80) {
+					output.push(stringFromCharCode(_currentValue2));
+				}
+			}
+		} catch (err) {
+			_didIteratorError = true;
+			_iteratorError = err;
+		} finally {
+			try {
+				if (!_iteratorNormalCompletion && _iterator.return) {
+					_iterator.return();
+				}
+			} finally {
+				if (_didIteratorError) {
+					throw _iteratorError;
+				}
+			}
+		}
+
+		var basicLength = output.length;
+		var handledCPCount = basicLength;
+
+		// `handledCPCount` is the number of code points that have been handled;
+		// `basicLength` is the number of basic code points.
+
+		// Finish the basic string with a delimiter unless it's empty.
+		if (basicLength) {
+			output.push(delimiter);
+		}
+
+		// Main encoding loop:
+		while (handledCPCount < inputLength) {
+
+			// All non-basic code points < n have been handled already. Find the next
+			// larger one:
+			var m = maxInt;
+			var _iteratorNormalCompletion2 = true;
+			var _didIteratorError2 = false;
+			var _iteratorError2 = undefined;
+
+			try {
+				for (var _iterator2 = input[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+					var currentValue = _step2.value;
+
+					if (currentValue >= n && currentValue < m) {
+						m = currentValue;
+					}
+				}
+
+				// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
+				// but guard against overflow.
+			} catch (err) {
+				_didIteratorError2 = true;
+				_iteratorError2 = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion2 && _iterator2.return) {
+						_iterator2.return();
+					}
+				} finally {
+					if (_didIteratorError2) {
+						throw _iteratorError2;
+					}
+				}
+			}
+
+			var handledCPCountPlusOne = handledCPCount + 1;
+			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+				error$1('overflow');
+			}
+
+			delta += (m - n) * handledCPCountPlusOne;
+			n = m;
+
+			var _iteratorNormalCompletion3 = true;
+			var _didIteratorError3 = false;
+			var _iteratorError3 = undefined;
+
+			try {
+				for (var _iterator3 = input[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+					var _currentValue = _step3.value;
+
+					if (_currentValue < n && ++delta > maxInt) {
+						error$1('overflow');
+					}
+					if (_currentValue == n) {
+						// Represent delta as a generalized variable-length integer.
+						var q = delta;
+						for (var k = base;; /* no condition */k += base) {
+							var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+							if (q < t) {
+								break;
+							}
+							var qMinusT = q - t;
+							var baseMinusT = base - t;
+							output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));
+							q = floor(qMinusT / baseMinusT);
+						}
+
+						output.push(stringFromCharCode(digitToBasic(q, 0)));
+						bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+						delta = 0;
+						++handledCPCount;
+					}
+				}
+			} catch (err) {
+				_didIteratorError3 = true;
+				_iteratorError3 = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion3 && _iterator3.return) {
+						_iterator3.return();
+					}
+				} finally {
+					if (_didIteratorError3) {
+						throw _iteratorError3;
+					}
+				}
+			}
+
+			++delta;
+			++n;
+		}
+		return output.join('');
+	};
+
+	/**
+	 * Converts a Punycode string representing a domain name or an email address
+	 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
+	 * it doesn't matter if you call it on a string that has already been
+	 * converted to Unicode.
+	 * @memberOf punycode
+	 * @param {String} input The Punycoded domain name or email address to
+	 * convert to Unicode.
+	 * @returns {String} The Unicode representation of the given Punycode
+	 * string.
+	 */
+	var toUnicode = function toUnicode(input) {
+		return mapDomain(input, function (string) {
+			return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
+		});
+	};
+
+	/**
+	 * Converts a Unicode string representing a domain name or an email address to
+	 * Punycode. Only the non-ASCII parts of the domain name will be converted,
+	 * i.e. it doesn't matter if you call it with a domain that's already in
+	 * ASCII.
+	 * @memberOf punycode
+	 * @param {String} input The domain name or email address to convert, as a
+	 * Unicode string.
+	 * @returns {String} The Punycode representation of the given domain name or
+	 * email address.
+	 */
+	var toASCII = function toASCII(input) {
+		return mapDomain(input, function (string) {
+			return regexNonASCII.test(string) ? 'xn--' + encode(string) : string;
+		});
+	};
+
+	/*--------------------------------------------------------------------------*/
+
+	/** Define the public API */
+	var punycode = {
+		/**
+	  * A string representing the current Punycode.js version number.
+	  * @memberOf punycode
+	  * @type String
+	  */
+		'version': '2.1.0',
+		/**
+	  * An object of methods to convert from JavaScript's internal character
+	  * representation (UCS-2) to Unicode code points, and back.
+	  * @see <https://mathiasbynens.be/notes/javascript-encoding>
+	  * @memberOf punycode
+	  * @type Object
+	  */
+		'ucs2': {
+			'decode': ucs2decode,
+			'encode': ucs2encode
+		},
+		'decode': decode,
+		'encode': encode,
+		'toASCII': toASCII,
+		'toUnicode': toUnicode
+	};
+
+	/**
+	 * URI.js
+	 *
+	 * @fileoverview An RFC 3986 compliant, scheme extendable URI parsing/validating/resolving library for JavaScript.
+	 * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
+	 * @see http://github.com/garycourt/uri-js
+	 */
+	/**
+	 * Copyright 2011 Gary Court. All rights reserved.
+	 *
+	 * Redistribution and use in source and binary forms, with or without modification, are
+	 * permitted provided that the following conditions are met:
+	 *
+	 *    1. Redistributions of source code must retain the above copyright notice, this list of
+	 *       conditions and the following disclaimer.
+	 *
+	 *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+	 *       of conditions and the following disclaimer in the documentation and/or other materials
+	 *       provided with the distribution.
+	 *
+	 * THIS SOFTWARE IS PROVIDED BY GARY COURT ``AS IS'' AND ANY EXPRESS OR IMPLIED
+	 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+	 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARY COURT OR
+	 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+	 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+	 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+	 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+	 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+	 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	 *
+	 * The views and conclusions contained in the software and documentation are those of the
+	 * authors and should not be interpreted as representing official policies, either expressed
+	 * or implied, of Gary Court.
+	 */
+	var SCHEMES = {};
+	function pctEncChar(chr) {
+	    var c = chr.charCodeAt(0);
+	    var e = void 0;
+	    if (c < 16) e = "%0" + c.toString(16).toUpperCase();else if (c < 128) e = "%" + c.toString(16).toUpperCase();else if (c < 2048) e = "%" + (c >> 6 | 192).toString(16).toUpperCase() + "%" + (c & 63 | 128).toString(16).toUpperCase();else e = "%" + (c >> 12 | 224).toString(16).toUpperCase() + "%" + (c >> 6 & 63 | 128).toString(16).toUpperCase() + "%" + (c & 63 | 128).toString(16).toUpperCase();
+	    return e;
+	}
+	function pctDecChars(str) {
+	    var newStr = "";
+	    var i = 0;
+	    var il = str.length;
+	    while (i < il) {
+	        var c = parseInt(str.substr(i + 1, 2), 16);
+	        if (c < 128) {
+	            newStr += String.fromCharCode(c);
+	            i += 3;
+	        } else if (c >= 194 && c < 224) {
+	            if (il - i >= 6) {
+	                var c2 = parseInt(str.substr(i + 4, 2), 16);
+	                newStr += String.fromCharCode((c & 31) << 6 | c2 & 63);
+	            } else {
+	                newStr += str.substr(i, 6);
+	            }
+	            i += 6;
+	        } else if (c >= 224) {
+	            if (il - i >= 9) {
+	                var _c = parseInt(str.substr(i + 4, 2), 16);
+	                var c3 = parseInt(str.substr(i + 7, 2), 16);
+	                newStr += String.fromCharCode((c & 15) << 12 | (_c & 63) << 6 | c3 & 63);
+	            } else {
+	                newStr += str.substr(i, 9);
+	            }
+	            i += 9;
+	        } else {
+	            newStr += str.substr(i, 3);
+	            i += 3;
+	        }
+	    }
+	    return newStr;
+	}
+	function _normalizeComponentEncoding(components, protocol) {
+	    function decodeUnreserved(str) {
+	        var decStr = pctDecChars(str);
+	        return !decStr.match(protocol.UNRESERVED) ? str : decStr;
+	    }
+	    if (components.scheme) components.scheme = String(components.scheme).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_SCHEME, "");
+	    if (components.userinfo !== undefined) components.userinfo = String(components.userinfo).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_USERINFO, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
+	    if (components.host !== undefined) components.host = String(components.host).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_HOST, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
+	    if (components.path !== undefined) components.path = String(components.path).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(components.scheme ? protocol.NOT_PATH : protocol.NOT_PATH_NOSCHEME, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
+	    if (components.query !== undefined) components.query = String(components.query).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_QUERY, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
+	    if (components.fragment !== undefined) components.fragment = String(components.fragment).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_FRAGMENT, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
+	    return components;
+	}
+
+	function _stripLeadingZeros(str) {
+	    return str.replace(/^0*(.*)/, "$1") || "0";
+	}
+	function _normalizeIPv4(host, protocol) {
+	    var matches = host.match(protocol.IPV4ADDRESS) || [];
+
+	    var _matches = slicedToArray(matches, 2),
+	        address = _matches[1];
+
+	    if (address) {
+	        return address.split(".").map(_stripLeadingZeros).join(".");
+	    } else {
+	        return host;
+	    }
+	}
+	function _normalizeIPv6(host, protocol) {
+	    var matches = host.match(protocol.IPV6ADDRESS) || [];
+
+	    var _matches2 = slicedToArray(matches, 3),
+	        address = _matches2[1],
+	        zone = _matches2[2];
+
+	    if (address) {
+	        var _address$toLowerCase$ = address.toLowerCase().split('::').reverse(),
+	            _address$toLowerCase$2 = slicedToArray(_address$toLowerCase$, 2),
+	            last = _address$toLowerCase$2[0],
+	            first = _address$toLowerCase$2[1];
+
+	        var firstFields = first ? first.split(":").map(_stripLeadingZeros) : [];
+	        var lastFields = last.split(":").map(_stripLeadingZeros);
+	        var isLastFieldIPv4Address = protocol.IPV4ADDRESS.test(lastFields[lastFields.length - 1]);
+	        var fieldCount = isLastFieldIPv4Address ? 7 : 8;
+	        var lastFieldsStart = lastFields.length - fieldCount;
+	        var fields = Array(fieldCount);
+	        for (var x = 0; x < fieldCount; ++x) {
+	            fields[x] = firstFields[x] || lastFields[lastFieldsStart + x] || '';
+	        }
+	        if (isLastFieldIPv4Address) {
+	            fields[fieldCount - 1] = _normalizeIPv4(fields[fieldCount - 1], protocol);
+	        }
+	        var allZeroFields = fields.reduce(function (acc, field, index) {
+	            if (!field || field === "0") {
+	                var lastLongest = acc[acc.length - 1];
+	                if (lastLongest && lastLongest.index + lastLongest.length === index) {
+	                    lastLongest.length++;
+	                } else {
+	                    acc.push({ index: index, length: 1 });
+	                }
+	            }
+	            return acc;
+	        }, []);
+	        var longestZeroFields = allZeroFields.sort(function (a, b) {
+	            return b.length - a.length;
+	        })[0];
+	        var newHost = void 0;
+	        if (longestZeroFields && longestZeroFields.length > 1) {
+	            var newFirst = fields.slice(0, longestZeroFields.index);
+	            var newLast = fields.slice(longestZeroFields.index + longestZeroFields.length);
+	            newHost = newFirst.join(":") + "::" + newLast.join(":");
+	        } else {
+	            newHost = fields.join(":");
+	        }
+	        if (zone) {
+	            newHost += "%" + zone;
+	        }
+	        return newHost;
+	    } else {
+	        return host;
+	    }
+	}
+	var URI_PARSE = /^(?:([^:\/?#]+):)?(?:\/\/((?:([^\/?#@]*)@)?(\[[^\/?#\]]+\]|[^\/?#:]*)(?:\:(\d*))?))?([^?#]*)(?:\?([^#]*))?(?:#((?:.|\n|\r)*))?/i;
+	var NO_MATCH_IS_UNDEFINED = "".match(/(){0}/)[1] === undefined;
+	function parse(uriString) {
+	    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+	    var components = {};
+	    var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;
+	    if (options.reference === "suffix") uriString = (options.scheme ? options.scheme + ":" : "") + "//" + uriString;
+	    var matches = uriString.match(URI_PARSE);
+	    if (matches) {
+	        if (NO_MATCH_IS_UNDEFINED) {
+	            //store each component
+	            components.scheme = matches[1];
+	            components.userinfo = matches[3];
+	            components.host = matches[4];
+	            components.port = parseInt(matches[5], 10);
+	            components.path = matches[6] || "";
+	            components.query = matches[7];
+	            components.fragment = matches[8];
+	            //fix port number
+	            if (isNaN(components.port)) {
+	                components.port = matches[5];
+	            }
+	        } else {
+	            //IE FIX for improper RegExp matching
+	            //store each component
+	            components.scheme = matches[1] || undefined;
+	            components.userinfo = uriString.indexOf("@") !== -1 ? matches[3] : undefined;
+	            components.host = uriString.indexOf("//") !== -1 ? matches[4] : undefined;
+	            components.port = parseInt(matches[5], 10);
+	            components.path = matches[6] || "";
+	            components.query = uriString.indexOf("?") !== -1 ? matches[7] : undefined;
+	            components.fragment = uriString.indexOf("#") !== -1 ? matches[8] : undefined;
+	            //fix port number
+	            if (isNaN(components.port)) {
+	                components.port = uriString.match(/\/\/(?:.|\n)*\:(?:\/|\?|\#|$)/) ? matches[4] : undefined;
+	            }
+	        }
+	        if (components.host) {
+	            //normalize IP hosts
+	            components.host = _normalizeIPv6(_normalizeIPv4(components.host, protocol), protocol);
+	        }
+	        //determine reference type
+	        if (components.scheme === undefined && components.userinfo === undefined && components.host === undefined && components.port === undefined && !components.path && components.query === undefined) {
+	            components.reference = "same-document";
+	        } else if (components.scheme === undefined) {
+	            components.reference = "relative";
+	        } else if (components.fragment === undefined) {
+	            components.reference = "absolute";
+	        } else {
+	            components.reference = "uri";
+	        }
+	        //check for reference errors
+	        if (options.reference && options.reference !== "suffix" && options.reference !== components.reference) {
+	            components.error = components.error || "URI is not a " + options.reference + " reference.";
+	        }
+	        //find scheme handler
+	        var schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];
+	        //check if scheme can't handle IRIs
+	        if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
+	            //if host component is a domain name
+	            if (components.host && (options.domainHost || schemeHandler && schemeHandler.domainHost)) {
+	                //convert Unicode IDN -> ASCII IDN
+	                try {
+	                    components.host = punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase());
+	                } catch (e) {
+	                    components.error = components.error || "Host's domain name can not be converted to ASCII via punycode: " + e;
+	                }
+	            }
+	            //convert IRI -> URI
+	            _normalizeComponentEncoding(components, URI_PROTOCOL);
+	        } else {
+	            //normalize encodings
+	            _normalizeComponentEncoding(components, protocol);
+	        }
+	        //perform scheme specific parsing
+	        if (schemeHandler && schemeHandler.parse) {
+	            schemeHandler.parse(components, options);
+	        }
+	    } else {
+	        components.error = components.error || "URI can not be parsed.";
+	    }
+	    return components;
+	}
+
+	function _recomposeAuthority(components, options) {
+	    var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;
+	    var uriTokens = [];
+	    if (components.userinfo !== undefined) {
+	        uriTokens.push(components.userinfo);
+	        uriTokens.push("@");
+	    }
+	    if (components.host !== undefined) {
+	        //normalize IP hosts, add brackets and escape zone separator for IPv6
+	        uriTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, function (_, $1, $2) {
+	            return "[" + $1 + ($2 ? "%25" + $2 : "") + "]";
+	        }));
+	    }
+	    if (typeof components.port === "number" || typeof components.port === "string") {
+	        uriTokens.push(":");
+	        uriTokens.push(String(components.port));
+	    }
+	    return uriTokens.length ? uriTokens.join("") : undefined;
+	}
+
+	var RDS1 = /^\.\.?\//;
+	var RDS2 = /^\/\.(\/|$)/;
+	var RDS3 = /^\/\.\.(\/|$)/;
+	var RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/;
+	function removeDotSegments(input) {
+	    var output = [];
+	    while (input.length) {
+	        if (input.match(RDS1)) {
+	            input = input.replace(RDS1, "");
+	        } else if (input.match(RDS2)) {
+	            input = input.replace(RDS2, "/");
+	        } else if (input.match(RDS3)) {
+	            input = input.replace(RDS3, "/");
+	            output.pop();
+	        } else if (input === "." || input === "..") {
+	            input = "";
+	        } else {
+	            var im = input.match(RDS5);
+	            if (im) {
+	                var s = im[0];
+	                input = input.slice(s.length);
+	                output.push(s);
+	            } else {
+	                throw new Error("Unexpected dot segment condition");
+	            }
+	        }
+	    }
+	    return output.join("");
+	}
+
+	function serialize(components) {
+	    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+	    var protocol = options.iri ? IRI_PROTOCOL : URI_PROTOCOL;
+	    var uriTokens = [];
+	    //find scheme handler
+	    var schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];
+	    //perform scheme specific serialization
+	    if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options);
+	    if (components.host) {
+	        //if host component is an IPv6 address
+	        if (protocol.IPV6ADDRESS.test(components.host)) ;
+	        //TODO: normalize IPv6 address as per RFC 5952
+
+	        //if host component is a domain name
+	        else if (options.domainHost || schemeHandler && schemeHandler.domainHost) {
+	                //convert IDN via punycode
+	                try {
+	                    components.host = !options.iri ? punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode.toUnicode(components.host);
+	                } catch (e) {
+	                    components.error = components.error || "Host's domain name can not be converted to " + (!options.iri ? "ASCII" : "Unicode") + " via punycode: " + e;
+	                }
+	            }
+	    }
+	    //normalize encoding
+	    _normalizeComponentEncoding(components, protocol);
+	    if (options.reference !== "suffix" && components.scheme) {
+	        uriTokens.push(components.scheme);
+	        uriTokens.push(":");
+	    }
+	    var authority = _recomposeAuthority(components, options);
+	    if (authority !== undefined) {
+	        if (options.reference !== "suffix") {
+	            uriTokens.push("//");
+	        }
+	        uriTokens.push(authority);
+	        if (components.path && components.path.charAt(0) !== "/") {
+	            uriTokens.push("/");
+	        }
+	    }
+	    if (components.path !== undefined) {
+	        var s = components.path;
+	        if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
+	            s = removeDotSegments(s);
+	        }
+	        if (authority === undefined) {
+	            s = s.replace(/^\/\//, "/%2F"); //don't allow the path to start with "//"
+	        }
+	        uriTokens.push(s);
+	    }
+	    if (components.query !== undefined) {
+	        uriTokens.push("?");
+	        uriTokens.push(components.query);
+	    }
+	    if (components.fragment !== undefined) {
+	        uriTokens.push("#");
+	        uriTokens.push(components.fragment);
+	    }
+	    return uriTokens.join(""); //merge tokens into a string
+	}
+
+	function resolveComponents(base, relative) {
+	    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+	    var skipNormalization = arguments[3];
+
+	    var target = {};
+	    if (!skipNormalization) {
+	        base = parse(serialize(base, options), options); //normalize base components
+	        relative = parse(serialize(relative, options), options); //normalize relative components
+	    }
+	    options = options || {};
+	    if (!options.tolerant && relative.scheme) {
+	        target.scheme = relative.scheme;
+	        //target.authority = relative.authority;
+	        target.userinfo = relative.userinfo;
+	        target.host = relative.host;
+	        target.port = relative.port;
+	        target.path = removeDotSegments(relative.path || "");
+	        target.query = relative.query;
+	    } else {
+	        if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {
+	            //target.authority = relative.authority;
+	            target.userinfo = relative.userinfo;
+	            target.host = relative.host;
+	            target.port = relative.port;
+	            target.path = removeDotSegments(relative.path || "");
+	            target.query = relative.query;
+	        } else {
+	            if (!relative.path) {
+	                target.path = base.path;
+	                if (relative.query !== undefined) {
+	                    target.query = relative.query;
+	                } else {
+	                    target.query = base.query;
+	                }
+	            } else {
+	                if (relative.path.charAt(0) === "/") {
+	                    target.path = removeDotSegments(relative.path);
+	                } else {
+	                    if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {
+	                        target.path = "/" + relative.path;
+	                    } else if (!base.path) {
+	                        target.path = relative.path;
+	                    } else {
+	                        target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
+	                    }
+	                    target.path = removeDotSegments(target.path);
+	                }
+	                target.query = relative.query;
+	            }
+	            //target.authority = base.authority;
+	            target.userinfo = base.userinfo;
+	            target.host = base.host;
+	            target.port = base.port;
+	        }
+	        target.scheme = base.scheme;
+	    }
+	    target.fragment = relative.fragment;
+	    return target;
+	}
+
+	function resolve(baseURI, relativeURI, options) {
+	    var schemelessOptions = assign({ scheme: 'null' }, options);
+	    return serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
+	}
+
+	function normalize(uri, options) {
+	    if (typeof uri === "string") {
+	        uri = serialize(parse(uri, options), options);
+	    } else if (typeOf(uri) === "object") {
+	        uri = parse(serialize(uri, options), options);
+	    }
+	    return uri;
+	}
+
+	function equal(uriA, uriB, options) {
+	    if (typeof uriA === "string") {
+	        uriA = serialize(parse(uriA, options), options);
+	    } else if (typeOf(uriA) === "object") {
+	        uriA = serialize(uriA, options);
+	    }
+	    if (typeof uriB === "string") {
+	        uriB = serialize(parse(uriB, options), options);
+	    } else if (typeOf(uriB) === "object") {
+	        uriB = serialize(uriB, options);
+	    }
+	    return uriA === uriB;
+	}
+
+	function escapeComponent(str, options) {
+	    return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.ESCAPE : IRI_PROTOCOL.ESCAPE, pctEncChar);
+	}
+
+	function unescapeComponent(str, options) {
+	    return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.PCT_ENCODED : IRI_PROTOCOL.PCT_ENCODED, pctDecChars);
+	}
+
+	var handler = {
+	    scheme: "http",
+	    domainHost: true,
+	    parse: function parse(components, options) {
+	        //report missing host
+	        if (!components.host) {
+	            components.error = components.error || "HTTP URIs must have a host.";
+	        }
+	        return components;
+	    },
+	    serialize: function serialize(components, options) {
+	        var secure = String(components.scheme).toLowerCase() === "https";
+	        //normalize the default port
+	        if (components.port === (secure ? 443 : 80) || components.port === "") {
+	            components.port = undefined;
+	        }
+	        //normalize the empty path
+	        if (!components.path) {
+	            components.path = "/";
+	        }
+	        //NOTE: We do not parse query strings for HTTP URIs
+	        //as WWW Form Url Encoded query strings are part of the HTML4+ spec,
+	        //and not the HTTP spec.
+	        return components;
+	    }
+	};
+
+	var handler$1 = {
+	    scheme: "https",
+	    domainHost: handler.domainHost,
+	    parse: handler.parse,
+	    serialize: handler.serialize
+	};
+
+	function isSecure(wsComponents) {
+	    return typeof wsComponents.secure === 'boolean' ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === "wss";
+	}
+	//RFC 6455
+	var handler$2 = {
+	    scheme: "ws",
+	    domainHost: true,
+	    parse: function parse(components, options) {
+	        var wsComponents = components;
+	        //indicate if the secure flag is set
+	        wsComponents.secure = isSecure(wsComponents);
+	        //construct resouce name
+	        wsComponents.resourceName = (wsComponents.path || '/') + (wsComponents.query ? '?' + wsComponents.query : '');
+	        wsComponents.path = undefined;
+	        wsComponents.query = undefined;
+	        return wsComponents;
+	    },
+	    serialize: function serialize(wsComponents, options) {
+	        //normalize the default port
+	        if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === "") {
+	            wsComponents.port = undefined;
+	        }
+	        //ensure scheme matches secure flag
+	        if (typeof wsComponents.secure === 'boolean') {
+	            wsComponents.scheme = wsComponents.secure ? 'wss' : 'ws';
+	            wsComponents.secure = undefined;
+	        }
+	        //reconstruct path from resource name
+	        if (wsComponents.resourceName) {
+	            var _wsComponents$resourc = wsComponents.resourceName.split('?'),
+	                _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2),
+	                path = _wsComponents$resourc2[0],
+	                query = _wsComponents$resourc2[1];
+
+	            wsComponents.path = path && path !== '/' ? path : undefined;
+	            wsComponents.query = query;
+	            wsComponents.resourceName = undefined;
+	        }
+	        //forbid fragment component
+	        wsComponents.fragment = undefined;
+	        return wsComponents;
+	    }
+	};
+
+	var handler$3 = {
+	    scheme: "wss",
+	    domainHost: handler$2.domainHost,
+	    parse: handler$2.parse,
+	    serialize: handler$2.serialize
+	};
+
+	var O = {};
+	//RFC 3986
+	var UNRESERVED$$ = "[A-Za-z0-9\\-\\.\\_\\~" + ("\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF" ) + "]";
+	var HEXDIG$$ = "[0-9A-Fa-f]"; //case-insensitive
+	var PCT_ENCODED$ = subexp(subexp("%[EFef]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + HEXDIG$$)); //expanded
+	//RFC 5322, except these symbols as per RFC 6068: @ : / ? # [ ] & ; =
+	//const ATEXT$$ = "[A-Za-z0-9\\!\\#\\$\\%\\&\\'\\*\\+\\-\\/\\=\\?\\^\\_\\`\\{\\|\\}\\~]";
+	//const WSP$$ = "[\\x20\\x09]";
+	//const OBS_QTEXT$$ = "[\\x01-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F]";  //(%d1-8 / %d11-12 / %d14-31 / %d127)
+	//const QTEXT$$ = merge("[\\x21\\x23-\\x5B\\x5D-\\x7E]", OBS_QTEXT$$);  //%d33 / %d35-91 / %d93-126 / obs-qtext
+	//const VCHAR$$ = "[\\x21-\\x7E]";
+	//const WSP$$ = "[\\x20\\x09]";
+	//const OBS_QP$ = subexp("\\\\" + merge("[\\x00\\x0D\\x0A]", OBS_QTEXT$$));  //%d0 / CR / LF / obs-qtext
+	//const FWS$ = subexp(subexp(WSP$$ + "*" + "\\x0D\\x0A") + "?" + WSP$$ + "+");
+	//const QUOTED_PAIR$ = subexp(subexp("\\\\" + subexp(VCHAR$$ + "|" + WSP$$)) + "|" + OBS_QP$);
+	//const QUOTED_STRING$ = subexp('\\"' + subexp(FWS$ + "?" + QCONTENT$) + "*" + FWS$ + "?" + '\\"');
+	var ATEXT$$ = "[A-Za-z0-9\\!\\$\\%\\'\\*\\+\\-\\^\\_\\`\\{\\|\\}\\~]";
+	var QTEXT$$ = "[\\!\\$\\%\\'\\(\\)\\*\\+\\,\\-\\.0-9\\<\\>A-Z\\x5E-\\x7E]";
+	var VCHAR$$ = merge(QTEXT$$, "[\\\"\\\\]");
+	var SOME_DELIMS$$ = "[\\!\\$\\'\\(\\)\\*\\+\\,\\;\\:\\@]";
+	var UNRESERVED = new RegExp(UNRESERVED$$, "g");
+	var PCT_ENCODED = new RegExp(PCT_ENCODED$, "g");
+	var NOT_LOCAL_PART = new RegExp(merge("[^]", ATEXT$$, "[\\.]", '[\\"]', VCHAR$$), "g");
+	var NOT_HFNAME = new RegExp(merge("[^]", UNRESERVED$$, SOME_DELIMS$$), "g");
+	var NOT_HFVALUE = NOT_HFNAME;
+	function decodeUnreserved(str) {
+	    var decStr = pctDecChars(str);
+	    return !decStr.match(UNRESERVED) ? str : decStr;
+	}
+	var handler$4 = {
+	    scheme: "mailto",
+	    parse: function parse$$1(components, options) {
+	        var mailtoComponents = components;
+	        var to = mailtoComponents.to = mailtoComponents.path ? mailtoComponents.path.split(",") : [];
+	        mailtoComponents.path = undefined;
+	        if (mailtoComponents.query) {
+	            var unknownHeaders = false;
+	            var headers = {};
+	            var hfields = mailtoComponents.query.split("&");
+	            for (var x = 0, xl = hfields.length; x < xl; ++x) {
+	                var hfield = hfields[x].split("=");
+	                switch (hfield[0]) {
+	                    case "to":
+	                        var toAddrs = hfield[1].split(",");
+	                        for (var _x = 0, _xl = toAddrs.length; _x < _xl; ++_x) {
+	                            to.push(toAddrs[_x]);
+	                        }
+	                        break;
+	                    case "subject":
+	                        mailtoComponents.subject = unescapeComponent(hfield[1], options);
+	                        break;
+	                    case "body":
+	                        mailtoComponents.body = unescapeComponent(hfield[1], options);
+	                        break;
+	                    default:
+	                        unknownHeaders = true;
+	                        headers[unescapeComponent(hfield[0], options)] = unescapeComponent(hfield[1], options);
+	                        break;
+	                }
+	            }
+	            if (unknownHeaders) mailtoComponents.headers = headers;
+	        }
+	        mailtoComponents.query = undefined;
+	        for (var _x2 = 0, _xl2 = to.length; _x2 < _xl2; ++_x2) {
+	            var addr = to[_x2].split("@");
+	            addr[0] = unescapeComponent(addr[0]);
+	            if (!options.unicodeSupport) {
+	                //convert Unicode IDN -> ASCII IDN
+	                try {
+	                    addr[1] = punycode.toASCII(unescapeComponent(addr[1], options).toLowerCase());
+	                } catch (e) {
+	                    mailtoComponents.error = mailtoComponents.error || "Email address's domain name can not be converted to ASCII via punycode: " + e;
+	                }
+	            } else {
+	                addr[1] = unescapeComponent(addr[1], options).toLowerCase();
+	            }
+	            to[_x2] = addr.join("@");
+	        }
+	        return mailtoComponents;
+	    },
+	    serialize: function serialize$$1(mailtoComponents, options) {
+	        var components = mailtoComponents;
+	        var to = toArray(mailtoComponents.to);
+	        if (to) {
+	            for (var x = 0, xl = to.length; x < xl; ++x) {
+	                var toAddr = String(to[x]);
+	                var atIdx = toAddr.lastIndexOf("@");
+	                var localPart = toAddr.slice(0, atIdx).replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_LOCAL_PART, pctEncChar);
+	                var domain = toAddr.slice(atIdx + 1);
+	                //convert IDN via punycode
+	                try {
+	                    domain = !options.iri ? punycode.toASCII(unescapeComponent(domain, options).toLowerCase()) : punycode.toUnicode(domain);
+	                } catch (e) {
+	                    components.error = components.error || "Email address's domain name can not be converted to " + (!options.iri ? "ASCII" : "Unicode") + " via punycode: " + e;
+	                }
+	                to[x] = localPart + "@" + domain;
+	            }
+	            components.path = to.join(",");
+	        }
+	        var headers = mailtoComponents.headers = mailtoComponents.headers || {};
+	        if (mailtoComponents.subject) headers["subject"] = mailtoComponents.subject;
+	        if (mailtoComponents.body) headers["body"] = mailtoComponents.body;
+	        var fields = [];
+	        for (var name in headers) {
+	            if (headers[name] !== O[name]) {
+	                fields.push(name.replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFNAME, pctEncChar) + "=" + headers[name].replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFVALUE, pctEncChar));
+	            }
+	        }
+	        if (fields.length) {
+	            components.query = fields.join("&");
+	        }
+	        return components;
+	    }
+	};
+
+	var URN_PARSE = /^([^\:]+)\:(.*)/;
+	//RFC 2141
+	var handler$5 = {
+	    scheme: "urn",
+	    parse: function parse$$1(components, options) {
+	        var matches = components.path && components.path.match(URN_PARSE);
+	        var urnComponents = components;
+	        if (matches) {
+	            var scheme = options.scheme || urnComponents.scheme || "urn";
+	            var nid = matches[1].toLowerCase();
+	            var nss = matches[2];
+	            var urnScheme = scheme + ":" + (options.nid || nid);
+	            var schemeHandler = SCHEMES[urnScheme];
+	            urnComponents.nid = nid;
+	            urnComponents.nss = nss;
+	            urnComponents.path = undefined;
+	            if (schemeHandler) {
+	                urnComponents = schemeHandler.parse(urnComponents, options);
+	            }
+	        } else {
+	            urnComponents.error = urnComponents.error || "URN can not be parsed.";
+	        }
+	        return urnComponents;
+	    },
+	    serialize: function serialize$$1(urnComponents, options) {
+	        var scheme = options.scheme || urnComponents.scheme || "urn";
+	        var nid = urnComponents.nid;
+	        var urnScheme = scheme + ":" + (options.nid || nid);
+	        var schemeHandler = SCHEMES[urnScheme];
+	        if (schemeHandler) {
+	            urnComponents = schemeHandler.serialize(urnComponents, options);
+	        }
+	        var uriComponents = urnComponents;
+	        var nss = urnComponents.nss;
+	        uriComponents.path = (nid || options.nid) + ":" + nss;
+	        return uriComponents;
+	    }
+	};
+
+	var UUID = /^[0-9A-Fa-f]{8}(?:\-[0-9A-Fa-f]{4}){3}\-[0-9A-Fa-f]{12}$/;
+	//RFC 4122
+	var handler$6 = {
+	    scheme: "urn:uuid",
+	    parse: function parse(urnComponents, options) {
+	        var uuidComponents = urnComponents;
+	        uuidComponents.uuid = uuidComponents.nss;
+	        uuidComponents.nss = undefined;
+	        if (!options.tolerant && (!uuidComponents.uuid || !uuidComponents.uuid.match(UUID))) {
+	            uuidComponents.error = uuidComponents.error || "UUID is not valid.";
+	        }
+	        return uuidComponents;
+	    },
+	    serialize: function serialize(uuidComponents, options) {
+	        var urnComponents = uuidComponents;
+	        //normalize UUID
+	        urnComponents.nss = (uuidComponents.uuid || "").toLowerCase();
+	        return urnComponents;
+	    }
+	};
+
+	SCHEMES[handler.scheme] = handler;
+	SCHEMES[handler$1.scheme] = handler$1;
+	SCHEMES[handler$2.scheme] = handler$2;
+	SCHEMES[handler$3.scheme] = handler$3;
+	SCHEMES[handler$4.scheme] = handler$4;
+	SCHEMES[handler$5.scheme] = handler$5;
+	SCHEMES[handler$6.scheme] = handler$6;
+
+	exports.SCHEMES = SCHEMES;
+	exports.pctEncChar = pctEncChar;
+	exports.pctDecChars = pctDecChars;
+	exports.parse = parse;
+	exports.removeDotSegments = removeDotSegments;
+	exports.serialize = serialize;
+	exports.resolveComponents = resolveComponents;
+	exports.resolve = resolve;
+	exports.normalize = normalize;
+	exports.equal = equal;
+	exports.escapeComponent = escapeComponent;
+	exports.unescapeComponent = unescapeComponent;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+	})));
+	
+} (uri_all, uri_all.exports));
+
+const URI = uri_all.exports;
 
-}(( 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;
-        }
+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);
 
-        for (s in subscribers){
-            if ( Object.prototype.hasOwnProperty.call(subscribers, s)){
-                callSubscriber( subscribers[s], originalMessage, data );
-            }
-        }
-    }
+const resolveUrl$3 = (contextUrl, url) => {
+  const resolvedUrl = URI.resolve(contextUrl, url, { iri: true });
+  const contextId = URI.resolve(contextUrl, "", { iri: true });
+  if (contextId && URI.parse(resolvedUrl).scheme === "file" && URI.parse(contextUrl).scheme !== "file") {
+    throw Error(`Can't access file '${resolvedUrl}' resource from network context '${contextUrl}'`);
+  }
+  return resolvedUrl;
+};
 
-    function createDeliveryFunction( message, data, immediateExceptions ){
-        return function deliverNamespaced(){
-            var topic = String( message ),
-                position = topic.lastIndexOf( '.' );
+const urlFragment$1 = (uri) => URI.unescapeComponent(URI.parse(uri).fragment) || "";
 
-            // deliver the message as it is now
-            deliverMessage(message, message, data, immediateExceptions);
+const CHAR_BACKWARD_SLASH = 47;
 
-            // 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 );
-            }
+const pathRelative$1 = (from, to) => {
+  if (from === to) {
+    return "";
+  }
 
-            deliverMessage(message, ALL_SUBSCRIBING_MSG, data, immediateExceptions);
-        };
+  let toStart = 1;
+  const fromLen = from.length - 1;
+  const toLen = to.length - toStart;
+
+  // Compare paths to find the longest common path from root
+  const length = fromLen < toLen ? fromLen : toLen;
+  let lastCommonSep = -1;
+  let i = 0;
+  for (; i < length; i++) {
+    const fromCode = from.charCodeAt(i + 1);
+    if (fromCode !== to.charCodeAt(toStart + i)) {
+      break;
+    } else if (fromCode === CHAR_BACKWARD_SLASH) {
+      lastCommonSep = i;
     }
+  }
 
-    function hasDirectSubscribersFor( message ) {
-        var topic = String( message ),
-            found = Boolean(Object.prototype.hasOwnProperty.call( messages, topic ) && hasKeys(messages[topic]));
-
-        return found;
+  if (toLen > length) {
+    if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
+      return to.slice(toStart + i + 1);
     }
-
-    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;
+    if (i === 0) {
+      return to.slice(toStart + i);
     }
-
-    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);
-      }
+  if (fromLen > length) {
+    if (from.charCodeAt(i + 1) === CHAR_BACKWARD_SLASH) {
+      lastCommonSep = i;
+    } else if (length === 0) {
+      lastCommonSep = 0;
     }
-  });
-  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 out = "";
+  // Generate the relative path based on the path difference between `to` and `from`
+  for (i = lastCommonSep + 2; i <= from.length; ++i) {
+    if (i === from.length || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
+      out += out.length === 0 ? ".." : "/..";
+    }
   }
 
-  let path = relative;
-  const queryIndex = relative.indexOf('?');
-  const hashIndex = relative.indexOf('#');
+  toStart += lastCommonSep;
 
-  if (hashIndex !== -1) {
-    const hash = path.substring(hashIndex);
-    resultObject.hash = hash;
-    path = path.substring(0, hashIndex);
+  // Lastly, append the rest of the destination (`to`) path that comes after
+  // the common path parts
+  if (out.length > 0) {
+    return `${out}${to.slice(toStart, to.length)}`;
   }
 
-  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;
+  if (to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
+    ++toStart;
   }
 
-  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"
+  return to.slice(toStart, to.length);
 };
-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);
+var common$1 = { jsonTypeOf: jsonTypeOf$2, resolveUrl: resolveUrl$3, urlFragment: urlFragment$1, pathRelative: pathRelative$1 };
 
-  return [decodeURI(urlReference), decodeURI(urlFragment)];
-};
+const curry$9 = justCurryIt;
 
-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 = "";
 
@@ -674,7 +1925,7 @@ const get$1 = (pointer, value = undefined) => {
 
 const set = (pointer, subject = undefined, value = undefined) => {
   const ptr = compile$P(pointer);
-  const fn = justCurryIt((subject, value) => _set(ptr, subject, value, nil$2));
+  const fn = curry$9((subject, value) => _set(ptr, subject, value, nil$2));
   return subject === undefined ? fn : fn(subject, value);
 };
 
@@ -698,7 +1949,7 @@ const _set = (pointer, subject, value, cursor) => {
 
 const assign = (pointer, subject = undefined, value = undefined) => {
   const ptr = compile$P(pointer);
-  const fn = justCurryIt((subject, value) => _assign(ptr, subject, value, nil$2));
+  const fn = curry$9((subject, value) => _assign(ptr, subject, value, nil$2));
   return subject === undefined ? fn : fn(subject, value);
 };
 
@@ -760,7 +2011,7 @@ const _remove = (pointer, subject, cursor) => {
   }
 };
 
-const append = justCurryIt((segment, pointer) => pointer + "/" + escape(segment));
+const append = curry$9((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, "~");
@@ -782,13 +2033,6 @@ const applySegment = (value, segment, cursor = "") => {
 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");
@@ -803,67 +2047,52 @@ const href = (ref) => ref[$__href];
 const value$2 = (ref) => ref[$__value];
 
 var reference = { cons: cons$1, isReference, href, value: value$2 };
-reference.cons;
-reference.isReference;
-reference.href;
-reference.value;
-
-const { jsonTypeOf: jsonTypeOf$1 } = common$1;
 
+const JsonPointer$1 = lib$3;
+const curry$8 = justCurryIt;
+const { resolveUrl: resolveUrl$2, jsonTypeOf: jsonTypeOf$1 } = common$1;
+const Reference$2 = reference;
 
 
 const nil$1 = Object.freeze({ id: "", pointer: "", instance: undefined, value: undefined });
-const cons = (instance, id = "") => Object.freeze({ ...nil$1, id, instance, value: instance });
+const cons = (instance, id = "") => Object.freeze({ ...nil$1, id: resolveUrl$2(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 value$1 = (doc) => Reference$2.isReference(doc.value) ? Reference$2.value(doc.value) : doc.value;
 const has$1 = (key, doc) => key in value$1(doc);
-const typeOf$1 = justCurryIt((doc, type) => jsonTypeOf$1(value$1(doc), type));
+const typeOf$1 = curry$8((doc, type) => jsonTypeOf$1(value$1(doc), type));
 
 const step$1 = (key, doc) => Object.freeze({
   ...doc,
-  pointer: lib$3.append(key, doc.pointer),
+  pointer: JsonPointer$1.append(key, doc.pointer),
   value: value$1(doc)[key]
 });
 
-const entries$2 = (doc) => Object.keys(value$1(doc))
+const entries$3 = (doc) => Object.keys(value$1(doc))
   .map((key) => [key, step$1(key, doc)]);
 
 const keys$1 = (doc) => Object.keys(value$1(doc));
 
-const map$2 = justCurryIt((fn, doc) => value$1(doc)
+const map$4 = curry$8((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)
+const filter$1 = curry$8((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)
+const reduce$3 = curry$8((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)
+const every$1 = curry$8((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)
+const some$1 = curry$8((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;
+var instance = { nil: nil$1, cons, uri: uri$1, value: value$1, has: has$1, typeOf: typeOf$1, step: step$1, entries: entries$3, keys: keys$1, map: map$4, filter: filter$1, reduce: reduce$3, every: every$1, some: some$1, length: length$1 };
+
+var contentType = {};
 
 /*!
  * content-type
@@ -916,8 +2145,8 @@ var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
  * @public
  */
 
-var format_1 = format$1;
-var parse_1 = parse;
+contentType.format = format$1;
+contentType.parse = parse;
 
 /**
  * Format object to media type.
@@ -1086,43 +2315,64 @@ function ContentType (type) {
   this.type = type;
 }
 
-var contentType = {
-	format: format_1,
-	parse: parse_1
-};
+var entries$2 = async (doc) => Object.entries(await doc);
+
+const curry$7 = justCurryIt;
+
 
-var entries$1 = async (doc) => Object.entries(await doc);
+var map$3 = curry$7(async (fn, doc) => (await doc).map(fn));
 
-var map$1 = justCurryIt(async (fn, doc) => (await doc).map(fn));
+const curry$6 = justCurryIt;
 
-var reduce = justCurryIt(async (fn, acc, doc) => {
+
+var reduce$2 = curry$6(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) => {
+const curry$5 = justCurryIt;
+const reduce$1 = reduce$2;
+
+
+var filter = curry$5(async (fn, doc, options = {}) => {
+  return reduce$1(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);
+const curry$4 = justCurryIt;
+const map$2 = map$3;
+
+
+var some = curry$4(async (fn, doc) => {
+  const results = await map$2(fn, doc);
   return (await Promise.all(results))
     .some((a) => a);
 });
 
-var every = justCurryIt(async (fn, doc) => {
+const curry$3 = justCurryIt;
+const map$1 = map$3;
+
+
+var every = curry$3(async (fn, doc) => {
   const results = await map$1(fn, doc);
   return (await Promise.all(results))
     .every((a) => a);
 });
 
-var pipeline = justCurryIt((fns, doc) => {
+const curry$2 = justCurryIt;
+
+
+var pipeline$1 = curry$2((fns, doc) => {
   return fns.reduce(async (acc, fn) => fn(await acc), doc);
 });
 
 var all = (doc) => Promise.all(doc);
 
+const pipeline = pipeline$1;
+const entries$1 = entries$2;
+const reduce = reduce$2;
+
+
 var allValues = (doc) => {
   return pipeline([
     entries$1,
@@ -1134,48 +2384,43 @@ var allValues = (doc) => {
 };
 
 var lib$2 = {
-  entries: entries$1,
-  map: map$1,
+  entries: entries$2,
+  map: map$3,
   filter: filter,
-  reduce: reduce,
+  reduce: reduce$2,
   some: some,
   every: every,
-  pipeline: pipeline,
+  pipeline: pipeline$1,
   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;
-
-
+const contentTypeParser = contentType;
+const curry$1 = justCurryIt;
+const Pact$a = lib$2;
+const JsonPointer = lib$3;
+const { jsonTypeOf, resolveUrl: resolveUrl$1, urlFragment, pathRelative } = common$1;
+const fetch$1 = fetch_browser;
+const Reference$1 = reference;
 
 
 // Config
 const config = {};
-const configAlias = {};
+const dialectJsonSchemaVersion = {};
 
-const setConfig = (schemaVersion, key, value) => {
-  if (!config[schemaVersion]) {
-    config[schemaVersion] = {};
+const setConfig = (jsonSchemaVersion, key, value) => {
+  if (!config[jsonSchemaVersion]) {
+    config[jsonSchemaVersion] = {};
   }
-  config[schemaVersion][key] = value;
+  config[jsonSchemaVersion][key] = value;
 };
 
-const getConfig = (schemaVersion, key) => {
-  const configVersion = schemaVersion in configAlias ? configAlias[schemaVersion] : schemaVersion;
-  if (configVersion in config) {
-    return config[configVersion][key];
+const getConfig = (dialectId, key) => {
+  const jsonSchemaVersion = dialectJsonSchemaVersion[dialectId] || dialectId;
+  if (jsonSchemaVersion in config) {
+    return config[jsonSchemaVersion][key];
   }
 };
 
@@ -1186,22 +2431,32 @@ 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");
+  // Dialect / JSON Schema Version
+  const dialectId = resolveUrl$1(schema["$schema"] || defaultSchemaVersion, "");
+  if (!dialectId) {
+    throw Error("Couldn't determine schema dialect");
   }
   delete schema["$schema"];
 
+  let jsonSchemaVersion;
+  if (schema.$vocabulary?.["https://json-schema.org/draft/2019-09/vocab/core"] === true) {
+    jsonSchemaVersion = "https://json-schema.org/draft/2019-09/vocab/core";
+  } else if (schema.$vocabulary?.["https://json-schema.org/draft/2020-12/vocab/core"] === true) {
+    jsonSchemaVersion = "https://json-schema.org/draft/2020-12/vocab/core";
+  } else {
+    jsonSchemaVersion = dialectJsonSchemaVersion[dialectId] || dialectId;
+  }
+
   // Identifier
-  const baseToken = getConfig(schemaVersion, "baseToken");
-  const anchorToken = getConfig(schemaVersion, "anchorToken");
-  const externalId = splitUrl$3(url)[0];
-  if (!externalId && !splitUrl$3(schema[baseToken] || "")[0]) {
+  const baseToken = getConfig(jsonSchemaVersion, "baseToken");
+  const anchorToken = getConfig(jsonSchemaVersion, "anchorToken");
+  const externalId = resolveUrl$1(url, "");
+  if (!externalId && !resolveUrl$1(schema[baseToken] || "", "")) {
     throw Error("Couldn't determine an identifier for the schema");
   }
-  const internalUrl = safeResolveUrl(externalId, schema[baseToken] || "");
-  const [id, fragment] = splitUrl$3(internalUrl);
+  const internalUrl = resolveUrl$1(externalId, schema[baseToken] || "");
+  const id = resolveUrl$1(internalUrl, "");
+  const fragment = urlFragment(internalUrl);
   delete schema[baseToken];
   if (fragment && baseToken === anchorToken) {
     schema[anchorToken] = anchorToken !== baseToken ? encodeURI(fragment) : `#${encodeURI(fragment)}`;
@@ -1210,9 +2465,12 @@ const add$1 = (schema, url = "", defaultSchemaVersion = "") => {
     schemaStoreAlias[externalId] = id;
   }
 
+  // JSON Schema version
+  dialectJsonSchemaVersion[id] = jsonSchemaVersion;
+
   // recursiveAnchor
   const dynamicAnchors = {};
-  const recursiveAnchorToken = getConfig(schemaVersion, "recursiveAnchorToken");
+  const recursiveAnchorToken = getConfig(dialectId, "recursiveAnchorToken");
   if (schema[recursiveAnchorToken] === true) {
     dynamicAnchors[""] = `${id}#`;
     schema[anchorToken] = "";
@@ -1221,22 +2479,20 @@ const add$1 = (schema, url = "", defaultSchemaVersion = "") => {
 
   // Vocabulary
   let vocabulary;
-  const vocabularyToken = getConfig(schemaVersion, "vocabularyToken");
+  const vocabularyToken = getConfig(dialectId, "vocabularyToken");
   if (jsonTypeOf(schema[vocabularyToken], "object")) {
-    configAlias[id] = schemaVersion;
     vocabulary = schema[vocabularyToken];
     delete schema[vocabularyToken];
   } else {
-    configAlias[id] = schemaVersion;
-    vocabulary = { [schemaVersion]: true };
+    vocabulary = { [dialectJsonSchemaVersion[dialectId]]: true };
   }
 
   // Store Schema
   const anchors = { "": "" };
   schemaStore[id] = {
     id: id,
-    schemaVersion: schemaVersion,
-    schema: processSchema(schema, id, schemaVersion, lib$3.nil, anchors, dynamicAnchors),
+    dialectId: dialectId,
+    schema: processSchema(schema, id, dialectId, JsonPointer.nil, anchors, dynamicAnchors),
     anchors: anchors,
     dynamicAnchors: dynamicAnchors,
     vocabulary: vocabulary,
@@ -1246,45 +2502,46 @@ const add$1 = (schema, url = "", defaultSchemaVersion = "") => {
   return id;
 };
 
-const processSchema = (subject, id, schemaVersion, pointer, anchors, dynamicAnchors) => {
+const processSchema = (subject, id, dialectId, 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");
+    const embeddedSchemaDialectId = typeof subject.$schema === "string" ? resolveUrl$1(subject.$schema, "") : dialectId;
+    const embeddedEmbeddedToken = getConfig(embeddedSchemaDialectId, "embeddedToken");
+    const embeddedAnchorToken = getConfig(embeddedSchemaDialectId, "anchorToken");
     if (typeof subject[embeddedEmbeddedToken] === "string" && (embeddedEmbeddedToken !== embeddedAnchorToken || subject[embeddedEmbeddedToken][0] !== "#")) {
-      const ref = safeResolveUrl(id, subject[embeddedEmbeddedToken]);
-      subject[embeddedEmbeddedToken] = ref;
-      add$1(subject, ref, schemaVersion);
-      return reference.cons(subject[embeddedEmbeddedToken], subject);
+      const ref = resolveUrl$1(id, subject[embeddedEmbeddedToken]);
+      const embeddedBaseToken = getConfig(embeddedSchemaDialectId, "baseToken");
+      subject[embeddedBaseToken] = ref;
+      add$1(subject, ref, dialectId);
+      return Reference$1.cons(subject[embeddedEmbeddedToken], subject);
     }
 
-    const anchorToken = getConfig(schemaVersion, "anchorToken");
-    const dynamicAnchorToken = getConfig(schemaVersion, "dynamicAnchorToken");
+    const anchorToken = getConfig(dialectId, "anchorToken");
+    const dynamicAnchorToken = getConfig(dialectId, "dynamicAnchorToken");
     if (typeof subject[dynamicAnchorToken] === "string") {
       dynamicAnchors[subject[dynamicAnchorToken]] = `${id}#${encodeURI(pointer)}`;
       anchors[subject[dynamicAnchorToken]] = pointer;
       delete subject[dynamicAnchorToken];
     }
 
-    const embeddedToken = getConfig(schemaVersion, "embeddedToken");
+    const embeddedToken = getConfig(dialectId, "embeddedToken");
     if (typeof subject[anchorToken] === "string") {
       const anchor = anchorToken !== embeddedToken ? subject[anchorToken] : subject[anchorToken].slice(1);
       anchors[anchor] = pointer;
       delete subject[anchorToken];
     }
 
-    const jrefToken = getConfig(schemaVersion, "jrefToken");
+    const jrefToken = getConfig(dialectId, "jrefToken");
     if (typeof subject[jrefToken] === "string") {
-      return reference.cons(subject[jrefToken], subject);
+      return Reference$1.cons(subject[jrefToken], subject);
     }
 
     for (const key in subject) {
-      subject[key] = processSchema(subject[key], id, schemaVersion, lib$3.append(key, pointer), anchors, dynamicAnchors);
+      subject[key] = processSchema(subject[key], id, dialectId, JsonPointer.append(key, pointer), anchors, dynamicAnchors);
     }
 
     return subject;
   } else if (Array.isArray(subject)) {
-    return subject.map((item, ndx) => processSchema(item, id, schemaVersion, lib$3.append(ndx, pointer), anchors, dynamicAnchors));
+    return subject.map((item, ndx) => processSchema(item, id, dialectId, JsonPointer.append(ndx, pointer), anchors, dynamicAnchors));
   } else {
     return subject;
   }
@@ -1300,9 +2557,9 @@ const markValidated = (id) => {
 // Schema Retrieval
 const nil = Object.freeze({
   id: "",
-  schemaVersion: undefined,
+  dialectId: undefined,
   vocabulary: {},
-  pointer: lib$3.nil,
+  pointer: JsonPointer.nil,
   schema: undefined,
   value: undefined,
   anchors: {},
@@ -1311,20 +2568,21 @@ const nil = Object.freeze({
 });
 
 const get = async (url, contextDoc = nil) => {
-  const resolvedUrl = safeResolveUrl(uri(contextDoc), url);
-  const [id, fragment] = splitUrl$3(resolvedUrl);
+  const resolvedUrl = resolveUrl$1(uri(contextDoc), url);
+  const id = resolveUrl$1(resolvedUrl, "");
+  const fragment = urlFragment(resolvedUrl);
 
   if (!hasStoredSchema(id)) {
-    const response = await fetch_browser(id, { headers: { Accept: "application/schema+json" } });
+    const response = await fetch$1(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}`);
+      const contentType = contentTypeParser.parse(response.headers.get("content-type")).type;
+      if (contentType !== "application/schema+json") {
+        throw Error(`${id} is not a schema. Found a document with media type: ${contentType}`);
       }
     }
 
@@ -1336,13 +2594,13 @@ const get = async (url, contextDoc = nil) => {
   const doc = Object.freeze({
     ...storedSchema,
     pointer: pointer,
-    value: lib$3.get(pointer, storedSchema.schema)
+    value: JsonPointer.get(pointer, storedSchema.schema)
   });
 
   return followReferences$1(doc);
 };
 
-const followReferences$1 = (doc) => reference.isReference(doc.value) ? get(reference.href(doc.value), doc) : doc;
+const followReferences$1 = (doc) => Reference$1.isReference(doc.value) ? get(Reference$1.href(doc.value), doc) : doc;
 
 const getAnchorPointer = (schema, fragment) => {
   if (!(fragment in schema.anchors)) {
@@ -1354,7 +2612,7 @@ const getAnchorPointer = (schema, 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 value = (doc) => Reference$1.isReference(doc.value) ? Reference$1.value(doc.value) : doc.value;
 const has = (key, doc) => key in value(doc);
 const typeOf = (doc, type) => jsonTypeOf(value(doc), type);
 
@@ -1362,7 +2620,7 @@ const step = (key, doc) => {
   const storedSchema = getStoredSchema(doc.id);
   const nextDoc = Object.freeze({
     ...doc,
-    pointer: lib$3.append(key, doc.pointer),
+    pointer: JsonPointer.append(key, doc.pointer),
     value: value(doc)[key],
     validated: storedSchema.validated
   });
@@ -1371,43 +2629,91 @@ const step = (key, doc) => {
 
 const keys = (doc) => Object.keys(value(doc));
 
-const entries = (doc) => lib$2.pipeline([
+const entries = (doc) => Pact$a.pipeline([
   value,
   Object.keys,
-  lib$2.map(async (key) => [key, await step(key, doc)]),
-  lib$2.all
+  Pact$a.map(async (key) => [key, await step(key, doc)]),
+  Pact$a.all
 ], doc);
 
-const map = justCurryIt((fn, doc) => lib$2.pipeline([
+const map = curry$1((fn, doc) => Pact$a.pipeline([
   value,
-  lib$2.map(async (item, ndx) => fn(await step(ndx, doc), ndx)),
-  lib$2.all
+  Pact$a.map(async (item, ndx) => fn(await step(ndx, doc), ndx)),
+  Pact$a.all
 ], doc));
 
 const length = (doc) => value(doc).length;
 
+const toSchemaDefaultOptions = {
+  parentId: "",
+  parentDialect: "",
+  includeEmbedded: true
+};
+const toSchema = (schemaDoc, options = {}) => {
+  const fullOptions = { ...toSchemaDefaultOptions, ...options };
+
+  const schema = JSON.parse(JSON.stringify(schemaDoc.schema, (key, value) => {
+    if (!Reference$1.isReference(value)) {
+      return value;
+    }
+
+    const refValue = Reference$1.value(value);
+    const embeddedDialect = typeof refValue.$schema === "string" ? resolveUrl$1(refValue.$schema, "") : schemaDoc.dialectId;
+    const embeddedToken = getConfig(embeddedDialect, "embeddedToken");
+    if (!fullOptions.includeEmbedded && embeddedToken in refValue) {
+      return;
+    } else {
+      return Reference$1.value(value);
+    }
+  }));
+
+  const dynamicAnchorToken = getConfig(schemaDoc.dialectId, "dynamicAnchorToken");
+  Object.entries(schemaDoc.dynamicAnchors)
+    .forEach(([anchor, uri]) => {
+      const pointer = urlFragment(uri);
+      JsonPointer.assign(pointer, schema, {
+        [dynamicAnchorToken]: anchor,
+        ...JsonPointer.get(pointer, schema)
+      });
+    });
+
+  const anchorToken = getConfig(schemaDoc.dialectId, "anchorToken");
+  Object.entries(schemaDoc.anchors)
+    .filter(([anchor]) => anchor !== "")
+    .forEach(([anchor, pointer]) => {
+      JsonPointer.assign(pointer, schema, {
+        [anchorToken]: anchor,
+        ...JsonPointer.get(pointer, schema)
+      });
+    });
+
+  const baseToken = getConfig(schemaDoc.dialectId, "baseToken");
+  const id = relativeUri(fullOptions.parentId, schemaDoc.id);
+  const dialect = fullOptions.parentDialect === schemaDoc.dialectId ? "" : schemaDoc.dialectId;
+  return {
+    ...(id && { [baseToken]: id }),
+    ...(dialect && { $schema: dialect }),
+    ...schema
+  };
+};
+
+const relativeUri = (from, to) => {
+  if (to.startsWith("file://")) {
+    const pathToSchema = from.slice(7, from.lastIndexOf("/"));
+    return from === "" ? "" : pathRelative(pathToSchema, to.slice(7));
+  } else {
+    return to;
+  }
+};
+
 var schema$5 = {
   setConfig, getConfig,
   add: add$1, get, markValidated,
-  uri, value, getAnchorPointer, typeOf, has, step, keys, entries, map, length
+  uri, value, getAnchorPointer, typeOf, has, step, keys, entries, map, length,
+  toSchema
 };
-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 {
+
+class InvalidSchemaError$3 extends Error {
   constructor(output) {
     super("Invalid Schema");
     this.name = this.constructor.name;
@@ -1415,12 +2721,14 @@ class InvalidSchemaError$1 extends Error {
   }
 }
 
-var invalidSchemaError = InvalidSchemaError$1;
-
-const { splitUrl: splitUrl$2 } = common$1;
-
-
+var invalidSchemaError = InvalidSchemaError$3;
 
+const curry = justCurryIt;
+const PubSub$1 = pubsub.exports;
+const { resolveUrl } = common$1;
+const Instance$E = instance;
+const Schema$R = schema$5;
+const InvalidSchemaError$2 = invalidSchemaError;
 
 
 const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED", VERBOSE = "VERBOSE";
@@ -1428,9 +2736,9 @@ 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 validate$2 = async (schema, value = undefined, outputFormat = undefined) => {
   const compiled = await compile$O(schema);
-  const interpretAst = (value, outputFormat) => interpret$O(compiled, instance.cons(value), outputFormat);
+  const interpretAst = (value, outputFormat) => interpret$O(compiled, Instance$E.cons(value), outputFormat);
 
   return value === undefined ? interpretAst : interpretAst(value, outputFormat);
 };
@@ -1441,15 +2749,15 @@ const compile$O = async (schema) => {
   return { ast, schemaUri };
 };
 
-const interpret$O = justCurryIt(({ ast, schemaUri }, value, outputFormat = FLAG) => {
+const interpret$O = curry(({ 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));
+  const subscriptionToken = PubSub$1.subscribe("result", outputHandler(outputFormat, output));
   interpretSchema(schemaUri, value, ast, {});
-  pubsub.unsubscribe(subscriptionToken);
+  PubSub$1.unsubscribe(subscriptionToken);
 
   return output[0];
 });
@@ -1515,11 +2823,11 @@ const compileSchema = async (schema, ast) => {
   schema = await followReferences(schema);
 
   // Vocabularies
-  if (!hasKeyword(`${schema.schemaVersion}#validate`)) {
-    const metaSchema = await schema$5.get(schema.schemaVersion);
+  if (!hasKeyword(`${schema.dialectId}#validate`)) {
+    const metaSchema = await Schema$R.get(schema.dialectId);
 
     // Check for mandatory vocabularies
-    const mandatoryVocabularies = schema$5.getConfig(metaSchema.id, "mandatoryVocabularies") || [];
+    const mandatoryVocabularies = Schema$R.getConfig(metaSchema.id, "mandatoryVocabularies") || [];
     mandatoryVocabularies.forEach((vocabularyId) => {
       if (!metaSchema.vocabulary[vocabularyId]) {
         throw Error(`Vocabulary '${vocabularyId}' must be explicitly declared and required`);
@@ -1542,20 +2850,20 @@ const compileSchema = async (schema, ast) => {
 
   // Meta validation
   if (shouldMetaValidate && !schema.validated) {
-    schema$5.markValidated(schema.id);
+    Schema$R.markValidated(schema.id);
 
     // Compile
-    if (!(schema.schemaVersion in metaValidators)) {
-      const metaSchema = await schema$5.get(schema.schemaVersion);
+    if (!(schema.dialectId in metaValidators)) {
+      const metaSchema = await Schema$R.get(schema.dialectId);
       const compiledSchema = await compile$O(metaSchema);
       metaValidators[metaSchema.id] = interpret$O(compiledSchema);
     }
 
     // Interpret
-    const schemaInstance = instance.cons(schema.schema, schema.id);
-    const metaResults = metaValidators[schema.schemaVersion](schemaInstance, metaOutputFormat);
+    const schemaInstance = Instance$E.cons(schema.schema, schema.id);
+    const metaResults = metaValidators[schema.dialectId](schemaInstance, metaOutputFormat);
     if (!metaResults.valid) {
-      throw new invalidSchemaError(metaResults);
+      throw new InvalidSchemaError$2(metaResults);
     }
   }
 
@@ -1567,16 +2875,16 @@ const compileSchema = async (schema, ast) => {
       anchors: schema.anchors
     };
   }
-  return getKeyword(`${schema.schemaVersion}#validate`).compile(schema, ast);
+  return getKeyword(`${schema.dialectId}#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;
+  return Schema$R.typeOf(doc, "string") ? followReferences(await Schema$R.get(Schema$R.value(doc), doc)) : doc;
 };
 
 const interpretSchema = (schemaUri, instance, ast, dynamicAnchors) => {
   const keywordId = getKeywordId(schemaUri, ast);
-  const id = splitUrl$2(schemaUri)[0];
+  const id = resolveUrl(schemaUri, "");
   return getKeyword(keywordId).interpret(schemaUri, instance, ast, { ...ast.metaData[id].dynamicAnchors, ...dynamicAnchors });
 };
 
@@ -1599,63 +2907,54 @@ const getKeywordId = (schemaUri, ast) => {
 };
 
 const add = (schema, url = "", defaultSchemaVersion = "") => {
-  const id = schema$5.add(schema, url, defaultSchemaVersion);
+  const id = Schema$R.add(schema, url, defaultSchemaVersion);
   delete metaValidators[id];
 };
 
 var core$2 = {
-  validate: validate$1, compile: compile$O, interpret: interpret$O,
+  validate: validate$2, 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 Schema$Q = schema$5;
+
+
+const compile$N = (schema) => Schema$Q.value(schema);
 const interpret$N = () => true;
 
-var metaData$2 = { compile: compile$N, interpret: interpret$N };
-metaData$2.compile;
-metaData$2.interpret;
+var metaData$3 = { compile: compile$N, interpret: interpret$N };
+
+const Pact$9 = lib$2;
+const PubSub = pubsub.exports;
+const Core$x = core$2;
+const Instance$D = instance;
+const Schema$P = schema$5;
+
 
 const compile$M = async (schema, ast) => {
-  const url = schema$5.uri(schema);
+  const url = Schema$P.uri(schema);
   if (!(url in ast)) {
     ast[url] = false; // Place dummy entry in ast to avoid recursive loops
 
-    const schemaValue = schema$5.value(schema);
+    const schemaValue = Schema$P.value(schema);
     if (!["object", "boolean"].includes(typeof schemaValue)) {
-      throw Error(`No schema found at '${schema$5.uri(schema)}'`);
+      throw Error(`No schema found at '${Schema$P.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];
+      `${schema.dialectId}#validate`,
+      Schema$P.uri(schema),
+      typeof schemaValue === "boolean" ? schemaValue : await Pact$9.pipeline([
+        Schema$P.entries,
+        Pact$9.map(([keyword, keywordSchema]) => [`${schema.dialectId}#${keyword}`, keywordSchema]),
+        Pact$9.filter(([keywordId]) => Core$x.hasKeyword(keywordId) && keywordId !== `${schema.dialectId}#validate`),
+        Pact$9.map(async ([keywordId, keywordSchema]) => {
+          const keywordAst = await Core$x.getKeyword(keywordId).compile(keywordSchema, ast, schema);
+          return [keywordId, Schema$P.uri(keywordSchema), keywordAst];
         }),
-        lib$2.all
+        Pact$9.all
       ], schema)
     ];
   }
@@ -1663,34 +2962,34 @@ const compile$M = async (schema, ast) => {
   return url;
 };
 
-const interpret$M = (uri, instance$1, ast, dynamicAnchors) => {
+const interpret$M = (uri, instance, ast, dynamicAnchors) => {
   const [keywordId, schemaUrl, nodes] = ast[uri];
 
-  pubsub.publishSync("result.start");
+  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.start");
+      const isValid = Core$x.getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
 
-      pubsub.publishSync("result", {
+      PubSub.publishSync("result", {
         keyword: keywordId,
         absoluteKeywordLocation: schemaUrl,
-        instanceLocation: instance.uri(instance$1),
+        instanceLocation: Instance$D.uri(instance),
         valid: isValid,
         ast: keywordValue
       });
-      pubsub.publishSync("result.end");
+      PubSub.publishSync("result.end");
       return isValid;
     });
 
-  pubsub.publishSync("result", {
+  PubSub.publishSync("result", {
     keyword: keywordId,
     absoluteKeywordLocation: schemaUrl,
-    instanceLocation: instance.uri(instance$1),
+    instanceLocation: Instance$D.uri(instance),
     valid: isValid,
     ast: uri
   });
-  pubsub.publishSync("result.end");
+  PubSub.publishSync("result.end");
   return isValid;
 };
 
@@ -1704,7 +3003,7 @@ const collectEvaluatedProperties$d = (uri, instance, ast, dynamicAnchors, isTop
   return nodes
     .filter(([keywordId]) => !isTop || !keywordId.endsWith("#unevaluatedProperties"))
     .reduce((acc, [keywordId, , keywordValue]) => {
-      const propertyNames = acc && core$2.getKeyword(keywordId).collectEvaluatedProperties(keywordValue, instance, ast, dynamicAnchors);
+      const propertyNames = acc && Core$x.getKeyword(keywordId).collectEvaluatedProperties(keywordValue, instance, ast, dynamicAnchors);
       return propertyNames !== false && [...acc, ...propertyNames];
     }, []);
 };
@@ -1719,22 +3018,28 @@ const collectEvaluatedItems$e = (uri, instance, ast, dynamicAnchors, isTop = fal
   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);
+      const itemIndexes = acc !== false && Core$x.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 validate$1 = { compile: compile$M, interpret: interpret$M, collectEvaluatedProperties: collectEvaluatedProperties$d, collectEvaluatedItems: collectEvaluatedItems$e };
+
+const metaData$2 = metaData$3;
+const validate = validate$1;
+
+
+var keywords$6 = { metaData: metaData$2, validate };
+
+const Core$w = core$2;
+const Schema$O = schema$5;
+const Instance$C = instance;
+const Reference = reference;
+const Keywords$2 = keywords$6;
+const InvalidSchemaError$1 = invalidSchemaError;
 
-var keywords$1 = { metaData: metaData$2, validate };
-keywords$1.metaData;
-keywords$1.validate;
 
-var lib$1 = { Core: core$2, Schema: schema$5, Instance: instance, Reference: reference, Keywords: keywords$1, InvalidSchemaError: invalidSchemaError };
+var lib$1 = { Core: Core$w, Schema: Schema$O, Instance: Instance$C, Reference, Keywords: Keywords$2, InvalidSchemaError: InvalidSchemaError$1 };
 
 const { Core: Core$v, Schema: Schema$N, Instance: Instance$B } = lib$1;
 
@@ -1763,8 +3068,6 @@ const interpret$L = ([numberOfItems, additionalItems], instance, ast, dynamicAnc
 };
 
 var additionalItems = { compile: compile$L, interpret: interpret$L };
-additionalItems.compile;
-additionalItems.interpret;
 
 const { Core: Core$u, Schema: Schema$M, Instance: Instance$A } = lib$1;
 
@@ -1789,9 +3092,6 @@ const collectEvaluatedItems$d = (keywordValue, instance, ast, dynamicAnchors) =>
 };
 
 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;
 
@@ -1826,8 +3126,6 @@ const interpret$J = ([propertyNames, propertyNamePatterns, 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;
 
@@ -1857,17 +3155,14 @@ const collectEvaluatedProperties$c = (keywordValue, instance, ast, dynamicAnchor
 };
 
 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 Pact$8 = lib$2;
 
 
-
-const compile$H = (schema, ast) => lib$2.pipeline([
+const compile$H = (schema, ast) => Pact$8.pipeline([
   Schema$J.map(async (itemSchema) => Core$r.compileSchema(await itemSchema, ast)),
-  lib$2.all
+  Pact$8.all
 ], schema);
 
 const interpret$H = (allOf, instance, ast, dynamicAnchors) => {
@@ -1889,18 +3184,14 @@ const collectEvaluatedItems$c = (allOf, instance, ast, dynamicAnchors) => {
 };
 
 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 Pact$7 = lib$2;
 
 
-
-const compile$G = (schema, ast) => lib$2.pipeline([
+const compile$G = (schema, ast) => Pact$7.pipeline([
   Schema$I.map(async (itemSchema) => Core$q.compileSchema(await itemSchema, ast)),
-  lib$2.all
+  Pact$7.all
 ], schema);
 
 const interpret$G = (anyOf, instance, ast, dynamicAnchors) => {
@@ -1923,10 +3214,6 @@ const collectEvaluatedItems$b = (anyOf, instance, ast, dynamicAnchors) => {
 };
 
 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;
@@ -1988,15 +3275,13 @@ function stringify(val, allowUndefined) {
 var fastestStableStringify = function(obj) { return '' + stringify(obj, false); };
 
 const { Schema: Schema$H, Instance: Instance$x } = lib$1;
+const jsonStringify$2 = fastestStableStringify;
 
 
-
-const compile$F = (schema) => fastestStableStringify(Schema$H.value(schema));
-const interpret$F = (const_, instance) => fastestStableStringify(Instance$x.value(instance)) === const_;
+const compile$F = (schema) => jsonStringify$2(Schema$H.value(schema));
+const interpret$F = (const_, instance) => jsonStringify$2(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;
 
@@ -2008,8 +3293,6 @@ const interpret$E = (contains, instance, ast, dynamicAnchors) => {
 };
 
 var contains = { compile: compile$E, interpret: interpret$E };
-contains.compile;
-contains.interpret;
 
 const { Core: Core$o, Schema: Schema$G, Instance: Instance$v } = lib$1;
 
@@ -2044,38 +3327,33 @@ const collectEvaluatedItems$a = (keywordValue, instance, ast, dynamicAnchors) =>
 };
 
 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 Pact$6 = lib$2;
 
 
 const compile$C = async (schema, ast) => {
-  await lib$2.pipeline([
+  await Pact$6.pipeline([
     Schema$F.entries,
-    lib$2.map(([, definitionSchema]) => Core$n.compileSchema(definitionSchema, ast)),
-    lib$2.all
+    Pact$6.map(([, definitionSchema]) => Core$n.compileSchema(definitionSchema, ast)),
+    Pact$6.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 Pact$5 = lib$2;
 
 
-
-const compile$B = (schema, ast) => lib$2.pipeline([
+const compile$B = (schema, ast) => Pact$5.pipeline([
   Schema$E.entries,
-  lib$2.map(async ([key, dependency]) => {
+  Pact$5.map(async ([key, dependency]) => {
     return [key, Schema$E.typeOf(dependency, "array") ? Schema$E.value(dependency) : await Core$m.compileSchema(dependency, ast)];
   }),
-  lib$2.all
+  Pact$5.all
 ], schema);
 
 const interpret$B = (dependencies, instance, ast, dynamicAnchors) => {
@@ -2095,17 +3373,15 @@ const interpret$B = (dependencies, 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 Pact$4 = lib$2;
 
 
-
-const compile$A = (schema) => lib$2.pipeline([
+const compile$A = (schema) => Pact$4.pipeline([
   Schema$D.entries,
-  lib$2.map(([key, dependentRequired]) => [key, Schema$D.value(dependentRequired)]),
-  lib$2.all
+  Pact$4.map(([key, dependentRequired]) => [key, Schema$D.value(dependentRequired)]),
+  Pact$4.all
 ], schema);
 
 const interpret$A = (dependentRequired, instance) => {
@@ -2117,17 +3393,15 @@ const interpret$A = (dependentRequired, instance) => {
 };
 
 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 Pact$3 = lib$2;
 
 
-
-const compile$z = (schema, ast) => lib$2.pipeline([
+const compile$z = (schema, ast) => Pact$3.pipeline([
   Schema$C.entries,
-  lib$2.map(async ([key, dependentSchema]) => [key, await Core$l.compileSchema(dependentSchema, ast)]),
-  lib$2.all
+  Pact$3.map(async ([key, dependentSchema]) => [key, await Core$l.compileSchema(dependentSchema, ast)]),
+  Pact$3.all
 ], schema);
 
 const interpret$z = (dependentSchemas, instance, ast, dynamicAnchors) => {
@@ -2150,20 +3424,15 @@ const collectEvaluatedProperties$9 = (dependentSchemas, instance, ast, dynamicAn
 };
 
 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 jsonStringify$1 = fastestStableStringify;
 
 
-
-const compile$y = (schema) => Schema$B.value(schema).map(fastestStableStringify);
-const interpret$y = (enum_, instance) => enum_.some((enumValue) => fastestStableStringify(Instance$r.value(instance)) === enumValue);
+const compile$y = (schema) => Schema$B.value(schema).map(jsonStringify$1);
+const interpret$y = (enum_, instance) => enum_.some((enumValue) => jsonStringify$1(Instance$r.value(instance)) === enumValue);
 
 var _enum = { compile: compile$y, interpret: interpret$y };
-_enum.compile;
-_enum.interpret;
 
 const { Schema: Schema$A, Instance: Instance$q } = lib$1;
 
@@ -2172,8 +3441,6 @@ 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;
 
@@ -2182,8 +3449,6 @@ 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;
 
@@ -2204,10 +3469,6 @@ const collectEvaluatedItems$9 = (ifSchema, instance, ast, dynamicAnchors) => {
 };
 
 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;
 
@@ -2252,10 +3513,6 @@ const collectEvaluatedItems$8 = ([guard, 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;
 
@@ -2300,10 +3557,6 @@ const collectEvaluatedItems$7 = ([guard, 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;
 
@@ -2336,9 +3589,6 @@ const collectEvaluatedItems$6 = (items, instance, ast, dynamicAnchors) => {
 };
 
 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;
 
@@ -2363,9 +3613,6 @@ const collectEvaluatedItems$5 = (keywordValue, instance, ast, dynamicAnchors) =>
 };
 
 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;
 
@@ -2374,8 +3621,6 @@ 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;
 
@@ -2384,8 +3629,6 @@ 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;
 
@@ -2394,8 +3637,6 @@ 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;
 
@@ -2404,8 +3645,6 @@ 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;
 
@@ -2427,8 +3666,6 @@ const interpret$m = ([maximum, isExclusive], instance) => {
 };
 
 var maximumExclusiveMaximum = { compile: compile$m, interpret: interpret$m };
-maximumExclusiveMaximum.compile;
-maximumExclusiveMaximum.interpret;
 
 const { Schema: Schema$p, Instance: Instance$h } = lib$1;
 
@@ -2437,8 +3674,6 @@ 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;
 
@@ -2447,8 +3682,6 @@ 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;
 
@@ -2457,8 +3690,6 @@ 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;
 
@@ -2467,8 +3698,6 @@ 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;
 
@@ -2477,8 +3706,6 @@ 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;
 
@@ -2500,8 +3727,6 @@ const interpret$g = ([minimum, isExclusive], instance) => {
 };
 
 var minimumExclusiveMinimum = { compile: compile$g, interpret: interpret$g };
-minimumExclusiveMinimum.compile;
-minimumExclusiveMinimum.interpret;
 
 const { Schema: Schema$j, Instance: Instance$b } = lib$1;
 
@@ -2510,8 +3735,6 @@ 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;
 
@@ -2530,8 +3753,6 @@ const interpret$e = (multipleOf, instance) => {
 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;
 
@@ -2540,8 +3761,6 @@ 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;
 
@@ -2591,10 +3810,6 @@ const collectEvaluatedItems$4 = (oneOf, instance, ast, dynamicAnchors) => {
 };
 
 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;
 
@@ -2603,17 +3818,15 @@ 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 Pact$2 = lib$2;
 
 
-
-const compile$a = (schema, ast) => lib$2.pipeline([
+const compile$a = (schema, ast) => Pact$2.pipeline([
   Schema$f.entries,
-  lib$2.map(async ([pattern, propertySchema]) => [new RegExp(pattern, "u"), await Core$d.compileSchema(propertySchema, ast)]),
-  lib$2.all
+  Pact$2.map(async ([pattern, propertySchema]) => [new RegExp(pattern, "u"), await Core$d.compileSchema(propertySchema, ast)]),
+  Pact$2.all
 ], schema);
 
 const interpret$a = (patternProperties, instance, ast, dynamicAnchors) => {
@@ -2629,9 +3842,6 @@ const collectEvaluatedProperties$4 = (patternProperties, instance, ast, dynamicA
 };
 
 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, "\\$&");
@@ -2648,13 +3858,13 @@ const splitUrl$1 = (url) => {
 var common = { isObject, escapeRegExp: escapeRegExp$1, splitUrl: splitUrl$1 };
 
 const { Core: Core$c, Schema: Schema$e, Instance: Instance$7 } = lib$1;
-
+const Pact$1 = lib$2;
 const { escapeRegExp } = common;
 
 
-const compile$9 = (schema, ast) => lib$2.pipeline([
+const compile$9 = (schema, ast) => Pact$1.pipeline([
   Schema$e.entries,
-  lib$2.reduce(async (acc, [propertyName, propertySchema]) => {
+  Pact$1.reduce(async (acc, [propertyName, propertySchema]) => {
     acc[propertyName] = await Core$c.compileSchema(propertySchema, ast);
     return acc;
   }, Object.create(null))
@@ -2672,9 +3882,6 @@ const collectEvaluatedProperties$3 = (properties, instance, ast, dynamicAnchors)
 };
 
 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;
 
@@ -2687,8 +3894,6 @@ const interpret$8 = (propertyNames, instance, 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;
@@ -2714,10 +3919,6 @@ 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;
 
@@ -2732,10 +3933,6 @@ 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;
 
@@ -2747,17 +3944,15 @@ const interpret$5 = (required, instance) => {
 };
 
 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 Pact = lib$2;
 
 
 const compile$4 = (schema, ast) => {
-  return lib$2.pipeline([
+  return Pact.pipeline([
     Schema$a.map((itemSchema) => Core$8.compileSchema(itemSchema, ast)),
-    lib$2.all
+    Pact.all
   ], schema);
 };
 
@@ -2774,9 +3969,6 @@ const collectEvaluatedItems$1 = (items, instance, ast, dynamicAnchors) => {
 };
 
 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;
 
@@ -2785,8 +3977,6 @@ 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;
 
@@ -2811,9 +4001,6 @@ const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
 };
 
 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;
 
@@ -2839,12 +4026,9 @@ const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors)
 };
 
 var unevaluatedProperties = { compile: compile$1, interpret: interpret$1, collectEvaluatedProperties };
-unevaluatedProperties.compile;
-unevaluatedProperties.interpret;
-unevaluatedProperties.collectEvaluatedProperties;
 
 const { Schema: Schema$6, Instance } = lib$1;
-
+const jsonStringify = fastestStableStringify;
 
 
 const compile = (schema) => Schema$6.value(schema);
@@ -2854,18 +4038,16 @@ const interpret = (uniqueItems, instance) => {
     return true;
   }
 
-  const normalizedItems = Instance.map((item) => fastestStableStringify(Instance.value(item)), instance);
+  const normalizedItems = Instance.map((item) => jsonStringify(Instance.value(item)), instance);
   return new Set(normalizedItems).size === normalizedItems.length;
 };
 
 var uniqueItems = { compile, interpret };
-uniqueItems.compile;
-uniqueItems.interpret;
 
-const { Keywords } = lib$1;
+const { Keywords: Keywords$1 } = lib$1;
 
 
-var keywords = {
+var keywords$5 = {
   additionalItems: additionalItems,
   additionalItems6: additionalItems6,
   additionalProperties: additionalProperties,
@@ -2893,7 +4075,7 @@ var keywords = {
   maxProperties: maxProperties,
   maximumExclusiveMaximum: maximumExclusiveMaximum,
   maximum: maximum,
-  metaData: Keywords.metaData,
+  metaData: Keywords$1.metaData,
   minItems: minItems,
   minLength: minLength,
   minLength6: minLength6,
@@ -2915,54 +4097,8 @@ var keywords = {
   unevaluatedItems: unevaluatedItems,
   unevaluatedProperties: unevaluatedProperties,
   uniqueItems: uniqueItems,
-  validate: Keywords.validate
+  validate: Keywords$1.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#",
@@ -3115,50 +4251,50 @@ var schema$4 = `{
 }`;
 
 const { Core: Core$5, Schema: Schema$5 } = lib$1;
-
-
+const keywords$4 = keywords$5;
+const metaSchema$4 = schema$4;
 
 
 // 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
+const jsonSchemaVersion$4 = "http://json-schema.org/draft-04/schema";
+
+Schema$5.setConfig(jsonSchemaVersion$4, "baseToken", "id");
+Schema$5.setConfig(jsonSchemaVersion$4, "embeddedToken", "id");
+Schema$5.setConfig(jsonSchemaVersion$4, "anchorToken", "id");
+Schema$5.setConfig(jsonSchemaVersion$4, "jrefToken", "$ref");
+
+Schema$5.add(JSON.parse(metaSchema$4));
+Core$5.defineVocabulary(jsonSchemaVersion$4, {
+  "validate": keywords$4.validate,
+  "additionalItems": keywords$4.additionalItems,
+  "additionalProperties": keywords$4.additionalProperties,
+  "allOf": keywords$4.allOf,
+  "anyOf": keywords$4.anyOf,
+  "default": keywords$4.metaData,
+  "definitions": keywords$4.definitions,
+  "dependencies": keywords$4.dependencies,
+  "description": keywords$4.metaData,
+  "enum": keywords$4.enum,
+  "format": keywords$4.metaData,
+  "items": keywords$4.items,
+  "maxItems": keywords$4.maxItems,
+  "maxLength": keywords$4.maxLength,
+  "maxProperties": keywords$4.maxProperties,
+  "maximum": keywords$4.maximumExclusiveMaximum,
+  "minItems": keywords$4.minItems,
+  "minLength": keywords$4.minLength,
+  "minProperties": keywords$4.minProperties,
+  "minimum": keywords$4.minimumExclusiveMinimum,
+  "multipleOf": keywords$4.multipleOf,
+  "not": keywords$4.not,
+  "oneOf": keywords$4.oneOf,
+  "pattern": keywords$4.pattern,
+  "patternProperties": keywords$4.patternProperties,
+  "properties": keywords$4.properties,
+  "required": keywords$4.required,
+  "title": keywords$4.metaData,
+  "type": keywords$4.type,
+  "uniqueItems": keywords$4.uniqueItems
 });
 
 var schema$3 = `{
@@ -3317,55 +4453,55 @@ var schema$3 = `{
 }`;
 
 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
+const keywords$3 = keywords$5;
+const metaSchema$3 = schema$3;
+
+
+const jsonSchemaVersion$3 = "http://json-schema.org/draft-06/schema";
+
+Schema$4.setConfig(jsonSchemaVersion$3, "baseToken", "$id");
+Schema$4.setConfig(jsonSchemaVersion$3, "embeddedToken", "$id");
+Schema$4.setConfig(jsonSchemaVersion$3, "anchorToken", "$id");
+Schema$4.setConfig(jsonSchemaVersion$3, "jrefToken", "$ref");
+
+Schema$4.add(JSON.parse(metaSchema$3));
+Core$4.defineVocabulary(jsonSchemaVersion$3, {
+  "validate": keywords$3.validate,
+  "additionalItems": keywords$3.additionalItems6,
+  "additionalProperties": keywords$3.additionalProperties6,
+  "allOf": keywords$3.allOf,
+  "anyOf": keywords$3.anyOf,
+  "const": keywords$3.const,
+  "contains": keywords$3.contains,
+  "default": keywords$3.metaData,
+  "definitions": keywords$3.definitions,
+  "dependencies": keywords$3.dependencies,
+  "description": keywords$3.metaData,
+  "enum": keywords$3.enum,
+  "examples": keywords$3.metaData,
+  "exclusiveMaximum": keywords$3.exclusiveMaximum,
+  "exclusiveMinimum": keywords$3.exclusiveMinimum,
+  "format": keywords$3.metaData,
+  "items": keywords$3.items,
+  "maxItems": keywords$3.maxItems,
+  "maxLength": keywords$3.maxLength6,
+  "maxProperties": keywords$3.maxProperties,
+  "maximum": keywords$3.maximum,
+  "minItems": keywords$3.minItems,
+  "minLength": keywords$3.minLength6,
+  "minProperties": keywords$3.minProperties,
+  "minimum": keywords$3.minimum,
+  "multipleOf": keywords$3.multipleOf,
+  "not": keywords$3.not,
+  "oneOf": keywords$3.oneOf,
+  "pattern": keywords$3.pattern,
+  "patternProperties": keywords$3.patternProperties,
+  "properties": keywords$3.properties,
+  "propertyNames": keywords$3.propertyNames,
+  "required": keywords$3.required,
+  "title": keywords$3.metaData,
+  "type": keywords$3.type,
+  "uniqueItems": keywords$3.uniqueItems
 });
 
 var schema$2 = `{
@@ -3542,59 +4678,59 @@ var schema$2 = `{
 }`;
 
 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
+const keywords$2 = keywords$5;
+const metaSchema$2 = schema$2;
+
+
+const jsonSchemaVersion$2 = "http://json-schema.org/draft-07/schema";
+
+Schema$3.setConfig(jsonSchemaVersion$2, "baseToken", "$id");
+Schema$3.setConfig(jsonSchemaVersion$2, "embeddedToken", "$id");
+Schema$3.setConfig(jsonSchemaVersion$2, "anchorToken", "$id");
+Schema$3.setConfig(jsonSchemaVersion$2, "jrefToken", "$ref");
+
+Schema$3.add(JSON.parse(metaSchema$2));
+Core$3.defineVocabulary(jsonSchemaVersion$2, {
+  "validate": keywords$2.validate,
+  "additionalItems": keywords$2.additionalItems6,
+  "additionalProperties": keywords$2.additionalProperties6,
+  "allOf": keywords$2.allOf,
+  "anyOf": keywords$2.anyOf,
+  "const": keywords$2.const,
+  "contains": keywords$2.contains,
+  "default": keywords$2.metaData,
+  "definitions": keywords$2.definitions,
+  "dependencies": keywords$2.dependencies,
+  "description": keywords$2.metaData,
+  "enum": keywords$2.enum,
+  "exclusiveMaximum": keywords$2.exclusiveMaximum,
+  "exclusiveMinimum": keywords$2.exclusiveMinimum,
+  "format": keywords$2.metaData,
+  "if": keywords$2.if,
+  "then": keywords$2.then,
+  "else": keywords$2.else,
+  "items": keywords$2.items,
+  "maxItems": keywords$2.maxItems,
+  "maxLength": keywords$2.maxLength6,
+  "maxProperties": keywords$2.maxProperties,
+  "maximum": keywords$2.maximum,
+  "minItems": keywords$2.minItems,
+  "minLength": keywords$2.minLength6,
+  "minProperties": keywords$2.minProperties,
+  "minimum": keywords$2.minimum,
+  "multipleOf": keywords$2.multipleOf,
+  "not": keywords$2.not,
+  "oneOf": keywords$2.oneOf,
+  "pattern": keywords$2.pattern,
+  "patternProperties": keywords$2.patternProperties,
+  "properties": keywords$2.properties,
+  "propertyNames": keywords$2.propertyNames,
+  "readOnly": keywords$2.metaData,
+  "required": keywords$2.required,
+  "title": keywords$2.metaData,
+  "type": keywords$2.type,
+  "uniqueItems": keywords$2.uniqueItems,
+  "writeOnly": keywords$2.metaData
 });
 
 var schema$1 = `{
@@ -3925,96 +5061,96 @@ var content$1 = `{
 }`;
 
 const { Core: Core$2, Schema: Schema$2 } = lib$1;
+const keywords$1 = keywords$5;
+const metaSchema$1 = schema$1;
+const coreMetaSchema$1 = core$1;
+const applicatorMetaSchema$1 = applicator$1;
+const validationMetaSchema$1 = validation$1;
+const metaDataMetaSchema$1 = metaData$1;
+const formatMetaSchema = format;
+const contentMetaSchema$1 = content$1;
 
 
+const jsonSchemaVersion$1 = "https://json-schema.org/draft/2019-09/vocab/core";
 
+Schema$2.setConfig(jsonSchemaVersion$1, "baseToken", "$id");
+Schema$2.setConfig(jsonSchemaVersion$1, "embeddedToken", "$id");
+Schema$2.setConfig(jsonSchemaVersion$1, "anchorToken", "$anchor");
+Schema$2.setConfig(jsonSchemaVersion$1, "recursiveAnchorToken", "$recursiveAnchor");
+Schema$2.setConfig(jsonSchemaVersion$1, "vocabularyToken", "$vocabulary");
+Schema$2.setConfig(jsonSchemaVersion$1, "mandatoryVocabularies", ["https://json-schema.org/draft/2019-09/vocab/core"]);
 
+Schema$2.add(JSON.parse(metaSchema$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));
+Schema$2.add(JSON.parse(coreMetaSchema$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
+  "validate": keywords$1.validate,
+  "$defs": keywords$1.definitions,
+  "$recursiveRef": keywords$1.dynamicRef,
+  "$ref": keywords$1.ref
 });
 
-Schema$2.add(JSON.parse(applicator$1));
+Schema$2.add(JSON.parse(applicatorMetaSchema$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
+  "additionalItems": keywords$1.additionalItems6,
+  "additionalProperties": keywords$1.additionalProperties6,
+  "allOf": keywords$1.allOf,
+  "anyOf": keywords$1.anyOf,
+  "contains": keywords$1.containsMinContainsMaxContains,
+  "dependentSchemas": keywords$1.dependentSchemas,
+  "if": keywords$1.if,
+  "then": keywords$1.then,
+  "else": keywords$1.else,
+  "items": keywords$1.items,
+  "not": keywords$1.not,
+  "oneOf": keywords$1.oneOf,
+  "patternProperties": keywords$1.patternProperties,
+  "properties": keywords$1.properties,
+  "propertyNames": keywords$1.propertyNames,
+  "unevaluatedItems": keywords$1.unevaluatedItems,
+  "unevaluatedProperties": keywords$1.unevaluatedProperties
 });
 
-Schema$2.add(JSON.parse(validation$1));
+Schema$2.add(JSON.parse(validationMetaSchema$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
+  "const": keywords$1.const,
+  "dependentRequired": keywords$1.dependentRequired,
+  "enum": keywords$1.enum,
+  "exclusiveMaximum": keywords$1.exclusiveMaximum,
+  "exclusiveMinimum": keywords$1.exclusiveMinimum,
+  "maxItems": keywords$1.maxItems,
+  "maxLength": keywords$1.maxLength6,
+  "maxProperties": keywords$1.maxProperties,
+  "maximum": keywords$1.maximum,
+  "minItems": keywords$1.minItems,
+  "minLength": keywords$1.minLength6,
+  "minProperties": keywords$1.minProperties,
+  "minimum": keywords$1.minimum,
+  "multipleOf": keywords$1.multipleOf,
+  "pattern": keywords$1.pattern,
+  "required": keywords$1.required,
+  "type": keywords$1.type,
+  "uniqueItems": keywords$1.uniqueItems
 });
 
-Schema$2.add(JSON.parse(metaData$1));
+Schema$2.add(JSON.parse(metaDataMetaSchema$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
+  "default": keywords$1.metaData,
+  "deprecated": keywords$1.metaData,
+  "description": keywords$1.metaData,
+  "examples": keywords$1.metaData,
+  "readOnly": keywords$1.metaData,
+  "title": keywords$1.metaData,
+  "writeOnly": keywords$1.metaData
 });
 
-Schema$2.add(JSON.parse(format));
+Schema$2.add(JSON.parse(formatMetaSchema));
 
-Schema$2.add(JSON.parse(content$1));
+Schema$2.add(JSON.parse(contentMetaSchema$1));
 Core$2.defineVocabulary("https://json-schema.org/draft/2019-09/vocab/content", {
-  "contentEncoding": keywords.metaData,
-  "contentMediaType": keywords.metaData,
-  "contentSchema": keywords.metaData
+  "contentEncoding": keywords$1.metaData,
+  "contentMediaType": keywords$1.metaData,
+  "contentSchema": keywords$1.metaData
 });
 
 var schema = `{
@@ -4372,30 +5508,30 @@ var unevaluated = `{
 }`;
 
 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));
+const keywords = keywords$5;
+const metaSchema = schema;
+const coreMetaSchema = core;
+const applicatorMetaSchema = applicator;
+const validationMetaSchema = validation;
+const metaDataMetaSchema = metaData;
+const formatAnnotationMetaSchema = formatAnnotation;
+const formatAssertionMetaSchema = formatAssertion;
+const contentMetaSchema = content;
+const unevaluatedMetaSchema = unevaluated;
+
+
+const jsonSchemaVersion = "https://json-schema.org/draft/2020-12/vocab/core";
+
+Schema$1.setConfig(jsonSchemaVersion, "baseToken", "$id");
+Schema$1.setConfig(jsonSchemaVersion, "embeddedToken", "$id");
+Schema$1.setConfig(jsonSchemaVersion, "anchorToken", "$anchor");
+Schema$1.setConfig(jsonSchemaVersion, "dynamicAnchorToken", "$dynamicAnchor");
+Schema$1.setConfig(jsonSchemaVersion, "vocabularyToken", "$vocabulary");
+Schema$1.setConfig(jsonSchemaVersion, "mandatoryVocabularies", ["https://json-schema.org/draft/2020-12/vocab/core"]);
+
+Schema$1.add(JSON.parse(metaSchema));
+
+Schema$1.add(JSON.parse(coreMetaSchema));
 Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/core", {
   "validate": keywords.validate,
   "$defs": keywords.definitions,
@@ -4403,7 +5539,7 @@ Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/core", {
   "$ref": keywords.ref
 });
 
-Schema$1.add(JSON.parse(applicator));
+Schema$1.add(JSON.parse(applicatorMetaSchema));
 Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/applicator", {
   "additionalProperties": keywords.additionalProperties6,
   "allOf": keywords.allOf,
@@ -4422,7 +5558,7 @@ Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/applicator"
   "propertyNames": keywords.propertyNames
 });
 
-Schema$1.add(JSON.parse(validation));
+Schema$1.add(JSON.parse(validationMetaSchema));
 Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/validation", {
   "const": keywords.const,
   "dependentRequired": keywords.dependentRequired,
@@ -4444,7 +5580,7 @@ Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/validation"
   "uniqueItems": keywords.uniqueItems
 });
 
-Schema$1.add(JSON.parse(metaData));
+Schema$1.add(JSON.parse(metaDataMetaSchema));
 Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/meta-data", {
   "default": keywords.metaData,
   "deprecated": keywords.metaData,
@@ -4455,28 +5591,28 @@ Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/meta-data",
   "writeOnly": keywords.metaData
 });
 
-Schema$1.add(JSON.parse(formatAnnotation));
+Schema$1.add(JSON.parse(formatAnnotationMetaSchema));
 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(formatAssertionMetaSchema));
 
-Schema$1.add(JSON.parse(content));
+Schema$1.add(JSON.parse(contentMetaSchema));
 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));
+Schema$1.add(JSON.parse(unevaluatedMetaSchema));
 Core$1.defineVocabulary("https://json-schema.org/draft/2020-12/vocab/unevaluated", {
   "unevaluatedItems": keywords.unevaluatedItems,
   "unevaluatedProperties": keywords.unevaluatedProperties
 });
 
 const { Core, Schema, InvalidSchemaError } = lib$1;
-
+const Keywords = keywords$5;
 
 
 
@@ -4497,35 +5633,9 @@ var lib = {
   BASIC: Core.BASIC,
   DETAILED: Core.DETAILED,
   VERBOSE: Core.VERBOSE,
-  Keywords: keywords,
+  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