@mountainpass/waychaser 5.0.15 → 5.0.17

package/dist/waychaser.es.js

@@ -134,210 +134,241 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
 
 var uriTemplateLite = {};
 
-/**
- * @version    20.5.0
- * @author     Lauri Rooden <lauri@rooden.ee>
- * @license    MIT License
- */
+var hasRequiredUriTemplateLite;
 
+function requireUriTemplateLite () {
+	if (hasRequiredUriTemplateLite) return uriTemplateLite;
+	hasRequiredUriTemplateLite = 1;
+	/**
+	 * @version    20.5.0
+	 * @author     Lauri Rooden <lauri@rooden.ee>
+	 * @license    MIT License
+	 */
 
 
-!function(URI) {
 
-	/**
-	 * URI Template
-	 * @see http://tools.ietf.org/html/rfc6570
-	 */
+	!function(URI) {
 
-	var RESERVED = /[!'()]/g
-	// /[[\]:\/!#$&()*+,;='?@]/g
-	, SEPARATORS = {"": ",", "+": ",", "#": ",", "?": "&"}
-	, escapeRe = /[$-\/?[-^{|}]/g
-	, expandRe = /\{([#&+.\/;?]?)((?:[-\w%.]+(\*|:\d+)?,?)+)\}/g
-	, parseRe  = RegExp(expandRe.source + "|.[^{]*?", "g");
+		/**
+		 * URI Template
+		 * @see http://tools.ietf.org/html/rfc6570
+		 */
 
-	/*** EXPAND ***/
-	function encodeNormal(val) {
-		return encodeURIComponent(val).replace(RESERVED, escape)
-	}
+		var RESERVED = /[!'()]/g
+		// /[[\]:\/!#$&()*+,;='?@]/g
+		, SEPARATORS = {"": ",", "+": ",", "#": ",", "?": "&"}
+		, escapeRe = /[$-\/?[-^{|}]/g
+		, expandRe = /\{([#&+.\/;?]?)((?:[-\w%.]+(\*|:\d+)?,?)+)\}/g
+		, parseRe  = RegExp(expandRe.source + "|.[^{]*?", "g");
 
-	function notNull(s) {
-		return s != null
-	}
+		/*** EXPAND ***/
+		function encodeNormal(val) {
+			return encodeURIComponent(val).replace(RESERVED, escape)
+		}
 
-	function mapCleanJoin(arr, mapFn, joinStr) {
-		arr = arr.map(mapFn).filter(notNull);
-		return arr.length && arr.join(joinStr)
-	}
+		function notNull(s) {
+			return s != null
+		}
 
-	function expand(template, data) {
-		return template.replace(expandRe, function(_, op, vals) {
-			var sep = SEPARATORS[op] || op
-			, named = sep == ";" || sep == "&"
-			, enc = op && sep == "," ? encodeURI : encodeNormal
-			, out = mapCleanJoin(vals.split(","), function(_name) {
-				var mod = _name.split(/[*:]/)
-				, name = mod[0]
-				, val = data[name];
-
-				if (val == null) return
-
-				if (typeof val == "object") {
-					mod = name != _name;
-					if (Array.isArray(val)) {
-						val = mapCleanJoin(val, enc, mod ? named ? sep + name + "=" : sep : "," );
+		function mapCleanJoin(arr, mapFn, joinStr) {
+			arr = arr.map(mapFn).filter(notNull);
+			return arr.length && arr.join(joinStr)
+		}
+
+		function expand(template, data) {
+			return template.replace(expandRe, function(_, op, vals) {
+				var sep = SEPARATORS[op] || op
+				, named = sep == ";" || sep == "&"
+				, enc = op && sep == "," ? encodeURI : encodeNormal
+				, out = mapCleanJoin(vals.split(","), function(_name) {
+					var mod = _name.split(/[*:]/)
+					, name = mod[0]
+					, val = data[name];
+
+					if (val == null) return
+
+					if (typeof val == "object") {
+						mod = name != _name;
+						if (Array.isArray(val)) {
+							val = mapCleanJoin(val, enc, mod ? named ? sep + name + "=" : sep : "," );
+						} else {
+							val = mapCleanJoin(Object.keys(val), function(key) {
+								return enc(key) + (mod ? "=" : ",") + enc(val[key])
+							}, mod && (named || sep == "/") ? sep : ",");
+							if (mod) named = 0;
+						}
+						if (!val) return
 					} else {
-						val = mapCleanJoin(Object.keys(val), function(key) {
-							return enc(key) + (mod ? "=" : ",") + enc(val[key])
-						}, mod && (named || sep == "/") ? sep : ",");
-						if (mod) named = 0;
+						val = enc(mod[1] ? val.slice(0, mod[1]) : val);
 					}
-					if (!val) return
-				} else {
-					val = enc(mod[1] ? val.slice(0, mod[1]) : val);
-				}
-
-				return (
-					named ?
-					name + (val || sep == "&" ? "=" + val : val) :
-					val
-				)
-			}, sep);
-
-			return out || out === "" ? (op != "+" ? op + out : out) : ""
-		}
-	)}
-
-	URI.expand = expand;
-	/**/
-
-	URI.Template = function Template(template) {
-		var self = this
-		//if (!(self instanceof Template)) return new Template(template)
-		/*** PARSE ***/
-		, pos = 0
-		, lengths = {}
-		, fnStr = ""
-		, reStr = "^" + template.replace(parseRe, function(_, op, vals) {
-			if (!vals) return escapeRegExp(_)
-
-			var sep = SEPARATORS[op] || op
-			, named = sep == ";" || sep == "&"
-			, reGroup = vals.split(",").map(function(_name) {
-				var mod = _name.split(/[*:]/)
-				, name = mod[0]
-				, re = (lengths[name] || "(") + ".*?)";
-
-				pos++;
-				//console.log("KEY", arguments)
-				if (mod[1]) {
-					re = "((?:%..|.){1," + mod[1] + "})";
-					lengths[name] = "(\\" + pos;
-				}
-				//TODO: decodeURIComponent throws an Error on invalid input, add try-catch
-				fnStr += "t=($[" + pos + "]||'').split('" + sep + "').map(decodeURIComponent);";
-				fnStr += "o[\"" + name + "\"]=t.length>1?t:t[0];";
-				return (
-					named ?
-					escapeRegExp(name) + "(?:=" + re + ")?" :
-					sep == "&" ?
-					escapeRegExp(name + "=") + re :
-					re
-				)
-			}).join(escapeRegExp(sep));
-			return (op != "+" ? escapeRegExp(op) + reGroup : reGroup)
-
-		}) + "$"
-		, re = RegExp(reStr)
-		, fn = Function("$", "var t,o={};" + fnStr + "return o");
-		self.template = template;
-		self.match = function(uri) {
-			var match = re.exec(uri);
-			return match && fn(match)
-		};
 
-		function escapeRegExp(string) {
-			return string.replace(escapeRe, "\\$&")
-		}
-		/**/
-		/*** EXPAND ***/
-		self.expand = expand.bind(self, template);
+					return (
+						named ?
+						name + (val || sep == "&" ? "=" + val : val) :
+						val
+					)
+				}, sep);
+
+				return out || out === "" ? (op != "+" ? op + out : out) : ""
+			}
+		)}
+
+		URI.expand = expand;
 		/**/
-	};
 
-// `this` is `exports` in NodeJS and `window` in browser.
-}(commonjsGlobal.URI || (commonjsGlobal.URI = {}));
+		URI.Template = function Template(template) {
+			var self = this
+			//if (!(self instanceof Template)) return new Template(template)
+			/*** PARSE ***/
+			, pos = 0
+			, lengths = {}
+			, fnStr = ""
+			, reStr = "^" + template.replace(parseRe, function(_, op, vals) {
+				if (!vals) return escapeRegExp(_)
+
+				var sep = SEPARATORS[op] || op
+				, named = sep == ";" || sep == "&"
+				, reGroup = vals.split(",").map(function(_name) {
+					var mod = _name.split(/[*:]/)
+					, name = mod[0]
+					, re = (lengths[name] || "(") + ".*?)";
+
+					pos++;
+					//console.log("KEY", arguments)
+					if (mod[1]) {
+						re = "((?:%..|.){1," + mod[1] + "})";
+						lengths[name] = "(\\" + pos;
+					}
+					//TODO: decodeURIComponent throws an Error on invalid input, add try-catch
+					fnStr += "t=($[" + pos + "]||'').split('" + sep + "').map(decodeURIComponent);";
+					fnStr += "o[\"" + name + "\"]=t.length>1?t:t[0];";
+					return (
+						named ?
+						escapeRegExp(name) + "(?:=" + re + ")?" :
+						sep == "&" ?
+						escapeRegExp(name + "=") + re :
+						re
+					)
+				}).join(escapeRegExp(sep));
+				return (op != "+" ? escapeRegExp(op) + reGroup : reGroup)
+
+			}) + "$"
+			, re = RegExp(reStr)
+			, fn = Function("$", "var t,o={};" + fnStr + "return o");
+			self.template = template;
+			self.match = function(uri) {
+				var match = re.exec(uri);
+				return match && fn(match)
+			};
+
+			function escapeRegExp(string) {
+				return string.replace(escapeRe, "\\$&")
+			}
+			/**/
+			/*** EXPAND ***/
+			self.expand = expand.bind(self, template);
+			/**/
+		};
 
-/* eslint-disable unicorn/prefer-ternary */
+	// `this` is `exports` in NodeJS and `window` in browser.
+	}(uriTemplateLite.URI || (uriTemplateLite.URI = {}));
+	return uriTemplateLite;
+}
 
+var uriTemplateLiteExports = requireUriTemplateLite();
 
+/* eslint-disable unicorn/prefer-ternary */
 /**
  *
  */
 function getUri() {
-  /* istanbul ignore next: it's complicated */
-  if (typeof window === 'undefined') {
-    // eslint-disable-next-line unicorn/prefer-module
-    return uriTemplateLite.URI || global.URI
-  } else {
-    return window.URI || uriTemplateLite.URI
-  }
+    /* istanbul ignore next: it's complicated */
+    if (typeof window === 'undefined') {
+        // eslint-disable-next-line unicorn/prefer-module
+        return uriTemplateLiteExports.URI || global.URI;
+    }
+    else {
+        return window.URI || uriTemplateLiteExports.URI;
+    }
 }
-
 /**
  *
  */
 function getExtendedUri() {
-  const base = getUri();
-  base.parameters = function (url) {
-    const template = new URI.Template(url);
-    return template.match(url)
-  };
-  return base
+    var base = getUri();
+    base.parameters = function (url) {
+        var template = new URI.Template(url);
+        return template.match(url);
+    };
+    return base;
 }
+var URI = getExtendedUri();
 
+var qsStringify$1;
+var hasRequiredQsStringify;
 
-const URI = getExtendedUri();
+function requireQsStringify () {
+	if (hasRequiredQsStringify) return qsStringify$1;
+	hasRequiredQsStringify = 1;
+	var has = Object.prototype.hasOwnProperty;
 
-var has = Object.prototype.hasOwnProperty;
+	/**
+	 * Stringify an object for use in a query string.
+	 *
+	 * @param {Object} obj - The object.
+	 * @param {string} prefix - When nesting, the parent key.
+	 *     keys in `obj` will be stringified as `prefix[key]`.
+	 * @returns {string}
+	 */
 
-/**
- * Stringify an object for use in a query string.
- *
- * @param {Object} obj - The object.
- * @param {string} prefix - When nesting, the parent key.
- *     keys in `obj` will be stringified as `prefix[key]`.
- * @returns {string}
- */
+	qsStringify$1 = function queryStringify (obj, prefix) {
+	  var pairs = [];
+	  for (var key in obj) {
+	    if (!has.call(obj, key)) {
+	      continue
+	    }
+
+	    var value = obj[key];
+	    var enkey = encodeURIComponent(key);
+	    var pair;
+	    if (typeof value === 'object') {
+	      pair = queryStringify(value, prefix ? prefix + '[' + enkey + ']' : enkey);
+	    } else {
+	      pair = (prefix ? prefix + '[' + enkey + ']' : enkey) + '=' + encodeURIComponent(value);
+	    }
+	    pairs.push(pair);
+	  }
+	  return pairs.join('&')
+	};
+	return qsStringify$1;
+}
 
-var qsStringify = function queryStringify (obj, prefix) {
-  var pairs = [];
-  for (var key in obj) {
-    if (!has.call(obj, key)) {
-      continue
-    }
+var qsStringifyExports = requireQsStringify();
+var qsStringify = /*@__PURE__*/getDefaultExportFromCjs(qsStringifyExports);
 
-    var value = obj[key];
-    var enkey = encodeURIComponent(key);
-    var pair;
-    if (typeof value === 'object') {
-      pair = queryStringify(value, prefix ? prefix + '[' + enkey + ']' : enkey);
-    } else {
-      pair = (prefix ? prefix + '[' + enkey + ']' : enkey) + '=' + encodeURIComponent(value);
-    }
-    pairs.push(pair);
-  }
-  return pairs.join('&')
-};
+var browser;
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser;
+	hasRequiredBrowser = 1;
+
+	/* eslint-env browser */
+	browser = typeof self === 'object' ? self.FormData : window.FormData;
+	return browser;
+}
 
-/* eslint-env browser */
-var browser = typeof self === 'object' ? self.FormData : window.FormData;
+var browserExports = requireBrowser();
+var FormData = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
 // negotiated (https://www.npmjs.com/package/negotiated) doesn't working in IE 11 due to missing regex polyfill stuff
+// @hapi/accept https://www.npmjs.com/package/@hapi/accept is too big (with all it's dependencies)
 /**
  * @param {string} accept
  */
@@ -411,346 +442,372 @@ function parseAccept(accept) {
  * @param supportedContentTypes
  * @param defaultType
  */
-function preferredContentType (
-  accept,
-  supportedContentTypes,
-  defaultType
-) {
-  if (accept) {
-    const acceptable = parseAccept(accept);
-
-    const acceptableMediaTypes = acceptable.find(row => {
-      return supportedContentTypes.includes(row.type)
-    });
-
-    return acceptableMediaTypes.type
-  } else {
-    return defaultType
-  }
-}
-
-var flat = flatten;
-flatten.flatten = flatten;
-flatten.unflatten = unflatten;
-
-function isBuffer (obj) {
-  return obj &&
-    obj.constructor &&
-    (typeof obj.constructor.isBuffer === 'function') &&
-    obj.constructor.isBuffer(obj)
-}
-
-function keyIdentity (key) {
-  return key
-}
-
-function flatten (target, opts) {
-  opts = opts || {};
-
-  const delimiter = opts.delimiter || '.';
-  const maxDepth = opts.maxDepth;
-  const transformKey = opts.transformKey || keyIdentity;
-  const output = {};
-
-  function step (object, prev, currentDepth) {
-    currentDepth = currentDepth || 1;
-    Object.keys(object).forEach(function (key) {
-      const value = object[key];
-      const isarray = opts.safe && Array.isArray(value);
-      const type = Object.prototype.toString.call(value);
-      const isbuffer = isBuffer(value);
-      const isobject = (
-        type === '[object Object]' ||
-        type === '[object Array]'
-      );
-
-      const newKey = prev
-        ? prev + delimiter + transformKey(key)
-        : transformKey(key);
-
-      if (!isarray && !isbuffer && isobject && Object.keys(value).length &&
-        (!opts.maxDepth || currentDepth < maxDepth)) {
-        return step(value, newKey, currentDepth + 1)
-      }
-
-      output[newKey] = value;
-    });
-  }
-
-  step(target);
-
-  return output
-}
-
-function unflatten (target, opts) {
-  opts = opts || {};
-
-  const delimiter = opts.delimiter || '.';
-  const overwrite = opts.overwrite || false;
-  const transformKey = opts.transformKey || keyIdentity;
-  const result = {};
-
-  const isbuffer = isBuffer(target);
-  if (isbuffer || Object.prototype.toString.call(target) !== '[object Object]') {
-    return target
-  }
-
-  // safely ensure that the key is
-  // an integer.
-  function getkey (key) {
-    const parsedKey = Number(key);
-
-    return (
-      isNaN(parsedKey) ||
-      key.indexOf('.') !== -1 ||
-      opts.object
-    ) ? key
-      : parsedKey
-  }
-
-  function addKeys (keyPrefix, recipient, target) {
-    return Object.keys(target).reduce(function (result, key) {
-      result[keyPrefix + delimiter + key] = target[key];
-
-      return result
-    }, recipient)
-  }
-
-  function isEmpty (val) {
-    const type = Object.prototype.toString.call(val);
-    const isArray = type === '[object Array]';
-    const isObject = type === '[object Object]';
-
-    if (!val) {
-      return true
-    } else if (isArray) {
-      return !val.length
-    } else if (isObject) {
-      return !Object.keys(val).length
-    }
-  }
-
-  target = Object.keys(target).reduce(function (result, key) {
-    const type = Object.prototype.toString.call(target[key]);
-    const isObject = (type === '[object Object]' || type === '[object Array]');
-    if (!isObject || isEmpty(target[key])) {
-      result[key] = target[key];
-      return result
-    } else {
-      return addKeys(
-        key,
-        result,
-        flatten(target[key], opts)
-      )
+function preferredContentType(accept, supportedContentTypes, defaultType) {
+    if (accept) {
+        var acceptable = parseAccept(accept);
+        var acceptableMediaTypes = acceptable.find(function (row) {
+            return supportedContentTypes.includes(row.type);
+        });
+        return acceptableMediaTypes.type;
     }
-  }, {});
-
-  Object.keys(target).forEach(function (key) {
-    const split = key.split(delimiter).map(transformKey);
-    let key1 = getkey(split.shift());
-    let key2 = getkey(split[0]);
-    let recipient = result;
-
-    while (key2 !== undefined) {
-      if (key1 === '__proto__') {
-        return
-      }
-
-      const type = Object.prototype.toString.call(recipient[key1]);
-      const isobject = (
-        type === '[object Object]' ||
-        type === '[object Array]'
-      );
-
-      // do not write over falsey, non-undefined values if overwrite is false
-      if (!overwrite && !isobject && typeof recipient[key1] !== 'undefined') {
-        return
-      }
-
-      if ((overwrite && !isobject) || (!overwrite && recipient[key1] == null)) {
-        recipient[key1] = (
-          typeof key2 === 'number' &&
-          !opts.object ? [] : {}
-        );
-      }
-
-      recipient = recipient[key1];
-      if (split.length > 0) {
-        key1 = getkey(split.shift());
-        key2 = getkey(split[0]);
-      }
+    else {
+        return defaultType;
     }
-
-    // unflatten again for 'messy objects'
-    recipient[key1] = unflatten(target[key], opts);
-  });
-
-  return result
 }
 
-var jsonpointer = {};
-
-var hasExcape = /~/;
-var escapeMatcher = /~[01]/g;
-function escapeReplacer (m) {
-  switch (m) {
-    case '~1': return '/'
-    case '~0': return '~'
-  }
-  throw new Error('Invalid tilde escape: ' + m)
-}
+var flat;
+var hasRequiredFlat;
+
+function requireFlat () {
+	if (hasRequiredFlat) return flat;
+	hasRequiredFlat = 1;
+	flat = flatten;
+	flatten.flatten = flatten;
+	flatten.unflatten = unflatten;
+
+	function isBuffer (obj) {
+	  return obj &&
+	    obj.constructor &&
+	    (typeof obj.constructor.isBuffer === 'function') &&
+	    obj.constructor.isBuffer(obj)
+	}
 
-function untilde (str) {
-  if (!hasExcape.test(str)) return str
-  return str.replace(escapeMatcher, escapeReplacer)
-}
+	function keyIdentity (key) {
+	  return key
+	}
 
-function setter (obj, pointer, value) {
-  var part;
-  var hasNextPart;
+	function flatten (target, opts) {
+	  opts = opts || {};
+
+	  const delimiter = opts.delimiter || '.';
+	  const maxDepth = opts.maxDepth;
+	  const transformKey = opts.transformKey || keyIdentity;
+	  const output = {};
+
+	  function step (object, prev, currentDepth) {
+	    currentDepth = currentDepth || 1;
+	    Object.keys(object).forEach(function (key) {
+	      const value = object[key];
+	      const isarray = opts.safe && Array.isArray(value);
+	      const type = Object.prototype.toString.call(value);
+	      const isbuffer = isBuffer(value);
+	      const isobject = (
+	        type === '[object Object]' ||
+	        type === '[object Array]'
+	      );
+
+	      const newKey = prev
+	        ? prev + delimiter + transformKey(key)
+	        : transformKey(key);
+
+	      if (!isarray && !isbuffer && isobject && Object.keys(value).length &&
+	        (!opts.maxDepth || currentDepth < maxDepth)) {
+	        return step(value, newKey, currentDepth + 1)
+	      }
+
+	      output[newKey] = value;
+	    });
+	  }
+
+	  step(target);
+
+	  return output
+	}
 
-  for (var p = 1, len = pointer.length; p < len;) {
-    if (pointer[p] === 'constructor' || pointer[p] === 'prototype' || pointer[p] === '__proto__') return obj
+	function unflatten (target, opts) {
+	  opts = opts || {};
+
+	  const delimiter = opts.delimiter || '.';
+	  const overwrite = opts.overwrite || false;
+	  const transformKey = opts.transformKey || keyIdentity;
+	  const result = {};
+
+	  const isbuffer = isBuffer(target);
+	  if (isbuffer || Object.prototype.toString.call(target) !== '[object Object]') {
+	    return target
+	  }
+
+	  // safely ensure that the key is
+	  // an integer.
+	  function getkey (key) {
+	    const parsedKey = Number(key);
+
+	    return (
+	      isNaN(parsedKey) ||
+	      key.indexOf('.') !== -1 ||
+	      opts.object
+	    ) ? key
+	      : parsedKey
+	  }
+
+	  function addKeys (keyPrefix, recipient, target) {
+	    return Object.keys(target).reduce(function (result, key) {
+	      result[keyPrefix + delimiter + key] = target[key];
+
+	      return result
+	    }, recipient)
+	  }
+
+	  function isEmpty (val) {
+	    const type = Object.prototype.toString.call(val);
+	    const isArray = type === '[object Array]';
+	    const isObject = type === '[object Object]';
+
+	    if (!val) {
+	      return true
+	    } else if (isArray) {
+	      return !val.length
+	    } else if (isObject) {
+	      return !Object.keys(val).length
+	    }
+	  }
+
+	  target = Object.keys(target).reduce(function (result, key) {
+	    const type = Object.prototype.toString.call(target[key]);
+	    const isObject = (type === '[object Object]' || type === '[object Array]');
+	    if (!isObject || isEmpty(target[key])) {
+	      result[key] = target[key];
+	      return result
+	    } else {
+	      return addKeys(
+	        key,
+	        result,
+	        flatten(target[key], opts)
+	      )
+	    }
+	  }, {});
+
+	  Object.keys(target).forEach(function (key) {
+	    const split = key.split(delimiter).map(transformKey);
+	    let key1 = getkey(split.shift());
+	    let key2 = getkey(split[0]);
+	    let recipient = result;
+
+	    while (key2 !== undefined) {
+	      if (key1 === '__proto__') {
+	        return
+	      }
+
+	      const type = Object.prototype.toString.call(recipient[key1]);
+	      const isobject = (
+	        type === '[object Object]' ||
+	        type === '[object Array]'
+	      );
+
+	      // do not write over falsey, non-undefined values if overwrite is false
+	      if (!overwrite && !isobject && typeof recipient[key1] !== 'undefined') {
+	        return
+	      }
+
+	      if ((overwrite && !isobject) || (!overwrite && recipient[key1] == null)) {
+	        recipient[key1] = (
+	          typeof key2 === 'number' &&
+	          !opts.object ? [] : {}
+	        );
+	      }
+
+	      recipient = recipient[key1];
+	      if (split.length > 0) {
+	        key1 = getkey(split.shift());
+	        key2 = getkey(split[0]);
+	      }
+	    }
+
+	    // unflatten again for 'messy objects'
+	    recipient[key1] = unflatten(target[key], opts);
+	  });
+
+	  return result
+	}
+	return flat;
+}
 
-    part = untilde(pointer[p++]);
-    hasNextPart = len > p;
+var flatExports = requireFlat();
+var flatten = /*@__PURE__*/getDefaultExportFromCjs(flatExports);
 
-    if (typeof obj[part] === 'undefined') {
-      // support setting of /-
-      if (Array.isArray(obj) && part === '-') {
-        part = obj.length;
-      }
+var jsonpointer = {};
 
-      // support nested objects/array when setting values
-      if (hasNextPart) {
-        if ((pointer[p] !== '' && pointer[p] < Infinity) || pointer[p] === '-') obj[part] = [];
-        else obj[part] = {};
-      }
-    }
+var hasRequiredJsonpointer;
+
+function requireJsonpointer () {
+	if (hasRequiredJsonpointer) return jsonpointer;
+	hasRequiredJsonpointer = 1;
+	var hasExcape = /~/;
+	var escapeMatcher = /~[01]/g;
+	function escapeReplacer (m) {
+	  switch (m) {
+	    case '~1': return '/'
+	    case '~0': return '~'
+	  }
+	  throw new Error('Invalid tilde escape: ' + m)
+	}
 
-    if (!hasNextPart) break
-    obj = obj[part];
-  }
+	function untilde (str) {
+	  if (!hasExcape.test(str)) return str
+	  return str.replace(escapeMatcher, escapeReplacer)
+	}
 
-  var oldValue = obj[part];
-  if (value === undefined) delete obj[part];
-  else obj[part] = value;
-  return oldValue
-}
+	function setter (obj, pointer, value) {
+	  var part;
+	  var hasNextPart;
+
+	  for (var p = 1, len = pointer.length; p < len;) {
+	    if (pointer[p] === 'constructor' || pointer[p] === 'prototype' || pointer[p] === '__proto__') return obj
+
+	    part = untilde(pointer[p++]);
+	    hasNextPart = len > p;
+
+	    if (typeof obj[part] === 'undefined') {
+	      // support setting of /-
+	      if (Array.isArray(obj) && part === '-') {
+	        part = obj.length;
+	      }
+
+	      // support nested objects/array when setting values
+	      if (hasNextPart) {
+	        if ((pointer[p] !== '' && pointer[p] < Infinity) || pointer[p] === '-') obj[part] = [];
+	        else obj[part] = {};
+	      }
+	    }
+
+	    if (!hasNextPart) break
+	    obj = obj[part];
+	  }
+
+	  var oldValue = obj[part];
+	  if (value === undefined) delete obj[part];
+	  else obj[part] = value;
+	  return oldValue
+	}
 
-function compilePointer (pointer) {
-  if (typeof pointer === 'string') {
-    pointer = pointer.split('/');
-    if (pointer[0] === '') return pointer
-    throw new Error('Invalid JSON pointer.')
-  } else if (Array.isArray(pointer)) {
-    for (const part of pointer) {
-      if (typeof part !== 'string' && typeof part !== 'number') {
-        throw new Error('Invalid JSON pointer. Must be of type string or number.')
-      }
-    }
-    return pointer
-  }
+	function compilePointer (pointer) {
+	  if (typeof pointer === 'string') {
+	    pointer = pointer.split('/');
+	    if (pointer[0] === '') return pointer
+	    throw new Error('Invalid JSON pointer.')
+	  } else if (Array.isArray(pointer)) {
+	    for (const part of pointer) {
+	      if (typeof part !== 'string' && typeof part !== 'number') {
+	        throw new Error('Invalid JSON pointer. Must be of type string or number.')
+	      }
+	    }
+	    return pointer
+	  }
+
+	  throw new Error('Invalid JSON pointer.')
+	}
 
-  throw new Error('Invalid JSON pointer.')
-}
+	function get (obj, pointer) {
+	  if (typeof obj !== 'object') throw new Error('Invalid input object.')
+	  pointer = compilePointer(pointer);
+	  var len = pointer.length;
+	  if (len === 1) return obj
+
+	  for (var p = 1; p < len;) {
+	    obj = obj[untilde(pointer[p++])];
+	    if (len === p) return obj
+	    if (typeof obj !== 'object' || obj === null) return undefined
+	  }
+	}
 
-function get (obj, pointer) {
-  if (typeof obj !== 'object') throw new Error('Invalid input object.')
-  pointer = compilePointer(pointer);
-  var len = pointer.length;
-  if (len === 1) return obj
-
-  for (var p = 1; p < len;) {
-    obj = obj[untilde(pointer[p++])];
-    if (len === p) return obj
-    if (typeof obj !== 'object' || obj === null) return undefined
-  }
-}
+	function set (obj, pointer, value) {
+	  if (typeof obj !== 'object') throw new Error('Invalid input object.')
+	  pointer = compilePointer(pointer);
+	  if (pointer.length === 0) throw new Error('Invalid JSON pointer for set.')
+	  return setter(obj, pointer, value)
+	}
 
-function set (obj, pointer, value) {
-  if (typeof obj !== 'object') throw new Error('Invalid input object.')
-  pointer = compilePointer(pointer);
-  if (pointer.length === 0) throw new Error('Invalid JSON pointer for set.')
-  return setter(obj, pointer, value)
-}
+	function compile (pointer) {
+	  var compiled = compilePointer(pointer);
+	  return {
+	    get: function (object) {
+	      return get(object, compiled)
+	    },
+	    set: function (object, value) {
+	      return set(object, compiled, value)
+	    }
+	  }
+	}
 
-function compile (pointer) {
-  var compiled = compilePointer(pointer);
-  return {
-    get: function (object) {
-      return get(object, compiled)
-    },
-    set: function (object, value) {
-      return set(object, compiled, value)
-    }
-  }
+	jsonpointer.get = get;
+	jsonpointer.set = set;
+	jsonpointer.compile = compile;
+	return jsonpointer;
 }
 
-jsonpointer.get = get;
-jsonpointer.set = set;
-jsonpointer.compile = compile;
+var jsonpointerExports = requireJsonpointer();
+var pointer = /*@__PURE__*/getDefaultExportFromCjs(jsonpointerExports);
 
 /**
  * @param method
  */
-function methodCanHaveBody (method) {
-  return !['GET', 'DELETE', 'TRACE', 'OPTIONS', 'HEAD'].includes(method)
+function methodCanHaveBody(method) {
+    return !['GET', 'DELETE', 'TRACE', 'OPTIONS', 'HEAD'].includes(method);
 }
 
 var lib = {};
 
-Object.defineProperty(lib, "__esModule", { value: true });
-var ProblemDocument_1 = lib.ProblemDocument = void 0;
-/**
- *
- * This class implements RFC7807 "problem detail", a way to carry machine-
- * readable details of errors in a HTTP response to avoid the need to
- * define new error response formats for HTTP APIs.
- *
- * Official Documentation @ https://datatracker.ietf.org/doc/html/rfc7807
- *
- * Consumers MUST use the "type" string as the primary identifier for
- * the problem type; the "title" string is advisory and included only
- * for users who are not aware of the semantics of the URI and do not
- * have the ability to discover them (e.g., offline log analysis).
- * Consumers SHOULD NOT automatically dereference the type URI.
- *
- * The "status" member, if present, is only advisory; it conveys the
- * HTTP status code used for the convenience of the consumer.
- * Generators MUST use the same status code in the actual HTTP response,
- * to assure that generic HTTP software that does not understand this
- * format still behaves correctly.  See Section 5 for further caveats
- * regarding its use.
- *
- * Consumers can use the status member to determine what the original
- * status code used by the generator was, in cases where it has been
- * changed (e.g., by an intermediary or cache), and when message bodies
- * persist without HTTP information.  Generic HTTP software will still
- * use the HTTP status code.
- *
- * The "detail" member, if present, ought to focus on helping the client
- * correct the problem, rather than giving debugging information.
- *
- * Consumers SHOULD NOT parse the "detail" member for information;
- * extensions are more suitable and less error-prone ways to obtain such
- * information.
- *
- * Note that both {@link BaseProblemDocumentProperties.type type} and {@link BaseProblemDocumentProperties.instance instance} accept relative URIs; this means
- * that they must be resolved relative to the document's base URI, as
- * per {@link https://datatracker.ietf.org/doc/html/rfc3986#section-5 [RFC3986], Section 5}.
- */
-class ProblemDocument {
-    /**
-     *
-     * construct a new ProblemDocument instance
-     * @param data properties to assign to the new instance
-     */
-    constructor(data) {
-        Object.assign(this, data);
-    }
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib;
+	hasRequiredLib = 1;
+	Object.defineProperty(lib, "__esModule", { value: true });
+	lib.ProblemDocument = void 0;
+	/**
+	 *
+	 * This class implements RFC7807 "problem detail", a way to carry machine-
+	 * readable details of errors in a HTTP response to avoid the need to
+	 * define new error response formats for HTTP APIs.
+	 *
+	 * Official Documentation @ https://datatracker.ietf.org/doc/html/rfc7807
+	 *
+	 * Consumers MUST use the "type" string as the primary identifier for
+	 * the problem type; the "title" string is advisory and included only
+	 * for users who are not aware of the semantics of the URI and do not
+	 * have the ability to discover them (e.g., offline log analysis).
+	 * Consumers SHOULD NOT automatically dereference the type URI.
+	 *
+	 * The "status" member, if present, is only advisory; it conveys the
+	 * HTTP status code used for the convenience of the consumer.
+	 * Generators MUST use the same status code in the actual HTTP response,
+	 * to assure that generic HTTP software that does not understand this
+	 * format still behaves correctly.  See Section 5 for further caveats
+	 * regarding its use.
+	 *
+	 * Consumers can use the status member to determine what the original
+	 * status code used by the generator was, in cases where it has been
+	 * changed (e.g., by an intermediary or cache), and when message bodies
+	 * persist without HTTP information.  Generic HTTP software will still
+	 * use the HTTP status code.
+	 *
+	 * The "detail" member, if present, ought to focus on helping the client
+	 * correct the problem, rather than giving debugging information.
+	 *
+	 * Consumers SHOULD NOT parse the "detail" member for information;
+	 * extensions are more suitable and less error-prone ways to obtain such
+	 * information.
+	 *
+	 * Note that both {@link BaseProblemDocumentProperties.type type} and {@link BaseProblemDocumentProperties.instance instance} accept relative URIs; this means
+	 * that they must be resolved relative to the document's base URI, as
+	 * per {@link https://datatracker.ietf.org/doc/html/rfc3986#section-5 [RFC3986], Section 5}.
+	 */
+	class ProblemDocument {
+	    /**
+	     *
+	     * construct a new ProblemDocument instance
+	     * @param data properties to assign to the new instance
+	     */
+	    constructor(data) {
+	        Object.assign(this, data);
+	    }
+	}
+	lib.ProblemDocument = ProblemDocument;
+	
+	return lib;
 }
-ProblemDocument_1 = lib.ProblemDocument = ProblemDocument;
+
+var libExports = requireLib();
 
 var Operation = /** @class */ (function () {
     function Operation(_a) {
@@ -783,7 +840,7 @@ var InvocableOperation = /** @class */ (function (_super) {
     InvocableOperation.prototype.invokeAsFragment = function (parameters, validator) {
         if (this.uri.startsWith('#/')) {
             var anchor = this.expandUrl(parameters).toString();
-            var fragmentContent = this.response.fullContent && jsonpointer.get(this.response.fullContent, anchor.slice(1));
+            var fragmentContent = this.response.fullContent && pointer.get(this.response.fullContent, anchor.slice(1));
             if (fragmentContent === undefined) {
                 return undefined;
             }
@@ -831,7 +888,7 @@ var InvocableOperation = /** @class */ (function (_super) {
         if (keys.length !== 0) {
             var field = currentUriParameters[keys[0]];
             var parentUri = currentUri.slice(1, currentUri.indexOf(field) - 1);
-            var parent_1 = parentUri === '' ? response.content : jsonpointer.get(response.content, parentUri);
+            var parent_1 = parentUri === '' ? response.content : pointer.get(response.content, parentUri);
             if (parent_1) {
                 var indices = Array.isArray(parent_1) ? __spreadArray([], __read(Array.from({ length: parent_1.length }).keys()), false) : Object.keys(parent_1);
                 return indices.flatMap(function (index) {
@@ -843,7 +900,7 @@ var InvocableOperation = /** @class */ (function (_super) {
             else {
                 throw new WayChaserProblem({
                     response: this.response,
-                    problem: new ProblemDocument_1({
+                    problem: new libExports.ProblemDocument({
                         type: "https://waychaser.io/fragment-uri-error",
                         title: "The fragment URI does not match the content structure",
                         uri: parentUri, content: response.content,
@@ -918,7 +975,7 @@ var InvocableOperation = /** @class */ (function (_super) {
                                 encodedContent = JSON.stringify(body);
                                 break;
                             case 'multipart/form-data':
-                                encodedContent = new browser();
+                                encodedContent = new FormData();
                                 for (name_1 in body) {
                                     encodedContent.append(name_1, body[name_1]);
                                 }
@@ -945,7 +1002,7 @@ var InvocableOperation = /** @class */ (function (_super) {
         return invokeUrl;
     };
     InvocableOperation.prototype.expandUrl = function (parameters) {
-        return URI.expand(this.uri, flat(parameters || {}));
+        return URI.expand(this.uri, flatten(parameters || {}));
     };
     return InvocableOperation;
 }(Operation));
@@ -1157,38 +1214,38 @@ function parseOperations(_a) {
     return expandedOperations;
 }
 
-const MediaTypes = {
-  HAL: 'application/hal+json',
-  SIREN: 'application/vnd.siren+json'
+var MediaTypes = {
+    HAL: 'application/hal+json',
+    SIREN: 'application/vnd.siren+json'
 };
 
 /**
  * @param relationship
  * @param curies
  */
-
 /**
  * @param relationship
  * @param curies
  */
-function deCurie (relationship, curies) {
-  // we can either look in the rel for ':' and try to convert if it exists, but then we'll be trying to covert almost
-  // everything because none standard rels typically start with 'http:' or 'https:'.
-  // otherwise we can iterate over all the curies and try to replace. Seems inefficient.
-  // Going with option 1 for now.
-  // ⚠️ NOTE TO SELF: never use 'http' or 'https' as a curie name or hilarity will not ensue 😬
-  // ⚠️ ALSO NOTE TO SELF: never use ':' in a curie name or hilarity will not ensue 😬
-  // I'm going to assume that if there are multiple ':' characters, then we ignore all but the first
-  const splitRelationship = relationship.split(/:(.+)/);
-  if (splitRelationship.length > 1) {
-    const [curieName, curieRemainder] = splitRelationship;
-    const rval = curies[curieName]
-      ? URI.expand(curies[curieName], { rel: curieRemainder })
-      : relationship;
-    return rval
-  } else {
-    return relationship
-  }
+function deCurie(relationship, curies) {
+    // we can either look in the rel for ':' and try to convert if it exists, but then we'll be trying to covert almost
+    // everything because none standard rels typically start with 'http:' or 'https:'.
+    // otherwise we can iterate over all the curies and try to replace. Seems inefficient.
+    // Going with option 1 for now.
+    // ⚠️ NOTE TO SELF: never use 'http' or 'https' as a curie name or hilarity will not ensue 😬
+    // ⚠️ ALSO NOTE TO SELF: never use ':' in a curie name or hilarity will not ensue 😬
+    // I'm going to assume that if there are multiple ':' characters, then we ignore all but the first
+    var splitRelationship = relationship.split(/:(.+)/);
+    if (splitRelationship.length > 1) {
+        var _a = __read(splitRelationship, 2), curieName = _a[0], curieRemainder = _a[1];
+        var rval = curies[curieName]
+            ? URI.expand(curies[curieName], { rel: curieRemainder })
+            : relationship;
+        return rval;
+    }
+    else {
+        return relationship;
+    }
 }
 
 /**
@@ -1197,10 +1254,10 @@ function deCurie (relationship, curies) {
  * @param curies
  */
 function mapHalLinkToOperation(relationship, link, curies) {
-  // we don't need to copy `templated` across, because when we invoke an operation, we always
-  // assume it's a template and expand it with the passed parameters
-  const { href, templated, ...otherProperties } = link;
-  return new Operation({ rel: deCurie(relationship, curies), uri: href, ...otherProperties })
+    // we don't need to copy `templated` across, because when we invoke an operation, we always
+    // assume it's a template and expand it with the passed parameters
+    var href = link.href; link.templated; var otherProperties = __rest(link, ["href", "templated"]);
+    return new Operation(__assign({ rel: deCurie(relationship, curies), uri: href }, otherProperties));
 }
 
 /**
@@ -1274,412 +1331,424 @@ function halHandler(response, content) {
     return operations;
 }
 
-var COMPATIBLE_ENCODING_PATTERN = /^utf-?8|ascii|utf-?16-?le|ucs-?2|base-?64|latin-?1$/i;
-var WS_TRIM_PATTERN = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
-var WS_CHAR_PATTERN = /\s|\uFEFF|\xA0/;
-var WS_FOLD_PATTERN = /\r?\n[\x20\x09]+/g;
-var DELIMITER_PATTERN = /[;,"]/;
-var WS_DELIMITER_PATTERN = /[;,"]|\s/;
-
-/**
- * Token character pattern
- * @type {RegExp}
- * @see https://tools.ietf.org/html/rfc7230#section-3.2.6
- */
-var TOKEN_PATTERN = /^[!#$%&'*+\-\.^_`|~\da-zA-Z]+$/;
-
-var STATE = {
-  IDLE: 1 << 0,
-  URI: 1 << 1,
-  ATTR: 1 << 2,
-};
-
-function trim( value ) {
-  return value.replace( WS_TRIM_PATTERN, '' )
-}
-
-function hasWhitespace( value ) {
-  return WS_CHAR_PATTERN.test( value )
-}
-
-function skipWhitespace( value, offset ) {
-  while( hasWhitespace( value[offset] ) ) {
-    offset++;
-  }
-  return offset
-}
-
-function needsQuotes( value ) {
-  return WS_DELIMITER_PATTERN.test( value ) ||
-    !TOKEN_PATTERN.test( value )
-}
-
-/**
- * Shallow compares two objects to check if their properties match.
- * @param {object} object1 First object to compare.
- * @param {object} object2 Second object to compare.
- * @returns {boolean} Do the objects have matching properties.
- */
-function shallowCompareObjects( object1, object2 ) {
-  return (
-    Object.keys( object1 ).length === Object.keys( object2 ).length &&
-    Object.keys( object1 ).every(
-      ( key ) => key in object2 && object1[ key ] === object2[ key ]
-    )
-  );
-}
-
-class Link {
-
-  /**
-   * Link
-   * @constructor
-   * @param {String} [value]
-   * @returns {Link}
-   */
-  constructor( value ) {
+var link;
+var hasRequiredLink;
 
-    /** @type {Array} URI references */
-    this.refs = [];
+function requireLink () {
+	if (hasRequiredLink) return link;
+	hasRequiredLink = 1;
 
-    if( value ) {
-      this.parse( value );
-    }
+	var COMPATIBLE_ENCODING_PATTERN = /^utf-?8|ascii|utf-?16-?le|ucs-?2|base-?64|latin-?1$/i;
+	var WS_TRIM_PATTERN = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
+	var WS_CHAR_PATTERN = /\s|\uFEFF|\xA0/;
+	var WS_FOLD_PATTERN = /\r?\n[\x20\x09]+/g;
+	var DELIMITER_PATTERN = /[;,"]/;
+	var WS_DELIMITER_PATTERN = /[;,"]|\s/;
 
-  }
+	/**
+	 * Token character pattern
+	 * @type {RegExp}
+	 * @see https://tools.ietf.org/html/rfc7230#section-3.2.6
+	 */
+	var TOKEN_PATTERN = /^[!#$%&'*+\-\.^_`|~\da-zA-Z]+$/;
 
-  /**
-   * Get refs with given relation type
-   * @param {String} value
-   * @returns {Array<Object>}
-   */
-  rel( value ) {
+	var STATE = {
+	  IDLE: 1 << 0,
+	  URI: 1 << 1,
+	  ATTR: 1 << 2,
+	};
 
-    var links = [];
-    var type = value.toLowerCase();
+	function trim( value ) {
+	  return value.replace( WS_TRIM_PATTERN, '' )
+	}
 
-    for( var i = 0; i < this.refs.length; i++ ) {
-      if( typeof this.refs[ i ].rel === 'string' && this.refs[ i ].rel.toLowerCase() === type ) {
-        links.push( this.refs[ i ] );
-      }
-    }
+	function hasWhitespace( value ) {
+	  return WS_CHAR_PATTERN.test( value )
+	}
 
-    return links
+	function skipWhitespace( value, offset ) {
+	  while( hasWhitespace( value[offset] ) ) {
+	    offset++;
+	  }
+	  return offset
+	}
 
-  }
+	function needsQuotes( value ) {
+	  return WS_DELIMITER_PATTERN.test( value ) ||
+	    !TOKEN_PATTERN.test( value )
+	}
 
-  /**
-   * Get refs where given attribute has a given value
-   * @param {String} attr
-   * @param {String} value
-   * @returns {Array<Object>}
-   */
-  get( attr, value ) {
+	/**
+	 * Shallow compares two objects to check if their properties match.
+	 * @param {object} object1 First object to compare.
+	 * @param {object} object2 Second object to compare.
+	 * @returns {boolean} Do the objects have matching properties.
+	 */
+	function shallowCompareObjects( object1, object2 ) {
+	  return (
+	    Object.keys( object1 ).length === Object.keys( object2 ).length &&
+	    Object.keys( object1 ).every(
+	      ( key ) => key in object2 && object1[ key ] === object2[ key ]
+	    )
+	  );
+	}
 
-    attr = attr.toLowerCase();
-    value = value.toLowerCase();
+	class Link {
 
-    var links = [];
+	  /**
+	   * Link
+	   * @constructor
+	   * @param {String} [value]
+	   * @returns {Link}
+	   */
+	  constructor( value ) {
 
-    for( var i = 0; i < this.refs.length; i++ ) {
-      if( typeof this.refs[ i ][ attr ] === 'string' && this.refs[ i ][ attr ].toLowerCase() === value ) {
-        links.push( this.refs[ i ] );
-      }
-    }
+	    /** @type {Array} URI references */
+	    this.refs = [];
 
-    return links
+	    if( value ) {
+	      this.parse( value );
+	    }
 
-  }
+	  }
 
-  /** Sets a reference. */
-  set( link ) {
-    this.refs.push( link );
-    return this
-  }
+	  /**
+	   * Get refs with given relation type
+	   * @param {String} value
+	   * @returns {Array<Object>}
+	   */
+	  rel( value ) {
 
-  /**
-   * Sets a reference if a reference with similar properties isn’t already set.
-   */
-  setUnique( link ) {
+	    var links = [];
+	    var type = value.toLowerCase();
+
+	    for( var i = 0; i < this.refs.length; i++ ) {
+	      if( typeof this.refs[ i ].rel === 'string' && this.refs[ i ].rel.toLowerCase() === type ) {
+	        links.push( this.refs[ i ] );
+	      }
+	    }
+
+	    return links
+
+	  }
+
+	  /**
+	   * Get refs where given attribute has a given value
+	   * @param {String} attr
+	   * @param {String} value
+	   * @returns {Array<Object>}
+	   */
+	  get( attr, value ) {
+
+	    attr = attr.toLowerCase();
+	    value = value.toLowerCase();
+
+	    var links = [];
+
+	    for( var i = 0; i < this.refs.length; i++ ) {
+	      if( typeof this.refs[ i ][ attr ] === 'string' && this.refs[ i ][ attr ].toLowerCase() === value ) {
+	        links.push( this.refs[ i ] );
+	      }
+	    }
+
+	    return links
+
+	  }
+
+	  /** Sets a reference. */
+	  set( link ) {
+	    this.refs.push( link );
+	    return this
+	  }
+
+	  /**
+	   * Sets a reference if a reference with similar properties isn’t already set.
+	   */
+	  setUnique( link ) {
+
+	    if( !this.refs.some(( ref ) => shallowCompareObjects( ref, link )) ) {
+	      this.refs.push( link );
+	    }
+
+	    return this
+
+	  }
+
+	  has( attr, value ) {
+
+	    attr = attr.toLowerCase();
+	    value = value.toLowerCase();
+
+	    for( var i = 0; i < this.refs.length; i++ ) {
+	      if( typeof this.refs[ i ][ attr ] === 'string' && this.refs[ i ][ attr ].toLowerCase() === value ) {
+	        return true
+	      }
+	    }
+
+	    return false
+
+	  }
+
+	  parse( value, offset ) {
+
+	    offset = offset || 0;
+	    value = offset ? value.slice( offset ) : value;
+
+	    // Trim & unfold folded lines
+	    value = trim( value ).replace( WS_FOLD_PATTERN, '' );
+
+	    var state = STATE.IDLE;
+	    var length = value.length;
+	    var offset = 0;
+	    var ref = null;
+
+	    while( offset < length ) {
+	      if( state === STATE.IDLE ) {
+	        if( hasWhitespace( value[offset] ) ) {
+	          offset++;
+	          continue
+	        } else if( value[offset] === '<' ) {
+	          if( ref != null ) {
+	            ref.rel != null ?
+	              this.refs.push( ...Link.expandRelations( ref ) ) :
+	              this.refs.push( ref );
+	          }
+	          var end = value.indexOf( '>', offset );
+	          if( end === -1 ) throw new Error( 'Expected end of URI delimiter at offset ' + offset )
+	          ref = { uri: value.slice( offset + 1, end ) };
+	          // this.refs.push( ref )
+	          offset = end;
+	          state = STATE.URI;
+	        } else {
+	          throw new Error( 'Unexpected character "' + value[offset] + '" at offset ' + offset )
+	        }
+	        offset++;
+	      } else if( state === STATE.URI ) {
+	        if( hasWhitespace( value[offset] ) ) {
+	          offset++;
+	          continue
+	        } else if( value[offset] === ';' ) {
+	          state = STATE.ATTR;
+	          offset++;
+	        } else if( value[offset] === ',' ) {
+	          state = STATE.IDLE;
+	          offset++;
+	        } else {
+	          throw new Error( 'Unexpected character "' + value[offset] + '" at offset ' + offset )
+	        }
+	      } else if( state === STATE.ATTR ) {
+	        if( value[offset] ===';' || hasWhitespace( value[offset] ) ) {
+	          offset++;
+	          continue
+	        }
+	        var end = value.indexOf( '=', offset );
+	        if( end === -1 ) end = value.indexOf( ';', offset );
+	        if( end === -1 ) end = value.length;
+	        var attr = trim( value.slice( offset, end ) ).toLowerCase();
+	        var attrValue = '';
+	        offset = end + 1;
+	        offset = skipWhitespace( value, offset );
+	        if( value[offset] === '"' ) {
+	          offset++;
+	          while( offset < length ) {
+	            if( value[offset] === '"' ) {
+	              offset++; break
+	            }
+	            if( value[offset] === '\\' ) {
+	              offset++;
+	            }
+	            attrValue += value[offset];
+	            offset++;
+	          }
+	        } else {
+	          var end = offset + 1;
+	          while( !DELIMITER_PATTERN.test( value[end] ) && end < length ) {
+	            end++;
+	          }
+	          attrValue = value.slice( offset, end );
+	          offset = end;
+	        }
+	        if( ref[ attr ] && Link.isSingleOccurenceAttr( attr ) ) ; else if( attr[ attr.length - 1 ] === '*' ) {
+	          ref[ attr ] = Link.parseExtendedValue( attrValue );
+	        } else {
+	          attrValue = attr === 'type' ?
+	            attrValue.toLowerCase() : attrValue;
+	          if( ref[ attr ] != null ) {
+	            if( Array.isArray( ref[ attr ] ) ) {
+	              ref[ attr ].push( attrValue );
+	            } else {
+	              ref[ attr ] = [ ref[ attr ], attrValue ];
+	            }
+	          } else {
+	            ref[ attr ] = attrValue;
+	          }
+	        }
+	        switch( value[offset] ) {
+	          case ',': state = STATE.IDLE; break
+	          case ';': state = STATE.ATTR; break
+	        }
+	        offset++;
+	      } else {
+	        throw new Error( 'Unknown parser state "' + state + '"' )
+	      }
+	    }
+
+	    if( ref != null ) {
+	      ref.rel != null ?
+	        this.refs.push( ...Link.expandRelations( ref ) ) :
+	        this.refs.push( ref );
+	    }
+
+	    ref = null;
+
+	    return this
+
+	  }
+
+	  toString() {
+
+	    var refs = [];
+	    var link = '';
+	    var ref = null;
+
+	    for( var i = 0; i < this.refs.length; i++ ) {
+	      ref = this.refs[i];
+	      link = Object.keys( this.refs[i] ).reduce( function( link, attr ) {
+	        if( attr === 'uri' ) return link
+	        return link + '; ' + Link.formatAttribute( attr, ref[ attr ] )
+	      }, '<' + ref.uri + '>' );
+	      refs.push( link );
+	    }
+
+	    return refs.join( ', ' )
+
+	  }
 
-    if( !this.refs.some(( ref ) => shallowCompareObjects( ref, link )) ) {
-      this.refs.push( link );
-    }
+	}
 
-    return this
+	/**
+	 * Determines whether an encoding can be
+	 * natively handled with a `Buffer`
+	 * @param {String} value
+	 * @returns {Boolean}
+	 */
+	Link.isCompatibleEncoding = function( value ) {
+	  return COMPATIBLE_ENCODING_PATTERN.test( value )
+	};
 
-  }
+	Link.parse = function( value, offset ) {
+	  return new Link().parse( value, offset )
+	};
 
-  has( attr, value ) {
+	Link.isSingleOccurenceAttr = function( attr ) {
+	  return attr === 'rel' || attr === 'type' || attr === 'media' ||
+	    attr === 'title' || attr === 'title*'
+	};
 
-    attr = attr.toLowerCase();
-    value = value.toLowerCase();
+	Link.isTokenAttr = function( attr ) {
+	  return attr === 'rel' || attr === 'type' || attr === 'anchor'
+	};
 
-    for( var i = 0; i < this.refs.length; i++ ) {
-      if( typeof this.refs[ i ][ attr ] === 'string' && this.refs[ i ][ attr ].toLowerCase() === value ) {
-        return true
-      }
-    }
+	Link.escapeQuotes = function( value ) {
+	  return value.replace( /"/g, '\\"' )
+	};
 
-    return false
-
-  }
-
-  parse( value, offset ) {
-
-    offset = offset || 0;
-    value = offset ? value.slice( offset ) : value;
-
-    // Trim & unfold folded lines
-    value = trim( value ).replace( WS_FOLD_PATTERN, '' );
-
-    var state = STATE.IDLE;
-    var length = value.length;
-    var offset = 0;
-    var ref = null;
-
-    while( offset < length ) {
-      if( state === STATE.IDLE ) {
-        if( hasWhitespace( value[offset] ) ) {
-          offset++;
-          continue
-        } else if( value[offset] === '<' ) {
-          if( ref != null ) {
-            ref.rel != null ?
-              this.refs.push( ...Link.expandRelations( ref ) ) :
-              this.refs.push( ref );
-          }
-          var end = value.indexOf( '>', offset );
-          if( end === -1 ) throw new Error( 'Expected end of URI delimiter at offset ' + offset )
-          ref = { uri: value.slice( offset + 1, end ) };
-          // this.refs.push( ref )
-          offset = end;
-          state = STATE.URI;
-        } else {
-          throw new Error( 'Unexpected character "' + value[offset] + '" at offset ' + offset )
-        }
-        offset++;
-      } else if( state === STATE.URI ) {
-        if( hasWhitespace( value[offset] ) ) {
-          offset++;
-          continue
-        } else if( value[offset] === ';' ) {
-          state = STATE.ATTR;
-          offset++;
-        } else if( value[offset] === ',' ) {
-          state = STATE.IDLE;
-          offset++;
-        } else {
-          throw new Error( 'Unexpected character "' + value[offset] + '" at offset ' + offset )
-        }
-      } else if( state === STATE.ATTR ) {
-        if( value[offset] ===';' || hasWhitespace( value[offset] ) ) {
-          offset++;
-          continue
-        }
-        var end = value.indexOf( '=', offset );
-        if( end === -1 ) end = value.indexOf( ';', offset );
-        if( end === -1 ) end = value.length;
-        var attr = trim( value.slice( offset, end ) ).toLowerCase();
-        var attrValue = '';
-        offset = end + 1;
-        offset = skipWhitespace( value, offset );
-        if( value[offset] === '"' ) {
-          offset++;
-          while( offset < length ) {
-            if( value[offset] === '"' ) {
-              offset++; break
-            }
-            if( value[offset] === '\\' ) {
-              offset++;
-            }
-            attrValue += value[offset];
-            offset++;
-          }
-        } else {
-          var end = offset + 1;
-          while( !DELIMITER_PATTERN.test( value[end] ) && end < length ) {
-            end++;
-          }
-          attrValue = value.slice( offset, end );
-          offset = end;
-        }
-        if( ref[ attr ] && Link.isSingleOccurenceAttr( attr ) ) ; else if( attr[ attr.length - 1 ] === '*' ) {
-          ref[ attr ] = Link.parseExtendedValue( attrValue );
-        } else {
-          attrValue = attr === 'type' ?
-            attrValue.toLowerCase() : attrValue;
-          if( ref[ attr ] != null ) {
-            if( Array.isArray( ref[ attr ] ) ) {
-              ref[ attr ].push( attrValue );
-            } else {
-              ref[ attr ] = [ ref[ attr ], attrValue ];
-            }
-          } else {
-            ref[ attr ] = attrValue;
-          }
-        }
-        switch( value[offset] ) {
-          case ',': state = STATE.IDLE; break
-          case ';': state = STATE.ATTR; break
-        }
-        offset++;
-      } else {
-        throw new Error( 'Unknown parser state "' + state + '"' )
-      }
-    }
+	Link.expandRelations = function( ref ) {
+	  var rels = ref.rel.split( ' ' );
+	  return rels.map( function( rel ) {
+	    var value = Object.assign( {}, ref );
+	    value.rel = rel;
+	    return value
+	  })
+	};
 
-    if( ref != null ) {
-      ref.rel != null ?
-        this.refs.push( ...Link.expandRelations( ref ) ) :
-        this.refs.push( ref );
-    }
+	/**
+	 * Parses an extended value and attempts to decode it
+	 * @internal
+	 * @param {String} value
+	 * @return {Object}
+	 */
+	Link.parseExtendedValue = function( value ) {
+	  var parts = /([^']+)?(?:'([^']*)')?(.+)/.exec( value );
+	  return {
+	    language: parts[2].toLowerCase(),
+	    encoding: Link.isCompatibleEncoding( parts[1] ) ?
+	      null : parts[1].toLowerCase(),
+	    value: Link.isCompatibleEncoding( parts[1] ) ?
+	      decodeURIComponent( parts[3] ) : parts[3]
+	  }
+	};
 
-    ref = null;
+	/**
+	 * Format a given extended attribute and it's value
+	 * @param {String} attr
+	 * @param {Object} data
+	 * @return {String}
+	 */
+	Link.formatExtendedAttribute = function( attr, data ) {
 
-    return this
+	  var encoding = ( data.encoding || 'utf-8' ).toUpperCase();
+	  var language = data.language || 'en';
 
-  }
+	  var encodedValue = '';
 
-  toString() {
+	  if( Buffer.isBuffer( data.value ) && Link.isCompatibleEncoding( encoding ) ) {
+	    encodedValue = data.value.toString( encoding );
+	  } else if( Buffer.isBuffer( data.value ) ) {
+	    encodedValue = data.value.toString( 'hex' )
+	      .replace( /[0-9a-f]{2}/gi, '%$1' );
+	  } else {
+	    encodedValue = encodeURIComponent( data.value );
+	  }
 
-    var refs = [];
-    var link = '';
-    var ref = null;
+	  return attr + '=' + encoding + '\'' +
+	    language + '\'' + encodedValue
 
-    for( var i = 0; i < this.refs.length; i++ ) {
-      ref = this.refs[i];
-      link = Object.keys( this.refs[i] ).reduce( function( link, attr ) {
-        if( attr === 'uri' ) return link
-        return link + '; ' + Link.formatAttribute( attr, ref[ attr ] )
-      }, '<' + ref.uri + '>' );
-      refs.push( link );
-    }
+	};
 
-    return refs.join( ', ' )
+	/**
+	 * Format a given attribute and it's value
+	 * @param {String} attr
+	 * @param {String|Object} value
+	 * @return {String}
+	 */
+	Link.formatAttribute = function( attr, value ) {
+
+	  if( Array.isArray( value ) ) {
+	    return value.map(( item ) => {
+	      return Link.formatAttribute( attr, item )
+	    }).join( '; ' )
+	  }
+
+	  if( attr[ attr.length - 1 ] === '*' || typeof value !== 'string' ) {
+	    return Link.formatExtendedAttribute( attr, value )
+	  }
+
+	  if( Link.isTokenAttr( attr ) ) {
+	    value = needsQuotes( value ) ?
+	      '"' + Link.escapeQuotes( value ) + '"' :
+	      Link.escapeQuotes( value );
+	  } else if( needsQuotes( value ) ) {
+	    value = encodeURIComponent( value );
+	    // We don't need to escape <SP> <,> <;> within quotes
+	    value = value
+	      .replace( /%20/g, ' ' )
+	      .replace( /%2C/g, ',' )
+	      .replace( /%3B/g, ';' );
+
+	    value = '"' + value + '"';
+	  }
+
+	  return attr + '=' + value
 
-  }
+	};
 
+	link = Link;
+	return link;
 }
 
-/**
- * Determines whether an encoding can be
- * natively handled with a `Buffer`
- * @param {String} value
- * @returns {Boolean}
- */
-Link.isCompatibleEncoding = function( value ) {
-  return COMPATIBLE_ENCODING_PATTERN.test( value )
-};
-
-Link.parse = function( value, offset ) {
-  return new Link().parse( value, offset )
-};
-
-Link.isSingleOccurenceAttr = function( attr ) {
-  return attr === 'rel' || attr === 'type' || attr === 'media' ||
-    attr === 'title' || attr === 'title*'
-};
-
-Link.isTokenAttr = function( attr ) {
-  return attr === 'rel' || attr === 'type' || attr === 'anchor'
-};
-
-Link.escapeQuotes = function( value ) {
-  return value.replace( /"/g, '\\"' )
-};
-
-Link.expandRelations = function( ref ) {
-  var rels = ref.rel.split( ' ' );
-  return rels.map( function( rel ) {
-    var value = Object.assign( {}, ref );
-    value.rel = rel;
-    return value
-  })
-};
-
-/**
- * Parses an extended value and attempts to decode it
- * @internal
- * @param {String} value
- * @return {Object}
- */
-Link.parseExtendedValue = function( value ) {
-  var parts = /([^']+)?(?:'([^']*)')?(.+)/.exec( value );
-  return {
-    language: parts[2].toLowerCase(),
-    encoding: Link.isCompatibleEncoding( parts[1] ) ?
-      null : parts[1].toLowerCase(),
-    value: Link.isCompatibleEncoding( parts[1] ) ?
-      decodeURIComponent( parts[3] ) : parts[3]
-  }
-};
-
-/**
- * Format a given extended attribute and it's value
- * @param {String} attr
- * @param {Object} data
- * @return {String}
- */
-Link.formatExtendedAttribute = function( attr, data ) {
-
-  var encoding = ( data.encoding || 'utf-8' ).toUpperCase();
-  var language = data.language || 'en';
-
-  var encodedValue = '';
-
-  if( Buffer.isBuffer( data.value ) && Link.isCompatibleEncoding( encoding ) ) {
-    encodedValue = data.value.toString( encoding );
-  } else if( Buffer.isBuffer( data.value ) ) {
-    encodedValue = data.value.toString( 'hex' )
-      .replace( /[0-9a-f]{2}/gi, '%$1' );
-  } else {
-    encodedValue = encodeURIComponent( data.value );
-  }
-
-  return attr + '=' + encoding + '\'' +
-    language + '\'' + encodedValue
-
-};
-
-/**
- * Format a given attribute and it's value
- * @param {String} attr
- * @param {String|Object} value
- * @return {String}
- */
-Link.formatAttribute = function( attr, value ) {
-
-  if( Array.isArray( value ) ) {
-    return value.map(( item ) => {
-      return Link.formatAttribute( attr, item )
-    }).join( '; ' )
-  }
-
-  if( attr[ attr.length - 1 ] === '*' || typeof value !== 'string' ) {
-    return Link.formatExtendedAttribute( attr, value )
-  }
-
-  if( Link.isTokenAttr( attr ) ) {
-    value = needsQuotes( value ) ?
-      '"' + Link.escapeQuotes( value ) + '"' :
-      Link.escapeQuotes( value );
-  } else if( needsQuotes( value ) ) {
-    value = encodeURIComponent( value );
-    // We don't need to escape <SP> <,> <;> within quotes
-    value = value
-      .replace( /%20/g, ' ' )
-      .replace( /%2C/g, ',' )
-      .replace( /%3B/g, ';' );
-
-    value = '"' + value + '"';
-  }
-
-  return attr + '=' + value
-
-};
-
-var link = Link;
+var linkExports = requireLink();
+var LinkHeader = /*@__PURE__*/getDefaultExportFromCjs(linkExports);
 
 /**
  * @param response
@@ -1694,7 +1763,7 @@ function linkHeaderHandler(response, content, stopper) {
  */
 function parseHeader(linkHeader) {
     if (linkHeader) {
-        var links = link.parse(linkHeader);
+        var links = LinkHeader.parse(linkHeader);
         return links.refs.map(function (reference) {
             var rel = reference.rel, uri = reference.uri, method = reference.method, accept = reference["accept*"], parameters = reference["params*"], otherProperties = __rest(reference, ["rel", "uri", "method", 'accept*', 'params*']);
             var parsedParameters = (parameters === null || parameters === void 0 ? void 0 : parameters.value)
@@ -1882,7 +1951,7 @@ var WayChaserResponse = /** @class */ (function () {
         this.fullContent = fullContent || content;
         this.content = content;
         this.operations = OperationArray.create();
-        var thisContext = flat({ this: content });
+        var thisContext = flatten({ this: content });
         if (parentOperations && anchor && defaultOptions) {
             this.allOperations = parentOperations;
             try {
@@ -1957,7 +2026,7 @@ var WayChaserResponse = /** @class */ (function () {
      * @throws {WayChaserProblem}
      */
     WayChaserResponse.create = function (baseResponse, content, defaultOptions, mergedOptions) {
-        if (content instanceof ProblemDocument_1) {
+        if (content instanceof libExports.ProblemDocument) {
             throw new WayChaserProblem({
                 response: new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions: defaultOptions, baseResponse: baseResponse, content: content, parameters: mergedOptions.parameters }),
                 problem: content,
@@ -2253,12 +2322,12 @@ function _waychaser(uriOrRequest, defaultOptions, options) {
                 case 4:
                     error_1 = _l.sent();
                     response = new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions: defaultOptions, baseResponse: baseResponse, content: error_1, parameters: mergedOptions.parameters });
-                    wayChaserProblem = error_1 instanceof ProblemDocument_1 ? new WayChaserProblem({
+                    wayChaserProblem = error_1 instanceof libExports.ProblemDocument ? new WayChaserProblem({
                         response: response,
                         problem: error_1,
                     }) : new WayChaserProblem({
                         response: response,
-                        problem: new ProblemDocument_1({
+                        problem: new libExports.ProblemDocument({
                             type: "https://waychaser.io/unexected-error",
                             title: "An unexpected error occurred",
                             error: error_1
@@ -2312,7 +2381,7 @@ function tryParseJson(content, contentType) {
         return JSON.parse(content);
     }
     catch (error) {
-        throw new ProblemDocument_1({
+        throw new libExports.ProblemDocument({
             type: "https://waychaser.io/invalid-json",
             title: "JSON response could not be parsed",
             detail: "The response document with content type '".concat(contentType, "' could not be parsed as json"),
@@ -2348,7 +2417,7 @@ var wayChaserDefaults = {
                     if (contentType === null || contentType === void 0 ? void 0 : contentType.endsWith('json')) {
                         jsonContent = tryParseJson(content, contentType);
                         if (contentType === 'application/problem+json') {
-                            throw Object.assign(new ProblemDocument_1(jsonContent), jsonContent);
+                            throw Object.assign(new libExports.ProblemDocument(jsonContent), jsonContent);
                         }
                         else {
                             return [2 /*return*/, jsonContent];