@mountainpass/waychaser 5.0.47 → 5.0.49

package/dist/waychaser.es.js

@@ -1,139 +1,3 @@
-/******************************************************************************
-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, SuppressedError, Symbol, Iterator */
-
-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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["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 (g && (g = 0, op[0] && (_ = 0)), _) 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));
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -288,11 +152,11 @@ function requireUriTemplateLite () {
 var uriTemplateLiteExports = requireUriTemplateLite();
 var Template = /*@__PURE__*/getDefaultExportFromCjs(uriTemplateLiteExports);
 
-var URI = {
-    Template: Template,
+const URI = {
+    Template,
     expand: uriTemplateLiteExports.expand,
-    parameters: function (url) {
-        var template = new Template(url);
+    parameters(url) {
+        const template = new Template(url);
         return template.match(url);
     }
 };
@@ -360,38 +224,27 @@ var FormData = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
  * @param {string} accept
  */
 function parseAccept(accept) {
-    var entries = accept.split(',');
+    const 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],
+        .map(entry => {
+        const fields = entry.split(';');
+        const type = fields.shift();
+        const types = type?.split('/');
+        const parsedEntry = {
+            type,
+            parentType: types?.[0],
+            subType: 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]);
-                }
+        for (const field of fields) {
+            const 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) {
+        .sort((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) {
@@ -416,12 +269,12 @@ function parseAccept(accept) {
             return 0;
         }
     })
-        .map(function (entry) {
+        .map(entry => {
         return {
             type: entry.type || ''
         };
     })
-        .filter(function (entry) { return entry.type !== ''; });
+        .filter(entry => entry.type !== '');
 }
 
 /**
@@ -431,8 +284,8 @@ function parseAccept(accept) {
  */
 function preferredContentType(accept, supportedContentTypes, defaultType) {
     if (accept) {
-        var acceptable = parseAccept(accept);
-        var acceptableMediaTypes = acceptable.find(function (row) {
+        const acceptable = parseAccept(accept);
+        const acceptableMediaTypes = acceptable.find(row => {
             return supportedContentTypes.includes(row.type);
         });
         return acceptableMediaTypes.type;
@@ -675,9 +528,8 @@ function requireLib () {
 
 var libExports = requireLib();
 
-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"]);
+class Operation {
+    constructor({ rel, uri, method, parameters, accept, anchor, ...otherProperties }) {
         this.rel = rel;
         this.uri = uri;
         this.method = method;
@@ -686,84 +538,74 @@ var Operation = /** @class */ (function () {
         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);
+}
+class InvocableOperation extends Operation {
+    constructor(operation, response, defaultOptions, thisContext) {
+        super(operation);
+        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) {
+    invokeAsFragment(parameters, validator) {
         if (this.uri.startsWith('#/')) {
-            var anchor = this.expandUrl(parameters).toString();
-            var fragmentContent = this.response.fullContent && pointer.get(this.response.fullContent, anchor.slice(1));
+            const anchor = this.expandUrl(parameters).toString();
+            const fragmentContent = this.response.fullContent && pointer.get(this.response.fullContent, anchor.slice(1));
             if (fragmentContent === undefined) {
                 return undefined;
             }
             if (validator) {
-                var validationResult = validator(fragmentContent);
+                const 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 });
+                    return new WayChaserResponse({ defaultOptions: this.defaultOptions, baseResponse: this.response.response, content: validationResult.content, fullContent: this.response.fullContent, anchor, parentOperations: this.response.allOperations, 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 })
+                        response: new WayChaserResponse({ defaultOptions: this.defaultOptions, baseResponse: this.response.response, content: fragmentContent, fullContent: this.response.fullContent, 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 });
+                return new WayChaserResponse({ defaultOptions: this.defaultOptions, baseResponse: this.response.response, content: fragmentContent, fullContent: this.response.fullContent, anchor, parentOperations: this.response.allOperations, 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)];
-                }
-                else {
-                    return [2 /*return*/, this.invoke(options).then(function (result) { return [result]; })];
-                }
-            });
-        });
-    };
-    InvocableOperation.prototype.doInvokeAll = function (parameters, validator) {
-        var _this = this;
-        var response = this.response;
+    }
+    async invokeAll(options) {
+        if (this.uri.startsWith('#/') && this.response instanceof WayChaserResponse) {
+            const result = this.doInvokeAll(options?.parameters || {});
+            return Promise.all(result);
+        }
+        else {
+            return this.invoke(options).then(result => [result]);
+        }
+    }
+    doInvokeAll(parameters, validator) {
+        const 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).replaceAll('%7B', "{").replaceAll('%7D', "}");
+        const template = new URI.Template(this.uri);
+        const uriParameters = Object.assign(URI.parameters(this.uri), parameters);
+        const currentUri = template.expand(uriParameters).replaceAll('%7B', "{").replaceAll('%7D', "}");
         // get unfilled parameters
-        var currentUriParameters = URI.parameters(currentUri);
-        var keys = Object.keys(currentUriParameters);
+        const currentUriParameters = URI.parameters(currentUri);
+        const keys = Object.keys(currentUriParameters);
         if (keys.length === 0) {
             return [this.invokeAsFragment(parameters, validator)];
         }
         else {
-            var field = currentUriParameters[keys[0]];
-            var parentUri = currentUri.slice(1, currentUri.indexOf(field) - 1);
-            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) {
-                    var _a;
-                    var extendedParameters = Object.assign({}, parameters, (_a = {}, _a[keys[0]] = index, _a));
-                    return _this.doInvokeAll(extendedParameters, validator);
+            const field = currentUriParameters[keys[0]];
+            const parentUri = currentUri.slice(1, currentUri.indexOf(field) - 1);
+            const parent = parentUri === '' ? response.content : pointer.get(response.content, parentUri);
+            if (parent) {
+                const indices = Array.isArray(parent) ? [...Array.from({ length: parent.length }).keys()] : Object.keys(parent);
+                return indices.flatMap(index => {
+                    const extendedParameters = Object.assign({}, parameters, { [keys[0]]: index });
+                    return this.doInvokeAll(extendedParameters, validator);
                 });
             }
             else {
@@ -773,129 +615,108 @@ var InvocableOperation = /** @class */ (function (_super) {
                         type: "https://waychaser.io/fragment-uri-error",
                         title: "The fragment URI does not match the content structure",
                         uri: parentUri, content: response.content,
-                        parameters: parameters
+                        parameters
                     }),
                 });
             }
         }
-    };
-    InvocableOperation.prototype.invoke = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var fragment, fragmentContent, 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) {
-                if (this.uri.startsWith('#/')) {
-                    return [2 /*return*/, this.invokeAsFragment(options === null || options === void 0 ? void 0 : options.parameters)];
+    }
+    async invoke(options) {
+        if (this.uri.startsWith('#/')) {
+            return this.invokeAsFragment(options?.parameters);
+        }
+        else if (this.uri.includes('#/')) {
+            // URI has both a path and a fragment (e.g., /addresses?q=...#/0)
+            // Resolve the fragment against the current response's content
+            const fragment = this.uri.slice(this.uri.indexOf('#/') + 1);
+            const fragmentContent = this.response.fullContent && pointer.get(this.response.fullContent, fragment);
+            if (fragmentContent !== undefined) {
+                return new WayChaserResponse({ defaultOptions: this.defaultOptions, baseResponse: this.response.response, content: fragmentContent, fullContent: this.response.fullContent, anchor: '#' + fragment, parentOperations: this.response.allOperations, parameters: options?.parameters });
+            }
+            // Fall through to HTTP request if fragment resolution fails
+        }
+        {
+            const parameterSpecs = this.parameters || {};
+            const parameters = Object.assign({}, this.defaultOptions.parameters, options?.parameters);
+            const invokeUrl = this.url(parameters);
+            const body = {};
+            /* istanbul ignore if reason: TODO */
+            if (Array.isArray(parameterSpecs)) {
+                for (const key of parameterSpecs) {
+                    body[key] = parameters?.[key];
                 }
-                else if (this.uri.includes('#/')) {
-                    fragment = this.uri.slice(this.uri.indexOf('#/') + 1);
-                    fragmentContent = this.response.fullContent && pointer.get(this.response.fullContent, fragment);
-                    if (fragmentContent !== undefined) {
-                        return [2 /*return*/, new WayChaserResponse({ defaultOptions: this.defaultOptions, baseResponse: this.response.response, content: fragmentContent, fullContent: this.response.fullContent, anchor: '#' + fragment, parentOperations: this.response.allOperations, parameters: options === null || options === void 0 ? void 0 : options.parameters })];
-                    }
-                    // Fall through to HTTP request if fragment resolution fails
+            }
+            else {
+                for (const key of Object.keys(parameterSpecs)) {
+                    body[key] = parameters?.[key];
                 }
-                {
-                    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; }
-                        }
+            }
+            let encodedContent;
+            let headers = {};
+            const requestOptions = Object.assign({}, options);
+            requestOptions.method = this.method;
+            if (Object.keys(this.parameters).length !== 0 && methodCanHaveBody(this.method || 'GET')) {
+                const 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;
                     }
-                    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; }
-                        }
+                    case 'application/json': {
+                        encodedContent = JSON.stringify(body);
+                        break;
                     }
-                    encodedContent = void 0;
-                    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 FormData();
-                                for (name_1 in body) {
-                                    encodedContent.append(name_1, body[name_1]);
-                                }
-                                break;
-                            }
+                    case 'multipart/form-data': {
+                        encodedContent = new FormData();
+                        for (const name in body) {
+                            encodedContent.append(name, body[name]);
                         }
-                        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);
+                        break;
                     }
-                    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);
+                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?.headers);
+            }
+            return _waychaser(invokeUrl.toString(), this.defaultOptions, requestOptions);
+        }
+    }
+    url(parameters) {
+        const expandedUri = this.expandUrl(parameters);
+        const invokeUrl = new URL(expandedUri, this.response.url);
         return invokeUrl;
-    };
-    InvocableOperation.prototype.expandUrl = function (parameters) {
+    }
+    expandUrl(parameters) {
         return URI.expand(this.uri, flatten(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;
+class OperationArray extends Array {
+    constructor(items) {
+        super();
+        if (items)
+            this.push(...items);
+    }
+    static get [Symbol.species]() {
+        return Array;
     }
-    OperationArray.create = function () {
+    static create() {
         return Object.create(OperationArray.prototype);
-    };
-    OperationArray.prototype.find = function (query, thisArgument) {
-        var finder = Array.prototype.find.bind(this);
+    }
+    find(query, thisArgument) {
+        const finder = Array.prototype.find.bind(this);
         if (typeof query === 'string') {
             return finder(objectFinder({ rel: query }), thisArgument);
         }
@@ -905,8 +726,8 @@ var OperationArray = /** @class */ (function (_super) {
         else {
             return finder(query, thisArgument);
         }
-    };
-    OperationArray.prototype.filter = function (query, thisArgument) {
+    }
+    filter(query, thisArgument) {
         if (typeof query === 'string') {
             return this.filter({ rel: query }, thisArgument);
         }
@@ -914,26 +735,23 @@ var OperationArray = /** @class */ (function (_super) {
             return this.filter(objectFinder(query), thisArgument);
         }
         else {
-            var filtered = Array.prototype.filter.bind(this)(query);
+            const 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);
+    }
+    invoke(relationship, options) {
+        const operation = this.find(relationship);
         return operation ? operation.invoke(options) : undefined;
-    };
-    OperationArray.prototype.invokeAll = function (relationship, options) {
-        var operations = this.filter(relationship);
-        return Promise.all(operations.map(function (operation) {
-            return operation.invokeAll(options);
-        })).then(function (arrayOfArrays) {
-            var flat = arrayOfArrays.flat();
+    }
+    invokeAll(relationship, options) {
+        const operations = this.filter(relationship);
+        return Promise.all(operations.map(operation => operation.invokeAll(options))).then(arrayOfArrays => {
+            const 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.
@@ -941,8 +759,8 @@ var OperationArray = /** @class */ (function (_super) {
  * @param query
  */
 function objectFinder(query) {
-    return function (o) {
-        for (var key in query) {
+    return (o) => {
+        for (const key in query) {
             if (query[key] !== o[key]) {
                 return false;
             }
@@ -955,54 +773,33 @@ function objectFinder(query) {
  * @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);
+    const expandedOperations = [];
+    const rangeRegex = /{\[(\d+)..(\d+)]}/;
+    const originalUrl = operation.uri.toString();
+    const 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, {
+        for (let index = Number.parseInt(matches[1]); index <= Number.parseInt(matches[2]); ++index) {
+            const 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; }
+            const thisExpandedOperations = expandOperation(newOp);
+            for (const operation of thisExpandedOperations) {
+                expandedOperations.push(operation);
             }
         }
     }
     else {
-        var originalAnchor = operation.anchor;
-        var anchorMatches = originalAnchor === null || originalAnchor === void 0 ? void 0 : originalAnchor.match(rangeRegex);
+        const originalAnchor = operation.anchor;
+        const anchorMatches = 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, {
+            for (let index = Number.parseInt(anchorMatches[1]); index <= Number.parseInt(anchorMatches[2]); ++index) {
+                const 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; }
+                const thisExpandedOperations = expandOperation(newOp);
+                for (const operation of thisExpandedOperations) {
+                    expandedOperations.push(operation);
                 }
             }
         }
@@ -1020,80 +817,38 @@ function expandOperation(operation) {
  * @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;
+function parseOperations({ handlers, baseResponse, content }) {
+    const operations = [];
+    let stop = false;
+    for (const handler of handlers) {
+        // TODO only call handers for the current media type
+        const handledOperations = handler.handler(baseResponse, content, () => {
+            stop = true;
+        });
+        if (handledOperations) {
+            for (const operation of handledOperations) {
+                operations.push(operation);
             }
         }
-    }
-    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);
+        if (stop) {
+            break;
         }
-        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 || '';
-                    if (!expandedOperations[anchor]) {
-                        expandedOperations[anchor] = [];
-                    }
-                    expandedOperations[anchor].push(operation_1);
-                }
+    const expandedOperations = {};
+    for (const operation of operations) {
+        const expanded = expandOperation(operation);
+        for (const operation of expanded) {
+            const anchor = operation.anchor || '';
+            if (!expandedOperations[anchor]) {
+                expandedOperations[anchor] = [];
             }
-            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);
+            expandedOperations[anchor].push(operation);
         }
-        finally { if (e_3) throw e_3.error; }
     }
     return expandedOperations;
 }
 
-var MediaTypes = {
+const MediaTypes = {
     HAL: 'application/hal+json',
     SIREN: 'application/vnd.siren+json'
 };
@@ -1114,10 +869,10 @@ function deCurie(relationship, curies) {
     // ⚠️ 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(/:(.+)/);
+    const splitRelationship = relationship.split(/:(.+)/);
     if (splitRelationship.length > 1) {
-        var _a = __read(splitRelationship, 2), curieName = _a[0], curieRemainder = _a[1];
-        var rval = curies[curieName]
+        const [curieName, curieRemainder] = splitRelationship;
+        const rval = curies[curieName]
             ? URI.expand(curies[curieName], { rel: curieRemainder })
             : relationship;
         return rval;
@@ -1135,8 +890,8 @@ function deCurie(relationship, 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
-    var href = link.href; link.templated; var otherProperties = __rest(link, ["href", "templated"]);
-    return new Operation(__assign({ rel: deCurie(relationship, curies), uri: href }, otherProperties));
+    const { href, templated: _templated, ...otherProperties } = link;
+    return new Operation({ rel: deCurie(relationship, curies), uri: href, ...otherProperties });
 }
 
 /**
@@ -1144,67 +899,35 @@ function mapHalLinkToOperation(relationship, link, curies) {
  * @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 &&
+    const operations = [];
+    const contentType = response.headers.get('content-type')?.split(';');
+    if (contentType?.[0] === MediaTypes.HAL &&
         content &&
         typeof content === 'object' &&
         '_links' in content) {
-        var body = content;
+        const 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 = {};
+        const 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; }
+                for (const curie of body._links.curies) {
+                    curies[curie.name] = curie.href;
                 }
             }
             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));
+        for (const key of Object.keys(body._links).filter(relationship => relationship !== 'curies')) {
+            if (Array.isArray(body._links[key])) {
+                for (const link of body._links[key]) {
+                    operations.push(mapHalLinkToOperation(key, link, curies));
                 }
             }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+            else {
+                operations.push(mapHalLinkToOperation(key, body._links[key], curies));
             }
-            finally { if (e_2) throw e_2.error; }
         }
     }
     return operations;
@@ -1635,20 +1358,30 @@ var LinkHeader = /*@__PURE__*/getDefaultExportFromCjs(linkExports);
  * @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);
+    return [
+        ...parseHeader(response.headers.get('link')),
+        ...parseHeader(response.headers.get('link-template'))
+    ];
 }
 /**
  * @param linkHeader
  */
 function parseHeader(linkHeader) {
     if (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)
-                ? JSON.parse(parameters === null || parameters === void 0 ? void 0 : parameters.value)
+        const links = LinkHeader.parse(linkHeader);
+        return links.refs.map(reference => {
+            const { rel, uri, method, 'accept*': accept, 'params*': parameters, ...otherProperties } = reference;
+            const parsedParameters = parameters?.value
+                ? JSON.parse(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));
+            return new Operation({
+                rel,
+                uri,
+                method,
+                parameters: parsedParameters,
+                accept: accept?.value,
+                ...otherProperties
+            });
         });
     }
     else {
@@ -1661,51 +1394,35 @@ function parseHeader(linkHeader) {
  * @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 = {};
+    const { name, href, fields, type, ...otherProperties } = action;
+    const 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; }
+        for (const parameter of fields) {
+            bodyParameters[parameter.name] = {};
         }
     }
-    return __assign({ rel: name, uri: href, accept: type, parameters: fields && bodyParameters }, otherProperties);
+    return {
+        rel: name,
+        uri: href,
+        accept: type,
+        parameters: fields && bodyParameters,
+        ...otherProperties
+    };
 }
 
 /**
  * @param content
  */
 function sirenActionHandler(content) {
-    var e_1, _a;
-    var operations = [];
+    const operations = [];
     if (content &&
         typeof content === 'object' &&
         'actions' in content) {
-        var body = content;
+        const 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; }
+            for (const action of body.actions) {
+                const operation = mapSirenActionToOperation(action);
+                operations.push(operation);
             }
         }
     }
@@ -1724,8 +1441,8 @@ 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));
+    const { href, rel, ...otherProperties } = link;
+    return new Operation({ rel: relationship, uri: href, ...otherProperties });
 }
 
 /**
@@ -1733,39 +1450,18 @@ function mapSirenLinkToOperation(relationship, link) {
  * @param content
  */
 function sirenLinkHandler(content) {
-    var e_1, _a, e_2, _b;
-    var operations = [];
+    const operations = [];
     if (content &&
         typeof content === 'object' &&
         'links' in content) {
-        var body = content;
+        const 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; }
-                    }
+            for (const link of body.links) {
+                for (const relationship of link.rel) {
+                    const mappedLink = mapSirenLinkToOperation(relationship, link);
+                    operations.push(mappedLink);
                 }
             }
-            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;
@@ -1776,10 +1472,12 @@ function sirenLinkHandler(content) {
  * @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);
+    const contentType = response.headers.get('content-type')?.split(';');
+    if (contentType?.[0] === MediaTypes.SIREN) {
+        return [
+            ...(sirenLinkHandler(content)),
+            ...(sirenActionHandler(content))
+        ];
     }
     return [];
 }
@@ -1788,7 +1486,7 @@ function sirenHandler(response, content) {
  * @param response
  */
 function locationHeaderHandler(response) {
-    var locationHeader = response === null || response === void 0 ? void 0 : response.headers.get('location');
+    const locationHeader = response?.headers.get('location');
     if (locationHeader) {
         return [new Operation({ rel: 'related', uri: locationHeader })];
     }
@@ -1800,74 +1498,65 @@ function locationHeaderHandler(response) {
  * @param additionalOptions
  */
 function augmentOptions(baseOptions, additionalOptions) {
-    var baseHandlers = baseOptions.handlers, baseDefaultHandlers = baseOptions.defaultHandlers, baseHeaders = baseOptions.headers, baseContentParser = baseOptions.contentParser, baseOther = __rest(baseOptions, ["handlers", "defaultHandlers", "headers", "contentParser"]);
-    var _a = additionalOptions || {}, additionalHandlers = _a.handlers, additionalDefaultHandlers = _a.defaultHandlers, additionalHeaders = _a.headers, additionalContentParser = _a.contentParser, additionalOther = __rest(_a, ["handlers", "defaultHandlers", "headers", "contentParser"]);
+    const { handlers: baseHandlers, defaultHandlers: baseDefaultHandlers, headers: baseHeaders, contentParser: baseContentParser, ...baseOther } = baseOptions;
+    const { handlers: additionalHandlers, defaultHandlers: additionalDefaultHandlers, headers: additionalHeaders, contentParser: additionalContentParser, ...additionalOther } = additionalOptions || {};
     // 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 mergedContentParser = additionalContentParser ? function (response) { return additionalContentParser(response, baseContentParser); } : baseContentParser;
-    return __assign(__assign(__assign({}, baseOther), additionalOther), { defaultHandlers: mergedHandlers, handlers: [], headers: __assign(__assign({}, baseHeaders), additionalHeaders), contentParser: mergedContentParser });
+    const mergedHandlers = sortHandlers([
+        ...(additionalHandlers || baseHandlers || []),
+        ...(additionalDefaultHandlers || baseDefaultHandlers || [])
+    ]);
+    const mergedContentParser = additionalContentParser ? (response) => additionalContentParser(response, baseContentParser) : baseContentParser;
+    return {
+        ...baseOther,
+        ...additionalOther,
+        defaultHandlers: mergedHandlers,
+        handlers: [],
+        headers: {
+            ...baseHeaders,
+            ...additionalHeaders
+        },
+        contentParser: mergedContentParser
+    };
 }
 
-var _a, _b;
+/* global Response */
 /**
  * @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;
+class WayChaserResponse {
+    constructor({ handlers, defaultOptions, baseResponse, content, fullContent, anchor, parentOperations, parameters }) {
         this.response = baseResponse;
         this.anchor = anchor;
         this.parameters = parameters || {};
         this.fullContent = fullContent || content;
         this.content = content;
         this.operations = OperationArray.create();
-        var thisContext = flatten({ this: content });
+        const thisContext = flatten({ 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; }
+            for (const operation of this.allOperations[anchor] || []) {
+                this.operations.push(new InvocableOperation(operation, this, defaultOptions, thisContext));
             }
             // 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) {
+            for (const 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);
+                    const template = new URI.Template(key);
+                    const parameters = template.match(this.anchor);
+                    const expandedAnchor = template.expand(parameters);
                     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; }
+                        const expandedOptions = Object.assign({}, defaultOptions, { parameters: Object.assign(parameters, defaultOptions.parameters) });
+                        for (const operation of this.allOperations[key]) {
+                            this.operations.push(new InvocableOperation(operation, this, expandedOptions, thisContext));
                         }
                     }
                 }
@@ -1875,24 +1564,14 @@ var WayChaserResponse = /** @class */ (function () {
         }
         else if (baseResponse && handlers && defaultOptions) {
             this.allOperations = parseOperations({
-                baseResponse: baseResponse,
-                content: content,
-                handlers: handlers
+                baseResponse,
+                content,
+                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; }
+            for (const operation of this.allOperations[''] || []) {
+                const op = new InvocableOperation(operation, this, defaultOptions, thisContext);
+                this.operations.push(op);
             }
         }
     }
@@ -1904,159 +1583,108 @@ var WayChaserResponse = /** @class */ (function () {
      * @returns
      * @throws {WayChaserProblem}
      */
-    WayChaserResponse.create = function (baseResponse, content, defaultOptions, mergedOptions) {
+    static create(baseResponse, content, defaultOptions, mergedOptions) {
         if (content instanceof libExports.ProblemDocument) {
             throw new WayChaserProblem({
-                response: new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions: defaultOptions, baseResponse: baseResponse, content: content, parameters: mergedOptions.parameters }),
+                response: new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions, baseResponse, content, parameters: mergedOptions.parameters }),
                 problem: content,
             });
         }
         else {
             if (mergedOptions.validator) {
-                var validationResult = mergedOptions.validator(content);
+                const validationResult = mergedOptions.validator(content);
                 if (isValidationSuccess(validationResult)) {
-                    return new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions: defaultOptions, baseResponse: baseResponse, content: validationResult.content, parameters: mergedOptions.parameters });
+                    return new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions, 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 }),
+                        response: new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions, baseResponse, content, parameters: mergedOptions.parameters }),
                         problem: validationResult.problem,
                     });
                 }
             }
             else {
-                return new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions: defaultOptions, baseResponse: baseResponse, content: content, parameters: mergedOptions.parameters });
+                return new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions, baseResponse, content, parameters: mergedOptions.parameters });
             }
         }
-    };
-    Object.defineProperty(WayChaserResponse.prototype, "ops", {
-        get: function () {
-            return this.operations;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    WayChaserResponse.prototype.invoke = function (relationship, options) {
+    }
+    get ops() {
+        return this.operations;
+    }
+    invoke(relationship, options) {
         return this.operations.invoke(relationship, options);
-    };
-    WayChaserResponse.prototype.invokeAll = function (relationship, options) {
+    }
+    invokeAll(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 () {
+    }
+    get body() {
         throw new Error('Not Implemented. Use `.content` instead');
-    };
-    WayChaserResponse.prototype.blob = function () {
+    }
+    get bodyUsed() {
+        return true;
+    }
+    get headers() {
+        return this.response?.headers;
+    }
+    get ok() {
+        return this.response ? this.response.ok : false;
+    }
+    get redirected() {
+        return this.response ? this.response.redirected : false;
+    }
+    get status() {
+        return this.response?.status;
+    }
+    get statusText() {
+        return this.response?.statusText;
+    }
+    get type() {
+        return this.response?.type;
+    }
+    get url() {
+        return this.response?.url;
+    }
+    arrayBuffer() {
         throw new Error('Not Implemented. Use `.content` instead');
-    };
-    WayChaserResponse.prototype.clone = function () {
+    }
+    blob() {
+        throw new Error('Not Implemented. Use `.content` instead');
+    }
+    clone() {
         throw new Error('Not Implemented');
-    };
-    WayChaserResponse.prototype.formData = function () {
+    }
+    formData() {
         throw new Error('Not Implemented. Use `.content` instead');
-    };
+    }
     // async json() {
     //   throw new Error('Not Implemented. Use `.content` instead')
     // }
-    WayChaserResponse.prototype.text = function () {
+    text() {
         throw new Error('Not Implemented. Use `.content` instead');
-    };
-    return WayChaserResponse;
-}());
-var WayChaserProblem = /** @class */ (function (_super) {
-    __extends(WayChaserProblem, _super);
-    function WayChaserProblem(_a) {
-        var response = _a.response, problem = _a.problem;
-        var _newTarget = this.constructor;
+    }
+}
+class WayChaserProblem extends Error {
+    constructor({ response, problem }) {
         // 'Error' breaks prototype chain here
-        var _this = _super.call(this, problem.detail) || this;
+        super(problem.detail);
         // restore prototype chain   
-        var actualProto = _newTarget.prototype;
+        const actualProto = new.target.prototype;
         if (Object.setPrototypeOf) {
-            Object.setPrototypeOf(_this, actualProto);
+            Object.setPrototypeOf(this, actualProto);
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         else {
-            _this.__proto__ = actualProto;
+            this.__proto__ = actualProto;
         }
-        _this.problem = problem;
-        _this.response = response;
-        return _this;
+        this.problem = problem;
+        this.response = response;
     }
-    return WayChaserProblem;
-}(Error));
+}
 /**
  * @param handlers
  */
 function sortHandlers(handlers) {
-    return handlers.sort(function (a, b) {
+    return handlers.sort((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);
@@ -2067,54 +1695,33 @@ function sortHandlers(handlers) {
  * @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 });
-                        }
-                    }
+    const rval = [];
+    for (const handlerSpec of handlers) {
+        for (const range of handlerSpec.mediaRanges) {
+            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) });
                 }
             }
-            catch (e_5_1) { e_5 = { error: e_5_1 }; }
-            finally {
-                try {
-                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+            else {
+                if (handlerSpec.q) {
+                    rval.push({ type: range, q: handlerSpec.q });
+                }
+                else {
+                    rval.push({ type: range, q: 1 });
                 }
-                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) {
+    const sorted = rval.sort((a, b) => {
         return a.q - b.q;
     });
-    var seen = new Set();
-    var filtered = sorted.filter(function (item) {
-        var k = item.type;
+    const seen = new Set();
+    const filtered = sorted.filter(item => {
+        const k = item.type;
         return seen.has(k) ? false : seen.add(k);
     });
     return filtered;
@@ -2126,113 +1733,73 @@ function allMediaRanges(handlers) {
  * @returns {Promise<WayChaserResponse<Content>>}
  * @throws {TypeError | AbortError | WayChaserProblem}
  */
-function _waychaser(uriOrRequest, defaultOptions, options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var mergedOptions, mergedHandlers, defaultAcceptRanges, defaultAcceptStrings, additionalAcceptHeader, fullAcceptHeader, updateOptions, stop, _a, _b, interceptor, baseResponse, content, response, _c, _d, interceptor, error_1, response, wayChaserProblem, _e, _f, interceptor;
-        var e_6, _g, e_7, _h, e_8, _j;
-        var _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 = ((_k = options === null || options === void 0 ? void 0 : options.headers) === null || _k === void 0 ? void 0 : _k['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 (_a = __values(updateOptions.preInterceptors || []), _b = _a.next(); !_b.done; _b = _a.next()) {
-                            interceptor = _b.value;
-                            interceptor(uriOrRequest, updateOptions, function () { return (stop = true); });
-                            if (stop) {
-                                break;
-                            }
-                        }
-                    }
-                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                    finally {
-                        try {
-                            if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
-                        }
-                        finally { if (e_6) throw e_6.error; }
-                    }
-                    return [4 /*yield*/, mergedOptions.fetch(uriOrRequest.toString(), updateOptions)];
-                case 1:
-                    baseResponse = _l.sent();
-                    _l.label = 2;
-                case 2:
-                    _l.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, mergedOptions.contentParser(baseResponse)
-                        // content is
-                        // 1. unknown, 
-                        // 4. undefined
-                    ];
-                case 3:
-                    content = _l.sent();
-                    response = WayChaserResponse.create(baseResponse, content, defaultOptions, mergedOptions);
-                    stop = false;
-                    try {
-                        for (_c = __values(updateOptions.postInterceptors), _d = _c.next(); !_d.done; _d = _c.next()) {
-                            interceptor = _d.value;
-                            interceptor(response, function () { return (stop = true); });
-                            if (stop) {
-                                break;
-                            }
-                        }
-                    }
-                    catch (e_7_1) { e_7 = { error: e_7_1 }; }
-                    finally {
-                        try {
-                            if (_d && !_d.done && (_h = _c.return)) _h.call(_c);
-                        }
-                        finally { if (e_7) throw e_7.error; }
-                    }
-                    return [2 /*return*/, response];
-                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 libExports.ProblemDocument ? new WayChaserProblem({
-                        response: response,
-                        problem: error_1,
-                    }) : new WayChaserProblem({
-                        response: response,
-                        problem: new libExports.ProblemDocument({
-                            type: "https://waychaser.io/unexected-error",
-                            title: "An unexpected error occurred",
-                            error: error_1
-                        }),
-                    });
-                    stop = false;
-                    try {
-                        for (_e = __values(updateOptions.postErrorInterceptors), _f = _e.next(); !_f.done; _f = _e.next()) {
-                            interceptor = _f.value;
-                            interceptor(wayChaserProblem, function () { return (stop = true); });
-                            if (stop) {
-                                break;
-                            }
-                        }
-                    }
-                    catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                    finally {
-                        try {
-                            if (_f && !_f.done && (_j = _e.return)) _j.call(_e);
-                        }
-                        finally { if (e_8) throw e_8.error; }
-                    }
-                    throw wayChaserProblem;
-                case 5: return [2 /*return*/];
+async function _waychaser(uriOrRequest, defaultOptions, options) {
+    const mergedOptions = augmentOptions(defaultOptions, options);
+    const mergedHandlers = mergedOptions.defaultHandlers;
+    if (!mergedOptions.fetch) {
+        throw new Error('No global fetch and fetch not provided in options');
+    }
+    const defaultAcceptRanges = allMediaRanges(mergedHandlers);
+    const defaultAcceptStrings = defaultAcceptRanges.map(accept => {
+        return accept.q === 1 ? accept.type : `${accept.type};q=${accept.q}`;
+    });
+    const additionalAcceptHeader = options?.headers?.['accept']
+        ? [options.headers['accept']]
+        : [];
+    const fullAcceptHeader = [
+        ...additionalAcceptHeader,
+        ...defaultAcceptStrings
+    ].join(',');
+    const updateOptions = {
+        ...mergedOptions,
+        headers: { ...mergedOptions.headers, accept: fullAcceptHeader }
+    };
+    let stop = false;
+    for (const interceptor of updateOptions.preInterceptors || []) {
+        interceptor(uriOrRequest, updateOptions, () => (stop = true));
+        if (stop) {
+            break;
+        }
+    }
+    const baseResponse = await mergedOptions.fetch(uriOrRequest.toString(), updateOptions);
+    try {
+        // TODO allow lazy loading of the content 
+        const content = await mergedOptions.contentParser(baseResponse);
+        // content is
+        // 1. unknown, 
+        // 4. undefined
+        const response = WayChaserResponse.create(baseResponse, content, defaultOptions, mergedOptions);
+        stop = false;
+        for (const interceptor of updateOptions.postInterceptors) {
+            interceptor(response, () => (stop = true));
+            if (stop) {
+                break;
             }
+        }
+        return response;
+    }
+    catch (error) {
+        const response = new WayChaserResponse({ handlers: mergedOptions.defaultHandlers, defaultOptions, baseResponse, content: error, parameters: mergedOptions.parameters });
+        const wayChaserProblem = error instanceof libExports.ProblemDocument ? new WayChaserProblem({
+            response,
+            problem: error,
+        }) : new WayChaserProblem({
+            response,
+            problem: new libExports.ProblemDocument({
+                type: "https://waychaser.io/unexected-error",
+                title: "An unexpected error occurred",
+                error
+            }),
         });
-    });
+        stop = false;
+        for (const interceptor of updateOptions.postErrorInterceptors) {
+            interceptor(wayChaserProblem, () => (stop = true));
+            if (stop) {
+                break;
+            }
+        }
+        throw wayChaserProblem;
+    }
 }
 /**
  *
@@ -2262,14 +1829,13 @@ function tryParseJson(content, contentType) {
         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"),
-            content: content,
-            error: error
+            detail: `The response document with content type '${contentType}' could not be parsed as json`,
+            content, error
         });
     }
 }
-var wayChaserDefaults = {
-    fetch: typeof globalThis === 'undefined' ? (_a = getGlobal()) === null || _a === void 0 ? void 0 : _a.fetch : (_b = globalThis.fetch) === null || _b === void 0 ? void 0 : _b.bind(globalThis),
+const wayChaserDefaults = {
+    fetch: typeof globalThis === 'undefined' ? getGlobal()?.fetch : globalThis.fetch?.bind(globalThis),
     handlers: [],
     defaultHandlers: sortHandlers([
         { handler: locationHeaderHandler, mediaRanges: ['*/*'], q: 0.4 },
@@ -2280,44 +1846,33 @@ var wayChaserDefaults = {
     preInterceptors: [],
     postInterceptors: [],
     postErrorInterceptors: [],
-    contentParser: function (response) { return __awaiter(void 0, void 0, void 0, function () {
-        var content, contentType, jsonContent;
-        var _a, _b;
-        return __generator(this, function (_c) {
-            switch (_c.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 = _c.sent();
-                    contentType = (_b = (_a = response.headers.get('content-type')) === null || _a === void 0 ? void 0 : _a.split(';')) === null || _b === void 0 ? void 0 : _b[0];
-                    if (contentType === null || contentType === void 0 ? void 0 : contentType.endsWith('json')) {
-                        jsonContent = tryParseJson(content, contentType);
-                        if (contentType === 'application/problem+json') {
-                            throw Object.assign(new libExports.ProblemDocument(jsonContent), jsonContent);
-                        }
-                        else {
-                            return [2 /*return*/, jsonContent];
-                        }
-                    }
-                    _c.label = 2;
-                case 2: return [2 /*return*/];
+    contentParser: async (response) => {
+        if (response.headers.get('content-length') &&
+            response.headers.get('content-length') !== '0') {
+            const content = await response.text();
+            const contentType = response.headers.get('content-type')?.split(';')?.[0];
+            if (contentType?.endsWith('json')) {
+                const jsonContent = tryParseJson(content, contentType);
+                if (contentType === 'application/problem+json') {
+                    throw Object.assign(new libExports.ProblemDocument(jsonContent), jsonContent);
+                }
+                else {
+                    return jsonContent;
+                }
             }
-        });
-    }); }
+        }
+        // else no content. Returning undefined
+    }
 };
 /**
  * @param newDefaults
  * @param oldDefaults
  */
 function _defaults(newDefaults, oldDefaults) {
-    var mergedOptions = augmentOptions(oldDefaults, newDefaults);
-    var defaultedWaychaser = function (uriOrRequest, options) { return _waychaser(uriOrRequest, mergedOptions, options); };
+    const mergedOptions = augmentOptions(oldDefaults, newDefaults);
+    const defaultedWaychaser = (uriOrRequest, options) => _waychaser(uriOrRequest, mergedOptions, options);
     defaultedWaychaser.currentDefaults = mergedOptions;
-    defaultedWaychaser.defaults = function (newDefaults) {
-        return _defaults(newDefaults, mergedOptions);
-    };
+    defaultedWaychaser.defaults = (newDefaults) => _defaults(newDefaults, mergedOptions);
     return defaultedWaychaser;
 }
 /**
@@ -2327,13 +1882,11 @@ function _defaults(newDefaults, oldDefaults) {
  * @returns WayChaserResponse<Content>
  * @throws TypeError | AbortError | WayChaserResponseProblem | Error
  */
-var waychaser = Object.assign(function (uriOrRequest, options) {
+const waychaser = Object.assign((uriOrRequest, options) => {
     return _waychaser(uriOrRequest, wayChaserDefaults, options);
 }, {
     currentDefaults: wayChaserDefaults,
-    defaults: function (newDefaults) {
-        return _defaults(newDefaults, wayChaserDefaults);
-    }
+    defaults: (newDefaults) => _defaults(newDefaults, wayChaserDefaults)
 });
 
 export { WayChaserProblem, WayChaserResponse, _waychaser, isValidationSuccess, sortHandlers, waychaser };