@mountainpass/waychaser 4.0.38 → 5.0.2

package/dist/waychaser.es.js

@@ -0,0 +1,2331 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var uriTemplateLite = {};
+
+/**
+ * @version    20.5.0
+ * @author     Lauri Rooden <lauri@rooden.ee>
+ * @license    MIT License
+ */
+
+
+
+!function(URI) {
+
+	/**
+	 * URI Template
+	 * @see http://tools.ietf.org/html/rfc6570
+	 */
+
+	var RESERVED = /[!'()]/g
+	// /[[\]:\/!#$&()*+,;='?@]/g
+	, SEPARATORS = {"": ",", "+": ",", "#": ",", "?": "&"}
+	, escapeRe = /[$-\/?[-^{|}]/g
+	, expandRe = /\{([#&+.\/;?]?)((?:[-\w%.]+(\*|:\d+)?,?)+)\}/g
+	, parseRe  = RegExp(expandRe.source + "|.[^{]*?", "g");
+
+	/*** EXPAND ***/
+	function encodeNormal(val) {
+		return encodeURIComponent(val).replace(RESERVED, escape)
+	}
+
+	function notNull(s) {
+		return s != null
+	}
+
+	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 = 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);
+		/**/
+	};
+
+// `this` is `exports` in NodeJS and `window` in browser.
+}(commonjsGlobal.URI || (commonjsGlobal.URI = {}));
+
+/* 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
+  }
+}
+
+/**
+ *
+ */
+function getExtendedUri() {
+  const base = getUri();
+  base.parameters = function (url) {
+    const template = new URI.Template(url);
+    return template.match(url)
+  };
+  return base
+}
+
+
+const URI = getExtendedUri();
+
+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}
+ */
+
+var qsStringify = 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('&')
+};
+
+/* eslint-env browser */
+
+var browser = typeof self == 'object' ? self.FormData : window.FormData;
+
+// negotiated (https://www.npmjs.com/package/negotiated) doesn't working in IE 11 due to missing regex polyfill stuff
+/**
+ * @param {string} accept
+ */
+function parseAccept(accept) {
+    var entries = accept.split(',');
+    return entries
+        .map(function (entry) {
+        var e_1, _a;
+        var fields = entry.split(';');
+        var type = fields.shift();
+        var types = type === null || type === void 0 ? void 0 : type.split('/');
+        var parsedEntry = {
+            type: type,
+            parentType: types === null || types === void 0 ? void 0 : types[0],
+            subType: types === null || types === void 0 ? void 0 : types[1],
+            q: 1
+        };
+        try {
+            for (var fields_1 = __values(fields), fields_1_1 = fields_1.next(); !fields_1_1.done; fields_1_1 = fields_1.next()) {
+                var field = fields_1_1.value;
+                var parsedFields = field.split('=');
+                if (field[0] === 'q') {
+                    parsedEntry[parsedFields[0]] = Number.parseFloat(parsedFields[1]);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (fields_1_1 && !fields_1_1.done && (_a = fields_1.return)) _a.call(fields_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return parsedEntry;
+    })
+        .sort(function (first, second) {
+        // It is expected to return a negative value if first argument is less than second argument, zero if they're
+        // equal and a positive value otherwise
+        if (first.q > second.q) {
+            return -1;
+        }
+        else if (first.q < second.q) {
+            return 1;
+        }
+        else if (first.parentType === '*' && second.parentType !== '*') {
+            return 1;
+        }
+        else if (first.parentType !== '*' && second.parentType === '*') {
+            return -1;
+        }
+        else if (first.subType === '*' && second.subType !== '*') {
+            return 1;
+        }
+        else if (first.subType !== '*' && second.subType === '*') {
+            return -1;
+        }
+        else {
+            return 0;
+        }
+    })
+        .map(function (entry) {
+        return {
+            type: entry.type || ''
+        };
+    })
+        .filter(function (entry) { return entry.type !== ''; });
+}
+
+/**
+ * @param 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)
+      )
+    }
+  }, {});
+
+  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
+}
+
+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)
+}
+
+function untilde (str) {
+  if (!hasExcape.test(str)) return str
+  return str.replace(escapeMatcher, escapeReplacer)
+}
+
+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
+  }
+
+  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') 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 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;
+
+/**
+ * @param 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);
+    }
+}
+ProblemDocument_1 = lib.ProblemDocument = ProblemDocument;
+
+var Operation = /** @class */ (function () {
+    function Operation(_a) {
+        var rel = _a.rel, uri = _a.uri, method = _a.method, parameters = _a.parameters, accept = _a.accept, anchor = _a.anchor, otherProperties = __rest(_a, ["rel", "uri", "method", "parameters", "accept", "anchor"]);
+        this.rel = rel;
+        this.uri = uri;
+        this.method = method;
+        this.parameters = parameters || {};
+        this.accept = accept;
+        this.anchor = anchor;
+        Object.assign(this, otherProperties);
+    }
+    return Operation;
+}());
+var InvocableOperation = /** @class */ (function (_super) {
+    __extends(InvocableOperation, _super);
+    function InvocableOperation(operation, response, defaultOptions, thisContext) {
+        var _this = _super.call(this, operation) || this;
+        _this.response = response;
+        _this.defaultOptions = defaultOptions;
+        if (_this.uri.includes('{this.')) {
+            _this.uri = URI.expand(_this.uri, thisContext);
+        }
+        return _this;
+        // const pathParameters = URI.parameters(operation.uri)
+        // for (const key in pathParameters) {
+        //   this.parameters[key] = {}
+        // }
+    }
+    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));
+            if (validator) {
+                var validationResult = validator(fragmentContent);
+                if (isValidationSuccess(validationResult)) {
+                    return new WayChaserResponse({ defaultOptions: this.defaultOptions, baseResponse: this.response.response, content: validationResult.content, fullContent: this.response.fullContent, anchor: anchor, parentOperations: this.response.allOperations, parameters: parameters });
+                }
+                else {
+                    throw new WayChaserProblem({
+                        problem: validationResult.problem,
+                        response: new WayChaserResponse({ defaultOptions: this.defaultOptions, baseResponse: this.response.response, content: fragmentContent, fullContent: this.response.fullContent, parameters: parameters })
+                    });
+                }
+            }
+            else {
+                return new WayChaserResponse({ defaultOptions: this.defaultOptions, baseResponse: this.response.response, content: fragmentContent, fullContent: this.response.fullContent, anchor: anchor, parentOperations: this.response.allOperations, parameters: parameters });
+            }
+        }
+    };
+    InvocableOperation.prototype.invokeAll = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                if (this.uri.startsWith('#/') && this.response instanceof WayChaserResponse) {
+                    result = this.doInvokeAll((options === null || options === void 0 ? void 0 : options.parameters) || {});
+                    return [2 /*return*/, Promise.all(result)];
+                }
+                return [2 /*return*/, Promise.all([this.invoke(options)])];
+            });
+        });
+    };
+    InvocableOperation.prototype.doInvokeAll = function (parameters, validator) {
+        var _this = this;
+        var response = this.response;
+        // expand the URI with whatever parameters have been passed in
+        var template = new URI.Template(this.uri);
+        var uriParameters = Object.assign(URI.parameters(this.uri), parameters);
+        var currentUri = template.expand(uriParameters).replace(/%7B/g, "{").replace(/%7D/g, "}");
+        // get unfilled parameters
+        var currentUriParameters = URI.parameters(currentUri);
+        var keys = Object.keys(currentUriParameters);
+        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);
+            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) {
+                    var _a;
+                    var extendedParameters = Object.assign({}, parameters, (_a = {}, _a[keys[0]] = index, _a));
+                    return _this.doInvokeAll(extendedParameters, validator);
+                });
+            }
+            else {
+                throw new WayChaserProblem({
+                    response: this.response,
+                    problem: new ProblemDocument_1({
+                        type: "https://waychaser.io/fragment-uri-error",
+                        title: "The fragment URI does not match the content structure",
+                        uri: parentUri, content: response.content,
+                        parameters: parameters
+                    }),
+                });
+            }
+        }
+        return [this.invokeAsFragment(parameters, validator)];
+    };
+    InvocableOperation.prototype.invoke = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fragment, parameterSpecs, parameters, invokeUrl, body, parameterSpecs_1, parameterSpecs_1_1, key, _a, _b, key, encodedContent, headers, requestOptions, contentType, name_1;
+            var e_1, _c, e_2, _d;
+            return __generator(this, function (_e) {
+                fragment = this.invokeAsFragment(options === null || options === void 0 ? void 0 : options.parameters);
+                if (fragment) {
+                    return [2 /*return*/, fragment];
+                }
+                parameterSpecs = this.parameters || {};
+                parameters = Object.assign({}, this.defaultOptions.parameters, options === null || options === void 0 ? void 0 : options.parameters);
+                invokeUrl = this.url(parameters);
+                body = {};
+                /* istanbul ignore if reason: TODO */
+                if (Array.isArray(parameterSpecs)) {
+                    try {
+                        for (parameterSpecs_1 = __values(parameterSpecs), parameterSpecs_1_1 = parameterSpecs_1.next(); !parameterSpecs_1_1.done; parameterSpecs_1_1 = parameterSpecs_1.next()) {
+                            key = parameterSpecs_1_1.value;
+                            body[key] = parameters === null || parameters === void 0 ? void 0 : parameters[key];
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (parameterSpecs_1_1 && !parameterSpecs_1_1.done && (_c = parameterSpecs_1.return)) _c.call(parameterSpecs_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+                else {
+                    try {
+                        for (_a = __values(Object.keys(parameterSpecs)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                            key = _b.value;
+                            body[key] = parameters === null || parameters === void 0 ? void 0 : parameters[key];
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+                headers = {};
+                requestOptions = Object.assign({}, options);
+                requestOptions.method = this.method;
+                if (Object.keys(this.parameters).length !== 0 && methodCanHaveBody(this.method || 'GET')) {
+                    contentType = preferredContentType(this.accept, [
+                        'application/x-www-form-urlencoded',
+                        'application/json',
+                        'multipart/form-data'
+                    ], 'application/x-www-form-urlencoded');
+                    switch (contentType) {
+                        case 'application/x-www-form-urlencoded':
+                            encodedContent = qsStringify(body);
+                            break;
+                        case 'application/json':
+                            encodedContent = JSON.stringify(body);
+                            break;
+                        case 'multipart/form-data':
+                            encodedContent = new browser();
+                            for (name_1 in body) {
+                                encodedContent.append(name_1, body[name_1]);
+                            }
+                            break;
+                    }
+                    if (contentType !== 'multipart/form-data') {
+                        headers = {
+                            'content-type': contentType
+                        };
+                    }
+                    // else fetch adds the right content-type header for us
+                    // with the boundaries
+                    requestOptions.body = encodedContent;
+                    requestOptions.headers = Object.assign(headers, options === null || options === void 0 ? void 0 : options.headers);
+                }
+                return [2 /*return*/, _waychaser(invokeUrl.toString(), this.defaultOptions, requestOptions)];
+            });
+        });
+    };
+    InvocableOperation.prototype.url = function (parameters) {
+        var expandedUri = this.expandUrl(parameters);
+        var invokeUrl = new URL(expandedUri, this.response.url);
+        return invokeUrl;
+    };
+    InvocableOperation.prototype.expandUrl = function (parameters) {
+        return URI.expand(this.uri, flat(parameters || {}));
+    };
+    return InvocableOperation;
+}(Operation));
+
+// const foo: Array<InvocableOperation> = []
+// foo.filter())
+var OperationArray = /** @class */ (function (_super) {
+    __extends(OperationArray, _super);
+    function OperationArray(items) {
+        return _super.apply(this, __spreadArray([], __read((items || [])), false)) || this;
+    }
+    OperationArray.create = function () {
+        return Object.create(OperationArray.prototype);
+    };
+    OperationArray.prototype.find = function (query, thisArgument) {
+        var finder = Array.prototype.find.bind(this);
+        if (typeof query === 'string') {
+            return finder(objectFinder({ rel: query }), thisArgument);
+        }
+        else if (typeof query === 'object') {
+            return finder(objectFinder(query), thisArgument);
+        }
+        else {
+            return finder(query, thisArgument);
+        }
+    };
+    OperationArray.prototype.filter = function (query, thisArgument) {
+        if (typeof query === 'string') {
+            return this.filter({ rel: query }, thisArgument);
+        }
+        else if (typeof query === 'object') {
+            return this.filter(objectFinder(query), thisArgument);
+        }
+        else {
+            var filtered = Array.prototype.filter.bind(this)(query);
+            Object.setPrototypeOf(filtered, OperationArray.prototype);
+            return filtered;
+        }
+    };
+    OperationArray.prototype.invoke = function (relationship, options) {
+        var operation = this.find(relationship);
+        return operation ? operation.invoke(options) : undefined;
+    };
+    OperationArray.prototype.invokeAll = function (relationship, options) {
+        return Promise.all(this.filter(relationship).map(function (operation) {
+            return operation.invokeAll(options);
+        })).then(function (arrayOfArrays) {
+            var flat = arrayOfArrays.flat();
+            return flat;
+        });
+    };
+    return OperationArray;
+}(Array));
+// ideally we'd just subclass Array, and that works most of the time, BUT sometimes in firefox, instead of it
+// giving us an ObjectArray, we get a plain old Array, without our invoke method or customised find method.
+// FU JavaScript, FU.
+/**
+ * @param query
+ */
+function objectFinder(query) {
+    return function (o) {
+        for (var key in query) {
+            if (query[key] !== o[key]) {
+                return false;
+            }
+        }
+        return true;
+    };
+}
+
+/**
+ * @param operation
+ */
+function expandOperation(operation) {
+    var e_1, _a, e_2, _b;
+    var expandedOperations = [];
+    var rangeRegex = /{\[(\d+)..(\d+)]}/;
+    var originalUrl = operation.uri.toString();
+    var matches = originalUrl.match(rangeRegex);
+    if (matches) {
+        for (var index = Number.parseInt(matches[1]); index <= Number.parseInt(matches[2]); ++index) {
+            var newOp = new Operation(Object.assign(operation, {
+                uri: originalUrl.replace(rangeRegex, index.toFixed(0))
+            }));
+            var thisExpandedOperations = expandOperation(newOp);
+            try {
+                for (var thisExpandedOperations_1 = (e_1 = void 0, __values(thisExpandedOperations)), thisExpandedOperations_1_1 = thisExpandedOperations_1.next(); !thisExpandedOperations_1_1.done; thisExpandedOperations_1_1 = thisExpandedOperations_1.next()) {
+                    var operation_1 = thisExpandedOperations_1_1.value;
+                    expandedOperations.push(operation_1);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (thisExpandedOperations_1_1 && !thisExpandedOperations_1_1.done && (_a = thisExpandedOperations_1.return)) _a.call(thisExpandedOperations_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+    }
+    else {
+        var originalAnchor = operation.anchor;
+        var anchorMatches = originalAnchor === null || originalAnchor === void 0 ? void 0 : originalAnchor.match(rangeRegex);
+        if (originalAnchor &&
+            anchorMatches) {
+            for (var index = Number.parseInt(anchorMatches[1]); index <= Number.parseInt(anchorMatches[2]); ++index) {
+                var newOp = new Operation(Object.assign(operation, {
+                    anchor: originalAnchor.replace(rangeRegex, index.toFixed(0))
+                }));
+                var thisExpandedOperations = expandOperation(newOp);
+                try {
+                    for (var thisExpandedOperations_2 = (e_2 = void 0, __values(thisExpandedOperations)), thisExpandedOperations_2_1 = thisExpandedOperations_2.next(); !thisExpandedOperations_2_1.done; thisExpandedOperations_2_1 = thisExpandedOperations_2.next()) {
+                        var operation_2 = thisExpandedOperations_2_1.value;
+                        expandedOperations.push(operation_2);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (thisExpandedOperations_2_1 && !thisExpandedOperations_2_1.done && (_b = thisExpandedOperations_2.return)) _b.call(thisExpandedOperations_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+        }
+        else {
+            expandedOperations.push(operation);
+        }
+    }
+    return expandedOperations;
+}
+
+/**
+ * @param root0
+ * @param root0.handlers
+ * @param root0.response
+ * @param root0.baseResponse
+ * @param root0.content
+ */
+function parseOperations(_a) {
+    var e_1, _b, e_2, _c, e_3, _d, e_4, _e;
+    var handlers = _a.handlers, baseResponse = _a.baseResponse, content = _a.content;
+    var operations = [];
+    var stop = false;
+    try {
+        for (var handlers_1 = __values(handlers), handlers_1_1 = handlers_1.next(); !handlers_1_1.done; handlers_1_1 = handlers_1.next()) {
+            var handler = handlers_1_1.value;
+            // TODO only call handers for the current media type
+            var handledOperations = handler.handler(baseResponse, content, function () {
+                stop = true;
+            });
+            if (handledOperations) {
+                try {
+                    for (var handledOperations_1 = (e_2 = void 0, __values(handledOperations)), handledOperations_1_1 = handledOperations_1.next(); !handledOperations_1_1.done; handledOperations_1_1 = handledOperations_1.next()) {
+                        var operation = handledOperations_1_1.value;
+                        operations.push(operation);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (handledOperations_1_1 && !handledOperations_1_1.done && (_c = handledOperations_1.return)) _c.call(handledOperations_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            if (stop) {
+                break;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (handlers_1_1 && !handlers_1_1.done && (_b = handlers_1.return)) _b.call(handlers_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var expandedOperations = {};
+    try {
+        for (var operations_1 = __values(operations), operations_1_1 = operations_1.next(); !operations_1_1.done; operations_1_1 = operations_1.next()) {
+            var operation = operations_1_1.value;
+            var expanded = expandOperation(operation);
+            try {
+                for (var expanded_1 = (e_4 = void 0, __values(expanded)), expanded_1_1 = expanded_1.next(); !expanded_1_1.done; expanded_1_1 = expanded_1.next()) {
+                    var operation_1 = expanded_1_1.value;
+                    var anchor = operation_1.anchor || '';
+                    expandedOperations[anchor] || (expandedOperations[anchor] = []);
+                    expandedOperations[anchor].push(operation_1);
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (expanded_1_1 && !expanded_1_1.done && (_e = expanded_1.return)) _e.call(expanded_1);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (operations_1_1 && !operations_1_1.done && (_d = operations_1.return)) _d.call(operations_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return expandedOperations;
+}
+
+const 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
+  }
+}
+
+/**
+ * @param relationship
+ * @param link
+ * @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 })
+}
+
+/**
+ * @param response
+ * @param content
+ */
+function halHandler(response, content) {
+    var e_1, _a, e_2, _b, e_3, _c;
+    var _d;
+    var operations = [];
+    var contentType = (_d = response.headers.get('content-type')) === null || _d === void 0 ? void 0 : _d.split(';');
+    if ((contentType === null || contentType === void 0 ? void 0 : contentType[0]) === MediaTypes.HAL &&
+        content &&
+        typeof content === 'object' &&
+        '_links' in content) {
+        var body = content;
+        // if there are curies in the Hal Links, we need to load them first, so we can expand them wherever they are used
+        // we also want to convert them to a map, for easy lookup
+        var curies = {};
+        if (body._links.curies) {
+            if (Array.isArray(body._links.curies)) {
+                try {
+                    for (var _e = __values(body._links.curies), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var curie = _f.value;
+                        curies[curie.name] = curie.href;
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            else {
+                curies[body._links.curies.name] = body._links.curies.href;
+            }
+        }
+        try {
+            for (var _g = __values(Object.keys(body._links).filter(function (relationship) { return relationship !== 'curies'; })), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var key = _h.value;
+                if (Array.isArray(body._links[key])) {
+                    try {
+                        for (var _j = (e_3 = void 0, __values(body._links[key])), _k = _j.next(); !_k.done; _k = _j.next()) {
+                            var link = _k.value;
+                            operations.push(mapHalLinkToOperation(key, link, curies));
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                }
+                else {
+                    operations.push(mapHalLinkToOperation(key, body._links[key], curies));
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    }
+    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 )
+}
+
+class Link {
+
+  /**
+   * Link
+   * @constructor
+   * @param {String} [value]
+   * @returns {Link}
+   */
+  constructor( value ) {
+
+    /** @type {Array} URI references */
+    this.refs = [];
+
+    if( value ) {
+      this.parse( value );
+    }
+
+  }
+
+  /**
+   * Get refs with given relation type
+   * @param {String} value
+   * @returns {Array<Object>}
+   */
+  rel( value ) {
+
+    var links = [];
+    var type = value.toLowerCase();
+
+    for( var i = 0; i < this.refs.length; i++ ) {
+      if( 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();
+
+    var links = [];
+
+    for( var i = 0; i < this.refs.length; i++ ) {
+      if( this.refs[ i ][ attr ] === value ) {
+        links.push( this.refs[ i ] );
+      }
+    }
+
+    return links
+
+  }
+
+  set( link ) {
+    this.refs.push( link );
+    return this
+  }
+
+  has( attr, value ) {
+
+    attr = attr.toLowerCase();
+
+    for( var i = 0; i < this.refs.length; i++ ) {
+      if( this.refs[ i ][ attr ] === 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 ) throw new Error( 'Expected attribute delimiter at offset ' + offset )
+        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( ', ' )
+
+  }
+
+}
+
+/**
+ * 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;
+
+/**
+ * @param response
+ * @param content
+ * @param stopper
+ */
+function linkHeaderHandler(response, content, stopper) {
+    return __spreadArray(__spreadArray([], __read(parseHeader(response.headers.get('link'))), false), __read(parseHeader(response.headers.get('link-template'))), false);
+}
+/**
+ * @param linkHeader
+ */
+function parseHeader(linkHeader) {
+    if (linkHeader) {
+        var links = link.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)
+                ? JSON.parse(parameters === null || parameters === void 0 ? void 0 : parameters.value)
+                : undefined;
+            return new Operation(__assign({ rel: rel, uri: uri, method: method, parameters: parsedParameters, accept: accept === null || accept === void 0 ? void 0 : accept.value }, otherProperties));
+        });
+    }
+    else {
+        return [];
+    }
+}
+
+/**
+ * @param {object} action the siren action to map
+ * @returns {object} the link objection that the @{param action} maps to
+ */
+function mapSirenActionToOperation(action) {
+    var e_1, _a;
+    var name = action.name, href = action.href, fields = action.fields, type = action.type, otherProperties = __rest(action, ["name", "href", "fields", "type"]);
+    var bodyParameters = {};
+    if (fields) {
+        try {
+            for (var fields_1 = __values(fields), fields_1_1 = fields_1.next(); !fields_1_1.done; fields_1_1 = fields_1.next()) {
+                var parameter = fields_1_1.value;
+                bodyParameters[parameter.name] = {};
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (fields_1_1 && !fields_1_1.done && (_a = fields_1.return)) _a.call(fields_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    return __assign({ rel: name, uri: href, accept: type, parameters: fields && bodyParameters }, otherProperties);
+}
+
+/**
+ * @param content
+ */
+function sirenActionHandler(content) {
+    var e_1, _a;
+    var operations = [];
+    if (content &&
+        typeof content === 'object' &&
+        'actions' in content) {
+        var body = content;
+        if (body.actions) {
+            try {
+                for (var _b = __values(body.actions), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var action = _c.value;
+                    var operation = mapSirenActionToOperation(action);
+                    operations.push(operation);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+    }
+    return operations;
+}
+
+/**
+ * @param relationship
+ * @param link
+ */
+/**
+ * @param relationship
+ * @param link
+ */
+function mapSirenLinkToOperation(relationship, link) {
+    // we don't need to copy `rel` across, because we already have that from the {@param relationship}.
+    // Also `rel` in `link` is an array, which is not what we're after.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var href = link.href; link.rel; var otherProperties = __rest(link, ["href", "rel"]);
+    return new Operation(__assign({ rel: relationship, uri: href }, otherProperties));
+}
+
+/**
+ * @param response
+ * @param content
+ */
+function sirenLinkHandler(content) {
+    var e_1, _a, e_2, _b;
+    var operations = [];
+    if (content &&
+        typeof content === 'object' &&
+        'links' in content) {
+        var body = content;
+        if (body.links) {
+            try {
+                for (var _c = __values(body.links), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var link = _d.value;
+                    try {
+                        for (var _e = (e_2 = void 0, __values(link.rel)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var relationship = _f.value;
+                            var mappedLink = mapSirenLinkToOperation(relationship, link);
+                            operations.push(mappedLink);
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+    }
+    return operations;
+}
+
+/**
+ * @param response
+ * @param content
+ */
+function sirenHandler(response, content) {
+    var _a;
+    var contentType = (_a = response.headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.split(';');
+    if ((contentType === null || contentType === void 0 ? void 0 : contentType[0]) === MediaTypes.SIREN) {
+        return __spreadArray(__spreadArray([], __read((sirenLinkHandler(content))), false), __read((sirenActionHandler(content))), false);
+    }
+    return [];
+}
+
+/**
+ * @param response
+ */
+function locationHeaderHandler(response) {
+    var locationHeader = response === null || response === void 0 ? void 0 : response.headers.get('location');
+    if (locationHeader) {
+        return [new Operation({ rel: 'related', uri: locationHeader })];
+    }
+    return [];
+}
+
+/**
+ * @param baseOptions
+ * @param additionalOptions
+ */
+function augmentOptions(baseOptions, additionalOptions) {
+    var baseHandlers = baseOptions.handlers, baseDefaultHandlers = baseOptions.defaultHandlers, baseHeaders = baseOptions.headers, baseOther = __rest(baseOptions, ["handlers", "defaultHandlers", "headers"]);
+    var _a = additionalOptions || {}, additionalHandlers = _a.handlers, additionalDefaultHandlers = _a.defaultHandlers, additionalHeaders = _a.headers, additionalOther = __rest(_a, ["handlers", "defaultHandlers", "headers"]);
+    // if additional has default, don't use base default
+    // if additional has handlers, don;'t use base handlers
+    // augment({ dh: [XXX] }, { h: [YYY] }) => { h: [], dh: [YYY, XXX] }
+    // augment({ dh: [XXX] }, { h: [YYY], dh: [] }) => { h: [], dh: [YYY] }
+    // augment({ dh: [YYY, XXX] }, { h: [ZZZ] }) => { h: [], dh: [ZZZ, YYY, XXX] }
+    // augment({ dh: [YYY, XXX] }, { h: [ZZZ], dh: [] }) => { h: [], dh: [ZZZ] }
+    var mergedHandlers = sortHandlers(__spreadArray(__spreadArray([], __read((additionalHandlers || baseHandlers || [])), false), __read((additionalDefaultHandlers || baseDefaultHandlers || [])), false));
+    var finalOptions = __assign(__assign(__assign({}, baseOther), additionalOther), { defaultHandlers: mergedHandlers, handlers: [], headers: __assign(__assign({}, baseHeaders), additionalHeaders) });
+    return finalOptions;
+}
+
+var _a, _b;
+/**
+ * @param result
+ */
+function isValidationSuccess(result) {
+    return result.success;
+}
+var WayChaserResponse = /** @class */ (function () {
+    function WayChaserResponse(_a) {
+        var e_1, _b, e_2, _c, e_3, _d;
+        var handlers = _a.handlers, defaultOptions = _a.defaultOptions, baseResponse = _a.baseResponse, content = _a.content, fullContent = _a.fullContent, anchor = _a.anchor, parentOperations = _a.parentOperations, parameters = _a.parameters;
+        this.response = baseResponse;
+        this.anchor = anchor;
+        this.parameters = parameters || {};
+        this.fullContent = fullContent || content;
+        this.content = content;
+        this.operations = OperationArray.create();
+        var thisContext = flat({ this: content });
+        if (parentOperations && anchor && defaultOptions) {
+            this.allOperations = parentOperations;
+            try {
+                for (var _e = __values(this.allOperations[anchor] || []), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var operation = _f.value;
+                    this.operations.push(new InvocableOperation(operation, this, defaultOptions, thisContext));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            // not only do we need to go through the operations with a matching anchor
+            // we also need to go though anchors that could match this.anchor
+            for (var key in this.allOperations) {
+                if (key !== '') {
+                    // need to see if key could match this.anchor
+                    var template = new URI.Template(key);
+                    var parameters_1 = template.match(this.anchor);
+                    var expandedAnchor = template.expand(parameters_1);
+                    if (expandedAnchor === this.anchor) {
+                        var expandedOptions = Object.assign({}, defaultOptions, { parameters: Object.assign(parameters_1, defaultOptions.parameters) });
+                        try {
+                            for (var _g = (e_2 = void 0, __values(this.allOperations[key])), _h = _g.next(); !_h.done; _h = _g.next()) {
+                                var operation = _h.value;
+                                this.operations.push(new InvocableOperation(operation, this, expandedOptions, thisContext));
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_h && !_h.done && (_c = _g.return)) _c.call(_g);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                    }
+                }
+            }
+        }
+        else if (baseResponse && handlers && defaultOptions) {
+            this.allOperations = parseOperations({
+                baseResponse: baseResponse,
+                content: content,
+                handlers: handlers
+            });
+            this.operations = OperationArray.create();
+            try {
+                for (var _j = __values(this.allOperations[''] || []), _k = _j.next(); !_k.done; _k = _j.next()) {
+                    var operation = _k.value;
+                    var op = new InvocableOperation(operation, this, defaultOptions, thisContext);
+                    this.operations.push(op);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_k && !_k.done && (_d = _j.return)) _d.call(_j);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        }
+    }
+    /**
+     * @param baseResponse
+     * @param content
+     * @param defaultOptions
+     * @param mergedOptions
+     * @returns
+     * @throws {WayChaserProblem}
+     */
+    WayChaserResponse.create = function (baseResponse, content, defaultOptions, mergedOptions) {
+        if (content instanceof ProblemDocument_1) {
+            throw new WayChaserProblem({
+                response: new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions: defaultOptions, baseResponse: baseResponse, content: content, parameters: mergedOptions.parameters }),
+                problem: content,
+            });
+        }
+        else {
+            if (mergedOptions.validator) {
+                var validationResult = mergedOptions.validator(content);
+                if (isValidationSuccess(validationResult)) {
+                    return new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions: defaultOptions, baseResponse: baseResponse, content: validationResult.content, parameters: mergedOptions.parameters });
+                }
+                else {
+                    throw new WayChaserProblem({
+                        response: new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions: defaultOptions, baseResponse: baseResponse, content: content, parameters: mergedOptions.parameters }),
+                        problem: validationResult.problem,
+                    });
+                }
+            }
+            else {
+                return new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions: defaultOptions, baseResponse: baseResponse, content: content, parameters: mergedOptions.parameters });
+            }
+        }
+    };
+    Object.defineProperty(WayChaserResponse.prototype, "ops", {
+        get: function () {
+            return this.operations;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    WayChaserResponse.prototype.invoke = function (relationship, options) {
+        return this.operations.invoke(relationship, options);
+    };
+    WayChaserResponse.prototype.invokeAll = function (relationship, options) {
+        return this.operations.invokeAll(relationship, options);
+    };
+    Object.defineProperty(WayChaserResponse.prototype, "body", {
+        get: function () {
+            throw new Error('Not Implemented. Use `.content` instead');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WayChaserResponse.prototype, "bodyUsed", {
+        get: function () {
+            return true;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WayChaserResponse.prototype, "headers", {
+        get: function () {
+            var _a;
+            return (_a = this.response) === null || _a === void 0 ? void 0 : _a.headers;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WayChaserResponse.prototype, "ok", {
+        get: function () {
+            return this.response ? this.response.ok : false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WayChaserResponse.prototype, "redirected", {
+        get: function () {
+            return this.response ? this.response.redirected : false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WayChaserResponse.prototype, "status", {
+        get: function () {
+            var _a;
+            return (_a = this.response) === null || _a === void 0 ? void 0 : _a.status;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WayChaserResponse.prototype, "statusText", {
+        get: function () {
+            var _a;
+            return (_a = this.response) === null || _a === void 0 ? void 0 : _a.statusText;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WayChaserResponse.prototype, "type", {
+        get: function () {
+            var _a;
+            return (_a = this.response) === null || _a === void 0 ? void 0 : _a.type;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WayChaserResponse.prototype, "url", {
+        get: function () {
+            var _a;
+            return (_a = this.response) === null || _a === void 0 ? void 0 : _a.url;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    WayChaserResponse.prototype.arrayBuffer = function () {
+        throw new Error('Not Implemented. Use `.content` instead');
+    };
+    WayChaserResponse.prototype.blob = function () {
+        throw new Error('Not Implemented. Use `.content` instead');
+    };
+    WayChaserResponse.prototype.clone = function () {
+        throw new Error('Not Implemented');
+    };
+    WayChaserResponse.prototype.formData = function () {
+        throw new Error('Not Implemented. Use `.content` instead');
+    };
+    // async json() {
+    //   throw new Error('Not Implemented. Use `.content` instead')
+    // }
+    WayChaserResponse.prototype.text = function () {
+        throw new Error('Not Implemented. Use `.content` instead');
+    };
+    return WayChaserResponse;
+}());
+var WayChaserProblem = /** @class */ (function (_super) {
+    __extends(WayChaserProblem, _super);
+    function WayChaserProblem(_a) {
+        var _newTarget = this.constructor;
+        var response = _a.response, problem = _a.problem;
+        var _this = 
+        // 'Error' breaks prototype chain here
+        _super.call(this, problem.detail) || this;
+        // restore prototype chain   
+        var actualProto = _newTarget.prototype;
+        if (Object.setPrototypeOf) {
+            Object.setPrototypeOf(_this, actualProto);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        else {
+            _this.__proto__ = actualProto;
+        }
+        _this.problem = problem;
+        _this.response = response;
+        return _this;
+    }
+    return WayChaserProblem;
+}(Error));
+/**
+ * @param handlers
+ */
+function sortHandlers(handlers) {
+    return handlers.sort(function (a, b) {
+        // -ve if less
+        // e.g. a.q = 0.3, b.q = 0.4, then a.q - b.q = 0.3 - 0.4 = -0.1
+        return (b.q || 1) - (a.q || 1);
+    });
+}
+// pre handlers is sorted
+/**
+ * @param handlers
+ */
+function allMediaRanges(handlers) {
+    var e_4, _a, e_5, _b;
+    var rval = [];
+    try {
+        for (var handlers_1 = __values(handlers), handlers_1_1 = handlers_1.next(); !handlers_1_1.done; handlers_1_1 = handlers_1.next()) {
+            var handlerSpec = handlers_1_1.value;
+            try {
+                for (var _c = (e_5 = void 0, __values(handlerSpec.mediaRanges)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var range = _d.value;
+                    if (typeof range === 'object') {
+                        if (handlerSpec.q) {
+                            rval.push({ type: range.mediaType, q: handlerSpec.q * (range.q || 1) });
+                        }
+                        else {
+                            rval.push({ type: range.mediaType, q: (range.q || 1) });
+                        }
+                    }
+                    else {
+                        if (handlerSpec.q) {
+                            rval.push({ type: range, q: handlerSpec.q });
+                        }
+                        else {
+                            rval.push({ type: range, q: 1 });
+                        }
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (handlers_1_1 && !handlers_1_1.done && (_a = handlers_1.return)) _a.call(handlers_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    var sorted = rval.sort(function (a, b) {
+        return a.q - b.q;
+    });
+    var seen = new Set();
+    var filtered = sorted.filter(function (item) {
+        var k = item.type;
+        return seen.has(k) ? false : seen.add(k);
+    });
+    return filtered;
+}
+/**
+ * @param uriOrRequest
+ * @param defaultOptions
+ * @param options
+ * @returns WayChaserResponse<Content>
+ * @throws TypeError | AbortError | WayChaserResponseProblem
+ */
+function _waychaser(uriOrRequest, defaultOptions, options) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var mergedOptions, mergedHandlers, defaultAcceptRanges, defaultAcceptStrings, additionalAcceptHeader, fullAcceptHeader, updateOptions, stop, _b, _c, interceptor, baseResponse, content, response, _d, _e, interceptor, _f, _g, interceptor;
+        var e_6, _h, e_7, _j, e_8, _k;
+        return __generator(this, function (_l) {
+            switch (_l.label) {
+                case 0:
+                    mergedOptions = augmentOptions(defaultOptions, options);
+                    mergedHandlers = mergedOptions.defaultHandlers;
+                    if (!mergedOptions.fetch) {
+                        throw new Error('No global fetch and fetch not provided in options');
+                    }
+                    defaultAcceptRanges = allMediaRanges(mergedHandlers);
+                    defaultAcceptStrings = defaultAcceptRanges.map(function (accept) {
+                        return accept.q === 1 ? accept.type : "".concat(accept.type, ";q=").concat(accept.q);
+                    });
+                    additionalAcceptHeader = ((_a = options === null || options === void 0 ? void 0 : options.headers) === null || _a === void 0 ? void 0 : _a['accept'])
+                        ? [options.headers['accept']]
+                        : [];
+                    fullAcceptHeader = __spreadArray(__spreadArray([], __read(additionalAcceptHeader), false), __read(defaultAcceptStrings), false).join(',');
+                    updateOptions = __assign(__assign({}, mergedOptions), { headers: __assign(__assign({}, mergedOptions.headers), { accept: fullAcceptHeader }) });
+                    stop = false;
+                    try {
+                        for (_b = __values(updateOptions.preInterceptors || []), _c = _b.next(); !_c.done; _c = _b.next()) {
+                            interceptor = _c.value;
+                            interceptor(uriOrRequest, updateOptions, function () { return (stop = true); });
+                            if (stop) {
+                                break;
+                            }
+                        }
+                    }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                    finally {
+                        try {
+                            if (_c && !_c.done && (_h = _b.return)) _h.call(_b);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                    }
+                    return [4 /*yield*/, mergedOptions.fetch(uriOrRequest.toString(), updateOptions)
+                        // TODO allow lazy loading of the content 
+                    ];
+                case 1:
+                    baseResponse = _l.sent();
+                    return [4 /*yield*/, mergedOptions.contentParser(baseResponse)
+                        // content is
+                        // 1. unknown, 
+                        // 2. a post response client side Problem Document,
+                        // 3. a server side ProblemDocument, or
+                        // 4. undefined
+                    ];
+                case 2:
+                    content = _l.sent();
+                    // content is
+                    // 1. unknown, 
+                    // 2. a post response client side Problem Document,
+                    // 3. a server side ProblemDocument, or
+                    // 4. undefined
+                    try {
+                        response = WayChaserResponse.create(baseResponse, content, defaultOptions, mergedOptions);
+                        stop = false;
+                        try {
+                            for (_d = __values(updateOptions.postInterceptors), _e = _d.next(); !_e.done; _e = _d.next()) {
+                                interceptor = _e.value;
+                                interceptor(response, function () { return (stop = true); });
+                                if (stop) {
+                                    break;
+                                }
+                            }
+                        }
+                        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                        finally {
+                            try {
+                                if (_e && !_e.done && (_j = _d.return)) _j.call(_d);
+                            }
+                            finally { if (e_7) throw e_7.error; }
+                        }
+                        return [2 /*return*/, response];
+                    }
+                    catch (error) {
+                        stop = false;
+                        try {
+                            for (_f = __values(updateOptions.postErrorInterceptors), _g = _f.next(); !_g.done; _g = _f.next()) {
+                                interceptor = _g.value;
+                                interceptor(error, function () { return (stop = true); });
+                                if (stop) {
+                                    break;
+                                }
+                            }
+                        }
+                        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                        finally {
+                            try {
+                                if (_g && !_g.done && (_k = _f.return)) _k.call(_f);
+                            }
+                            finally { if (e_8) throw e_8.error; }
+                        }
+                        throw error;
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ *
+ */
+function getGlobal() {
+    if (typeof self !== 'undefined') {
+        return self;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof global !== 'undefined') {
+        return global;
+    }
+    return;
+}
+var wayChaserDefaults = {
+    fetch: typeof window !== 'undefined' ? (_a = window.fetch) === null || _a === void 0 ? void 0 : _a.bind(window) : (_b = getGlobal()) === null || _b === void 0 ? void 0 : _b.fetch,
+    handlers: [],
+    defaultHandlers: sortHandlers([
+        { handler: locationHeaderHandler, mediaRanges: ['*/*'], q: 0.4 },
+        { handler: linkHeaderHandler, mediaRanges: ['*/*'], q: 0.5 },
+        { handler: halHandler, mediaRanges: [MediaTypes.HAL], q: 0.5 },
+        { handler: sirenHandler, mediaRanges: [MediaTypes.SIREN], q: 0.5 }
+    ]),
+    preInterceptors: [],
+    postInterceptors: [],
+    postErrorInterceptors: [],
+    contentParser: function (response) { return __awaiter(void 0, void 0, void 0, function () {
+        var content, contentType, jsonContent;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!(response.headers.get('content-length') &&
+                        response.headers.get('content-length') !== '0')) return [3 /*break*/, 2];
+                    return [4 /*yield*/, response.text()];
+                case 1:
+                    content = _b.sent();
+                    contentType = response.headers.get('content-type');
+                    if ((_a = contentType === null || contentType === void 0 ? void 0 : contentType.split(';')) === null || _a === void 0 ? void 0 : _a[0].endsWith('json')) {
+                        try {
+                            jsonContent = JSON.parse(content);
+                            return [2 /*return*/, contentType === 'application/problem+json' ? Object.assign(new ProblemDocument_1(jsonContent), jsonContent) : jsonContent];
+                        }
+                        catch (error) {
+                            return [2 /*return*/, new ProblemDocument_1({
+                                    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"),
+                                    content: content,
+                                    error: error
+                                })];
+                        }
+                    }
+                    return [2 /*return*/, new ProblemDocument_1(__assign({ type: "https://waychaser.io/unsupported-content-type", title: "The response has an unsupported content type", detail: "The response document has a content type of '".concat(contentType, "' which is not supported"), content: content }, (contentType && { contentType: contentType })))];
+                case 2: return [2 /*return*/];
+            }
+        });
+    }); }
+};
+/**
+ * @param newDefaults
+ * @param oldDefaults
+ */
+function _defaults(newDefaults, oldDefaults) {
+    var mergedOptions = augmentOptions(oldDefaults, newDefaults);
+    var defaultedWaychaser = function (uriOrRequest, options) { return _waychaser(uriOrRequest, mergedOptions, options); };
+    defaultedWaychaser.currentDefaults = mergedOptions;
+    defaultedWaychaser.defaults = function (newDefaults) {
+        return _defaults(newDefaults, mergedOptions);
+    };
+    return defaultedWaychaser;
+}
+/**
+ * calls fetch on the passed in uriOrRequest and parses the response
+ *
+ * @param uriOrRequest see RequestInit
+ * @param options see WayChaserOptions
+ * @returns WayChaserResponse<Content>
+ * @throws TypeError | AbortError | WayChaserResponseProblem | Error
+ */
+var waychaser = Object.assign(function (uriOrRequest, options) {
+    return _waychaser(uriOrRequest, wayChaserDefaults, options);
+}, {
+    currentDefaults: wayChaserDefaults,
+    defaults: function (newDefaults) {
+        return _defaults(newDefaults, wayChaserDefaults);
+    }
+});
+
+export { WayChaserProblem, WayChaserResponse, _waychaser, isValidationSuccess, sortHandlers, waychaser };