@hyperjump/json-schema 0.18.3 → 0.19.0

package/dist/json-schema-system.js

@@ -46,6 +46,10 @@ System.register('JsonSchema', [], (function (exports) {
 
       var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
+      function unwrapExports (x) {
+      	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+      }
+
       function createCommonjsModule(fn, module) {
       	return module = { exports: {} }, fn(module, module.exports), module.exports;
       }
@@ -405,217 +409,1413 @@ System.register('JsonSchema', [], (function (exports) {
       });
       pubsub.PubSub;
 
-      var urlResolveBrowser = urlResolve;
+      var uri_all = createCommonjsModule(function (module, exports) {
+      /** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js */
+      (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];
+          }
 
-      /*
-      The majority of the module is built by following RFC1808
-      url: https://tools.ietf.org/html/rfc1808
-      */
+          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;
+      }
 
-      // adds a slash at end if not present
-      function _addSlash (url) {
-        return url + (url[url.length-1] === '/' ? '' : '/');
+      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);
 
-      // resolve the ..'s (directory up) and such
-      function _pathResolve (path) {
-        let pathSplit = path.split('/');
+      var IRI_PROTOCOL = buildExps(true);
 
-        // happens when path starts with /
-        if (pathSplit[0] === '') {
-          pathSplit = pathSplit.slice(1);
-        }
+      var slicedToArray = function () {
+        function sliceIterator(arr, i) {
+          var _arr = [];
+          var _n = true;
+          var _d = false;
+          var _e = undefined;
 
-        // 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);
+          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 '/' + resultArray.join('/');
-      }
 
-      // parses a base url string into an object containing host, path and query
-      function _baseParse (base) {
-        const resultObject = {
-          host: '',
-          path: '',
-          query: '',
-          protocol: ''
+          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");
+          }
         };
+      }();
 
-        let path = base;
-        let protocolEndIndex = base.indexOf('//');
 
-        resultObject.protocol = path.substring(0, protocolEndIndex);
 
-        protocolEndIndex += 2; // add two to pass double slash
 
-        const pathIndex = base.indexOf('/', protocolEndIndex);
-        const queryIndex = base.indexOf('?');
-        const hashIndex = base.indexOf('#');
 
-        if (hashIndex !== -1) {
-          path = path.substring(0, hashIndex); // remove hash, not needed for base
-        }
 
-        if (queryIndex !== -1) {
-          const query = path.substring(queryIndex); // remove query, save in return obj
-          resultObject.query = query;
-          path = path.substring(0, queryIndex);
-        }
 
-        if (pathIndex !== -1) {
-          const host = path.substring(0, pathIndex); // separate host & path
-          resultObject.host = host;
-          path = path.substring(pathIndex);
-          resultObject.path = path;
-        } else {
-          resultObject.host = path; // there was no path, therefore path is host
-        }
 
-        return resultObject;
-      }
 
-      // https://tools.ietf.org/html/rfc3986#section-3.1
-      const _scheme = '[a-z][a-z0-9+.-]*'; // ALPHA *( ALPHA / DIGIT / "+" / "-" / "."  )]
-      const _isAbsolute = new RegExp(`^(${_scheme}:)?//`, 'i');
-
-      // parses a relative url string into an object containing the href,
-      // hash, query and whether it is a net path, absolute path or relative path
-      function _relativeParse (relative) {
-        const resultObject = {
-          href: relative, // href is always what was passed through
-          hash: '',
-          query: '',
-          netPath: false,
-          absolutePath: false,
-          relativePath: false
-        };
-        // check for protocol
-        // if protocol exists, is net path (absolute URL)
-        if (_isAbsolute.test(relative)) {
-          resultObject.netPath = true;
-          // return, in this case the relative is the resolved url, no need to parse.
-          return resultObject;
-        }
 
-        // if / is first, this is an absolute path,
-        // I.E. it overwrites the base URL's path
-        if (relative[0] === '/') {
-          resultObject.absolutePath = true;
-          // return resultObject
-        } else if (relative !== '') {
-          resultObject.relativePath = true;
-        }
 
-        let path = relative;
-        const queryIndex = relative.indexOf('?');
-        const hashIndex = relative.indexOf('#');
 
-        if (hashIndex !== -1) {
-          const hash = path.substring(hashIndex);
-          resultObject.hash = hash;
-          path = path.substring(0, hashIndex);
-        }
 
-        if (queryIndex !== -1) {
-          const query = path.substring(queryIndex);
-          resultObject.query = query;
-          path = path.substring(0, queryIndex);
+      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);
         }
+      };
 
-        resultObject.path = path; // whatever is left is path
-        return resultObject;
+      /** 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]);
       }
 
-      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);
+      /**
+       * 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;
       }
 
-      function _shouldAddProtocol (url) {
-        return url.startsWith('//');
+      /**
+       * 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;
       }
 
-      /*
-      * 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();
+      /**
+       * 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;
+      }
 
-        // about is always absolute
-        if (relative.startsWith('about:')) {
-          return relative;
-        }
+      /**
+       * 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));
+      };
 
-        const baseObj = _baseParse(base);
-        const relativeObj = _relativeParse(relative);
+      /**
+       * 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;
+      };
 
-        if (!baseObj.protocol && !relativeObj.netPath) {
-          throw new Error('Error, protocol is not specified');
-        }
+      /**
+       * 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
+      };
 
-        if (relativeObj.netPath) { // relative is full qualified URL
-          if (_shouldAddProtocol(relativeObj.href)) {
-            relativeObj.href = baseObj.protocol + relativeObj.href;
+      /**
+       * 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;
+      }
 
-          if (_shouldAddSlash(relativeObj.href)) {
-            return _addSlash(relativeObj.href);
+      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;
+      }
 
-          return relativeObj.href;
-        } else if (relativeObj.absolutePath) { // relative is an absolute path
-          const {path, query, hash} = relativeObj;
+      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;
+      }
 
-          return baseObj.host + _pathResolve(path) + query + hash;
-        } else if (relativeObj.relativePath) { // relative is a relative path
-          const {path, query, hash} = relativeObj;
+      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("");
+      }
 
-          let basePath = baseObj.path;
-          let resultString = baseObj.host;
+      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
+      }
 
-          let resolvePath;
+      function resolveComponents(base, relative) {
+          var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+          var skipNormalization = arguments[3];
 
-          if (path.length === 0) {
-            resolvePath = basePath;
+          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 {
-            // remove last segment if no slash at end
-            basePath = basePath.substring(0, basePath.lastIndexOf('/'));
-            resolvePath = _pathResolve(basePath + '/' + path);
+              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;
+      }
 
-          // if result is just the base host, add /
-          if ((resolvePath === '') && (!query) && (!hash)) {
-            resultString += '/';
-          } else {
-            resultString += resolvePath + query + hash;
+      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;
+      }
 
-          return resultString;
-        } else {
-          const {host, path, query} = baseObj;
-          // when path and query aren't supplied add slash
-          if ((!path) && (!query)) {
-            return _addSlash(host);
+      function equal(uriA, uriB, options) {
+          if (typeof uriA === "string") {
+              uriA = serialize(parse(uriA, options), options);
+          } else if (typeOf(uriA) === "object") {
+              uriA = serialize(uriA, options);
           }
-          return host + path + query + relativeObj.hash;
-        }
+          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 });
+
+      })));
+
+      });
+
+      unwrapExports(uri_all);
+
       const isObject$1 = (value) => typeof value === "object" && !Array.isArray(value) && value !== null;
       const isType = {
         null: (value) => value === null,
@@ -628,29 +1828,17 @@ System.register('JsonSchema', [], (function (exports) {
       };
       const jsonTypeOf$2 = (value, type) => isType[type](value);
 
-      const splitUrl$4 = (url) => {
-        const indexOfHash = url.indexOf("#");
-        const ndx = indexOfHash === -1 ? url.length : indexOfHash;
-        const urlReference = url.slice(0, ndx);
-        const urlFragment = url.slice(ndx + 1);
-
-        return [decodeURI(urlReference), decodeURI(urlFragment)];
-      };
-
-      const getScheme = (url) => {
-        const matches = RegExp(/^(.+):\/\//).exec(url);
-        return matches ? matches[1] : "";
-      };
-
-      const safeResolveUrl$1 = (contextUrl, url) => {
-        const resolvedUrl = urlResolveBrowser(contextUrl, url);
-        const contextId = splitUrl$4(contextUrl)[0];
-        if (contextId && getScheme(resolvedUrl) === "file" && getScheme(contextId) !== "file") {
+      const resolveUrl$3 = (contextUrl, url) => {
+        const resolvedUrl = uri_all.resolve(contextUrl, url, { iri: true });
+        const contextId = uri_all.resolve(contextUrl, "", { iri: true });
+        if (contextId && uri_all.parse(resolvedUrl).scheme === "file" && uri_all.parse(contextUrl).scheme !== "file") {
           throw Error(`Can't access file '${resolvedUrl}' resource from network context '${contextUrl}'`);
         }
         return resolvedUrl;
       };
 
+      const urlFragment$1 = (uri) => uri_all.unescapeComponent(uri_all.parse(uri).fragment) || "";
+
       const CHAR_BACKWARD_SLASH = 47;
 
       const pathRelative$1 = (from, to) => {
@@ -714,7 +1902,7 @@ System.register('JsonSchema', [], (function (exports) {
         return to.slice(toStart, to.length);
       };
 
-      var common$1 = { jsonTypeOf: jsonTypeOf$2, splitUrl: splitUrl$4, safeResolveUrl: safeResolveUrl$1, pathRelative: pathRelative$1 };
+      var common$1 = { jsonTypeOf: jsonTypeOf$2, resolveUrl: resolveUrl$3, urlFragment: urlFragment$1, pathRelative: pathRelative$1 };
 
       const nil$2 = "";
 
@@ -872,12 +2060,12 @@ System.register('JsonSchema', [], (function (exports) {
       reference.href;
       reference.value;
 
-      const { jsonTypeOf: jsonTypeOf$1 } = common$1;
+      const { resolveUrl: resolveUrl$2, jsonTypeOf: jsonTypeOf$1 } = common$1;
 
 
 
       const nil$1 = Object.freeze({ id: "", pointer: "", instance: undefined, value: undefined });
-      const cons = (instance, id = "") => Object.freeze({ ...nil$1, id, instance, value: instance });
+      const 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 has$1 = (key, doc) => key in value$1(doc);
@@ -1220,7 +2408,7 @@ System.register('JsonSchema', [], (function (exports) {
 
       var fetch_browser = fetch;
 
-      const { jsonTypeOf, splitUrl: splitUrl$3, safeResolveUrl, pathRelative } = common$1;
+      const { jsonTypeOf, resolveUrl: resolveUrl$1, urlFragment, pathRelative } = common$1;
 
 
 
@@ -1251,7 +2439,7 @@ System.register('JsonSchema', [], (function (exports) {
         schema = JSON.parse(JSON.stringify(schema));
 
         // Schema Version
-        const schemaVersion = splitUrl$3(schema["$schema"] || defaultSchemaVersion)[0];
+        const schemaVersion = resolveUrl$1(schema["$schema"] || defaultSchemaVersion, "");
         if (!schemaVersion) {
           throw Error("Couldn't determine schema version");
         }
@@ -1260,12 +2448,13 @@ System.register('JsonSchema', [], (function (exports) {
         // 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 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)}`;
@@ -1312,11 +2501,11 @@ System.register('JsonSchema', [], (function (exports) {
 
       const processSchema = (subject, id, schemaVersion, pointer, anchors, dynamicAnchors) => {
         if (jsonTypeOf(subject, "object")) {
-          const embeddedSchemaVersion = typeof subject["$schema"] === "string" ? splitUrl$3(subject["$schema"])[0] : schemaVersion;
+          const embeddedSchemaVersion = typeof subject["$schema"] === "string" ? resolveUrl$1(subject["$schema"], "") : schemaVersion;
           const embeddedEmbeddedToken = getConfig(embeddedSchemaVersion, "embeddedToken");
           const embeddedAnchorToken = getConfig(embeddedSchemaVersion, "anchorToken");
           if (typeof subject[embeddedEmbeddedToken] === "string" && (embeddedEmbeddedToken !== embeddedAnchorToken || subject[embeddedEmbeddedToken][0] !== "#")) {
-            const ref = safeResolveUrl(id, subject[embeddedEmbeddedToken]);
+            const ref = resolveUrl$1(id, subject[embeddedEmbeddedToken]);
             subject[embeddedEmbeddedToken] = ref;
             add$1(subject, ref, schemaVersion);
             return reference.cons(subject[embeddedEmbeddedToken], subject);
@@ -1375,8 +2564,9 @@ System.register('JsonSchema', [], (function (exports) {
       });
 
       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" } });
@@ -1476,7 +2666,7 @@ System.register('JsonSchema', [], (function (exports) {
         const dynamicAnchorToken = getConfig(schemaDoc.schemaVersion, "dynamicAnchorToken");
         Object.entries(schemaDoc.dynamicAnchors)
           .forEach(([anchor, uri]) => {
-            const pointer = splitUrl$3(uri)[1];
+            const pointer = urlFragment(uri);
             lib$3.assign(pointer, schema, {
               [dynamicAnchorToken]: anchor,
               ...lib$3.get(pointer, schema)
@@ -1545,7 +2735,7 @@ System.register('JsonSchema', [], (function (exports) {
 
       var invalidSchemaError = InvalidSchemaError$1;
 
-      const { splitUrl: splitUrl$2 } = common$1;
+      const { resolveUrl } = common$1;
 
 
 
@@ -1704,7 +2894,7 @@ System.register('JsonSchema', [], (function (exports) {
 
       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 });
       };