mappersmith - npm Package Compare versions

Comparing version 2.42.0 to 2.43.0-beta.0

client-builder.d.ts

 import { Manifest, ManifestOptions, GlobalConfigs, ResourceTypeConstraint } from './manifest';
 import { Response } from './response';
 import { RequestContext } from './request';
-import { Gateway } from './gateway';
+import { Gateway } from './gateway/index';
 import type { Params } from './types';
@@ -6,0 +6,0 @@ export type AsyncFunction = (params?: Params, context?: RequestContext) => Promise<Response>;

client-builder.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_builder_exports = {};
+__export(client_builder_exports, {
+  ClientBuilder: () => ClientBuilder,
+  default: () => client_builder_default
 });
-exports["default"] = exports.ClientBuilder = void 0;
-var _manifest = require("./manifest");
-var _request = require("./request");
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-var isFactoryConfigured = function isFactoryConfigured(factory) {
+module.exports = __toCommonJS(client_builder_exports);
+var import_manifest = require("./manifest");
+var import_request = require("./request");
+const isFactoryConfigured = (factory) => {
   if (!factory || !factory()) {
@@ -24,151 +33,114 @@ return false;
 };
-
-/**
- * @typedef ClientBuilder
- * @param {Object} manifestDefinition - manifest definition with at least the `resources` key
- * @param {Function} GatewayClassFactory - factory function that returns a gateway class
- */
-var ClientBuilder = /*#__PURE__*/function () {
-  function ClientBuilder(manifestDefinition, GatewayClassFactory, configs) {
-    _classCallCheck(this, ClientBuilder);
-    _defineProperty(this, "Promise", void 0);
-    _defineProperty(this, "manifest", void 0);
-    _defineProperty(this, "GatewayClassFactory", void 0);
-    _defineProperty(this, "maxMiddlewareStackExecutionAllowed", void 0);
+class ClientBuilder {
+  Promise;
+  manifest;
+  GatewayClassFactory;
+  maxMiddlewareStackExecutionAllowed;
+  constructor(manifestDefinition, GatewayClassFactory, configs) {
     if (!manifestDefinition) {
-      throw new Error("[Mappersmith] invalid manifest (".concat(manifestDefinition, ")"));
+      throw new Error(`[Mappersmith] invalid manifest (${manifestDefinition})`);
     }
     if (!isFactoryConfigured(GatewayClassFactory)) {
-      throw new Error('[Mappersmith] gateway class not configured (configs.gateway)');
+      throw new Error("[Mappersmith] gateway class not configured (configs.gateway)");
     }
     if (!configs.Promise) {
-      throw new Error('[Mappersmith] Promise not configured (configs.Promise)');
+      throw new Error("[Mappersmith] Promise not configured (configs.Promise)");
     }
     this.Promise = configs.Promise;
-    this.manifest = new _manifest.Manifest(manifestDefinition, configs);
+    this.manifest = new import_manifest.Manifest(manifestDefinition, configs);
     this.GatewayClassFactory = GatewayClassFactory;
     this.maxMiddlewareStackExecutionAllowed = configs.maxMiddlewareStackExecutionAllowed;
   }
-  _createClass(ClientBuilder, [{
-    key: "build",
-    value: function build() {
-      var _this = this;
-      var client = {
-        _manifest: this.manifest
+  build() {
+    const client = { _manifest: this.manifest };
+    this.manifest.eachResource((resourceName, methods) => {
+      client[resourceName] = this.buildResource(resourceName, methods);
+    });
+    return client;
+  }
+  buildResource(resourceName, methods) {
+    const initialResourceValue = {};
+    const resource = methods.reduce((resource2, method) => {
+      const resourceMethod = (requestParams, context) => {
+        const request = new import_request.Request(method.descriptor, requestParams, context);
+        return this.invokeMiddlewares(String(resourceName), method.name, request);
       };
-      this.manifest.eachResource(function (resourceName, methods) {
-        client[resourceName] = _this.buildResource(resourceName, methods);
-      });
-      return client;
-    }
-  }, {
-    key: "buildResource",
-    value: function buildResource(resourceName, methods) {
-      var _this2 = this;
-      var initialResourceValue = {};
-      var resource = methods.reduce(function (resource, method) {
-        var resourceMethod = function resourceMethod(requestParams, context) {
-          var request = new _request.Request(method.descriptor, requestParams, context);
-          // `resourceName` can be `PropertyKey`, making this `string | number | Symbol`, therefore the string conversion
-          // to stop type bleeding.
-          return _this2.invokeMiddlewares(String(resourceName), method.name, request);
-        };
-        return _objectSpread(_objectSpread({}, resource), {}, _defineProperty({}, method.name, resourceMethod));
-      }, initialResourceValue);
-
-      // @hint: This type assert is needed as the compiler cannot be made to understand that the reduce produce a
-      // non-partial result on a partial input. This is due to a shortcoming of the type signature for Array<T>.reduce().
-      // @link: https://github.com/microsoft/TypeScript/blob/v3.7.2/lib/lib.es5.d.ts#L1186
-      return resource;
-    }
-  }, {
-    key: "invokeMiddlewares",
-    value: function invokeMiddlewares(resourceName, resourceMethod, initialRequest) {
-      var _this3 = this;
-      var middleware = this.manifest.createMiddleware({
-        resourceName: resourceName,
-        resourceMethod: resourceMethod
-      });
-      var GatewayClass = this.GatewayClassFactory();
-      var gatewayConfigs = this.manifest.gatewayConfigs;
-      var requestPhaseFailureContext = {
-        middleware: null,
-        returnedInvalidRequest: false,
-        abortExecution: false
+      return {
+        ...resource2,
+        [method.name]: resourceMethod
       };
-      var getInitialRequest = function getInitialRequest() {
-        return _this3.Promise.resolve(initialRequest);
+    }, initialResourceValue);
+    return resource;
+  }
+  invokeMiddlewares(resourceName, resourceMethod, initialRequest) {
+    const middleware = this.manifest.createMiddleware({ resourceName, resourceMethod });
+    const GatewayClass = this.GatewayClassFactory();
+    const gatewayConfigs = this.manifest.gatewayConfigs;
+    const requestPhaseFailureContext = {
+      middleware: null,
+      returnedInvalidRequest: false,
+      abortExecution: false
+    };
+    const getInitialRequest = () => this.Promise.resolve(initialRequest);
+    const chainRequestPhase = (next, middleware2) => () => {
+      const abort = (error) => {
+        requestPhaseFailureContext.abortExecution = true;
+        throw error;
       };
-      var chainRequestPhase = function chainRequestPhase(next, middleware) {
-        return function () {
-          var abort = function abort(error) {
-            requestPhaseFailureContext.abortExecution = true;
-            throw error;
-          };
-          return _this3.Promise.resolve().then(function () {
-            return middleware.prepareRequest(next, abort);
-          }).then(function (request) {
-            if (request instanceof _request.Request) {
-              return request;
-            }
-
-            // FIXME: Here be dragons: prepareRequest is typed as Promise<Response | void>
-            // but this code clearly expects it can be something else... anything.
-            // Hence manual cast to `unknown` above.
-            requestPhaseFailureContext.returnedInvalidRequest = true;
-            var typeValue = _typeof(request);
-            var prettyType = typeValue === 'object' || typeValue === 'function' ?
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            request.name || typeValue : typeValue;
-            throw new Error("[Mappersmith] middleware \"".concat(middleware.__name, "\" should return \"Request\" but returned \"").concat(prettyType, "\""));
-          })["catch"](function (e) {
-            requestPhaseFailureContext.middleware = middleware.__name || null;
-            throw e;
-          });
-        };
+      return this.Promise.resolve().then(() => middleware2.prepareRequest(next, abort)).then((request) => {
+        if (request instanceof import_request.Request) {
+          return request;
+        }
+        requestPhaseFailureContext.returnedInvalidRequest = true;
+        const typeValue = typeof request;
+        const prettyType = typeValue === "object" || typeValue === "function" ? (
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          request.name || typeValue
+        ) : typeValue;
+        throw new Error(
+          `[Mappersmith] middleware "${middleware2.__name}" should return "Request" but returned "${prettyType}"`
+        );
+      }).catch((e) => {
+        requestPhaseFailureContext.middleware = middleware2.__name || null;
+        throw e;
+      });
+    };
+    const prepareRequest = middleware.reduce(chainRequestPhase, getInitialRequest);
+    let executions = 0;
+    const executeMiddlewareStack = () => prepareRequest().catch((e) => {
+      const { returnedInvalidRequest, abortExecution, middleware: middleware2 } = requestPhaseFailureContext;
+      if (returnedInvalidRequest || abortExecution) {
+        throw e;
+      }
+      const error = new Error(
+        `[Mappersmith] middleware "${middleware2}" failed in the request phase: ${e.message}`
+      );
+      error.stack = e.stack;
+      throw error;
+    }).then((finalRequest) => {
+      executions++;
+      if (executions > this.maxMiddlewareStackExecutionAllowed) {
+        throw new Error(
+          `[Mappersmith] infinite loop detected (middleware stack invoked ${executions} times). Check the use of "renew" in one of the middleware.`
+        );
+      }
+      const renew = executeMiddlewareStack;
+      const chainResponsePhase = (previousValue, currentValue) => () => {
+        const nextValue = currentValue.response(previousValue, renew, finalRequest);
+        return nextValue;
       };
-      var prepareRequest = middleware.reduce(chainRequestPhase, getInitialRequest);
-      var executions = 0;
-      var executeMiddlewareStack = function executeMiddlewareStack() {
-        return prepareRequest()["catch"](function (e) {
-          var returnedInvalidRequest = requestPhaseFailureContext.returnedInvalidRequest,
-            abortExecution = requestPhaseFailureContext.abortExecution,
-            middleware = requestPhaseFailureContext.middleware;
-          if (returnedInvalidRequest || abortExecution) {
-            throw e;
-          }
-          var error = new Error("[Mappersmith] middleware \"".concat(middleware, "\" failed in the request phase: ").concat(e.message));
-          error.stack = e.stack;
-          throw error;
-        }).then(function (finalRequest) {
-          executions++;
-          if (executions > _this3.maxMiddlewareStackExecutionAllowed) {
-            throw new Error("[Mappersmith] infinite loop detected (middleware stack invoked ".concat(executions, " times). Check the use of \"renew\" in one of the middleware."));
-          }
-          var renew = executeMiddlewareStack;
-          var chainResponsePhase = function chainResponsePhase(previousValue, currentValue) {
-            return function () {
-              // Deliberately putting this on two separate lines - to get typescript to not return "any"
-              var nextValue = currentValue.response(previousValue, renew, finalRequest);
-              return nextValue;
-            };
-          };
-          var callGateway = function callGateway() {
-            return new GatewayClass(finalRequest, gatewayConfigs).call();
-          };
-          var execute = middleware.reduce(chainResponsePhase, callGateway);
-          return execute();
-        });
-      };
-      return new this.Promise(function (resolve, reject) {
-        executeMiddlewareStack().then(function (response) {
-          return resolve(response);
-        })["catch"](reject);
-      });
-    }
-  }]);
-  return ClientBuilder;
-}();
-exports.ClientBuilder = ClientBuilder;
-var _default = ClientBuilder;
-exports["default"] = _default;
+      const callGateway = () => new GatewayClass(finalRequest, gatewayConfigs).call();
+      const execute = middleware.reduce(chainResponsePhase, callGateway);
+      return execute();
+    });
+    return new this.Promise((resolve, reject) => {
+      executeMiddlewareStack().then((response) => resolve(response)).catch(reject);
+    });
+  }
+}
+var client_builder_default = ClientBuilder;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClientBuilder
+});
+//# sourceMappingURL=client-builder.js.map

gateway/fetch.d.ts

 /// <reference types="node" />
-import { Gateway, Method } from '../gateway';
+import { Gateway, Method } from './index';
 import Response from '../response';
@@ -4,0 +4,0 @@ /**

gateway/fetch.js

 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fetch_exports = {};
+__export(fetch_exports, {
+  Fetch: () => Fetch,
+  default: () => fetch_default
 });
-exports["default"] = exports.Fetch = void 0;
-var _gateway = require("../gateway");
-var _response = _interopRequireDefault(require("../response"));
-var _mappersmith = require("../mappersmith");
-var _utils = require("../utils");
-var _timeoutError = require("./timeout-error");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } // Fetch can be used in nodejs, so it should always use the btoa util
-/**
- * Gateway which uses the "fetch" implementation configured in "configs.fetch".
- * By default "configs.fetch" will receive the global fetch, this gateway doesn't
- * use browser specific code, with a proper "fetch" implementation it can also be
- * used with node.js
- */
-var Fetch = /*#__PURE__*/function (_Gateway) {
-  _inherits(Fetch, _Gateway);
-  var _super = _createSuper(Fetch);
-  function Fetch() {
-    _classCallCheck(this, Fetch);
-    return _super.apply(this, arguments);
+module.exports = __toCommonJS(fetch_exports);
+var import_index = require("./index");
+var import_response = __toESM(require("../response"));
+var import_mappersmith = require("../mappersmith");
+var import_utils = require("../utils/index");
+var import_timeout_error = require("./timeout-error");
+class Fetch extends import_index.Gateway {
+  get() {
+    this.performRequest("get");
   }
-  _createClass(Fetch, [{
-    key: "get",
-    value: function get() {
-      this.performRequest('get');
+  head() {
+    this.performRequest("head");
+  }
+  post() {
+    this.performRequest("post");
+  }
+  put() {
+    this.performRequest("put");
+  }
+  patch() {
+    this.performRequest("patch");
+  }
+  delete() {
+    this.performRequest("delete");
+  }
+  performRequest(method) {
+    const fetch = import_mappersmith.configs.fetch;
+    if (!fetch) {
+      throw new Error(
+        `[Mappersmith] global fetch does not exist, please assign "configs.fetch" to a valid implementation`
+      );
     }
-  }, {
-    key: "head",
-    value: function head() {
-      this.performRequest('head');
+    const customHeaders = {};
+    const body = this.prepareBody(method, customHeaders);
+    const auth = this.request.auth();
+    if (auth) {
+      const username = auth.username || "";
+      const password = auth.password || "";
+      customHeaders["authorization"] = `Basic ${(0, import_utils.btoa)(`${username}:${password}`)}`;
     }
-  }, {
-    key: "post",
-    value: function post() {
-      this.performRequest('post');
+    const headers = (0, import_utils.assign)(customHeaders, this.request.headers());
+    const requestMethod = this.shouldEmulateHTTP() ? "post" : method;
+    const init = (0, import_utils.assign)({ method: requestMethod, headers, body }, this.options().Fetch);
+    const timeout = this.request.timeout();
+    let timer = null;
+    let canceled = false;
+    if (timeout) {
+      timer = setTimeout(() => {
+        canceled = true;
+        const error = (0, import_timeout_error.createTimeoutError)(`Timeout (${timeout}ms)`);
+        this.dispatchClientError(error.message, error);
+      }, timeout);
     }
-  }, {
-    key: "put",
-    value: function put() {
-      this.performRequest('put');
-    }
-  }, {
-    key: "patch",
-    value: function patch() {
-      this.performRequest('patch');
-    }
-  }, {
-    key: "delete",
-    value: function _delete() {
-      this.performRequest('delete');
-    }
-  }, {
-    key: "performRequest",
-    value: function performRequest(method) {
-      var _this = this;
-      var fetch = _mappersmith.configs.fetch;
-      if (!fetch) {
-        throw new Error("[Mappersmith] global fetch does not exist, please assign \"configs.fetch\" to a valid implementation");
+    fetch(this.request.url(), init).then((fetchResponse) => {
+      if (canceled) {
+        return;
       }
-      var customHeaders = {};
-      var body = this.prepareBody(method, customHeaders);
-      var auth = this.request.auth();
-      if (auth) {
-        var username = auth.username || '';
-        var password = auth.password || '';
-        customHeaders['authorization'] = "Basic ".concat((0, _utils.btoa)("".concat(username, ":").concat(password)));
-      }
-      var headers = (0, _utils.assign)(customHeaders, this.request.headers());
-      var requestMethod = this.shouldEmulateHTTP() ? 'post' : method;
-      var init = (0, _utils.assign)({
-        method: requestMethod,
-        headers: headers,
-        body: body
-      }, this.options().Fetch);
-      var timeout = this.request.timeout();
-      var timer = null;
-      var canceled = false;
-      if (timeout) {
-        timer = setTimeout(function () {
-          canceled = true;
-          var error = (0, _timeoutError.createTimeoutError)("Timeout (".concat(timeout, "ms)"));
-          _this.dispatchClientError(error.message, error);
-        }, timeout);
-      }
-      fetch(this.request.url(), init).then(function (fetchResponse) {
-        if (canceled) {
-          return;
-        }
-        timer && clearTimeout(timer);
-        var responseData;
-        if (_this.request.isBinary()) {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          if (typeof fetchResponse.buffer === 'function') {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            responseData = fetchResponse.buffer();
-          } else {
-            responseData = fetchResponse.arrayBuffer();
-          }
+      timer && clearTimeout(timer);
+      let responseData;
+      if (this.request.isBinary()) {
+        if (typeof fetchResponse.buffer === "function") {
+          responseData = fetchResponse.buffer();
         } else {
-          responseData = fetchResponse.text();
+          responseData = fetchResponse.arrayBuffer();
         }
-        responseData.then(function (data) {
-          _this.dispatchResponse(_this.createResponse(fetchResponse, data));
-        });
-      })["catch"](function (error) {
-        if (canceled) {
-          return;
-        }
-        timer && clearTimeout(timer);
-        _this.dispatchClientError(error.message, error);
+      } else {
+        responseData = fetchResponse.text();
+      }
+      responseData.then((data) => {
+        this.dispatchResponse(this.createResponse(fetchResponse, data));
       });
-    }
-  }, {
-    key: "createResponse",
-    value: function createResponse(fetchResponse, data) {
-      var status = fetchResponse.status;
-      var responseHeaders = {};
-      fetchResponse.headers.forEach(function (value, key) {
-        responseHeaders[key] = value;
-      });
-
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      return new _response["default"](this.request, status, data, responseHeaders);
-    }
-  }]);
-  return Fetch;
-}(_gateway.Gateway);
-exports.Fetch = Fetch;
-var _default = Fetch;
-exports["default"] = _default;
+    }).catch((error) => {
+      if (canceled) {
+        return;
+      }
+      timer && clearTimeout(timer);
+      this.dispatchClientError(error.message, error);
+    });
+  }
+  createResponse(fetchResponse, data) {
+    const status = fetchResponse.status;
+    const responseHeaders = {};
+    fetchResponse.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    return new import_response.default(this.request, status, data, responseHeaders);
+  }
+}
+var fetch_default = Fetch;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fetch
+});
+//# sourceMappingURL=fetch.js.map

gateway/http.d.ts

 /// <reference types="node" />
 import * as http from 'http';
-import { Gateway, Method } from '../gateway';
+import { Gateway, Method } from './index';
 import type { HTTPGatewayConfiguration, HTTPRequestParams } from './types';
@@ -5,0 +5,0 @@ import Response from '../response';

gateway/http.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var http_exports = {};
+__export(http_exports, {
+  HTTP: () => HTTP,
+  default: () => http_default
 });
-exports["default"] = exports.HTTP = void 0;
-var url = _interopRequireWildcard(require("url"));
-var http = _interopRequireWildcard(require("http"));
-var https = _interopRequireWildcard(require("https"));
-var _utils = require("../utils");
-var _gateway = require("../gateway");
-var _response = _interopRequireDefault(require("../response"));
-var _timeoutError = require("./timeout-error");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-var HTTP = /*#__PURE__*/function (_Gateway) {
-  _inherits(HTTP, _Gateway);
-  var _super = _createSuper(HTTP);
-  function HTTP() {
-    var _this;
-    _classCallCheck(this, HTTP);
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    _this = _super.call.apply(_super, [this].concat(args));
-    _defineProperty(_assertThisInitialized(_this), "canceled", false);
-    return _this;
+module.exports = __toCommonJS(http_exports);
+var url = __toESM(require("url"));
+var http = __toESM(require("http"));
+var https = __toESM(require("https"));
+var import_utils = require("../utils/index");
+var import_index = require("./index");
+var import_response = __toESM(require("../response"));
+var import_timeout_error = require("./timeout-error");
+class HTTP extends import_index.Gateway {
+  canceled = false;
+  get() {
+    this.performRequest("get");
   }
-  _createClass(HTTP, [{
-    key: "get",
-    value: function get() {
-      this.performRequest('get');
+  head() {
+    this.performRequest("head");
+  }
+  post() {
+    this.performRequest("post");
+  }
+  put() {
+    this.performRequest("put");
+  }
+  patch() {
+    this.performRequest("patch");
+  }
+  delete() {
+    this.performRequest("delete");
+  }
+  performRequest(method) {
+    const headers = {};
+    const defaults = url.parse(this.request.url());
+    const requestMethod = this.shouldEmulateHTTP() ? "post" : method;
+    const body = this.prepareBody(method, headers);
+    const timeout = this.request.timeout();
+    this.canceled = false;
+    if (body && typeof body !== "boolean" && typeof body !== "number" && typeof body.length === "number") {
+      headers["content-length"] = Buffer.byteLength(body);
     }
-  }, {
-    key: "head",
-    value: function head() {
-      this.performRequest('head');
+    const handler = defaults.protocol === "https:" ? https : http;
+    const requestParams = (0, import_utils.assign)(defaults, {
+      method: requestMethod,
+      headers: (0, import_utils.assign)(headers, this.request.headers())
+    });
+    const auth = this.request.auth();
+    if (auth) {
+      const username = auth.username || "";
+      const password = auth.password || "";
+      requestParams["auth"] = `${username}:${password}`;
     }
-  }, {
-    key: "post",
-    value: function post() {
-      this.performRequest('post');
+    const httpOptions = this.options().HTTP;
+    if (httpOptions.useSocketConnectionTimeout) {
+      requestParams["timeout"] = timeout;
     }
-  }, {
-    key: "put",
-    value: function put() {
-      this.performRequest('put');
+    if (httpOptions.configure) {
+      (0, import_utils.assign)(requestParams, httpOptions.configure(requestParams));
     }
-  }, {
-    key: "patch",
-    value: function patch() {
-      this.performRequest('patch');
+    if (httpOptions.onRequestWillStart) {
+      httpOptions.onRequestWillStart(requestParams);
     }
-  }, {
-    key: "delete",
-    value: function _delete() {
-      this.performRequest('delete');
-    }
-  }, {
-    key: "performRequest",
-    value: function performRequest(method) {
-      var _this2 = this;
-      var headers = {};
-      // FIXME: Deprecated API
-      // eslint-disable-next-line n/no-deprecated-api
-      var defaults = url.parse(this.request.url());
-      var requestMethod = this.shouldEmulateHTTP() ? 'post' : method;
-      var body = this.prepareBody(method, headers);
-      var timeout = this.request.timeout();
-      this.canceled = false;
-      if (body && typeof body !== 'boolean' && typeof body !== 'number' && typeof body.length === 'number') {
-        headers['content-length'] = Buffer.byteLength(body);
+    const httpRequest = handler.request(
+      requestParams,
+      (httpResponse) => this.onResponse(httpResponse, httpOptions, requestParams)
+    );
+    httpRequest.on("socket", (socket) => {
+      if (httpOptions.onRequestSocketAssigned) {
+        httpOptions.onRequestSocketAssigned(requestParams);
       }
-      var handler = defaults.protocol === 'https:' ? https : http;
-      var requestParams = (0, _utils.assign)(defaults, {
-        method: requestMethod,
-        headers: (0, _utils.assign)(headers, this.request.headers())
-      });
-      var auth = this.request.auth();
-      if (auth) {
-        var username = auth.username || '';
-        var password = auth.password || '';
-        requestParams['auth'] = "".concat(username, ":").concat(password);
-      }
-      var httpOptions = this.options().HTTP;
-      if (httpOptions.useSocketConnectionTimeout) {
-        requestParams['timeout'] = timeout;
-      }
-      if (httpOptions.configure) {
-        (0, _utils.assign)(requestParams, httpOptions.configure(requestParams));
-      }
-      if (httpOptions.onRequestWillStart) {
-        httpOptions.onRequestWillStart(requestParams);
-      }
-      var httpRequest = handler.request(requestParams, function (httpResponse) {
-        return _this2.onResponse(httpResponse, httpOptions, requestParams);
-      });
-      httpRequest.on('socket', function (socket) {
-        if (httpOptions.onRequestSocketAssigned) {
-          httpOptions.onRequestSocketAssigned(requestParams);
+      socket.on("lookup", () => {
+        if (httpOptions.onSocketLookup) {
+          httpOptions.onSocketLookup(requestParams);
         }
-        socket.on('lookup', function () {
-          if (httpOptions.onSocketLookup) {
-            httpOptions.onSocketLookup(requestParams);
-          }
-        });
-        socket.on('connect', function () {
-          if (httpOptions.onSocketConnect) {
-            httpOptions.onSocketConnect(requestParams);
-          }
-        });
-        socket.on('secureConnect', function () {
-          if (httpOptions.onSocketSecureConnect) {
-            httpOptions.onSocketSecureConnect(requestParams);
-          }
-        });
       });
-      httpRequest.on('error', function (e) {
-        return _this2.onError(e);
-      });
-      body && httpRequest.write(body);
-      if (timeout) {
-        if (!httpOptions.useSocketConnectionTimeout) {
-          httpRequest.setTimeout(timeout);
+      socket.on("connect", () => {
+        if (httpOptions.onSocketConnect) {
+          httpOptions.onSocketConnect(requestParams);
         }
-        httpRequest.on('timeout', function () {
-          _this2.canceled = true;
-          httpRequest.abort();
-          var error = (0, _timeoutError.createTimeoutError)("Timeout (".concat(timeout, "ms)"));
-          _this2.dispatchClientError(error.message, error);
-        });
-      }
-      httpRequest.end();
-    }
-  }, {
-    key: "onResponse",
-    value: function onResponse(httpResponse, httpOptions, requestParams) {
-      var _this3 = this;
-      var rawData = [];
-      if (!this.request.isBinary()) {
-        httpResponse.setEncoding('utf8');
-      }
-      httpResponse.once('readable', function () {
-        if (httpOptions.onResponseReadable) {
-          httpOptions.onResponseReadable(requestParams);
-        }
       });
-      httpResponse.on('data', function (chunk) {
-        return rawData.push(chunk);
-      }).on('end', function () {
-        if (_this3.canceled) {
-          return;
+      socket.on("secureConnect", () => {
+        if (httpOptions.onSocketSecureConnect) {
+          httpOptions.onSocketSecureConnect(requestParams);
         }
-        _this3.dispatchResponse(_this3.createResponse(httpResponse, rawData));
       });
-      httpResponse.on('end', function () {
-        if (httpOptions.onResponseEnd) {
-          httpOptions.onResponseEnd(requestParams);
-        }
+    });
+    httpRequest.on("error", (e) => this.onError(e));
+    body && httpRequest.write(body);
+    if (timeout) {
+      if (!httpOptions.useSocketConnectionTimeout) {
+        httpRequest.setTimeout(timeout);
+      }
+      httpRequest.on("timeout", () => {
+        this.canceled = true;
+        httpRequest.abort();
+        const error = (0, import_timeout_error.createTimeoutError)(`Timeout (${timeout}ms)`);
+        this.dispatchClientError(error.message, error);
       });
     }
-  }, {
-    key: "onError",
-    value: function onError(e) {
+    httpRequest.end();
+  }
+  onResponse(httpResponse, httpOptions, requestParams) {
+    const rawData = [];
+    if (!this.request.isBinary()) {
+      httpResponse.setEncoding("utf8");
+    }
+    httpResponse.once("readable", () => {
+      if (httpOptions.onResponseReadable) {
+        httpOptions.onResponseReadable(requestParams);
+      }
+    });
+    httpResponse.on("data", (chunk) => rawData.push(chunk)).on("end", () => {
       if (this.canceled) {
         return;
       }
-      this.dispatchClientError(e.message, e);
+      this.dispatchResponse(this.createResponse(httpResponse, rawData));
+    });
+    httpResponse.on("end", () => {
+      if (httpOptions.onResponseEnd) {
+        httpOptions.onResponseEnd(requestParams);
+      }
+    });
+  }
+  onError(e) {
+    if (this.canceled) {
+      return;
     }
-  }, {
-    key: "createResponse",
-    value: function createResponse(httpResponse, rawData) {
-      var responseData = this.request.isBinary() ? Buffer.concat(rawData) : rawData.join('');
-      return new _response["default"](this.request, httpResponse.statusCode, responseData,
+    this.dispatchClientError(e.message, e);
+  }
+  createResponse(httpResponse, rawData) {
+    const responseData = this.request.isBinary() ? Buffer.concat(rawData) : rawData.join("");
+    return new import_response.default(
+      this.request,
+      httpResponse.statusCode,
+      responseData,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      httpResponse.headers);
-    }
-  }]);
-  return HTTP;
-}(_gateway.Gateway);
-exports.HTTP = HTTP;
-var _default = HTTP;
-exports["default"] = _default;
+      httpResponse.headers
+    );
+  }
+}
+var http_default = HTTP;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HTTP
+});
+//# sourceMappingURL=http.js.map

gateway/mock.d.ts

@@ -1,2 +0,2 @@
-import { Gateway } from '../gateway';
+import { Gateway } from './index';
 export declare class Mock extends Gateway {
@@ -3,0 +3,0 @@ get(): void;

gateway/mock.js

 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mock_exports = {};
+__export(mock_exports, {
+  Mock: () => Mock,
+  default: () => mock_default
 });
-exports["default"] = exports.Mock = void 0;
-var _gateway = require("../gateway");
-var _test = require("../test");
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-var Mock = /*#__PURE__*/function (_Gateway) {
-  _inherits(Mock, _Gateway);
-  var _super = _createSuper(Mock);
-  function Mock() {
-    _classCallCheck(this, Mock);
-    return _super.apply(this, arguments);
+module.exports = __toCommonJS(mock_exports);
+var import_index = require("./index");
+var import_test = require("../test/index");
+class Mock extends import_index.Gateway {
+  get() {
+    this.callMock();
   }
-  _createClass(Mock, [{
-    key: "get",
-    value: function get() {
-      this.callMock();
-    }
-  }, {
-    key: "head",
-    value: function head() {
-      this.callMock();
-    }
-  }, {
-    key: "post",
-    value: function post() {
-      this.callMock();
-    }
-  }, {
-    key: "put",
-    value: function put() {
-      this.callMock();
-    }
-  }, {
-    key: "patch",
-    value: function patch() {
-      this.callMock();
-    }
-  }, {
-    key: "delete",
-    value: function _delete() {
-      this.callMock();
-    }
-  }, {
-    key: "callMock",
-    value: function callMock() {
-      var _this = this;
-      return (0, _test.lookupResponseAsync)(this.request).then(function (response) {
-        return _this.dispatchResponse(response);
-      })["catch"](function (e) {
-        return _this.dispatchClientError(e.message, e);
-      });
-    }
-  }]);
-  return Mock;
-}(_gateway.Gateway);
-exports.Mock = Mock;
-var _default = Mock;
-exports["default"] = _default;
+  head() {
+    this.callMock();
+  }
+  post() {
+    this.callMock();
+  }
+  put() {
+    this.callMock();
+  }
+  patch() {
+    this.callMock();
+  }
+  delete() {
+    this.callMock();
+  }
+  callMock() {
+    return (0, import_test.lookupResponseAsync)(this.request).then((response) => this.dispatchResponse(response)).catch((e) => this.dispatchClientError(e.message, e));
+  }
+}
+var mock_default = Mock;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Mock
+});
+//# sourceMappingURL=mock.js.map

gateway/timeout-error.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var timeout_error_exports = {};
+__export(timeout_error_exports, {
+  createTimeoutError: () => createTimeoutError,
+  isTimeoutError: () => isTimeoutError
 });
-exports.isTimeoutError = exports.createTimeoutError = void 0;
-var isTimeoutError = function isTimeoutError(e) {
-  return e && e.name === 'TimeoutError';
+module.exports = __toCommonJS(timeout_error_exports);
+const isTimeoutError = (e) => {
+  return e && e.name === "TimeoutError";
 };
-exports.isTimeoutError = isTimeoutError;
-var createTimeoutError = function createTimeoutError(message) {
-  var error = new Error(message);
-  error.name = 'TimeoutError';
+const createTimeoutError = (message) => {
+  const error = new Error(message);
+  error.name = "TimeoutError";
   return error;
 };
-exports.createTimeoutError = createTimeoutError;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTimeoutError,
+  isTimeoutError
+});
+//# sourceMappingURL=timeout-error.js.map

gateway/types.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

gateway/xhr.d.ts

@@ -1,4 +0,4 @@
-import { Gateway, Method } from '../gateway';
+import { Gateway, Method } from './index';
 import Response from '../response';
-import { Headers } from '../types';
+import type { Headers } from '../types';
 export declare class XHR extends Gateway {
@@ -5,0 +5,0 @@ private canceled;

gateway/xhr.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var xhr_exports = {};
+__export(xhr_exports, {
+  XHR: () => XHR,
+  default: () => xhr_default
 });
-exports["default"] = exports.XHR = void 0;
-var _gateway = require("../gateway");
-var _response = _interopRequireDefault(require("../response"));
-var _utils = require("../utils");
-var _timeoutError = require("./timeout-error");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-var toBase64 = window.btoa || _utils.btoa;
-var XHR = /*#__PURE__*/function (_Gateway) {
-  _inherits(XHR, _Gateway);
-  var _super = _createSuper(XHR);
-  function XHR() {
-    var _this;
-    _classCallCheck(this, XHR);
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
+module.exports = __toCommonJS(xhr_exports);
+var import_index = require("./index");
+var import_response = __toESM(require("../response"));
+var import_utils = require("../utils/index");
+var import_timeout_error = require("./timeout-error");
+let toBase64;
+try {
+  toBase64 = window.btoa;
+} catch {
+  toBase64 = import_utils.btoa;
+}
+class XHR extends import_index.Gateway {
+  canceled = false;
+  timer;
+  get() {
+    const xmlHttpRequest = this.createXHR();
+    xmlHttpRequest.open("GET", this.request.url(), true);
+    this.setHeaders(xmlHttpRequest, {});
+    this.configureTimeout(xmlHttpRequest);
+    this.configureBinary(xmlHttpRequest);
+    xmlHttpRequest.send();
+  }
+  head() {
+    const xmlHttpRequest = this.createXHR();
+    xmlHttpRequest.open("HEAD", this.request.url(), true);
+    this.setHeaders(xmlHttpRequest, {});
+    this.configureTimeout(xmlHttpRequest);
+    this.configureBinary(xmlHttpRequest);
+    xmlHttpRequest.send();
+  }
+  post() {
+    this.performRequest("post");
+  }
+  put() {
+    this.performRequest("put");
+  }
+  patch() {
+    this.performRequest("patch");
+  }
+  delete() {
+    this.performRequest("delete");
+  }
+  configureBinary(xmlHttpRequest) {
+    if (this.request.isBinary()) {
+      xmlHttpRequest.responseType = "blob";
     }
-    _this = _super.call.apply(_super, [this].concat(args));
-    _defineProperty(_assertThisInitialized(_this), "canceled", false);
-    _defineProperty(_assertThisInitialized(_this), "timer", void 0);
-    return _this;
   }
-  _createClass(XHR, [{
-    key: "get",
-    value: function get() {
-      var xmlHttpRequest = this.createXHR();
-      xmlHttpRequest.open('GET', this.request.url(), true);
-      this.setHeaders(xmlHttpRequest, {});
-      this.configureTimeout(xmlHttpRequest);
-      this.configureBinary(xmlHttpRequest);
-      xmlHttpRequest.send();
+  configureTimeout(xmlHttpRequest) {
+    this.canceled = false;
+    this.timer = void 0;
+    const timeout = this.request.timeout();
+    if (timeout) {
+      xmlHttpRequest.timeout = timeout;
+      xmlHttpRequest.addEventListener("timeout", () => {
+        this.canceled = true;
+        this.timer && clearTimeout(this.timer);
+        const error = (0, import_timeout_error.createTimeoutError)(`Timeout (${timeout}ms)`);
+        this.dispatchClientError(error.message, error);
+      });
+      this.timer = setTimeout(() => {
+        this.canceled = true;
+        const error = (0, import_timeout_error.createTimeoutError)(`Timeout (${timeout}ms)`);
+        this.dispatchClientError(error.message, error);
+      }, timeout + 1);
     }
-  }, {
-    key: "head",
-    value: function head() {
-      var xmlHttpRequest = this.createXHR();
-      xmlHttpRequest.open('HEAD', this.request.url(), true);
-      this.setHeaders(xmlHttpRequest, {});
-      this.configureTimeout(xmlHttpRequest);
-      this.configureBinary(xmlHttpRequest);
-      xmlHttpRequest.send();
-    }
-  }, {
-    key: "post",
-    value: function post() {
-      this.performRequest('post');
-    }
-  }, {
-    key: "put",
-    value: function put() {
-      this.performRequest('put');
-    }
-  }, {
-    key: "patch",
-    value: function patch() {
-      this.performRequest('patch');
-    }
-  }, {
-    key: "delete",
-    value: function _delete() {
-      this.performRequest('delete');
-    }
-  }, {
-    key: "configureBinary",
-    value: function configureBinary(xmlHttpRequest) {
-      if (this.request.isBinary()) {
-        xmlHttpRequest.responseType = 'blob';
+  }
+  configureCallbacks(xmlHttpRequest) {
+    xmlHttpRequest.addEventListener("load", () => {
+      if (this.canceled) {
+        return;
       }
-    }
-  }, {
-    key: "configureTimeout",
-    value: function configureTimeout(xmlHttpRequest) {
-      var _this2 = this;
-      this.canceled = false;
-      this.timer = undefined;
-      var timeout = this.request.timeout();
-      if (timeout) {
-        xmlHttpRequest.timeout = timeout;
-        xmlHttpRequest.addEventListener('timeout', function () {
-          _this2.canceled = true;
-          _this2.timer && clearTimeout(_this2.timer);
-          var error = (0, _timeoutError.createTimeoutError)("Timeout (".concat(timeout, "ms)"));
-          _this2.dispatchClientError(error.message, error);
-        });
-
-        // PhantomJS doesn't support timeout for XMLHttpRequest
-        this.timer = setTimeout(function () {
-          _this2.canceled = true;
-          var error = (0, _timeoutError.createTimeoutError)("Timeout (".concat(timeout, "ms)"));
-          _this2.dispatchClientError(error.message, error);
-        }, timeout + 1);
+      this.timer && clearTimeout(this.timer);
+      this.dispatchResponse(this.createResponse(xmlHttpRequest));
+    });
+    xmlHttpRequest.addEventListener("error", (e) => {
+      if (this.canceled) {
+        return;
       }
-    }
-  }, {
-    key: "configureCallbacks",
-    value: function configureCallbacks(xmlHttpRequest) {
-      var _this3 = this;
-      xmlHttpRequest.addEventListener('load', function () {
-        if (_this3.canceled) {
-          return;
-        }
-        _this3.timer && clearTimeout(_this3.timer);
-        _this3.dispatchResponse(_this3.createResponse(xmlHttpRequest));
-      });
-      xmlHttpRequest.addEventListener('error', function (e) {
-        if (_this3.canceled) {
-          return;
-        }
-        _this3.timer && clearTimeout(_this3.timer);
-        var guessedErrorCause = e ?
+      this.timer && clearTimeout(this.timer);
+      const guessedErrorCause = e ? (
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        e.message || e.name : xmlHttpRequest.responseText;
-        var errorMessage = 'Network error';
-        var enhancedMessage = guessedErrorCause ? ": ".concat(guessedErrorCause) : '';
-        var error = new Error("".concat(errorMessage).concat(enhancedMessage));
-        _this3.dispatchClientError(errorMessage, error);
-      });
-      var xhrOptions = this.options().XHR;
-      if (xhrOptions.withCredentials) {
-        xmlHttpRequest.withCredentials = true;
-      }
-      if (xhrOptions.configure) {
-        xhrOptions.configure(xmlHttpRequest);
-      }
+        e.message || e.name
+      ) : xmlHttpRequest.responseText;
+      const errorMessage = "Network error";
+      const enhancedMessage = guessedErrorCause ? `: ${guessedErrorCause}` : "";
+      const error = new Error(`${errorMessage}${enhancedMessage}`);
+      this.dispatchClientError(errorMessage, error);
+    });
+    const xhrOptions = this.options().XHR;
+    if (xhrOptions.withCredentials) {
+      xmlHttpRequest.withCredentials = true;
     }
-  }, {
-    key: "performRequest",
-    value: function performRequest(method) {
-      var requestMethod = this.shouldEmulateHTTP() ? 'post' : method;
-      var xmlHttpRequest = this.createXHR();
-      xmlHttpRequest.open(requestMethod.toUpperCase(), this.request.url(), true);
-      var customHeaders = {};
-      var body = this.prepareBody(method, customHeaders);
-      this.setHeaders(xmlHttpRequest, customHeaders);
-      this.configureTimeout(xmlHttpRequest);
-      this.configureBinary(xmlHttpRequest);
-      xmlHttpRequest.send(body);
+    if (xhrOptions.configure) {
+      xhrOptions.configure(xmlHttpRequest);
     }
-  }, {
-    key: "createResponse",
-    value: function createResponse(xmlHttpRequest) {
-      var status = xmlHttpRequest.status;
-      var data = this.request.isBinary() ? xmlHttpRequest.response : xmlHttpRequest.responseText;
-      var responseHeaders = (0, _utils.parseResponseHeaders)(xmlHttpRequest.getAllResponseHeaders());
-      return new _response["default"](this.request, status, data, responseHeaders);
-    }
-  }, {
-    key: "setHeaders",
-    value: function setHeaders(xmlHttpRequest, customHeaders) {
-      var auth = this.request.auth();
-      var headers = (0, _utils.assign)(customHeaders, _objectSpread(_objectSpread({}, this.request.headers()), auth ? {
-        authorization: "Basic ".concat(toBase64("".concat(auth.username, ":").concat(auth.password)))
-      } : {}));
-      Object.keys(headers).forEach(function (headerName) {
-        xmlHttpRequest.setRequestHeader(headerName, "".concat(headers[headerName]));
-      });
-    }
-  }, {
-    key: "createXHR",
-    value: function createXHR() {
-      var xmlHttpRequest = new XMLHttpRequest();
-      this.configureCallbacks(xmlHttpRequest);
-      return xmlHttpRequest;
-    }
-  }]);
-  return XHR;
-}(_gateway.Gateway);
-exports.XHR = XHR;
-var _default = XHR;
-exports["default"] = _default;
+  }
+  performRequest(method) {
+    const requestMethod = this.shouldEmulateHTTP() ? "post" : method;
+    const xmlHttpRequest = this.createXHR();
+    xmlHttpRequest.open(requestMethod.toUpperCase(), this.request.url(), true);
+    const customHeaders = {};
+    const body = this.prepareBody(method, customHeaders);
+    this.setHeaders(xmlHttpRequest, customHeaders);
+    this.configureTimeout(xmlHttpRequest);
+    this.configureBinary(xmlHttpRequest);
+    xmlHttpRequest.send(body);
+  }
+  createResponse(xmlHttpRequest) {
+    const status = xmlHttpRequest.status;
+    const data = this.request.isBinary() ? xmlHttpRequest.response : xmlHttpRequest.responseText;
+    const responseHeaders = (0, import_utils.parseResponseHeaders)(xmlHttpRequest.getAllResponseHeaders());
+    return new import_response.default(this.request, status, data, responseHeaders);
+  }
+  setHeaders(xmlHttpRequest, customHeaders) {
+    const auth = this.request.auth();
+    const headers = (0, import_utils.assign)(customHeaders, {
+      ...this.request.headers(),
+      ...auth ? { authorization: `Basic ${toBase64(`${auth.username}:${auth.password}`)}` } : {}
+    });
+    Object.keys(headers).forEach((headerName) => {
+      xmlHttpRequest.setRequestHeader(headerName, `${headers[headerName]}`);
+    });
+  }
+  createXHR() {
+    const xmlHttpRequest = new XMLHttpRequest();
+    this.configureCallbacks(xmlHttpRequest);
+    return xmlHttpRequest;
+  }
+}
+var xhr_default = XHR;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  XHR
+});
+//# sourceMappingURL=xhr.js.map

index.d.ts

@@ -1,37 +0,23 @@
-import type { GlobalConfigs, ManifestOptions, ResourceTypeConstraint } from './manifest'
-export type { GlobalConfigs, ManifestOptions, ResourceTypeConstraint }
-export type { Request, RequestContext } from './request'
-export type { Headers, Params as Parameters, Auth as Authorization } from './types'
-export type { Gateway } from './gateway'
-export type { XHR as XhrGateway } from './gateway/xhr'
-export type { HTTP as HTTPGateway } from './gateway/http'
-export type { Fetch as FetchGateway } from './gateway/fetch'
-export type { Mock as MockGateway } from './gateway/mock'
-export type {
-  HTTPRequestParams,
-  HTTPGatewayConfiguration,
-  GatewayConfiguration,
-} from './gateway/types'
-export { Response, ParsedJSON } from './response'
-export type {
-  AbortFn,
-  Context,
-  Middleware,
-  MiddlewareDescriptor,
-  MiddlewareParams,
-  RenewFn,
-  RequestGetter,
-  ResponseGetter,
-} from './middleware'
-export type { AsyncFunction, AsyncFunctions, Client } from './client-builder'
+import type { GlobalConfigs, ManifestOptions, ResourceTypeConstraint } from './manifest';
+export type { GlobalConfigs, ManifestOptions, ResourceTypeConstraint };
+export type { Request, RequestContext } from './request';
+export type { Primitive, Hash, Headers, Body, Params as Parameters, Auth as Authorization, NestedParam, NestedParamArray, RequestParams, ParameterEncoderFn, } from './types';
+export type { Gateway } from './gateway/index';
+export type { XHR as XhrGateway } from './gateway/xhr';
+export type { HTTP as HTTPGateway } from './gateway/http';
+export type { Fetch as FetchGateway } from './gateway/fetch';
+export type { Mock as MockGateway } from './gateway/mock';
+export type { HTTPRequestParams, HTTPGatewayConfiguration, GatewayConfiguration, } from './gateway/types';
+export { Response } from './response';
+export type { ParsedJSON } from './response';
+export type { AbortFn, Context, Middleware, MiddlewareDescriptor, MiddlewareParams, RenewFn, RequestGetter, ResponseGetter, } from './middleware/index';
+export type { AsyncFunction, AsyncFunctions, Client } from './client-builder';
 /**
  * @deprecated, use ManifestOptions instead
  */
-export type Options<Resources extends ResourceTypeConstraint> = ManifestOptions<Resources>
-
+export type Options<Resources extends ResourceTypeConstraint> = ManifestOptions<Resources>;
 /**
  * @deprecated, use GlobalConfigs instead
  */
-export type Configuration = GlobalConfigs
-
-export { default, version, configs, setContext } from './mappersmith'
+export type Configuration = GlobalConfigs;
+export { default, version, configs, setContext } from './mappersmith';

index.js

 "use strict";
-
-/* eslint-disable @typescript-eslint/no-var-requires */
-var lib = require('./mappersmith');
-var _process, defaultGateway;
-
-// Prevents webpack to load the nodejs process polyfill
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  Response: () => import_response.Response,
+  configs: () => import_mappersmith.configs,
+  default: () => import_mappersmith.default,
+  setContext: () => import_mappersmith.setContext,
+  version: () => import_mappersmith.version
+});
+module.exports = __toCommonJS(src_exports);
+var lib = __toESM(require("./mappersmith"));
+var import_xhr = __toESM(require("./gateway/xhr"));
+var import_http = __toESM(require("./gateway/http"));
+var import_fetch = __toESM(require("./gateway/fetch"));
+var import_response = require("./response");
+var import_mappersmith = __toESM(require("./mappersmith"));
+const { configs } = lib;
+let _process = null;
+let defaultGateway = null;
 try {
-  // eslint-disable-next-line no-eval
-  _process = eval('typeof __TEST_SERVICE_WORKER__ === "undefined" && typeof process === "object" ? process : undefined');
-} catch (e) {} // eslint-disable-line no-empty
-
-if (typeof XMLHttpRequest !== 'undefined') {
-  // For browsers use XHR adapter
-  defaultGateway = require('./gateway/xhr')["default"];
-} else if (typeof _process !== 'undefined') {
-  // For node use HTTP adapter
-  defaultGateway = require('./gateway/http')["default"];
-} else if (typeof self !== 'undefined') {
-  // For service workers use fetch adapter
-  defaultGateway = require('./gateway/fetch')["default"];
+  _process = eval(
+    'typeof __TEST_SERVICE_WORKER__ === "undefined" && typeof process === "object" ? process : undefined'
+  );
+} catch (e) {
 }
-lib.configs.gateway = defaultGateway;
-module.exports = lib;
+if (typeof XMLHttpRequest !== "undefined") {
+  defaultGateway = import_xhr.default;
+} else if (typeof _process !== "undefined") {
+  defaultGateway = import_http.default;
+} else if (typeof self !== "undefined") {
+  defaultGateway = import_fetch.default;
+}
+configs.gateway = defaultGateway;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Response,
+  configs,
+  setContext,
+  version
+});
+//# sourceMappingURL=index.js.map

manifest.d.ts

 import { MethodDescriptor, MethodDescriptorParams } from './method-descriptor';
 import type { ParameterEncoderFn } from './types';
 import type { GatewayConfiguration } from './gateway/types';
-import type { Gateway } from './gateway';
-import { Context, Middleware, MiddlewareDescriptor, MiddlewareParams } from './middleware';
+import type { Gateway } from './gateway/index';
+import { Context, Middleware, MiddlewareDescriptor, MiddlewareParams } from './middleware/index';
 export interface GlobalConfigs {
@@ -7,0 +7,0 @@ context: Context;

manifest.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var manifest_exports = {};
+__export(manifest_exports, {
+  Manifest: () => Manifest,
+  default: () => manifest_default
 });
-exports["default"] = exports.Manifest = void 0;
-var _methodDescriptor = require("./method-descriptor");
-var _utils = require("./utils");
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-/**
- * @typedef Manifest
- * @param {Object} obj
- *   @param {Object} obj.gatewayConfigs - default: base values from mappersmith
- *   @param {Object} obj.ignoreGlobalMiddleware - default: false
- *   @param {Object} obj.resources - default: {}
- *   @param {Array}  obj.middleware or obj.middlewares - default: []
- * @param {Object} globalConfigs
- */
-var Manifest = /*#__PURE__*/function () {
-  function Manifest(options, _ref) {
-    var gatewayConfigs = _ref.gatewayConfigs,
-      _ref$middleware = _ref.middleware,
-      middleware = _ref$middleware === void 0 ? [] : _ref$middleware,
-      _ref$context = _ref.context,
-      context = _ref$context === void 0 ? {} : _ref$context;
-    _classCallCheck(this, Manifest);
-    _defineProperty(this, "host", void 0);
-    _defineProperty(this, "allowResourceHostOverride", void 0);
-    _defineProperty(this, "parameterEncoder", void 0);
-    _defineProperty(this, "bodyAttr", void 0);
-    _defineProperty(this, "headersAttr", void 0);
-    _defineProperty(this, "authAttr", void 0);
-    _defineProperty(this, "timeoutAttr", void 0);
-    _defineProperty(this, "hostAttr", void 0);
-    _defineProperty(this, "clientId", void 0);
-    _defineProperty(this, "gatewayConfigs", void 0);
-    _defineProperty(this, "resources", void 0);
-    _defineProperty(this, "context", void 0);
-    _defineProperty(this, "middleware", void 0);
+module.exports = __toCommonJS(manifest_exports);
+var import_method_descriptor = require("./method-descriptor");
+var import_utils = require("./utils/index");
+class Manifest {
+  host;
+  allowResourceHostOverride;
+  parameterEncoder;
+  bodyAttr;
+  headersAttr;
+  authAttr;
+  timeoutAttr;
+  hostAttr;
+  clientId;
+  gatewayConfigs;
+  resources;
+  context;
+  middleware;
+  constructor(options, { gatewayConfigs, middleware = [], context = {} }) {
     this.host = options.host;
@@ -61,101 +51,92 @@ this.allowResourceHostOverride = options.allowResourceHostOverride || false;
     this.clientId = options.clientId || null;
-    this.gatewayConfigs = (0, _utils.assign)({}, gatewayConfigs, options.gatewayConfigs);
+    this.gatewayConfigs = (0, import_utils.assign)({}, gatewayConfigs, options.gatewayConfigs);
     this.resources = options.resources || {};
     this.context = context;
-
-    // TODO: deprecate obj.middlewares in favor of obj.middleware
-    var clientMiddleware = options.middleware || options.middlewares || [];
+    const clientMiddleware = options.middleware || options.middlewares || [];
     if (options.ignoreGlobalMiddleware) {
       this.middleware = clientMiddleware;
     } else {
-      this.middleware = [].concat(_toConsumableArray(clientMiddleware), _toConsumableArray(middleware));
+      this.middleware = [...clientMiddleware, ...middleware];
     }
   }
-  _createClass(Manifest, [{
-    key: "eachResource",
-    value: function eachResource(callback) {
-      var _this = this;
-      Object.keys(this.resources).forEach(function (resourceName) {
-        var methods = _this.eachMethod(resourceName, function (methodName) {
-          return {
-            name: methodName,
-            descriptor: _this.createMethodDescriptor(resourceName, methodName)
-          };
-        });
-        callback(resourceName, methods);
-      });
+  eachResource(callback) {
+    Object.keys(this.resources).forEach((resourceName) => {
+      const methods = this.eachMethod(resourceName, (methodName) => ({
+        name: methodName,
+        descriptor: this.createMethodDescriptor(resourceName, methodName)
+      }));
+      callback(resourceName, methods);
+    });
+  }
+  eachMethod(resourceName, callback) {
+    return Object.keys(this.resources[resourceName]).map(callback);
+  }
+  createMethodDescriptor(resourceName, methodName) {
+    const definition = this.resources[resourceName][methodName];
+    if (!definition || !["string", "function"].includes(typeof definition.path)) {
+      throw new Error(
+        `[Mappersmith] path is undefined for resource "${resourceName}" method "${methodName}"`
+      );
     }
-  }, {
-    key: "eachMethod",
-    value: function eachMethod(resourceName, callback) {
-      return Object.keys(this.resources[resourceName]).map(callback);
-    }
-  }, {
-    key: "createMethodDescriptor",
-    value: function createMethodDescriptor(resourceName, methodName) {
-      var definition = this.resources[resourceName][methodName];
-      if (!definition || !['string', 'function'].includes(_typeof(definition.path))) {
-        throw new Error("[Mappersmith] path is undefined for resource \"".concat(resourceName, "\" method \"").concat(methodName, "\""));
-      }
-      return new _methodDescriptor.MethodDescriptor((0, _utils.assign)({
-        host: this.host,
-        allowResourceHostOverride: this.allowResourceHostOverride,
-        parameterEncoder: this.parameterEncoder,
-        bodyAttr: this.bodyAttr,
-        headersAttr: this.headersAttr,
-        authAttr: this.authAttr,
-        timeoutAttr: this.timeoutAttr,
-        hostAttr: this.hostAttr
-      }, definition));
-    }
-
-    /**
-     * @param {Object} args
-     *   @param {String|Null} args.clientId
-     *   @param {String} args.resourceName
-     *   @param {String} args.resourceMethod
-     *   @param {Object} args.context
-     *   @param {Boolean} args.mockRequest
-     *
-     * @return {Array<Object>}
-     */
-  }, {
-    key: "createMiddleware",
-    value: function createMiddleware(args) {
-      var _this2 = this;
-      var createInstance = function createInstance(middlewareFactory) {
-        var defaultDescriptor = {
-          __name: middlewareFactory.name || middlewareFactory.toString(),
-          response: function response(next) {
-            return next();
-          },
-          /**
-           * @since 2.27.0
-           * Replaced the request method
-           */
-          prepareRequest: function prepareRequest(next) {
-            var _this3 = this;
-            return this.request ? next().then(function (req) {
-              var _this3$request;
-              return (_this3$request = _this3.request) === null || _this3$request === void 0 ? void 0 : _this3$request.call(_this3, req);
-            }) : next();
-          }
-        };
-        var middlewareParams = (0, _utils.assign)(args, {
-          clientId: _this2.clientId,
-          context: (0, _utils.assign)({}, _this2.context)
-        });
-        return (0, _utils.assign)(defaultDescriptor, middlewareFactory(middlewareParams));
+    return new import_method_descriptor.MethodDescriptor(
+      (0, import_utils.assign)(
+        {
+          host: this.host,
+          allowResourceHostOverride: this.allowResourceHostOverride,
+          parameterEncoder: this.parameterEncoder,
+          bodyAttr: this.bodyAttr,
+          headersAttr: this.headersAttr,
+          authAttr: this.authAttr,
+          timeoutAttr: this.timeoutAttr,
+          hostAttr: this.hostAttr
+        },
+        definition
+      )
+    );
+  }
+  /**
+   * @param {Object} args
+   *   @param {String|Null} args.clientId
+   *   @param {String} args.resourceName
+   *   @param {String} args.resourceMethod
+   *   @param {Object} args.context
+   *   @param {Boolean} args.mockRequest
+   *
+   * @return {Array<Object>}
+   */
+  createMiddleware(args) {
+    const createInstance = (middlewareFactory) => {
+      const defaultDescriptor = {
+        __name: middlewareFactory.name || middlewareFactory.toString(),
+        response(next) {
+          return next();
+        },
+        /**
+         * @since 2.27.0
+         * Replaced the request method
+         */
+        prepareRequest(next) {
+          return this.request ? next().then((req) => {
+            var _a;
+            return (_a = this.request) == null ? void 0 : _a.call(this, req);
+          }) : next();
+        }
       };
-      var name = args.resourceName,
-        method = args.resourceMethod;
-      var resourceMiddleware = this.createMethodDescriptor(name, method).middleware;
-      var middlewares = [].concat(_toConsumableArray(resourceMiddleware), _toConsumableArray(this.middleware));
-      return middlewares.map(createInstance);
-    }
-  }]);
-  return Manifest;
-}();
-exports.Manifest = Manifest;
-var _default = Manifest;
-exports["default"] = _default;
+      const middlewareParams = (0, import_utils.assign)(args, {
+        clientId: this.clientId,
+        context: (0, import_utils.assign)({}, this.context)
+      });
+      return (0, import_utils.assign)(defaultDescriptor, middlewareFactory(middlewareParams));
+    };
+    const { resourceName: name, resourceMethod: method } = args;
+    const resourceMiddleware = this.createMethodDescriptor(name, method).middleware;
+    const middlewares = [...resourceMiddleware, ...this.middleware];
+    return middlewares.map(createInstance);
+  }
+}
+var manifest_default = Manifest;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Manifest
+});
+//# sourceMappingURL=manifest.js.map

mappersmith.d.ts

 import { Client } from './client-builder';
 import { GlobalConfigs, ManifestOptions, ResourceTypeConstraint } from './manifest';
-import { Context } from './middleware';
+import { Context } from './middleware/index';
 /**
@@ -8,3 +8,3 @@ * Can be used to test for `instanceof Response`
 export { Response } from './response';
-export declare const version: string;
+export { version } from './version';
 export declare const configs: GlobalConfigs;
@@ -11,0 +11,0 @@ /**

mappersmith.js

 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "Response", {
-  enumerable: true,
-  get: function get() {
-    return _response.Response;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mappersmith_exports = {};
+__export(mappersmith_exports, {
+  Response: () => import_response.Response,
+  configs: () => configs,
+  default: () => forge,
+  setContext: () => setContext,
+  version: () => import_version.version
 });
-exports.configs = void 0;
-exports["default"] = forge;
-exports.version = exports.setContext = void 0;
-var _clientBuilder = _interopRequireDefault(require("./client-builder"));
-var _utils = require("./utils");
-var Version = _interopRequireWildcard(require("./version.json"));
-var _response = require("./response");
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-/**
- * Can be used to test for `instanceof Response`
- */
-
-var version = Version.version;
-exports.version = version;
-var configs = {
+module.exports = __toCommonJS(mappersmith_exports);
+var import_client_builder = __toESM(require("./client-builder"));
+var import_utils = require("./utils/index");
+var import_response = require("./response");
+var import_version = require("./version");
+const configs = {
   context: {},
   middleware: [],
-  Promise: typeof Promise === 'function' ? Promise : null,
-  fetch: typeof fetch === 'function' ? fetch : null,
+  Promise: typeof Promise === "function" ? Promise : null,
+  fetch: typeof fetch === "function" ? fetch : null,
   /**
-   * The maximum amount of executions allowed before it is considered an infinite loop.
-   * In the response phase of middleware, it's possible to execute a function called "renew",
-   * which can be used to rerun the middleware stack. This feature is useful in some scenarios,
-   * for example, re-fetching an invalid access token.
-    * This configuration is used to detect infinite loops, don't increase this value too much
-   * @default 2
-   */
+     * The maximum amount of executions allowed before it is considered an infinite loop.
+     * In the response phase of middleware, it's possible to execute a function called "renew",
+     * which can be used to rerun the middleware stack. This feature is useful in some scenarios,
+     * for example, re-fetching an invalid access token.
+  
+     * This configuration is used to detect infinite loops, don't increase this value too much
+     * @default 2
+     */
   maxMiddlewareStackExecutionAllowed: 2,
@@ -119,22 +133,23 @@ /**
        */
-      credentials: 'omit'
+      credentials: "omit"
     }
   }
 };
-
-/**
- * @deprecated Shouldn't be used, not safe for concurrent use.
- * @param {Object} context
- */
-exports.configs = configs;
-var setContext = function setContext(context) {
-  console.warn('The use of setContext is deprecated - you need to find another way to pass data between your middlewares.');
-  configs.context = (0, _utils.assign)(configs.context, context);
+const setContext = (context) => {
+  console.warn(
+    "The use of setContext is deprecated - you need to find another way to pass data between your middlewares."
+  );
+  configs.context = (0, import_utils.assign)(configs.context, context);
 };
-exports.setContext = setContext;
 function forge(manifest) {
-  var GatewayClassFactory = function GatewayClassFactory() {
-    return configs.gateway;
-  };
-  return new _clientBuilder["default"](manifest, GatewayClassFactory, configs).build();
-}
+  const GatewayClassFactory = () => configs.gateway;
+  return new import_client_builder.default(manifest, GatewayClassFactory, configs).build();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Response,
+  configs,
+  setContext,
+  version
+});
+//# sourceMappingURL=mappersmith.js.map

method-descriptor.d.ts

 import type { Headers, RequestParams, ParameterEncoderFn, Params } from './types';
-import type { Middleware } from './middleware';
+import type { Middleware } from './middleware/index';
 export interface MethodDescriptorParams {
@@ -4,0 +4,0 @@ allowResourceHostOverride?: boolean;

method-descriptor.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var method_descriptor_exports = {};
+__export(method_descriptor_exports, {
+  MethodDescriptor: () => MethodDescriptor,
+  default: () => method_descriptor_default
 });
-exports["default"] = exports.MethodDescriptor = void 0;
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-/**
- * @typedef MethodDescriptor
- * @param {MethodDescriptorParams} params
- *   @param {boolean} params.allowResourceHostOverride
- *   @param {Function} params.parameterEncoder
- *   @param {String} params.authAttr - auth attribute name. Default: 'auth'
- *   @param {boolean} params.binary
- *   @param {String} params.bodyAttr - body attribute name. Default: 'body'
- *   @param {Headers} params.headers
- *   @param {String} params.headersAttr - headers attribute name. Default: 'headers'
- *   @param {String} params.host
- *   @param {String} params.hostAttr - host attribute name. Default: 'host'
- *   @param {String} params.method
- *   @param {Middleware[]} params.middleware
- *   @param {Middleware[]} params.middlewares - alias for middleware
- *   @param {RequestParams} params.params
- *   @param {String|Function} params.path
- *   @param {String} params.pathAttr. Default: 'path'
- *   @param {Object} params.queryParamAlias
- *   @param {Number} params.timeoutAttr - timeout attribute name. Default: 'timeout'
- */
-var MethodDescriptor = /*#__PURE__*/_createClass(function MethodDescriptor(params) {
-  _classCallCheck(this, MethodDescriptor);
-  _defineProperty(this, "allowResourceHostOverride", void 0);
-  _defineProperty(this, "parameterEncoder", void 0);
-  _defineProperty(this, "authAttr", void 0);
-  _defineProperty(this, "binary", void 0);
-  _defineProperty(this, "bodyAttr", void 0);
-  _defineProperty(this, "headers", void 0);
-  _defineProperty(this, "headersAttr", void 0);
-  _defineProperty(this, "host", void 0);
-  _defineProperty(this, "hostAttr", void 0);
-  _defineProperty(this, "method", void 0);
-  _defineProperty(this, "middleware", void 0);
-  _defineProperty(this, "params", void 0);
-  _defineProperty(this, "path", void 0);
-  _defineProperty(this, "pathAttr", void 0);
-  _defineProperty(this, "queryParamAlias", void 0);
-  _defineProperty(this, "timeoutAttr", void 0);
-  this.allowResourceHostOverride = params.allowResourceHostOverride || false;
-  this.parameterEncoder = params.parameterEncoder || encodeURIComponent;
-  this.binary = params.binary || false;
-  this.headers = params.headers;
-  this.host = params.host;
-  this.method = params.method || 'get';
-  this.params = params.params;
-  this.path = params.path;
-  this.queryParamAlias = params.queryParamAlias || {};
-  this.authAttr = params.authAttr || 'auth';
-  this.bodyAttr = params.bodyAttr || 'body';
-  this.headersAttr = params.headersAttr || 'headers';
-  this.hostAttr = params.hostAttr || 'host';
-  this.pathAttr = params.pathAttr || 'path';
-  this.timeoutAttr = params.timeoutAttr || 'timeout';
-  var resourceMiddleware = params.middleware || params.middlewares || [];
-  this.middleware = resourceMiddleware;
+module.exports = __toCommonJS(method_descriptor_exports);
+class MethodDescriptor {
+  allowResourceHostOverride;
+  parameterEncoder;
+  authAttr;
+  binary;
+  bodyAttr;
+  headers;
+  headersAttr;
+  host;
+  hostAttr;
+  method;
+  middleware;
+  params;
+  path;
+  pathAttr;
+  queryParamAlias;
+  timeoutAttr;
+  constructor(params) {
+    this.allowResourceHostOverride = params.allowResourceHostOverride || false;
+    this.parameterEncoder = params.parameterEncoder || encodeURIComponent;
+    this.binary = params.binary || false;
+    this.headers = params.headers;
+    this.host = params.host;
+    this.method = params.method || "get";
+    this.params = params.params;
+    this.path = params.path;
+    this.queryParamAlias = params.queryParamAlias || {};
+    this.authAttr = params.authAttr || "auth";
+    this.bodyAttr = params.bodyAttr || "body";
+    this.headersAttr = params.headersAttr || "headers";
+    this.hostAttr = params.hostAttr || "host";
+    this.pathAttr = params.pathAttr || "path";
+    this.timeoutAttr = params.timeoutAttr || "timeout";
+    const resourceMiddleware = params.middleware || params.middlewares || [];
+    this.middleware = resourceMiddleware;
+  }
+}
+var method_descriptor_default = MethodDescriptor;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MethodDescriptor
 });
-exports.MethodDescriptor = MethodDescriptor;
-var _default = MethodDescriptor;
-exports["default"] = _default;
+//# sourceMappingURL=method-descriptor.js.map

middleware/basic-auth.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var basic_auth_exports = {};
+__export(basic_auth_exports, {
+  default: () => basic_auth_default
 });
-exports["default"] = void 0;
-var _utils = require("../utils");
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-/**
- * Automatically configure your requests with basic auth
- *
- * Example:
- * In your manifest:
- * {
- *   middleware: [ BasicAuthMiddleware({ username: 'bob', password: 'bob' }) ]
- * }
- *
- * Making the call:
- * client.User.all()
- * // => header: "Authorization: Basic Ym9iOmJvYg=="
- */
-var _default = function _default(authConfig) {
-  return function BasicAuthMiddleware() {
-    return {
-      prepareRequest: function prepareRequest(next) {
-        return _asyncToGenerator(function* () {
-          var request = yield next();
-          var auth = request.auth();
-          return !auth // Keep the override
-          ? request.enhance({
-            auth: (0, _utils.assign)({}, authConfig)
-          }) : request;
-        })();
-      }
-    };
+module.exports = __toCommonJS(basic_auth_exports);
+var import_utils = require("../utils/index");
+var basic_auth_default = (authConfig) => function BasicAuthMiddleware() {
+  return {
+    async prepareRequest(next) {
+      const request = await next();
+      const auth = request.auth();
+      return !auth ? request.enhance({ auth: (0, import_utils.assign)({}, authConfig) }) : request;
+    }
   };
 };
-exports["default"] = _default;
+//# sourceMappingURL=basic-auth.js.map

middleware/csrf.js

 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var csrf_exports = {};
+__export(csrf_exports, {
+  default: () => csrf_default
 });
-exports["default"] = void 0;
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-/**
- * Sets a request header with the value of a cookie from document.cookie, if it exists
- */
-var _default = function _default() {
-  var cookieName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'csrfToken';
-  var headerName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'x-csrf-token';
-  return function CsrfMiddleware() {
-    var REGEXP_COOKIE_NAME = new RegExp(cookieName + '[^;]+');
-    var getCookie = function getCookie() {
-      var cookieString = REGEXP_COOKIE_NAME.exec((document || {}).cookie || '');
-      return cookieString ? decodeURIComponent(cookieString.toString().replace(/^[^=]+./, '')) : undefined;
-    };
-    return {
-      prepareRequest: function prepareRequest(next) {
-        return _asyncToGenerator(function* () {
-          var request = yield next();
-          if (typeof document === 'undefined') {
-            return request;
-          }
-          var csrf = getCookie();
-          return !csrf ? request : request.enhance({
-            headers: _defineProperty({}, headerName, csrf)
-          });
-        })();
+module.exports = __toCommonJS(csrf_exports);
+var csrf_default = (cookieName = "csrfToken", headerName = "x-csrf-token") => function CsrfMiddleware() {
+  const REGEXP_COOKIE_NAME = new RegExp(cookieName + "[^;]+");
+  const getCookie = () => {
+    const cookieString = REGEXP_COOKIE_NAME.exec((document || {}).cookie || "");
+    return cookieString ? decodeURIComponent(cookieString.toString().replace(/^[^=]+./, "")) : void 0;
+  };
+  return {
+    async prepareRequest(next) {
+      const request = await next();
+      if (typeof document === "undefined") {
+        return request;
       }
-    };
+      const csrf = getCookie();
+      return !csrf ? request : request.enhance({
+        headers: { [headerName]: csrf }
+      });
+    }
   };
 };
-exports["default"] = _default;
+//# sourceMappingURL=csrf.js.map

middleware/duration.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var duration_exports = {};
+__export(duration_exports, {
+  default: () => duration_default
 });
-exports["default"] = void 0;
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-/**
- * Adds started_at, ended_at and duration headers to the response
- */
-var DurationMiddleware = function DurationMiddleware(_ref) {
-  var mockRequest = _ref.mockRequest;
-  return {
-    prepareRequest: function prepareRequest(next) {
-      return _asyncToGenerator(function* () {
-        if (mockRequest) {
-          return next();
-        }
-        var request = yield next();
-        return request.enhance({
-          headers: {
-            'X-Started-At': Date.now()
-          }
-        });
-      })();
-    },
-    response: function response(next) {
-      return _asyncToGenerator(function* () {
-        var response = yield next();
-        var endedAt = Date.now();
-        var startedAt = response.request().header('x-started-at');
-        return response.enhance({
-          headers: {
-            'X-Started-At': startedAt,
-            'X-Ended-At': endedAt,
-            'X-Duration': endedAt - startedAt
-          }
-        });
-      })();
+module.exports = __toCommonJS(duration_exports);
+const DurationMiddleware = ({ mockRequest }) => ({
+  async prepareRequest(next) {
+    if (mockRequest) {
+      return next();
     }
-  };
-};
-var _default = DurationMiddleware;
-exports["default"] = _default;
+    const request = await next();
+    return request.enhance({
+      headers: { "X-Started-At": Date.now() }
+    });
+  },
+  async response(next) {
+    const response = await next();
+    const endedAt = Date.now();
+    const startedAt = response.request().header("x-started-at");
+    return response.enhance({
+      headers: {
+        "X-Started-At": startedAt,
+        "X-Ended-At": endedAt,
+        "X-Duration": endedAt - startedAt
+      }
+    });
+  }
+});
+var duration_default = DurationMiddleware;
+//# sourceMappingURL=duration.js.map

middleware/encode-json.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = exports.CONTENT_TYPE_JSON = void 0;
-var _response = require("../response");
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-var CONTENT_TYPE_JSON = 'application/json;charset=utf-8';
-exports.CONTENT_TYPE_JSON = CONTENT_TYPE_JSON;
-var isJson = function isJson(contentType) {
-  return _response.REGEXP_CONTENT_TYPE_JSON.test(contentType);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var alreadyEncoded = function alreadyEncoded(body) {
-  return typeof body === 'string';
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-
-/**
- * Automatically encode your objects into JSON
- *
- * Example:
- * client.User.all({ body: { name: 'bob' } })
- * // => body: {"name":"bob"}
- * // => header: "Content-Type=application/json;charset=utf-8"
- */
-var EncodeJsonMiddleware = function EncodeJsonMiddleware() {
-  return {
-    prepareRequest: function prepareRequest(next) {
-      return _asyncToGenerator(function* () {
-        var request = yield next();
-        try {
-          var body = request.body();
-          var contentType = request.header('content-type');
-          if (body) {
-            var shouldEncodeBody = contentType == null || typeof contentType === 'string' && isJson(contentType) && !alreadyEncoded(body);
-            var encodedBody = shouldEncodeBody ? JSON.stringify(body) : body;
-            return request.enhance({
-              headers: {
-                'content-type': contentType == null ? CONTENT_TYPE_JSON : contentType
-              },
-              body: encodedBody
-            });
-          }
-        } catch (e) {} // eslint-disable-line no-empty
-        return request;
-      })();
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var encode_json_exports = {};
+__export(encode_json_exports, {
+  CONTENT_TYPE_JSON: () => CONTENT_TYPE_JSON,
+  default: () => encode_json_default
+});
+module.exports = __toCommonJS(encode_json_exports);
+var import_response = require("../response");
+const CONTENT_TYPE_JSON = "application/json;charset=utf-8";
+const isJson = (contentType) => import_response.REGEXP_CONTENT_TYPE_JSON.test(contentType);
+const alreadyEncoded = (body) => typeof body === "string";
+const EncodeJsonMiddleware = () => ({
+  async prepareRequest(next) {
+    const request = await next();
+    try {
+      const body = request.body();
+      const contentType = request.header("content-type");
+      if (body) {
+        const shouldEncodeBody = contentType == null || typeof contentType === "string" && isJson(contentType) && !alreadyEncoded(body);
+        const encodedBody = shouldEncodeBody ? JSON.stringify(body) : body;
+        return request.enhance({
+          headers: { "content-type": contentType == null ? CONTENT_TYPE_JSON : contentType },
+          body: encodedBody
+        });
+      }
+    } catch (e) {
     }
-  };
-};
-var _default = EncodeJsonMiddleware;
-exports["default"] = _default;
+    return request;
+  }
+});
+var encode_json_default = EncodeJsonMiddleware;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONTENT_TYPE_JSON
+});
+//# sourceMappingURL=encode-json.js.map

middleware/global-error-handler.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var global_error_handler_exports = {};
+__export(global_error_handler_exports, {
+  default: () => global_error_handler_default,
+  setErrorHandler: () => setErrorHandler
 });
-exports.setErrorHandler = exports["default"] = void 0;
-var _index = require("../index");
-var handler = null;
-var setErrorHandler = function setErrorHandler(errorHandler) {
+module.exports = __toCommonJS(global_error_handler_exports);
+var import__ = require("../index");
+let handler = null;
+const setErrorHandler = (errorHandler) => {
   handler = errorHandler;
 };
-
-/**
- * Provides a catch-all function for all requests. If the catch-all
- * function returns `true` it prevents the original promise to continue.
- */
-exports.setErrorHandler = setErrorHandler;
-var GlobalErrorHandlerMiddleware = function GlobalErrorHandlerMiddleware() {
-  return {
-    response: function response(next) {
-      if (!_index.configs.Promise) {
-        return next();
-      }
-      return new _index.configs.Promise(function (resolve, reject) {
-        next().then(function (response) {
-          return resolve(response);
-        })["catch"](function (response) {
-          var proceed = true;
-          handler && (proceed = !(handler(response) === true));
-          proceed && reject(response);
-        });
+const GlobalErrorHandlerMiddleware = () => ({
+  response(next) {
+    if (!import__.configs.Promise) {
+      return next();
+    }
+    return new import__.configs.Promise((resolve, reject) => {
+      next().then((response) => resolve(response)).catch((response) => {
+        let proceed = true;
+        handler && (proceed = !(handler(response) === true));
+        proceed && reject(response);
       });
-    }
-  };
-};
-var _default = GlobalErrorHandlerMiddleware;
-exports["default"] = _default;
+    });
+  }
+});
+var global_error_handler_default = GlobalErrorHandlerMiddleware;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setErrorHandler
+});
+//# sourceMappingURL=global-error-handler.js.map

middleware/index.d.ts

@@ -1,19 +0,25 @@
-import type { Request } from '../request';
-import type { Response } from '../response';
-export type Context = object;
-export type RequestGetter = () => Promise<Request>;
-export type ResponseGetter = () => Promise<Response>;
-export type AbortFn = (error: Error) => void;
-export type RenewFn = () => Promise<Response>;
+import type { Request } from '../request'
+import type { Response } from '../response'
+
+export type Context = object
+
+export type RequestGetter = () => Promise<Request>
+
+export type ResponseGetter = () => Promise<Response>
+
+export type AbortFn = (error: Error) => void
+
+export type RenewFn = () => Promise<Response>
+
 export interface MiddlewareDescriptor {
-    __name?: string;
+  __name?: string
+  /**
+   * @deprecated: Use prepareRequest
+   */
+  request?(request: Request): Promise<Request> | Request
+  /**
+   * Allows a middleware to tap into the prepare request phase
+   */
+  prepareRequest(
     /**
-     * @deprecated: Use prepareRequest
-     */
-    request?(request: Request): Promise<Request> | Request;
-    /**
-     * Allows a middleware to tap into the prepare request phase
-     */
-    prepareRequest(
-    /**
      * This function must return a `Promise` resolving the `Request`.
@@ -23,12 +29,13 @@ *
      */
-    next: RequestGetter, 
+    next: RequestGetter,
     /**
      * Function that can be used to abort the middleware execution early on and throw a custom error to the user.
      */
-    abort: AbortFn): Promise<Request | void>;
+    abort: AbortFn
+  ): Promise<Request | void>
+  /**
+   * Allows a middleware to tap into the response phase
+   */
+  response(
     /**
-     * Allows a middleware to tap into the response phase
-     */
-    response(
-    /**
      * This function must return a `Promise` resolving the `Response`.
@@ -38,3 +45,3 @@ *
      */
-    next: ResponseGetter, 
+    next: ResponseGetter,
     /**
@@ -45,3 +52,3 @@ * Function that is used to rerun the middleware stack.
      */
-    renew: RenewFn, 
+    renew: RenewFn,
     /**
@@ -52,12 +59,17 @@ * The final request object (after the whole middleware chain has prepared and all `prepareRequest` been executed).
      */
-    request: Request): Promise<Response>;
+    request: Request
+  ): Promise<Response>
 }
+
 export interface MiddlewareParams {
-    readonly clientId: string | null;
-    readonly context: Context;
-    readonly resourceMethod: string;
-    readonly resourceName: string;
-    readonly mockRequest?: boolean;
+  readonly clientId: string | null
+  readonly context: Context
+  readonly resourceMethod: string
+  readonly resourceName: string
+  readonly mockRequest?: boolean
 }
-type DefaultPrivateProps = {};
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type DefaultPrivateProps = {}
+
 /**
@@ -69,3 +81,4 @@ * Mappersmith middleware, used to describe a factory function that given MiddlewareParams
  */
-export type Middleware<PrivateProps extends Record<string, unknown> = DefaultPrivateProps> = (params: MiddlewareParams) => Partial<MiddlewareDescriptor & PrivateProps>;
-export {};
+export type Middleware<PrivateProps extends Record<string, unknown> = DefaultPrivateProps> = (
+  params: MiddlewareParams
+) => Partial<MiddlewareDescriptor & PrivateProps>

middleware/log.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var log_exports = {};
+__export(log_exports, {
+  default: () => log_default,
+  defaultErrorLogger: () => defaultErrorLogger,
+  defaultSuccessLogger: () => defaultSuccessLogger,
+  setErrorLogger: () => setErrorLogger,
+  setLoggerEnabled: () => setLoggerEnabled,
+  setSuccessLogger: () => setSuccessLogger
 });
-exports.setSuccessLogger = exports.setLoggerEnabled = exports.setErrorLogger = exports.defaultSuccessLogger = exports.defaultErrorLogger = exports["default"] = void 0;
-var _response = require("../response");
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-var defaultSuccessLogger = function defaultSuccessLogger(message) {
-  var logger = console.info ? console.info : console.log;
+module.exports = __toCommonJS(log_exports);
+var import_response = require("../response");
+const defaultSuccessLogger = (message) => {
+  const logger = console.info ? console.info : console.log;
   logger(message);
 };
-exports.defaultSuccessLogger = defaultSuccessLogger;
-var defaultErrorLogger = function defaultErrorLogger(message) {
-  var logger = console.error ? console.error : console.log;
+const defaultErrorLogger = (message) => {
+  const logger = console.error ? console.error : console.log;
   logger(message);
 };
-exports.defaultErrorLogger = defaultErrorLogger;
-var isLoggerEnabled = Boolean(console && console.log);
-var successLogger = defaultSuccessLogger;
-var errorLogger = defaultErrorLogger;
-var setSuccessLogger = function setSuccessLogger(logger) {
+let isLoggerEnabled = Boolean(console && console.log);
+let successLogger = defaultSuccessLogger;
+let errorLogger = defaultErrorLogger;
+const setSuccessLogger = (logger) => {
   successLogger = logger;
 };
-exports.setSuccessLogger = setSuccessLogger;
-var setErrorLogger = function setErrorLogger(logger) {
+const setErrorLogger = (logger) => {
   errorLogger = logger;
 };
-exports.setErrorLogger = setErrorLogger;
-var setLoggerEnabled = function setLoggerEnabled(value) {
+const setLoggerEnabled = (value) => {
   isLoggerEnabled = value;
 };
-exports.setLoggerEnabled = setLoggerEnabled;
-var log = function log(request, response) {
+const log = (request, response) => {
   if (isLoggerEnabled) {
-    var httpCall = "".concat(request.method().toUpperCase(), " ").concat(request.url());
-    var direction = response ? '<-' : '->';
-    var isError = response && !response.success();
-    var errorLabel = isError ? '(ERROR) ' : '';
-    var extra = response ? " status=".concat(response.status(), " '").concat(response.rawData(), "'") : '';
-    var logger = isError ? errorLogger : successLogger;
-    logger("".concat(direction, " ").concat(errorLabel).concat(httpCall).concat(extra));
+    const httpCall = `${request.method().toUpperCase()} ${request.url()}`;
+    const direction = response ? "<-" : "->";
+    const isError = response && !response.success();
+    const errorLabel = isError ? "(ERROR) " : "";
+    const extra = response ? ` status=${response.status()} '${response.rawData()}'` : "";
+    const logger = isError ? errorLogger : successLogger;
+    logger(`${direction} ${errorLabel}${httpCall}${extra}`);
   }
   return response || request;
 };
-
-/**
- * Log all requests and responses.
- */
-var ConsoleLogMiddleware = function ConsoleLogMiddleware() {
-  return {
-    prepareRequest: function prepareRequest(next) {
-      return _asyncToGenerator(function* () {
-        var request = yield next();
-        log(request);
-        return request;
-      })();
-    },
-    response: function response(next) {
-      return _asyncToGenerator(function* () {
-        try {
-          var response = yield next();
-          log(response.request(), response);
-          return response;
-        } catch (err) {
-          if (err instanceof _response.Response) {
-            log(err.request(), err);
-          }
-          throw err;
-        }
-      })();
+const ConsoleLogMiddleware = () => ({
+  async prepareRequest(next) {
+    const request = await next();
+    log(request);
+    return request;
+  },
+  async response(next) {
+    try {
+      const response = await next();
+      log(response.request(), response);
+      return response;
+    } catch (err) {
+      if (err instanceof import_response.Response) {
+        log(err.request(), err);
+      }
+      throw err;
     }
-  };
-};
-var _default = ConsoleLogMiddleware;
-exports["default"] = _default;
+  }
+});
+var log_default = ConsoleLogMiddleware;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultErrorLogger,
+  defaultSuccessLogger,
+  setErrorLogger,
+  setLoggerEnabled,
+  setSuccessLogger
+});
+//# sourceMappingURL=log.js.map

middleware/retry/index.js

 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "calculateExponentialRetryTime", {
-  enumerable: true,
-  get: function get() {
-    return _v.calculateExponentialRetryTime;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var retry_exports = {};
+__export(retry_exports, {
+  calculateExponentialRetryTime: () => import_v1.calculateExponentialRetryTime,
+  default: () => import_v1.default,
+  setRetryConfigs: () => import_v1.setRetryConfigs
 });
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function get() {
-    return _v["default"];
-  }
+module.exports = __toCommonJS(retry_exports);
+var import_v1 = __toESM(require("./v1/index"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateExponentialRetryTime,
+  setRetryConfigs
 });
-Object.defineProperty(exports, "setRetryConfigs", {
-  enumerable: true,
-  get: function get() {
-    return _v.setRetryConfigs;
-  }
-});
-var _v = _interopRequireWildcard(require("./v1"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+//# sourceMappingURL=index.js.map

middleware/retry/v1/index.d.ts

 // @deprecated: Version 1 of retry is deprecated and should not be used anymore
-import { Middleware } from '../../index'
+import type { Middleware } from '../../index'
+import type { RetryMiddlewareOptions } from '../v2/index'
 
-declare const Retry: Middleware
-export default Retry
+/**
+ * @deprecated: Version 1 of retry is deprecated and should not be used anymore
+ */
+declare const RetryMiddleware: Middleware
+export default RetryMiddleware
+
+/**
+ * @deprecated: Version 1 of retry is deprecated and should not be used anymore
+ */
+declare const setRetryConfigs: (configs: Partial<RetryMiddlewareOptions>) => void
+
+/**
+ * @deprecated: Version 1 of retry is deprecated and should not be used anymore
+ */
+declare const calculateExponentialRetryTime: (retryTime: number) => number
+
+export { setRetryConfigs, calculateExponentialRetryTime }

middleware/retry/v1/index.js

 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var v1_exports = {};
+__export(v1_exports, {
+  calculateExponentialRetryTime: () => calculateExponentialRetryTime,
+  default: () => RetryMiddleware,
+  setRetryConfigs: () => setRetryConfigs
 });
-exports.calculateExponentialRetryTime = void 0;
-exports["default"] = RetryMiddleware;
-exports.setRetryConfigs = void 0;
-var _utils = require("../../../utils");
-var _v = _interopRequireWildcard(require("../v2"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-var retryConfigs = (0, _utils.assign)({}, _v.defaultRetryConfigs);
-
-/**
- * @deprecated The use of setRetryConfigs is deprecated as it sets a global config
-    which may cause troubles if you need multiple different configurations.
-    Use middleware/retry/v2 instead which supports passing in a configuration object.
- *
- * @param {Object} newConfigs
- *   @param {String} newConfigs.headerRetryCount (default: 'X-Mappersmith-Retry-Count')
- *   @param {String} newConfigs.headerRetryTime (default: 'X-Mappersmith-Retry-Time')
- *   @param {Number} newConfigs.maxRetryTimeInSecs (default: 5)
- *   @param {Number} newConfigs.initialRetryTimeInSecs (default: 1)
- *   @param {Number} newConfigs.factor (default: 0.2) - randomization factor
- *   @param {Number} newConfigs.multiplier (default: 2) - exponential factor
- *   @param {Number} newConfigs.retries (default: 5) - max retries
- */
-var setRetryConfigs = function setRetryConfigs(newConfigs) {
-  console.warn('The use of setRetryConfigs is deprecated - use RetryMiddleware v2 instead.');
-  retryConfigs = (0, _utils.assign)({}, retryConfigs, newConfigs);
-  middlewareInstance = (0, _v["default"])(retryConfigs)();
+module.exports = __toCommonJS(v1_exports);
+var import_utils = require("../../../utils");
+var import_v2 = __toESM(require("../v2"));
+let retryConfigs = (0, import_utils.assign)({}, import_v2.defaultRetryConfigs);
+const setRetryConfigs = (newConfigs) => {
+  console.warn("The use of setRetryConfigs is deprecated - use RetryMiddleware v2 instead.");
+  retryConfigs = (0, import_utils.assign)({}, retryConfigs, newConfigs);
+  middlewareInstance = (0, import_v2.default)(retryConfigs)();
 };
-
-/**
- * This middleware will automatically retry GET requests up to the configured amount of
- * retries using a randomization function that grows exponentially. The retry count and
- * the time used will be included as a header in the response.
- *
- * The retry time is calculated using the following formula:
- *   retryTime = min(
- *     random(previousRetryTime - randomizedFactor, previousRetryTime + randomizedFactor) * multipler,
- *     maxRetryTime
- *   )
- *
- * Take a look at `calculateExponentialRetryTime` for more information.
- *
- * Parameters can be configured using the method `setRetryConfigs`.
- */
-exports.setRetryConfigs = setRetryConfigs;
-var middlewareInstance = (0, _v["default"])(retryConfigs)();
+let middlewareInstance = (0, import_v2.default)(retryConfigs)();
 function RetryMiddleware() {
   return {
-    request: function request(_request) {
-      return middlewareInstance.request(_request);
+    request(request) {
+      return middlewareInstance.request(request);
     },
-    response: function response(next) {
+    response(next) {
       return middlewareInstance.response(next);
@@ -63,20 +55,18 @@ }
 }
-
-/**
- * Increases the retry time for each attempt using a randomization function that grows exponentially.
- * The value is limited by `retryConfigs.maxRetryTimeInSecs`.
- * @param {Number} retryTime
- *
- * @return {Number}
- */
-var calculateExponentialRetryTime = function calculateExponentialRetryTime(retryTime) {
-  return Math.min(randomFromRetryTime(retryTime) * retryConfigs.multiplier, retryConfigs.maxRetryTimeInSecs * 1000);
-};
-exports.calculateExponentialRetryTime = calculateExponentialRetryTime;
-var randomFromRetryTime = function randomFromRetryTime(retryTime) {
-  var delta = retryConfigs.factor * retryTime;
+const calculateExponentialRetryTime = (retryTime) => Math.min(
+  randomFromRetryTime(retryTime) * retryConfigs.multiplier,
+  retryConfigs.maxRetryTimeInSecs * 1e3
+);
+const randomFromRetryTime = (retryTime) => {
+  const delta = retryConfigs.factor * retryTime;
   return random(retryTime - delta, retryTime + delta);
 };
-var random = function random(min, max) {
+const random = (min, max) => {
   return Math.random() * (max - min) + min;
-};
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateExponentialRetryTime,
+  setRetryConfigs
+});
+//# sourceMappingURL=index.js.map

middleware/retry/v2/index.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var v2_exports = {};
+__export(v2_exports, {
+  calculateExponentialRetryTime: () => calculateExponentialRetryTime,
+  default: () => v2_default,
+  defaultRetryConfigs: () => defaultRetryConfigs
 });
-exports.defaultRetryConfigs = exports["default"] = exports.calculateExponentialRetryTime = void 0;
-var _index = require("../../../index");
-var _utils = require("../../../utils");
-var _response = require("../../../response");
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-var defaultRetryConfigs = {
-  headerRetryCount: 'X-Mappersmith-Retry-Count',
-  headerRetryTime: 'X-Mappersmith-Retry-Time',
+module.exports = __toCommonJS(v2_exports);
+var import__ = require("../../../index");
+var import_utils = require("../../../utils/index");
+var import_response = require("../../../response");
+const defaultRetryConfigs = {
+  headerRetryCount: "X-Mappersmith-Retry-Count",
+  headerRetryTime: "X-Mappersmith-Retry-Time",
   maxRetryTimeInSecs: 5,
@@ -25,69 +40,44 @@ initialRetryTimeInSecs: 0.1,
   // max retries
-  validateRetry: function validateRetry(response) {
-    return response.responseStatus >= 500;
-  } // a function that returns true if the request should be retried
+  validateRetry: (response) => response.responseStatus >= 500
+  // a function that returns true if the request should be retried
 };
-exports.defaultRetryConfigs = defaultRetryConfigs;
-/**
- * This middleware will automatically retry GET requests up to the configured amount of
- * retries using a randomization function that grows exponentially. The retry count and
- * the time used will be included as a header in the response.
- *
- * The retry time is calculated using the following formula:
- *   retryTime = min(
- *     random(previousRetryTime - randomizedFactor, previousRetryTime + randomizedFactor) * multipler,
- *     maxRetryTime
- *   )
- *
- * Take a look at `calculateExponentialRetryTime` for more information.
- *
- *  @param {Object} retryConfigs
- *   @param {String} retryConfigs.headerRetryCount (default: 'X-Mappersmith-Retry-Count')
- *   @param {String} retryConfigs.headerRetryTime (default: 'X-Mappersmith-Retry-Time')
- *   @param {Number} retryConfigs.maxRetryTimeInSecs (default: 5)
- *   @param {Number} retryConfigs.initialRetryTimeInSecs (default: 1)
- *   @param {Number} retryConfigs.factor (default: 0.2) - randomization factor
- *   @param {Number} retryConfigs.multiplier (default: 2) - exponential factor
- *   @param {Number} retryConfigs.retries (default: 5) - max retries
- */
-var _default = function _default() {
-  var customConfigs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  return function RetryMiddleware() {
-    return {
-      request: function request(_request) {
-        this.enableRetry = _request.method() === 'get';
-        this.inboundRequest = _request;
-        return _request;
-      },
-      response: function response(next) {
-        var retryConfigs = (0, _utils.assign)({}, defaultRetryConfigs, customConfigs);
-        var inboundRequest = this.inboundRequest;
-        if (!this.enableRetry) {
-          return next();
-        }
-        if (!_index.configs.Promise) {
-          return next();
-        }
-        if (!inboundRequest) {
-          return next();
-        }
-        return new _index.configs.Promise(function (resolve, reject) {
-          var retryTime = retryConfigs.initialRetryTimeInSecs * 1000;
-          retriableRequest(resolve, reject, next, inboundRequest)(randomFromRetryTime(retryTime, retryConfigs.factor), 0, retryConfigs);
-        });
+var v2_default = (customConfigs = {}) => function RetryMiddleware() {
+  return {
+    request(request) {
+      this.enableRetry = request.method() === "get";
+      this.inboundRequest = request;
+      return request;
+    },
+    response(next) {
+      const retryConfigs = (0, import_utils.assign)({}, defaultRetryConfigs, customConfigs);
+      const inboundRequest = this.inboundRequest;
+      if (!this.enableRetry) {
+        return next();
       }
-    };
+      if (!import__.configs.Promise) {
+        return next();
+      }
+      if (!inboundRequest) {
+        return next();
+      }
+      return new import__.configs.Promise((resolve, reject) => {
+        const retryTime = retryConfigs.initialRetryTimeInSecs * 1e3;
+        retriableRequest(
+          resolve,
+          reject,
+          next,
+          inboundRequest
+        )(randomFromRetryTime(retryTime, retryConfigs.factor), 0, retryConfigs);
+      });
+    }
   };
 };
-exports["default"] = _default;
-var retriableRequest = function retriableRequest(resolve, reject, next, request) {
-  var retry = function retry(retryTime, retryCount, retryConfigs) {
-    var nextRetryTime = calculateExponentialRetryTime(retryTime, retryConfigs);
-    var shouldRetry = retryCount < retryConfigs.retries;
-    var scheduleRequest = function scheduleRequest() {
-      setTimeout(function () {
-        return retry(nextRetryTime, retryCount + 1, retryConfigs);
-      }, retryTime);
+const retriableRequest = (resolve, reject, next, request) => {
+  const retry = (retryTime, retryCount, retryConfigs) => {
+    const nextRetryTime = calculateExponentialRetryTime(retryTime, retryConfigs);
+    const shouldRetry = retryCount < retryConfigs.retries;
+    const scheduleRequest = () => {
+      setTimeout(() => retry(nextRetryTime, retryCount + 1, retryConfigs), retryTime);
     };
-    next().then(function (response) {
+    next().then((response) => {
       if (shouldRetry && retryConfigs.validateRetry(response)) {
@@ -97,15 +87,23 @@ scheduleRequest();
         try {
-          resolve(enhancedResponse(response, retryConfigs.headerRetryCount, retryCount, retryConfigs.headerRetryTime, retryTime));
+          resolve(
+            enhancedResponse(
+              response,
+              retryConfigs.headerRetryCount,
+              retryCount,
+              retryConfigs.headerRetryTime,
+              retryTime
+            )
+          );
         } catch (e) {
-          var errorMessage = '';
+          let errorMessage = "";
           if (response instanceof Error) {
             errorMessage = response.message;
           }
-          if (_typeof(e) === 'object' && e !== null && 'message' in e) {
+          if (typeof e === "object" && e !== null && "message" in e) {
             errorMessage = e.message;
           }
-          reject(new _response.Response(request, 400, errorMessage, {}, [new Error(errorMessage)]));
+          reject(new import_response.Response(request, 400, errorMessage, {}, [new Error(errorMessage)]));
         }
       }
-    })["catch"](function (response) {
+    }).catch((response) => {
       if (shouldRetry && retryConfigs.validateRetry(response)) {
@@ -115,12 +113,20 @@ scheduleRequest();
         try {
-          reject(enhancedResponse(response, retryConfigs.headerRetryCount, retryCount, retryConfigs.headerRetryTime, retryTime));
+          reject(
+            enhancedResponse(
+              response,
+              retryConfigs.headerRetryCount,
+              retryCount,
+              retryConfigs.headerRetryTime,
+              retryTime
+            )
+          );
         } catch (e) {
-          var errorMessage = '';
+          let errorMessage = "";
           if (response instanceof Error) {
             errorMessage = response.message;
           }
-          if (_typeof(e) === 'object' && e !== null && 'message' in e) {
+          if (typeof e === "object" && e !== null && "message" in e) {
             errorMessage = e.message;
           }
-          reject(new _response.Response(request, 400, errorMessage, {}, [response]));
+          reject(new import_response.Response(request, 400, errorMessage, {}, [response]));
         }
@@ -132,26 +138,24 @@ }
 };
-
-/**
- * Increases the retry time for each attempt using a randomization function that grows exponentially.
- * The value is limited by `retryConfigs.maxRetryTimeInSecs`.
- * @param {Number} retryTime
- *
- * @return {Number}
- */
-var calculateExponentialRetryTime = function calculateExponentialRetryTime(retryTime, retryConfigs) {
-  return Math.min(randomFromRetryTime(retryTime, retryConfigs.factor) * retryConfigs.multiplier, retryConfigs.maxRetryTimeInSecs * 1000);
-};
-exports.calculateExponentialRetryTime = calculateExponentialRetryTime;
-var randomFromRetryTime = function randomFromRetryTime(retryTime, factor) {
-  var delta = factor * retryTime;
+const calculateExponentialRetryTime = (retryTime, retryConfigs) => Math.min(
+  randomFromRetryTime(retryTime, retryConfigs.factor) * retryConfigs.multiplier,
+  retryConfigs.maxRetryTimeInSecs * 1e3
+);
+const randomFromRetryTime = (retryTime, factor) => {
+  const delta = factor * retryTime;
   return random(retryTime - delta, retryTime + delta);
 };
-var random = function random(min, max) {
+const random = (min, max) => {
   return Math.random() * (max - min) + min;
 };
-var enhancedResponse = function enhancedResponse(response, headerRetryCount, retryCount, headerRetryTime, retryTime) {
-  var _headers;
-  return response.enhance({
-    headers: (_headers = {}, _defineProperty(_headers, headerRetryCount, retryCount), _defineProperty(_headers, headerRetryTime, retryTime), _headers)
-  });
-};
+const enhancedResponse = (response, headerRetryCount, retryCount, headerRetryTime, retryTime) => response.enhance({
+  headers: {
+    [headerRetryCount]: retryCount,
+    [headerRetryTime]: retryTime
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateExponentialRetryTime,
+  defaultRetryConfigs
+});
+//# sourceMappingURL=index.js.map

middleware/timeout.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var timeout_exports = {};
+__export(timeout_exports, {
+  default: () => timeout_default
 });
-exports["default"] = void 0;
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-/**
- * Automatically configure your requests with a default timeout
- *
- * Example:
- * In your manifest:
- * {
- *   middleware: [ TimeoutMiddleware(500) ]
- * }
- *
- * You can still override the default value:
- * client.User.all({ timeout: 100 })
- */
-var _default = function _default(timeoutValue) {
-  return function TimeoutMiddleware() {
-    return {
-      prepareRequest: function prepareRequest(next) {
-        return _asyncToGenerator(function* () {
-          var request = yield next();
-          var timeout = request.timeout();
-          return !timeout // Keep the override
-          ? request.enhance({
-            timeout: timeoutValue
-          }) : request;
-        })();
-      }
-    };
+module.exports = __toCommonJS(timeout_exports);
+var timeout_default = (timeoutValue) => function TimeoutMiddleware() {
+  return {
+    async prepareRequest(next) {
+      const request = await next();
+      const timeout = request.timeout();
+      return !timeout ? request.enhance({ timeout: timeoutValue }) : request;
+    }
   };
 };
-exports["default"] = _default;
+//# sourceMappingURL=timeout.js.map

middlewares/basic-auth.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function get() {
-    return _basicAuth["default"];
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var basic_auth_exports = {};
+__export(basic_auth_exports, {
+  default: () => import_basic_auth.default
 });
-var _basicAuth = _interopRequireDefault(require("../middleware/basic-auth"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+module.exports = __toCommonJS(basic_auth_exports);
+var import_basic_auth = __toESM(require("../middleware/basic-auth"));
+//# sourceMappingURL=basic-auth.js.map

middlewares/csrf.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function get() {
-    return _csrf["default"];
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var csrf_exports = {};
+__export(csrf_exports, {
+  default: () => import_csrf.default
 });
-var _csrf = _interopRequireDefault(require("../middleware/csrf"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+module.exports = __toCommonJS(csrf_exports);
+var import_csrf = __toESM(require("../middleware/csrf"));
+//# sourceMappingURL=csrf.js.map

middlewares/duration.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function get() {
-    return _duration["default"];
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var duration_exports = {};
+__export(duration_exports, {
+  default: () => import_duration.default
 });
-var _duration = _interopRequireDefault(require("../middleware/duration"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+module.exports = __toCommonJS(duration_exports);
+var import_duration = __toESM(require("../middleware/duration"));
+//# sourceMappingURL=duration.js.map

middlewares/encode-json.js

 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "CONTENT_TYPE_JSON", {
-  enumerable: true,
-  get: function get() {
-    return _encodeJson.CONTENT_TYPE_JSON;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var encode_json_exports = {};
+__export(encode_json_exports, {
+  CONTENT_TYPE_JSON: () => import_encode_json.CONTENT_TYPE_JSON,
+  default: () => import_encode_json.default
 });
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function get() {
-    return _encodeJson["default"];
-  }
+module.exports = __toCommonJS(encode_json_exports);
+var import_encode_json = __toESM(require("../middleware/encode-json"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONTENT_TYPE_JSON
 });
-var _encodeJson = _interopRequireWildcard(require("../middleware/encode-json"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+//# sourceMappingURL=encode-json.js.map

middlewares/global-error-handler.js

 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function get() {
-    return _globalErrorHandler["default"];
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var global_error_handler_exports = {};
+__export(global_error_handler_exports, {
+  default: () => import_global_error_handler.default,
+  setErrorHandler: () => import_global_error_handler.setErrorHandler
 });
-Object.defineProperty(exports, "setErrorHandler", {
-  enumerable: true,
-  get: function get() {
-    return _globalErrorHandler.setErrorHandler;
-  }
+module.exports = __toCommonJS(global_error_handler_exports);
+var import_global_error_handler = __toESM(require("../middleware/global-error-handler"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setErrorHandler
 });
-var _globalErrorHandler = _interopRequireWildcard(require("../middleware/global-error-handler"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+//# sourceMappingURL=global-error-handler.js.map

middlewares/log.js

 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function get() {
-    return _log["default"];
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var log_exports = {};
+__export(log_exports, {
+  default: () => import_log.default,
+  defaultErrorLogger: () => import_log.defaultErrorLogger,
+  defaultSuccessLogger: () => import_log.defaultSuccessLogger,
+  setErrorLogger: () => import_log.setErrorLogger,
+  setLoggerEnabled: () => import_log.setLoggerEnabled,
+  setSuccessLogger: () => import_log.setSuccessLogger
 });
-Object.defineProperty(exports, "defaultErrorLogger", {
-  enumerable: true,
-  get: function get() {
-    return _log.defaultErrorLogger;
-  }
+module.exports = __toCommonJS(log_exports);
+var import_log = __toESM(require("../middleware/log"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultErrorLogger,
+  defaultSuccessLogger,
+  setErrorLogger,
+  setLoggerEnabled,
+  setSuccessLogger
 });
-Object.defineProperty(exports, "defaultSuccessLogger", {
-  enumerable: true,
-  get: function get() {
-    return _log.defaultSuccessLogger;
-  }
-});
-Object.defineProperty(exports, "setErrorLogger", {
-  enumerable: true,
-  get: function get() {
-    return _log.setErrorLogger;
-  }
-});
-Object.defineProperty(exports, "setLoggerEnabled", {
-  enumerable: true,
-  get: function get() {
-    return _log.setLoggerEnabled;
-  }
-});
-Object.defineProperty(exports, "setSuccessLogger", {
-  enumerable: true,
-  get: function get() {
-    return _log.setSuccessLogger;
-  }
-});
-var _log = _interopRequireWildcard(require("../middleware/log"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+//# sourceMappingURL=log.js.map

middlewares/retry/index.js

 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "calculateExponentialRetryTime", {
-  enumerable: true,
-  get: function get() {
-    return _retry.calculateExponentialRetryTime;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var retry_exports = {};
+__export(retry_exports, {
+  calculateExponentialRetryTime: () => import_retry.calculateExponentialRetryTime,
+  default: () => import_retry.default,
+  setRetryConfigs: () => import_retry.setRetryConfigs
 });
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function get() {
-    return _retry["default"];
-  }
+module.exports = __toCommonJS(retry_exports);
+var import_retry = __toESM(require("../../middleware/retry/index"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateExponentialRetryTime,
+  setRetryConfigs
 });
-Object.defineProperty(exports, "setRetryConfigs", {
-  enumerable: true,
-  get: function get() {
-    return _retry.setRetryConfigs;
-  }
-});
-var _retry = _interopRequireWildcard(require("../../middleware/retry"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+//# sourceMappingURL=index.js.map

middlewares/retry/v2/index.js

 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "calculateExponentialRetryTime", {
-  enumerable: true,
-  get: function get() {
-    return _v.calculateExponentialRetryTime;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var v2_exports = {};
+__export(v2_exports, {
+  calculateExponentialRetryTime: () => import_v2.calculateExponentialRetryTime,
+  default: () => import_v2.default
 });
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function get() {
-    return _v["default"];
-  }
+module.exports = __toCommonJS(v2_exports);
+var import_v2 = __toESM(require("../../../middleware/retry/v2/index"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateExponentialRetryTime
 });
-var _v = _interopRequireWildcard(require("../../../middleware/retry/v2"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+//# sourceMappingURL=index.js.map

middlewares/timeout.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function get() {
-    return _timeout["default"];
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var timeout_exports = {};
+__export(timeout_exports, {
+  default: () => import_timeout.default
 });
-var _timeout = _interopRequireDefault(require("../middleware/timeout"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+module.exports = __toCommonJS(timeout_exports);
+var import_timeout = __toESM(require("../middleware/timeout"));
+//# sourceMappingURL=timeout.js.map

mocks/mock-assert.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mock_assert_exports = {};
+__export(mock_assert_exports, {
+  default: () => mock_assert_default
 });
-exports["default"] = void 0;
-/**
- * @typedef MockAssert
- */
+module.exports = __toCommonJS(mock_assert_exports);
 function MockAssert(calls) {
-  this.calls = function () {
-    return calls;
-  };
-  this.callsCount = function () {
-    return calls.length;
-  };
-  this.mostRecentCall = function () {
-    return calls[calls.length - 1] || null;
-  };
+  this.calls = () => calls;
+  this.callsCount = () => calls.length;
+  this.mostRecentCall = () => calls[calls.length - 1] || null;
 }
-var _default = MockAssert;
-exports["default"] = _default;
+var mock_assert_default = MockAssert;
+//# sourceMappingURL=mock-assert.js.map

mocks/mock-request.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mock_request_exports = {};
+__export(mock_request_exports, {
+  default: () => mock_request_default
 });
-exports["default"] = void 0;
-var _mockAssert = _interopRequireDefault(require("./mock-assert"));
-var _response = _interopRequireDefault(require("../response"));
-var _utils = require("../utils");
-var _clone = require("../utils/clone");
-var _mockUtils = require("./mock-utils");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-/**
- * @param {number} id
- * @param {object} props
- *   @param {string} props.method
- *   @param {string|function} props.url
- *   @param {string|function} props.body - request body
- *   @param {object} props.response
- *     @param {string} props.response.body
- *     @param {object} props.response.headers
- *     @param {integer} props.response.status
- */
+module.exports = __toCommonJS(mock_request_exports);
+var import_mock_assert = __toESM(require("./mock-assert"));
+var import_response = __toESM(require("../response"));
+var import_utils = require("../utils/index");
+var import_clone = require("../utils/clone");
+var import_mock_utils = require("./mock-utils");
 function MockRequest(id, props) {
   this.id = id;
-  this.method = props.method || 'get';
-  this.urlFunction = typeof props.url === 'function';
+  this.method = props.method || "get";
+  this.urlFunction = typeof props.url === "function";
   this.url = props.url;
-  this.bodyFunction = typeof props.body === 'function';
-  this.body = this.bodyFunction ? props.body : (0, _mockUtils.toSortedQueryString)(props.body);
-  this.headersFunction = typeof props.headers === 'function';
-  this.headers = props.headersFunction ? props.headers : (0, _mockUtils.toSortedQueryString)(props.headers);
+  this.bodyFunction = typeof props.body === "function";
+  this.body = this.bodyFunction ? props.body : (0, import_mock_utils.toSortedQueryString)(props.body);
+  this.headersFunction = typeof props.headers === "function";
+  this.headers = props.headersFunction ? props.headers : (0, import_mock_utils.toSortedQueryString)(props.headers);
   this.headersObject = props.headers;
@@ -37,3 +52,3 @@ this.responseHeaders = props.response.headers || {};
   this.responseHandler = props.response.handler;
-  this.statusFunction = typeof props.response.status === 'function';
+  this.statusFunction = typeof props.response.status === "function";
   this.responseStatus = props.response.status || 200;
@@ -48,7 +63,7 @@ this.calls = [];
    */
-  setResponseData: function setResponseData(responseData) {
-    if ((0, _utils.isPlainObject)(responseData)) {
+  setResponseData(responseData) {
+    if ((0, import_utils.isPlainObject)(responseData)) {
       this.responseData = JSON.stringify(responseData);
-      if (!this.responseHeaders['content-type']) {
-        this.responseHeaders['content-type'] = 'application/json';
+      if (!this.responseHeaders["content-type"]) {
+        this.responseHeaders["content-type"] = "application/json";
       }
@@ -62,12 +77,12 @@ } else {
    */
-  call: function call(request) {
-    var assertObject = this.assertObject();
+  call(request) {
+    const assertObject = this.assertObject();
     if (this.responseHandler) {
       this.setResponseData(this.responseHandler(request, assertObject));
     }
-    var status = this.statusFunction ? this.responseStatus(request, assertObject) : this.responseStatus;
+    const status = this.statusFunction ? this.responseStatus(request, assertObject) : this.responseStatus;
     this.calls.push(request);
-    var responseData = (0, _clone.clone)(this.responseData);
-    var responseHeaders = (0, _clone.clone)(this.responseHeaders);
-    return new _response["default"](request, status, responseData, responseHeaders);
+    const responseData = (0, import_clone.clone)(this.responseData);
+    const responseHeaders = (0, import_clone.clone)(this.responseHeaders);
+    return new import_response.default(request, status, responseData, responseHeaders);
   },
@@ -77,4 +92,4 @@ /**
    */
-  assertObject: function assertObject() {
-    return new _mockAssert["default"](this.calls);
+  assertObject() {
+    return new import_mock_assert.default(this.calls);
   },
@@ -86,12 +101,11 @@ /**
    */
-  isExactMatch: function isExactMatch(request) {
-    var _this = this;
-    var bodyMatch = function bodyMatch() {
-      if (_this.body === undefined) {
+  isExactMatch(request) {
+    const bodyMatch = () => {
+      if (this.body === void 0) {
         return true;
       }
-      return _this.bodyFunction ? _this.body(request.body()) : _this.body === (0, _mockUtils.toSortedQueryString)(request.body());
+      return this.bodyFunction ? this.body(request.body()) : this.body === (0, import_mock_utils.toSortedQueryString)(request.body());
     };
-    var urlMatch = this.urlFunction ? this.url(request.url(), request.params()) : (0, _mockUtils.sortedUrl)(this.url) === (0, _mockUtils.sortedUrl)(request.url());
-    var headerMatch = !this.headers || (this.headersFunction ? this.headers(request.headers()) : (0, _mockUtils.isSubset)(this.headersObject, request.headers()));
+    const urlMatch = this.urlFunction ? this.url(request.url(), request.params()) : (0, import_mock_utils.sortedUrl)(this.url) === (0, import_mock_utils.sortedUrl)(request.url());
+    const headerMatch = !this.headers || (this.headersFunction ? this.headers(request.headers()) : (0, import_mock_utils.isSubset)(this.headersObject, request.headers()));
     return this.method === request.method() && urlMatch && bodyMatch() && headerMatch;
@@ -104,3 +118,3 @@ },
    */
-  isPartialMatch: function isPartialMatch(request) {
+  isPartialMatch(request) {
     return new RegExp(this.method).test(request.method()) && new RegExp(this.url).test(request.url());
@@ -111,7 +125,7 @@ },
    */
-  toMockRequest: function toMockRequest() {
+  toMockRequest() {
     return this;
   }
 };
-var _default = MockRequest;
-exports["default"] = _default;
+var mock_request_default = MockRequest;
+//# sourceMappingURL=mock-request.js.map

mocks/mock-resource.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mock_resource_exports = {};
+__export(mock_resource_exports, {
+  default: () => mock_resource_default
 });
-exports["default"] = void 0;
-var _mappersmith = require("../mappersmith");
-var _mockRequest = _interopRequireDefault(require("./mock-request"));
-var _request = _interopRequireDefault(require("../request"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-var VALUE_NOT_MATCHED = '<MAPPERSMITH_VALUE_NOT_MATCHED>';
-
-/**
- * @param {Integer} id
- * @param {Object} client - the client generated by {@link forge}
- */
+module.exports = __toCommonJS(mock_resource_exports);
+var import_mappersmith = require("../mappersmith");
+var import_mock_request = __toESM(require("./mock-request"));
+var import_request = __toESM(require("../request"));
+const VALUE_NOT_MATCHED = "<MAPPERSMITH_VALUE_NOT_MATCHED>";
 function MockResource(id, client) {
@@ -39,3 +60,3 @@ if (!client || !client._manifest) {
    */
-  resource: function resource(resourceName) {
+  resource(resourceName) {
     this.resourceName = resourceName;
@@ -47,3 +68,3 @@ return this;
    */
-  method: function method(methodName) {
+  method(methodName) {
     this.methodName = methodName;
@@ -55,3 +76,3 @@ return this;
    */
-  "with": function _with(requestParams) {
+  with(requestParams) {
     this.requestParams = requestParams;
@@ -63,3 +84,3 @@ return this;
    */
-  headers: function headers(responseHeaders) {
+  headers(responseHeaders) {
     this.responseHeaders = responseHeaders;
@@ -71,4 +92,4 @@ return this;
    */
-  status: function status(responder) {
-    if (typeof responder === 'function') {
+  status(responder) {
+    if (typeof responder === "function") {
       this.responseStatusHandler = responder;
@@ -83,4 +104,4 @@ } else {
    */
-  response: function response(responder) {
-    if (typeof responder === 'function') {
+  response(responder) {
+    if (typeof responder === "function") {
       this.responseHandler = responder;
@@ -95,8 +116,7 @@ } else {
    */
-  assertObjectAsync: function assertObjectAsync() {
-    var _this = this;
-    return this.createAsyncRequest().then(function (finalRequest) {
-      _this.asyncFinalRequest = finalRequest;
-      _this.pendingMiddlewareExecution = false;
-      return _this.toMockRequest().assertObject();
+  assertObjectAsync() {
+    return this.createAsyncRequest().then((finalRequest) => {
+      this.asyncFinalRequest = finalRequest;
+      this.pendingMiddlewareExecution = false;
+      return this.toMockRequest().assertObject();
     });
@@ -107,5 +127,3 @@ },
    */
-  assertObject: function assertObject() {
-    // The middleware "prepareRequest" phase is always async, so the middleware
-    // stack will never run when assertObject is used
+  assertObject() {
     return this.toMockRequest().assertObject();
@@ -116,7 +134,7 @@ },
    */
-  toMockRequest: function toMockRequest() {
-    var finalRequest = this.asyncFinalRequest ? this.asyncFinalRequest : this.createRequest();
-    var responseStatus = this.responseStatusHandler || this.responseStatus;
+  toMockRequest() {
+    const finalRequest = this.asyncFinalRequest ? this.asyncFinalRequest : this.createRequest();
+    const responseStatus = this.responseStatusHandler || this.responseStatus;
     if (!this.mockRequest) {
-      this.mockRequest = new _mockRequest["default"](this.id, {
+      this.mockRequest = new import_mock_request.default(this.id, {
         method: finalRequest.method(),
@@ -139,16 +157,11 @@ url: this.generateUrlMatcher(finalRequest),
    */
-  generateUrlMatcher: function generateUrlMatcher(finalRequest) {
-    var _this2 = this;
-    var params = finalRequest.params();
-    var hasParamMatchers = Object.keys(params).find(function (key) {
-      return typeof params[key] === 'function';
-    });
+  generateUrlMatcher(finalRequest) {
+    const params = finalRequest.params();
+    const hasParamMatchers = Object.keys(params).find((key) => typeof params[key] === "function");
     if (!hasParamMatchers) {
       return finalRequest.url();
     }
-    var urlMatcher = function urlMatcher(requestUrl, requestParams) {
-      var additionalParams = _this2.evaluateParamMatchers(params, requestParams);
-      var testRequest = finalRequest.enhance({
-        params: additionalParams
-      });
+    const urlMatcher = (requestUrl, requestParams) => {
+      const additionalParams = this.evaluateParamMatchers(params, requestParams);
+      const testRequest = finalRequest.enhance({ params: additionalParams });
       return testRequest.url() === requestUrl;
@@ -161,11 +174,10 @@ };
    */
-  executeMiddlewareStack: function executeMiddlewareStack() {
-    var _this3 = this;
-    return this.createAsyncRequest().then(function (finalRequest) {
-      _this3.asyncFinalRequest = finalRequest;
-      if (_this3.mockRequest) {
-        var urlMatcher = _this3.generateUrlMatcher(finalRequest);
-        _this3.mockRequest.url = urlMatcher;
-        _this3.mockRequest.body = finalRequest.body();
-        _this3.pendingMiddlewareExecution = false;
+  executeMiddlewareStack() {
+    return this.createAsyncRequest().then((finalRequest) => {
+      this.asyncFinalRequest = finalRequest;
+      if (this.mockRequest) {
+        const urlMatcher = this.generateUrlMatcher(finalRequest);
+        this.mockRequest.url = urlMatcher;
+        this.mockRequest.body = finalRequest.body();
+        this.pendingMiddlewareExecution = false;
       }
@@ -177,11 +189,9 @@ });
    */
-  evaluateParamMatchers: function evaluateParamMatchers(mockParams, requestParams) {
-    return Object.keys(mockParams).reduce(function (obj, key) {
-      var matcher = mockParams[key];
-      if (typeof matcher !== 'function') {
+  evaluateParamMatchers(mockParams, requestParams) {
+    return Object.keys(mockParams).reduce((obj, key) => {
+      const matcher = mockParams[key];
+      if (typeof matcher !== "function") {
         return obj;
       }
-      var value = requestParams[key];
-      // Only evaluate if key was provided in request params.
-      // Otherwise we always consider it not to match.
+      const value = requestParams[key];
       if (key in requestParams && matcher(value)) {
@@ -199,5 +209,8 @@ obj[key] = value;
    */
-  createRequest: function createRequest() {
-    var methodDescriptor = this.manifest.createMethodDescriptor(this.resourceName, this.methodName);
-    return new _request["default"](methodDescriptor, this.requestParams);
+  createRequest() {
+    const methodDescriptor = this.manifest.createMethodDescriptor(
+      this.resourceName,
+      this.methodName
+    );
+    return new import_request.default(methodDescriptor, this.requestParams);
   },
@@ -208,6 +221,9 @@ /**
    */
-  createAsyncRequest: function createAsyncRequest() {
-    var methodDescriptor = this.manifest.createMethodDescriptor(this.resourceName, this.methodName);
-    var initialRequest = new _request["default"](methodDescriptor, this.requestParams);
-    var middleware = this.manifest.createMiddleware({
+  createAsyncRequest() {
+    const methodDescriptor = this.manifest.createMethodDescriptor(
+      this.resourceName,
+      this.methodName
+    );
+    const initialRequest = new import_request.default(methodDescriptor, this.requestParams);
+    const middleware = this.manifest.createMiddleware({
       resourceName: this.resourceName,
@@ -217,19 +233,14 @@ resourceMethod: this.methodName,
     });
-    var abort = function abort(error) {
+    const abort = (error) => {
       throw error;
     };
-    var getInitialRequest = function getInitialRequest() {
-      return _mappersmith.configs.Promise.resolve(initialRequest);
-    };
-    var prepareRequest = middleware.reduce(function (next, middleware) {
-      return function () {
-        return _mappersmith.configs.Promise.resolve().then(function () {
-          return middleware.prepareRequest(next, abort);
-        });
-      };
-    }, getInitialRequest);
+    const getInitialRequest = () => import_mappersmith.configs.Promise.resolve(initialRequest);
+    const prepareRequest = middleware.reduce(
+      (next, middleware2) => () => import_mappersmith.configs.Promise.resolve().then(() => middleware2.prepareRequest(next, abort)),
+      getInitialRequest
+    );
     return prepareRequest();
   }
 };
-var _default = MockResource;
-exports["default"] = _default;
+var mock_resource_default = MockResource;
+//# sourceMappingURL=mock-resource.js.map

mocks/mock-utils.js

 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mock_utils_exports = {};
+__export(mock_utils_exports, {
+  isSubset: () => isSubset,
+  sortedUrl: () => sortedUrl,
+  toSortedQueryString: () => toSortedQueryString
 });
-exports.isSubset = isSubset;
-exports.sortedUrl = sortedUrl;
-exports.toSortedQueryString = toSortedQueryString;
-var _utils = require("../utils");
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+module.exports = __toCommonJS(mock_utils_exports);
+var import_utils = require("../utils/index");
 function toSortedQueryString(entry) {
-  if (!(0, _utils.isPlainObject)(entry)) {
+  if (!(0, import_utils.isPlainObject)(entry)) {
     return entry;
   }
-  return (0, _utils.validKeys)(entry).sort().map(function (key) {
-    var value = entry[key];
-    if ((0, _utils.isPlainObject)(value)) {
+  return (0, import_utils.validKeys)(entry).sort().map((key) => {
+    const value = entry[key];
+    if ((0, import_utils.isPlainObject)(value)) {
       return toSortedQueryString(value);
     }
-    return (0, _utils.buildRecursive)(key, value);
-  }).join('&').replace(/%20/g, '+');
+    return (0, import_utils.buildRecursive)(key, value);
+  }).join("&").replace(/%20/g, "+");
 }
-
-/**
- * Filters an `object` by keeping only the keys fulfilling the `predicate`
- *
- * @param {Object} object - An object
- * @param {Function} predicate - A function of type (key: string) => boolean
- * @returns {Object} The filtered object
- */
 function filterByPredicate(object, predicate) {
-  return Object.entries(object).filter(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 1),
-      key = _ref2[0];
-    return predicate(key);
-  }).reduce(function (acc, _ref3) {
-    var _ref4 = _slicedToArray(_ref3, 2),
-      key = _ref4[0],
-      value = _ref4[1];
-    return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, key, value));
-  }, {});
+  return Object.entries(object).filter(([key]) => predicate(key)).reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
 }
-
-/**
- * Verify if the object `A` is contained within object `B` - shallowly.
- * In other words, is A a subset of B?
- *
- * @see https://en.wikipedia.org/wiki/Subset
- *
- * @param {Object} A - The object to test
- * @param {Object} B - The superset object to verify against
- * @returns A boolean representing if A is a shallow subset of B
- */
 function isSubset(A, B) {
-  // Make B only contain the non-nullish keys it has in in common with A
-  var keysFromA = (0, _utils.validKeys)(A);
-  var filteredB = filterByPredicate(B, function (keyFromB) {
-    return keysFromA.includes(keyFromB);
-  });
+  const keysFromA = (0, import_utils.validKeys)(A);
+  const filteredB = filterByPredicate(B, (keyFromB) => keysFromA.includes(keyFromB));
   return toSortedQueryString(A) === toSortedQueryString(filteredB);
 }
-
-/**
- * Sort the query params on a URL based on the 'key=value' string value.
- * E.g. /example?b=2&a=1 will become /example?a=1&b=2
- *
- * @param {String} url - a URL that should be sorted (with or without query params)
- */
 function sortedUrl(url) {
-  var urlParts = url.split('?');
+  const urlParts = url.split("?");
   if (urlParts.length > 1) {
-    var query = urlParts[1];
-    var sortedQuery = query.split('&').sort().join('&');
-    return "".concat(urlParts[0], "?").concat(sortedQuery);
+    const query = urlParts[1];
+    const sortedQuery = query.split("&").sort().join("&");
+    return `${urlParts[0]}?${sortedQuery}`;
   } else {
     return urlParts[0];
   }
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isSubset,
+  sortedUrl,
+  toSortedQueryString
+});
+//# sourceMappingURL=mock-utils.js.map

package.json

 {
   "name": "mappersmith",
-  "version": "2.42.0",
+  "version": "2.43.0-beta.0",
   "description": "It is a lightweight rest client for node.js and the browser",
@@ -11,6 +11,73 @@ "author": "Tulio Ornelas <[e-mail]>",
   ],
-  "main": "index.js",
-  "types": "index.d.ts",
-  "publishConfig": {
-    "directory": "lib"
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.mjs",
+      "require": "./index.js"
+    },
+    "./test": {
+      "import": "./esm/test/index.mjs",
+      "require": "./test/index.js"
+    },
+    "./gateway/fetch": {
+      "import": "./esm/gateway/fetch.mjs",
+      "require": "./gateway/fetch.js"
+    },
+    "./gateway/http": {
+      "import": "./esm/gateway/http.mjs",
+      "require": "./gateway/http.js"
+    },
+    "./gateway/xhr": {
+      "import": "./esm/gateway/xhr.mjs",
+      "require": "./gateway/xhr.js"
+    },
+    "./gateway/mock": {
+      "import": "./esm/gateway/mock.mjs",
+      "require": "./gateway/mock.js"
+    },
+    "./gateway/timeout-error": {
+      "import": "./esm/gateway/timeout-error.mjs",
+      "require": "./gateway/timeout-error.js"
+    },
+    "./middleware/basic-auth": {
+      "import": "./esm/middleware/basic-auth.mjs",
+      "require": "./middleware/basic-auth.js"
+    },
+    "./middleware/csrf": {
+      "import": "./esm/middleware/csrf.mjs",
+      "require": "./middleware/csrf.js"
+    },
+    "./middleware/duration": {
+      "import": "./esm/middleware/duration.mjs",
+      "require": "./middleware/duration.js"
+    },
+    "./middleware/encode-json": {
+      "import": "./esm/middleware/encode-json.mjs",
+      "require": "./middleware/encode-json.js"
+    },
+    "./middleware/global-error-handler": {
+      "import": "./esm/middleware/global-error-handler.mjs",
+      "require": "./middleware/global-error-handler.js"
+    },
+    "./middleware/log": {
+      "import": "./esm/middleware/log.mjs",
+      "require": "./middleware/log.js"
+    },
+    "./middleware/retry": {
+      "import": "./esm/middleware/retry/index.mjs",
+      "require": "./middleware/retry/index.js"
+    },
+    "./middleware/retry/v1": {
+      "import": "./esm/middleware/retry/v1/index.mjs",
+      "require": "./middleware/retry/v1/index.js"
+    },
+    "./middleware/retry/v2": {
+      "import": "./esm/middleware/retry/v2/index.mjs",
+      "require": "./middleware/retry/v2/index.js"
+    },
+    "./middleware/timeout": {
+      "import": "./esm/middleware/timeout.mjs",
+      "require": "./middleware/timeout.js"
+    }
   },
@@ -20,8 +87,8 @@ "scripts": {
     "test:browser": "jest --config jestSetup/configs/config.web.json",
-    "test:browser:integration:cmd": "cross-env NODE_ENV=test yarn karma start spec/integration/browser/karma.conf.js",
-    "test:browser:integration": "concurrently --success first --names \"test,server\" --kill-others \"yarn wait-on http://localhost:9090/ping --log && cross-env SINGLE_RUN=true yarn test:browser:integration:cmd\" \"yarn integration-server\"",
+    "test:browser:integration:cmd": "cross-env NODE_ENV=test yarn karma start spec/integration/browser/karma.conf.ts",
+    "test:browser:integration": "concurrently --success first --names \"test,server\" --kill-others \"yarn wait-on http://localhost:9090/ping --log && cross-env yarn test:browser:integration:cmd\" \"yarn integration-server\"",
     "test:browser:watch": "yarn jest --config jestSetup/configs/config.web.json --watchAll",
     "test:node": "yarn jest --config jestSetup/configs/config.node.json",
     "test:node:integration:cmd": "cross-env NODE_ENV=test cross-env NODE_PATH=. cross-env JASMINE_CONFIG_PATH=spec/integration/node/support/jasmine.json jasmine",
-    "test:node:integration": "concurrently --success first --names \"test,server\" --kill-others \"yarn wait-on http://localhost:9090/ping --log && cross-env SINGLE_RUN=true yarn test:node:integration:cmd\" \"yarn integration-server\"",
+    "test:node:integration": "concurrently --success first --names \"test,server\" --kill-others \"yarn wait-on http://localhost:9090/ping --log && cross-env yarn test:node:integration:cmd\" \"yarn integration-server\"",
     "test:node:watch": "yarn jest --config jestSetup/configs/config.node.json --watchAll",
@@ -36,10 +103,11 @@ "test:service-worker": "yarn jest --config jestSetup/configs/config.sw.json",
     "build:node": "yarn babel src -d lib/ --extensions '.js,.ts' --ignore '**/*.spec.ts','**/*.spec.js','**/*.d.ts'",
-    "build:browser": "yarn webpack --config webpack.conf.js",
+    "build:browser": "yarn webpack --config webpack.conf.ts",
     "build:typings": "yarn tsc --project tsconfig.typings.json && yarn copy:dts",
-    "build": "yarn copy:version:src && yarn build:node && yarn build:typings && yarn build:browser",
-    "build:clean": "rm -rf lib/ dist/ && yarn build",
-    "build:project": "./scripts/build-project.sh",
-    "copy:dts": "copyfiles -u 1 \"src/**/*.d.ts\" lib/",
-    "copy:version:src": "echo \\{\\\"version\\\":\\\"$npm_package_version\\\"\\} > src/version.json",
-    "lint": "yarn eslint \"{src,spec}/**/*.[j|t]s\""
+    "build": "yarn copy:version:src && yarn tsup && yarn build:typings",
+    "build:clean": "rm -rf dist/ && yarn build",
+    "build:project": "NODE_ENV=production yarn build:clean",
+    "copy:dts": "copyfiles -u 1 \"src/**/*.d.ts\" dist/",
+    "copy:version:src": "echo export const version = \\'$npm_package_version\\' > src/version.ts",
+    "lint": "yarn eslint \"{src,spec}/**/*.[j|t]s\"",
+    "publish:prepare": "./scripts/publish-prepare.sh"
   },
@@ -71,20 +139,22 @@ "repository": {
   "devDependencies": {
-    "@babel/cli": "^7.0.0",
-    "@babel/core": "^7.0.0",
-    "@babel/plugin-proposal-class-properties": "^7.0.0",
-    "@babel/plugin-proposal-object-rest-spread": "^7.0.0",
-    "@babel/preset-env": "^7.0.0",
-    "@babel/preset-typescript": "^7.0.0",
-    "@babel/register": "<7.12.0",
+    "@babel/cli": "^7.22.10",
+    "@babel/core": "^7.22.11",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
+    "@babel/preset-env": "^7.22.14",
+    "@babel/preset-typescript": "^7.22.11",
+    "@babel/register": "^7.22.5",
     "@changesets/cli": "^2.26.2",
-    "@chiragrupani/karma-chromium-edge-launcher": "^2.1.1",
-    "@types/jest": "^27.0.0",
+    "@chiragrupani/karma-chromium-edge-launcher": "^2.3.1",
+    "@types/jest": "^29.5.4",
+    "@types/karma": "^6.3.4",
     "@types/node": "^20.5.7",
-    "@typescript-eslint/eslint-plugin": "^5.4.0",
-    "@typescript-eslint/parser": "^5.4.0",
+    "@types/webpack": "^5.28.2",
+    "@typescript-eslint/eslint-plugin": "^6.5.0",
+    "@typescript-eslint/parser": "^6.5.0",
     "babel-core": "^7.0.0-bridge.0",
-    "babel-jest": "^27.0.0",
-    "babel-loader": "^8.2.2",
+    "babel-jest": "^29.6.4",
+    "babel-loader": "^9.1.3",
     "babel-plugin-minify-replace": "^0.5.0",
-    "body-parser": "^1.19.0",
+    "body-parser": "^1.20.2",
     "browser-resolve": "^2.0.0",
@@ -94,40 +164,42 @@ "concurrently": "^8.2.1",
     "copyfiles": "^2.4.1",
-    "core-js": "^3.21.1",
+    "core-js": "^3.32.1",
     "cross-env": "^7.0.3",
-    "eslint": "^8.0.1",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-config-standard": "^17.0.0-1",
-    "eslint-plugin-import": "^2.24.2",
-    "eslint-plugin-n": "^14.0.0",
+    "eslint": "^8.48.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-n": "^16.0.2",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^6.0.0",
-    "express": "^4.17.1",
+    "eslint-plugin-promise": "^6.1.1",
+    "express": "^4.18.2",
     "faux-jax-tulios": "^5.0.9",
-    "jasmine": "^4.0.0",
-    "jasmine-core": "^4.0.0",
-    "jest": "^27.0.0",
+    "jasmine": "^5.1.0",
+    "jasmine-core": "^5.1.1",
+    "jest": "^29.6.4",
+    "jest-environment-jsdom": "^29.6.4",
     "js-md5": "^0.7.3",
-    "karma": "^6.3.4",
-    "karma-chrome-launcher": "^3.1.0",
-    "karma-jasmine": "^4.0.1",
-    "karma-sourcemap-loader": "^0.3.8",
-    "karma-spec-reporter": "^0.0.33",
-    "karma-webpack": "<5.0.0",
+    "karma": "^6.4.2",
+    "karma-chrome-launcher": "^3.2.0",
+    "karma-jasmine": "^5.1.0",
+    "karma-sourcemap-loader": "^0.4.0",
+    "karma-spec-reporter": "^0.0.36",
+    "karma-webpack": "^5.0.0",
     "mockdate": "^3.0.5",
-    "multer": "^1.4.3",
-    "node-fetch": "^2.6.7",
+    "multer": "^1.4.5-lts.1",
+    "node-fetch": "<3.0.0",
     "pnp-webpack-plugin": "^1.7.0",
-    "prettier": "^2.5.0",
-    "puppeteer": "^13.1.1",
-    "regenerator-runtime": "^0.13.9",
-    "ts-jest": "^27.0.0",
-    "ts-node": "^10.2.1",
-    "typescript": "^4.4.3",
+    "prettier": "^3.0.3",
+    "puppeteer": "^21.1.1",
+    "regenerator-runtime": "^0.14.0",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "tsup": "^7.2.0",
+    "typescript": "^5.2.2",
     "uglifyjs-webpack-plugin": "^2.2.0",
     "wait-on": "^7.0.1",
-    "webpack": "<5.0.0",
-    "webpack-cli": "^4.8.0",
-    "whatwg-fetch": "^3.6.2"
+    "webpack": "^5.88.2",
+    "webpack-cli": "^5.1.4",
+    "whatwg-fetch": "^3.6.18"
   },
   "packageManager": "yarn@3.6.3"
 }

README.md

@@ -87,20 +87,23 @@ [![npm version](https://badge.fury.io/js/mappersmith.svg)](http://badge.fury.io/js/mappersmith)
 
-```javascript
-import forge from 'mappersmith'
+```typescript
+import forge, { configs } from "mappersmith"
+import { Fetch } from "mappersmith/gateway/fetch"
 
+configs.gateway = Fetch;
+
 const github = forge({
-  clientId: 'github',
-  host: 'https://status.github.com',
+  clientId: "github",
+  host: "https://www.githubstatus.com",
   resources: {
     Status: {
-      current: { path: '/api/status.json' },
-      messages: { path: '/api/messages.json' },
-      lastMessage: { path: '/api/last-message.json' }
-    }
-  }
-})
+      current: { path: "/api/v2/status.json" },
+      summary: { path: "/api/v2/summary.json" },
+      components: { path: "/api/v2/components.json" },
+    },
+  },
+});
 
-github.Status.lastMessage().then((response) => {
-  console.log(`status: ${response.data()}`)
-})
+github.Status.current().then((response) => {
+  console.log(`summary`, response.data());
+});
 ```
@@ -113,3 +116,5 @@
 ```javascript
-const forge = require('mappersmith').default
+const forge = require("mappersmith").default;
+const { configs } = require("mappersmith");
+const FetchGateway = require("mappersmith/gateway/fetch").default;
 ```
@@ -1426,2 +1431,10 @@
 
+### WIP
+
+Build esm, umd and cjs with a single command:
+
+```sh
+yarn tsup
+```
+
 ### Package project only
@@ -1428,0 +1441,0 @@

request.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var request_exports = {};
+__export(request_exports, {
+  Request: () => Request,
+  default: () => request_default
 });
-exports["default"] = exports.Request = void 0;
-var _utils = require("./utils");
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-var REGEXP_DYNAMIC_SEGMENT = /{([^}?]+)\??}/;
-var REGEXP_OPTIONAL_DYNAMIC_SEGMENT = /\/?{([^}?]+)\?}/g;
-var REGEXP_TRAILING_SLASH = /\/$/;
-
-/**
- * Removes the object type without removing Record types in the union
- */
-/**
- * @typedef Request
- * @param {MethodDescriptor} methodDescriptor
- * @param {RequestParams} requestParams, defaults to an empty object ({})
- * @param {RequestContext} request context store, defaults to an empty object ({})
- */
-var Request = /*#__PURE__*/function () {
-  function Request(methodDescriptor) {
-    var requestParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var requestContext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    _classCallCheck(this, Request);
-    _defineProperty(this, "methodDescriptor", void 0);
-    _defineProperty(this, "requestParams", void 0);
-    _defineProperty(this, "requestContext", void 0);
+module.exports = __toCommonJS(request_exports);
+var import_utils = require("./utils/index");
+const REGEXP_DYNAMIC_SEGMENT = /{([^}?]+)\??}/;
+const REGEXP_OPTIONAL_DYNAMIC_SEGMENT = /\/?{([^}?]+)\?}/g;
+const REGEXP_TRAILING_SLASH = /\/$/;
+class Request {
+  methodDescriptor;
+  requestParams;
+  requestContext;
+  constructor(methodDescriptor, requestParams = {}, requestContext = {}) {
     this.methodDescriptor = methodDescriptor;
@@ -42,254 +38,202 @@ this.requestParams = requestParams;
   }
-  _createClass(Request, [{
-    key: "isParam",
-    value: function isParam(key) {
-      return key !== this.methodDescriptor.headersAttr && key !== this.methodDescriptor.bodyAttr && key !== this.methodDescriptor.authAttr && key !== this.methodDescriptor.timeoutAttr && key !== this.methodDescriptor.hostAttr && key !== this.methodDescriptor.pathAttr;
+  isParam(key) {
+    return key !== this.methodDescriptor.headersAttr && key !== this.methodDescriptor.bodyAttr && key !== this.methodDescriptor.authAttr && key !== this.methodDescriptor.timeoutAttr && key !== this.methodDescriptor.hostAttr && key !== this.methodDescriptor.pathAttr;
+  }
+  params() {
+    const params = (0, import_utils.assign)({}, this.methodDescriptor.params, this.requestParams);
+    return Object.keys(params).reduce((obj, key) => {
+      if (this.isParam(key)) {
+        obj[key] = params[key];
+      }
+      return obj;
+    }, {});
+  }
+  /**
+   * Returns the request context; a key value object.
+   * Useful to pass information from upstream middleware to a downstream one.
+   */
+  context() {
+    return this.requestContext;
+  }
+  /**
+   * Returns the HTTP method in lowercase
+   */
+  method() {
+    return this.methodDescriptor.method.toLowerCase();
+  }
+  /**
+   * Returns host name without trailing slash
+   * Example: 'http://example.org'
+   */
+  host() {
+    const { allowResourceHostOverride, hostAttr, host } = this.methodDescriptor;
+    const originalHost = allowResourceHostOverride ? this.requestParams[hostAttr] || host || "" : host || "";
+    if (typeof originalHost === "string") {
+      return originalHost.replace(REGEXP_TRAILING_SLASH, "");
     }
-  }, {
-    key: "params",
-    value: function params() {
-      var _this = this;
-      var params = (0, _utils.assign)({}, this.methodDescriptor.params, this.requestParams);
-      return Object.keys(params).reduce(function (obj, key) {
-        if (_this.isParam(key)) {
-          obj[key] = params[key];
-        }
-        return obj;
-      }, {});
+    return "";
+  }
+  /**
+   * Returns path with parameters and leading slash.
+   * Example: '/some/path?param1=true'
+   *
+   * @throws {Error} if any dynamic segment is missing.
+   * Example:
+   *  Imagine the path '/some/{name}', the error will be similar to:
+   *    '[Mappersmith] required parameter missing (name), "/some/{name}" cannot be resolved'
+   */
+  path() {
+    const { pathAttr: mdPathAttr, path: mdPath } = this.methodDescriptor;
+    const originalPath = this.requestParams[mdPathAttr] || mdPath || "";
+    const params = this.params();
+    let path;
+    if (typeof originalPath === "function") {
+      path = originalPath(params);
+      if (typeof path !== "string") {
+        throw new Error(
+          `[Mappersmith] method descriptor function did not return a string, params=${JSON.stringify(
+            params
+          )}`
+        );
+      }
+    } else {
+      path = originalPath;
     }
-
-    /**
-     * Returns the request context; a key value object.
-     * Useful to pass information from upstream middleware to a downstream one.
-     */
-  }, {
-    key: "context",
-    value: function context() {
-      return this.requestContext;
+    const regexp = new RegExp(REGEXP_DYNAMIC_SEGMENT, "g");
+    const dynamicSegmentKeys = [];
+    let match;
+    while ((match = regexp.exec(path)) !== null) {
+      dynamicSegmentKeys.push(match[1]);
     }
-
-    /**
-     * Returns the HTTP method in lowercase
-     */
-  }, {
-    key: "method",
-    value: function method() {
-      return this.methodDescriptor.method.toLowerCase();
-    }
-
-    /**
-     * Returns host name without trailing slash
-     * Example: 'http://example.org'
-     */
-  }, {
-    key: "host",
-    value: function host() {
-      var _this$methodDescripto = this.methodDescriptor,
-        allowResourceHostOverride = _this$methodDescripto.allowResourceHostOverride,
-        hostAttr = _this$methodDescripto.hostAttr,
-        host = _this$methodDescripto.host;
-      var originalHost = allowResourceHostOverride ? this.requestParams[hostAttr] || host || '' : host || '';
-      if (typeof originalHost === 'string') {
-        return originalHost.replace(REGEXP_TRAILING_SLASH, '');
+    for (const key of dynamicSegmentKeys) {
+      const pattern = new RegExp(`{${key}\\??}`, "g");
+      const value = params[key];
+      if (value != null && typeof value !== "object") {
+        path = path.replace(pattern, this.methodDescriptor.parameterEncoder(value));
+        delete params[key];
       }
-      return '';
     }
-
-    /**
-     * Returns path with parameters and leading slash.
-     * Example: '/some/path?param1=true'
-     *
-     * @throws {Error} if any dynamic segment is missing.
-     * Example:
-     *  Imagine the path '/some/{name}', the error will be similar to:
-     *    '[Mappersmith] required parameter missing (name), "/some/{name}" cannot be resolved'
-     */
-  }, {
-    key: "path",
-    value: function path() {
-      var _this2 = this;
-      var _this$methodDescripto2 = this.methodDescriptor,
-        mdPathAttr = _this$methodDescripto2.pathAttr,
-        mdPath = _this$methodDescripto2.path;
-      var originalPath = this.requestParams[mdPathAttr] || mdPath || '';
-      var params = this.params();
-      var path;
-      if (typeof originalPath === 'function') {
-        path = originalPath(params);
-        if (typeof path !== 'string') {
-          throw new Error("[Mappersmith] method descriptor function did not return a string, params=".concat(JSON.stringify(params)));
-        }
-      } else {
-        path = originalPath;
-      }
-
-      // RegExp with 'g'-flag is stateful, therefore defining it locally
-      var regexp = new RegExp(REGEXP_DYNAMIC_SEGMENT, 'g');
-      var dynamicSegmentKeys = [];
-      var match;
-      while ((match = regexp.exec(path)) !== null) {
-        dynamicSegmentKeys.push(match[1]);
-      }
-      for (var _i = 0, _dynamicSegmentKeys = dynamicSegmentKeys; _i < _dynamicSegmentKeys.length; _i++) {
-        var key = _dynamicSegmentKeys[_i];
-        var pattern = new RegExp("{".concat(key, "\\??}"), 'g');
-        var value = params[key];
-        if (value != null && _typeof(value) !== 'object') {
-          path = path.replace(pattern, this.methodDescriptor.parameterEncoder(value));
-          delete params[key];
-        }
-      }
-      path = path.replace(REGEXP_OPTIONAL_DYNAMIC_SEGMENT, '');
-      var missingDynamicSegmentMatch = path.match(REGEXP_DYNAMIC_SEGMENT);
-      if (missingDynamicSegmentMatch) {
-        throw new Error("[Mappersmith] required parameter missing (".concat(missingDynamicSegmentMatch[1], "), \"").concat(path, "\" cannot be resolved"));
-      }
-      var aliasedParams = Object.keys(params).reduce(function (aliased, key) {
-        var aliasedKey = _this2.methodDescriptor.queryParamAlias[key] || key;
-        var value = params[key];
+    path = path.replace(REGEXP_OPTIONAL_DYNAMIC_SEGMENT, "");
+    const missingDynamicSegmentMatch = path.match(REGEXP_DYNAMIC_SEGMENT);
+    if (missingDynamicSegmentMatch) {
+      throw new Error(
+        `[Mappersmith] required parameter missing (${missingDynamicSegmentMatch[1]}), "${path}" cannot be resolved`
+      );
+    }
+    const aliasedParams = Object.keys(params).reduce(
+      (aliased, key) => {
+        const aliasedKey = this.methodDescriptor.queryParamAlias[key] || key;
+        const value = params[key];
         if (value != null) {
-          /**
-           * Here we use `ExcludeObject` to surgically remove the `object` type from `value`.
-           * We need it as `object` is too broad to be useful, whereas `value` is also typed
-           * as NestedParam, which is the correct shape for param objects.
-           */
           aliased[aliasedKey] = value;
         }
         return aliased;
-      }, {});
-      var queryString = (0, _utils.toQueryString)(aliasedParams, this.methodDescriptor.parameterEncoder);
-      if (typeof queryString === 'string' && queryString.length !== 0) {
-        var hasQuery = path.includes('?');
-        path += "".concat(hasQuery ? '&' : '?').concat(queryString);
-      }
-
-      // https://www.rfc-editor.org/rfc/rfc1738#section-3.3
-      if (path[0] !== '/' && path.length > 0) {
-        path = "/".concat(path);
-      }
-      return path;
+      },
+      {}
+    );
+    const queryString = (0, import_utils.toQueryString)(aliasedParams, this.methodDescriptor.parameterEncoder);
+    if (typeof queryString === "string" && queryString.length !== 0) {
+      const hasQuery = path.includes("?");
+      path += `${hasQuery ? "&" : "?"}${queryString}`;
     }
-
-    /**
-     * Returns the template path, without params, before interpolation.
-     * If path is a function, returns the result of request.path()
-     * Example: '/some/{param}/path'
-     */
-  }, {
-    key: "pathTemplate",
-    value: function pathTemplate() {
-      var path = this.methodDescriptor.path;
-      var prependSlash = function prependSlash(str) {
-        return str[0] !== '/' ? "/".concat(str) : str;
-      };
-      if (typeof path === 'function') {
-        return prependSlash(path(this.params()));
-      }
-      return prependSlash(path);
+    if (path[0] !== "/" && path.length > 0) {
+      path = `/${path}`;
     }
-
-    /**
-     * Returns the full URL
-     * Example: http://example.org/some/path?param1=true
-     *
-     */
-  }, {
-    key: "url",
-    value: function url() {
-      return "".concat(this.host()).concat(this.path());
+    return path;
+  }
+  /**
+   * Returns the template path, without params, before interpolation.
+   * If path is a function, returns the result of request.path()
+   * Example: '/some/{param}/path'
+   */
+  pathTemplate() {
+    const path = this.methodDescriptor.path;
+    const prependSlash = (str) => str[0] !== "/" ? `/${str}` : str;
+    if (typeof path === "function") {
+      return prependSlash(path(this.params()));
     }
-
-    /**
-     * Returns an object with the headers. Header names are converted to
-     * lowercase
-     */
-  }, {
-    key: "headers",
-    value: function headers() {
-      var headerAttr = this.methodDescriptor.headersAttr;
-      var headers = this.requestParams[headerAttr] || {};
-      if (typeof headers === 'function') {
-        return headers;
-      }
-      var mergedHeaders = _objectSpread(_objectSpread({}, this.methodDescriptor.headers), headers);
-      return (0, _utils.lowerCaseObjectKeys)(mergedHeaders);
+    return prependSlash(path);
+  }
+  /**
+   * Returns the full URL
+   * Example: http://example.org/some/path?param1=true
+   *
+   */
+  url() {
+    return `${this.host()}${this.path()}`;
+  }
+  /**
+   * Returns an object with the headers. Header names are converted to
+   * lowercase
+   */
+  headers() {
+    const headerAttr = this.methodDescriptor.headersAttr;
+    const headers = this.requestParams[headerAttr] || {};
+    if (typeof headers === "function") {
+      return headers;
     }
-
-    /**
-     * Utility method to get a header value by name
-     */
-  }, {
-    key: "header",
-    value: function header(name) {
-      var key = name.toLowerCase();
-      if (key in this.headers()) {
-        return this.headers()[key];
-      }
-      return undefined;
+    const mergedHeaders = { ...this.methodDescriptor.headers, ...headers };
+    return (0, import_utils.lowerCaseObjectKeys)(mergedHeaders);
+  }
+  /**
+   * Utility method to get a header value by name
+   */
+  header(name) {
+    const key = name.toLowerCase();
+    if (key in this.headers()) {
+      return this.headers()[key];
     }
-  }, {
-    key: "body",
-    value: function body() {
-      return this.requestParams[this.methodDescriptor.bodyAttr];
-    }
-  }, {
-    key: "auth",
-    value: function auth() {
-      return this.requestParams[this.methodDescriptor.authAttr];
-    }
-  }, {
-    key: "timeout",
-    value: function timeout() {
-      return this.requestParams[this.methodDescriptor.timeoutAttr];
-    }
-
-    /**
-     * Enhances current request returning a new Request
-     * @param {RequestParams} extras
-     *   @param {Object} extras.auth - it will replace the current auth
-     *   @param {String|Object} extras.body - it will replace the current body
-     *   @param {Headers} extras.headers - it will be merged with current headers
-     *   @param {String} extras.host - it will replace the current timeout
-     *   @param {RequestParams} extras.params - it will be merged with current params
-     *   @param {Number} extras.timeout - it will replace the current timeout
-     * @param {Object} requestContext - Use to pass information between different middleware.
-     */
-  }, {
-    key: "enhance",
-    value: function enhance(extras, requestContext) {
-      var authKey = this.methodDescriptor.authAttr;
-      var bodyKey = this.methodDescriptor.bodyAttr;
-      var headerKey = this.methodDescriptor.headersAttr;
-      var hostKey = this.methodDescriptor.hostAttr;
-      var timeoutKey = this.methodDescriptor.timeoutAttr;
-      var pathKey = this.methodDescriptor.pathAttr;
-
-      // Note: The result of merging an instance of RequestParams with instance of Params
-      // is simply a RequestParams with even more [param: string]'s on it.
-      var requestParams = (0, _utils.assign)({}, this.requestParams, extras.params);
-      var headers = this.requestParams[headerKey];
-      var mergedHeaders = (0, _utils.assign)({}, headers, extras.headers);
-      requestParams[headerKey] = mergedHeaders;
-      extras.auth && (requestParams[authKey] = extras.auth);
-      extras.body && (requestParams[bodyKey] = extras.body);
-      extras.host && (requestParams[hostKey] = extras.host);
-      extras.timeout && (requestParams[timeoutKey] = extras.timeout);
-      extras.path && (requestParams[pathKey] = extras.path);
-      var nextContext = _objectSpread(_objectSpread({}, this.requestContext), requestContext);
-      return new Request(this.methodDescriptor, requestParams, nextContext);
-    }
-
-    /**
-     * Is the request expecting a binary response?
-     */
-  }, {
-    key: "isBinary",
-    value: function isBinary() {
-      return this.methodDescriptor.binary;
-    }
-  }]);
-  return Request;
-}();
-exports.Request = Request;
-var _default = Request;
-exports["default"] = _default;
+    return void 0;
+  }
+  body() {
+    return this.requestParams[this.methodDescriptor.bodyAttr];
+  }
+  auth() {
+    return this.requestParams[this.methodDescriptor.authAttr];
+  }
+  timeout() {
+    return this.requestParams[this.methodDescriptor.timeoutAttr];
+  }
+  /**
+   * Enhances current request returning a new Request
+   * @param {RequestParams} extras
+   *   @param {Object} extras.auth - it will replace the current auth
+   *   @param {String|Object} extras.body - it will replace the current body
+   *   @param {Headers} extras.headers - it will be merged with current headers
+   *   @param {String} extras.host - it will replace the current timeout
+   *   @param {RequestParams} extras.params - it will be merged with current params
+   *   @param {Number} extras.timeout - it will replace the current timeout
+   * @param {Object} requestContext - Use to pass information between different middleware.
+   */
+  enhance(extras, requestContext) {
+    const authKey = this.methodDescriptor.authAttr;
+    const bodyKey = this.methodDescriptor.bodyAttr;
+    const headerKey = this.methodDescriptor.headersAttr;
+    const hostKey = this.methodDescriptor.hostAttr;
+    const timeoutKey = this.methodDescriptor.timeoutAttr;
+    const pathKey = this.methodDescriptor.pathAttr;
+    const requestParams = (0, import_utils.assign)({}, this.requestParams, extras.params);
+    const headers = this.requestParams[headerKey];
+    const mergedHeaders = (0, import_utils.assign)({}, headers, extras.headers);
+    requestParams[headerKey] = mergedHeaders;
+    extras.auth && (requestParams[authKey] = extras.auth);
+    extras.body && (requestParams[bodyKey] = extras.body);
+    extras.host && (requestParams[hostKey] = extras.host);
+    extras.timeout && (requestParams[timeoutKey] = extras.timeout);
+    extras.path && (requestParams[pathKey] = extras.path);
+    const nextContext = { ...this.requestContext, ...requestContext };
+    return new Request(this.methodDescriptor, requestParams, nextContext);
+  }
+  /**
+   * Is the request expecting a binary response?
+   */
+  isBinary() {
+    return this.methodDescriptor.binary;
+  }
+}
+var request_default = Request;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Request
+});
+//# sourceMappingURL=request.js.map

response.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var response_exports = {};
+__export(response_exports, {
+  REGEXP_CONTENT_TYPE_JSON: () => REGEXP_CONTENT_TYPE_JSON,
+  Response: () => Response,
+  default: () => response_default
 });
-exports["default"] = exports.Response = exports.REGEXP_CONTENT_TYPE_JSON = void 0;
-var _utils = require("./utils");
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-var REGEXP_CONTENT_TYPE_JSON = /^application\/(json|.*\+json)/;
-
-/**
- * @typedef Response
- * @param {Request} originalRequest, for auth it hides the password
- * @param {Integer} responseStatus
- * @param {String} responseData, defaults to null
- * @param {Object} responseHeaders, defaults to an empty object ({})
- * @param {Array<Error>} errors, defaults to an empty array ([])
- */
-exports.REGEXP_CONTENT_TYPE_JSON = REGEXP_CONTENT_TYPE_JSON;
-var Response = /*#__PURE__*/function () {
-  function Response(originalRequest, responseStatus, responseData, responseHeaders, errors) {
-    _classCallCheck(this, Response);
-    _defineProperty(this, "originalRequest", void 0);
-    _defineProperty(this, "responseStatus", void 0);
-    _defineProperty(this, "responseData", void 0);
-    _defineProperty(this, "responseHeaders", void 0);
-    // eslint-disable-next-line no-use-before-define
-    _defineProperty(this, "errors", void 0);
-    _defineProperty(this, "timeElapsed", void 0);
-    var auth = originalRequest.requestParams && originalRequest.requestParams.auth;
+module.exports = __toCommonJS(response_exports);
+var import_utils = require("./utils/index");
+const REGEXP_CONTENT_TYPE_JSON = /^application\/(json|.*\+json)/;
+class Response {
+  originalRequest;
+  responseStatus;
+  responseData;
+  responseHeaders;
+  // eslint-disable-next-line no-use-before-define
+  errors;
+  timeElapsed;
+  constructor(originalRequest, responseStatus, responseData, responseHeaders, errors) {
+    const auth = originalRequest.requestParams && originalRequest.requestParams.auth;
     if (auth) {
-      var maskedAuth = _objectSpread(_objectSpread({}, auth), {}, {
-        password: '***'
-      });
-      this.originalRequest = originalRequest.enhance({
-        auth: maskedAuth
-      });
+      const maskedAuth = { ...auth, password: "***" };
+      this.originalRequest = originalRequest.enhance({ auth: maskedAuth });
     } else {
@@ -56,3 +45,3 @@ this.originalRequest = originalRequest;
     this.responseStatus = responseStatus;
-    this.responseData = responseData !== null && responseData !== void 0 ? responseData : null;
+    this.responseData = responseData ?? null;
     this.responseHeaders = responseHeaders || {};
@@ -62,121 +51,101 @@ this.errors = errors || [];
   }
-  _createClass(Response, [{
-    key: "request",
-    value: function request() {
-      return this.originalRequest;
+  request() {
+    return this.originalRequest;
+  }
+  status() {
+    if (this.responseStatus === 1223) {
+      return 204;
     }
-  }, {
-    key: "status",
-    value: function status() {
-      // IE sends 1223 instead of 204
-      if (this.responseStatus === 1223) {
-        return 204;
-      }
-      return this.responseStatus;
+    return this.responseStatus;
+  }
+  /**
+   * Returns true if status is greater or equal 200 or lower than 400
+   */
+  success() {
+    const status = this.status();
+    return status >= 200 && status < 400;
+  }
+  /**
+   * Returns an object with the headers. Header names are converted to
+   * lowercase
+   */
+  headers() {
+    return (0, import_utils.lowerCaseObjectKeys)(this.responseHeaders);
+  }
+  /**
+   * Utility method to get a header value by name
+   */
+  header(name) {
+    const key = name.toLowerCase();
+    if (key in this.headers()) {
+      return this.headers()[key];
     }
-
-    /**
-     * Returns true if status is greater or equal 200 or lower than 400
-     */
-  }, {
-    key: "success",
-    value: function success() {
-      var status = this.status();
-      return status >= 200 && status < 400;
-    }
-
-    /**
-     * Returns an object with the headers. Header names are converted to
-     * lowercase
-     */
-  }, {
-    key: "headers",
-    value: function headers() {
-      return (0, _utils.lowerCaseObjectKeys)(this.responseHeaders);
-    }
-
-    /**
-     * Utility method to get a header value by name
-     */
-  }, {
-    key: "header",
-    value: function header(name) {
-      var key = name.toLowerCase();
-      if (key in this.headers()) {
-        return this.headers()[key];
+    return void 0;
+  }
+  /**
+   * Returns the original response data
+   */
+  rawData() {
+    return this.responseData;
+  }
+  /**
+   * Returns the response data, if "Content-Type" is "application/json"
+   * it parses the response and returns an object.
+   * Friendly reminder:
+   *  - JSON.parse() can return null, an Array or an object.
+   */
+  data() {
+    if (this.isContentTypeJSON() && this.responseData !== null) {
+      try {
+        return JSON.parse(this.responseData);
+      } catch (e) {
       }
-      return undefined;
     }
-
-    /**
-     * Returns the original response data
-     */
-  }, {
-    key: "rawData",
-    value: function rawData() {
-      return this.responseData;
+    return this.responseData;
+  }
+  isContentTypeJSON() {
+    const contentType = this.header("content-type");
+    if (contentType === void 0) {
+      return false;
     }
-
-    /**
-     * Returns the response data, if "Content-Type" is "application/json"
-     * it parses the response and returns an object.
-     * Friendly reminder:
-     *  - JSON.parse() can return null, an Array or an object.
-     */
-  }, {
-    key: "data",
-    value: function data() {
-      if (this.isContentTypeJSON() && this.responseData !== null) {
-        try {
-          return JSON.parse(this.responseData);
-        } catch (e) {} // eslint-disable-line no-empty
-      }
-
-      return this.responseData;
+    return REGEXP_CONTENT_TYPE_JSON.test(contentType);
+  }
+  /**
+   * Returns the last error instance that caused the request to fail
+   */
+  error() {
+    const lastError = this.errors[this.errors.length - 1] || null;
+    if (typeof lastError === "string") {
+      return new Error(lastError);
     }
-  }, {
-    key: "isContentTypeJSON",
-    value: function isContentTypeJSON() {
-      var contentType = this.header('content-type');
-      if (contentType === undefined) {
-        return false;
-      }
-      return REGEXP_CONTENT_TYPE_JSON.test(contentType);
-    }
-
-    /**
-     * Returns the last error instance that caused the request to fail
-     */
-  }, {
-    key: "error",
-    value: function error() {
-      var lastError = this.errors[this.errors.length - 1] || null;
-      if (typeof lastError === 'string') {
-        return new Error(lastError);
-      }
-      return lastError;
-    }
-
-    /**
-     * Enhances current Response returning a new Response
-     *
-     * @param {Object} extras
-     *   @param {Integer} extras.status - it will replace the current status
-     *   @param {String} extras.rawData - it will replace the current rawData
-     *   @param {Object} extras.headers - it will be merged with current headers
-     *   @param {Error} extras.error    - it will be added to the list of errors
-     */
-  }, {
-    key: "enhance",
-    value: function enhance(extras) {
-      var mergedHeaders = _objectSpread(_objectSpread({}, this.headers()), extras.headers || {});
-      var enhancedResponse = new Response(this.request(), extras.status || this.status(), extras.rawData || this.rawData(), mergedHeaders, extras.error ? [].concat(_toConsumableArray(this.errors), [extras.error]) : _toConsumableArray(this.errors));
-      enhancedResponse.timeElapsed = this.timeElapsed;
-      return enhancedResponse;
-    }
-  }]);
-  return Response;
-}();
-exports.Response = Response;
-var _default = Response;
-exports["default"] = _default;
+    return lastError;
+  }
+  /**
+   * Enhances current Response returning a new Response
+   *
+   * @param {Object} extras
+   *   @param {Integer} extras.status - it will replace the current status
+   *   @param {String} extras.rawData - it will replace the current rawData
+   *   @param {Object} extras.headers - it will be merged with current headers
+   *   @param {Error} extras.error    - it will be added to the list of errors
+   */
+  enhance(extras) {
+    const mergedHeaders = { ...this.headers(), ...extras.headers || {} };
+    const enhancedResponse = new Response(
+      this.request(),
+      extras.status || this.status(),
+      extras.rawData || this.rawData(),
+      mergedHeaders,
+      extras.error ? [...this.errors, extras.error] : [...this.errors]
+    );
+    enhancedResponse.timeElapsed = this.timeElapsed;
+    return enhancedResponse;
+  }
+}
+var response_default = Response;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REGEXP_CONTENT_TYPE_JSON,
+  Response
+});
+//# sourceMappingURL=response.js.map

test/index.d.ts

@@ -37,3 +37,3 @@ import { Client } from '../client-builder'
   ResourcesType,
-  ResourceName extends keyof ResourcesType = keyof ResourcesType
+  ResourceName extends keyof ResourcesType = keyof ResourcesType,
 >(client: Client<ResourcesType>): MockClient<ResourcesType, ResourceName>
@@ -70,2 +70,2 @@
 
-export const m: TestMatchFunctions
+export declare const m: TestMatchFunctions

test/index.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.mockRequest = exports.mockClient = exports.m = exports.lookupResponseAsync = exports.lookupResponse = exports.install = exports.clear = void 0;
-Object.defineProperty(exports, "requestFactory", {
-  enumerable: true,
-  get: function get() {
-    return _requestFactory.requestFactory;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var test_exports = {};
+__export(test_exports, {
+  clear: () => clear,
+  install: () => install,
+  lookupResponse: () => lookupResponse,
+  lookupResponseAsync: () => lookupResponseAsync,
+  m: () => m,
+  mockClient: () => mockClient,
+  mockRequest: () => mockRequest,
+  requestFactory: () => import_request_factory.requestFactory,
+  responseFactory: () => import_response_factory.responseFactory,
+  uninstall: () => uninstall,
+  unusedMocks: () => unusedMocks
 });
-Object.defineProperty(exports, "responseFactory", {
-  enumerable: true,
-  get: function get() {
-    return _responseFactory.responseFactory;
-  }
-});
-exports.unusedMocks = exports.uninstall = void 0;
-var _mockRequest = _interopRequireDefault(require("../mocks/mock-request"));
-var _mockResource = _interopRequireDefault(require("../mocks/mock-resource"));
-var _mock = _interopRequireDefault(require("../gateway/mock"));
-var _index = require("../index");
-var _utils = require("../utils");
-var _requestFactory = require("./request-factory");
-var _responseFactory = require("./response-factory");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-var store = [];
-var ids = 1;
-var originalGateway = null;
-
-/**
- * High level abstraction, it works directly on your client mocking
- * the resources and their methods.
- * @param {Object} client - the client generated by {@link forge}
- *
- * @return {MockAssert}
- */
-var mockClient = function mockClient(client) {
-  var entry = new _mockResource["default"](ids++, client);
+module.exports = __toCommonJS(test_exports);
+var import_mock_request = __toESM(require("../mocks/mock-request"));
+var import_mock_resource = __toESM(require("../mocks/mock-resource"));
+var import_mock = __toESM(require("../gateway/mock"));
+var import__ = require("../index");
+var import_utils = require("../utils/index");
+var import_request_factory = require("./request-factory");
+var import_response_factory = require("./response-factory");
+let store = [];
+let ids = 1;
+let originalGateway = null;
+const mockClient = (client) => {
+  const entry = new import_mock_resource.default(ids++, client);
   store.push(entry);
   return entry;
 };
-
-/**
- * Low level abstraction, very useful for automations
- * @param {Object} props
- *   @param {String} props.method - request method (get, post, etc)
- *   @param {String} props.url - request url (http://example.com)
- *   @param {String} props.body - request body
- *   @param {String} props.response
- *     @param {String} props.response.status
- *     @param {String} props.response.headers
- *     @param {String} props.response.body
- *
- * @return {MockAssert}
- */
-exports.mockClient = mockClient;
-var mockRequest = function mockRequest(props) {
-  var entry = new _mockRequest["default"](ids++, props);
+const mockRequest = (props) => {
+  const entry = new import_mock_request.default(ids++, props);
   store.push(entry);
   return entry.assertObject();
 };
-
-/**
- * Setup the test library
- */
-exports.mockRequest = mockRequest;
-var install = function install() {
-  originalGateway = _index.configs.gateway;
-  _index.configs.gateway = _mock["default"];
+const install = () => {
+  originalGateway = import__.configs.gateway;
+  import__.configs.gateway = import_mock.default;
 };
-
-/**
- * Teardown the test library
- */
-exports.install = install;
-var uninstall = function uninstall() {
+const uninstall = () => {
   clear();
   if (originalGateway) {
-    _index.configs.gateway = originalGateway;
+    import__.configs.gateway = originalGateway;
     originalGateway = null;
   }
 };
-
-/**
- * Cleans up all mocks
- */
-exports.uninstall = uninstall;
-var clear = function clear() {
+const clear = () => {
   store = [];
 };
-
-/**
- * Returns number of unused mocks
- * @returns {Number}
- */
-exports.clear = clear;
-var unusedMocks = function unusedMocks() {
-  var mocks = store.map(function (mock) {
-    return mock.toMockRequest();
+const unusedMocks = () => {
+  const mocks = store.map((mock) => mock.toMockRequest());
+  let count = 0;
+  mocks.forEach((mock) => {
+    if (mock.calls.length === 0)
+      count++;
   });
-  var count = 0;
-  mocks.forEach(function (mock) {
-    if (mock.calls.length === 0) count++;
-  });
   return count;
 };
-
-/**
- * Similar to "lookupResponse" but it also runs the request/prepareRequest phase of the middleware
- * stack
- *
- * @param {Request} request
- * @return {Promise<Response>}
- * @throws Will throw an error if it doesn't find a mock to match the given request
- */
-exports.unusedMocks = unusedMocks;
-var lookupResponseAsync = function lookupResponseAsync(request) {
-  var mocksPendingMiddlewareExecution = store.filter(function (mock) {
-    return mock.pendingMiddlewareExecution;
-  });
-  return _index.configs.Promise.all(mocksPendingMiddlewareExecution.map(function (mock) {
-    return mock.executeMiddlewareStack();
-  })).then(function () {
-    return lookupResponse(request);
-  });
+const lookupResponseAsync = (request) => {
+  const mocksPendingMiddlewareExecution = store.filter((mock) => mock.pendingMiddlewareExecution);
+  return import__.configs.Promise.all(
+    mocksPendingMiddlewareExecution.map((mock) => mock.executeMiddlewareStack())
+  ).then(() => lookupResponse(request));
 };
-
-/**
- * @param {Request} request
- * @return {Response}
- * @throws Will throw an error if it doesn't find a mock to match the given request
- */
-exports.lookupResponseAsync = lookupResponseAsync;
-var lookupResponse = function lookupResponse(request) {
-  var mocks = store.map(function (mock) {
-    return mock.toMockRequest();
-  });
-  var exactMatch = mocks.filter(function (mock) {
-    return mock.isExactMatch(request);
-  }).pop();
+const lookupResponse = (request) => {
+  const mocks = store.map((mock) => mock.toMockRequest());
+  const exactMatch = mocks.filter((mock) => mock.isExactMatch(request)).pop();
   if (exactMatch) {
     return exactMatch.call(request);
   }
-  var partialMatch = mocks.filter(function (mock) {
-    return mock.isPartialMatch(request);
-  }).pop();
+  const partialMatch = mocks.filter((mock) => mock.isPartialMatch(request)).pop();
   if (partialMatch) {
-    throw new Error("[Mappersmith Test] No exact match found for ".concat(requestToLog(request), ", partial match with ").concat(mockToLog(partialMatch), ", check your mock definition"));
+    throw new Error(
+      `[Mappersmith Test] No exact match found for ${requestToLog(
+        request
+      )}, partial match with ${mockToLog(partialMatch)}, check your mock definition`
+    );
   }
-  throw new Error("[Mappersmith Test] No match found for ".concat(requestToLog(request), ", check your mock definition"));
+  throw new Error(
+    `[Mappersmith Test] No match found for ${requestToLog(request)}, check your mock definition`
+  );
 };
-
-/**
- * List of match functions
- */
-exports.lookupResponse = lookupResponse;
-var m = {
-  stringMatching: function stringMatching(regexp) {
+const m = {
+  stringMatching: (regexp) => {
     if (!(regexp instanceof RegExp)) {
-      throw new Error("[Mappersmith Test] \"stringMatching\" received an invalid regexp (".concat(regexp, ")"));
+      throw new Error(`[Mappersmith Test] "stringMatching" received an invalid regexp (${regexp})`);
     }
-    return function (string) {
-      return regexp.test(string);
-    };
+    return (string) => regexp.test(string);
   },
-  stringContaining: function stringContaining(sample) {
-    if (typeof sample !== 'string') {
-      throw new Error("[Mappersmith Test] \"stringContaining\" received an invalid string (".concat(sample, ")"));
+  stringContaining: (sample) => {
+    if (typeof sample !== "string") {
+      throw new Error(
+        `[Mappersmith Test] "stringContaining" received an invalid string (${sample})`
+      );
     }
-    return function (string) {
-      return stringIncludes(string, sample);
-    };
+    return (string) => stringIncludes(string, sample);
   },
-  uuid4: function uuid4() {
-    // NOTE: based on https://github.com/chriso/validator.js/blob/3443132beccddf06c3f0a5e88c1dd2ee6513b612/src/lib/isUUID.js
-    var uuid4Rx = /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i;
-    return function (string) {
-      return uuid4Rx.test(string);
-    };
+  uuid4: () => {
+    const uuid4Rx = /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i;
+    return (string) => uuid4Rx.test(string);
   },
-  anything: function anything() {
-    return function () {
-      return true;
-    };
-  }
+  anything: () => () => true
 };
-exports.m = m;
-var requestToLog = function requestToLog(request) {
-  return "\"".concat(request.method().toUpperCase(), " ").concat(request.url(), "\" (body: \"").concat((0, _utils.toQueryString)(request.body()), "\"; headers: \"").concat((0, _utils.toQueryString)(request.headers()), "\")");
-};
-var mockToLog = function mockToLog(requestMock) {
-  return "\"".concat(requestMock.method.toUpperCase(), " ").concat(requestMock.url, "\" (body: \"").concat(requestMock.body, "\"; headers: \"").concat(requestMock.headers, "\")");
-};
-var stringIncludes = function stringIncludes(str, search, start) {
-  if (typeof start !== 'number') {
+const requestToLog = (request) => `"${request.method().toUpperCase()} ${request.url()}" (body: "${(0, import_utils.toQueryString)(
+  request.body()
+)}"; headers: "${(0, import_utils.toQueryString)(request.headers())}")`;
+const mockToLog = (requestMock) => `"${requestMock.method.toUpperCase()} ${requestMock.url}" (body: "${requestMock.body}"; headers: "${requestMock.headers}")`;
+const stringIncludes = (str, search, start) => {
+  if (typeof start !== "number") {
     start = 0;
   }
-  if (typeof str.includes === 'function') {
+  if (typeof str.includes === "function") {
     return str.includes(search, start);
@@ -207,2 +147,17 @@ }
   return str.indexOf(search, start) !== -1;
-};
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clear,
+  install,
+  lookupResponse,
+  lookupResponseAsync,
+  m,
+  mockClient,
+  mockRequest,
+  requestFactory,
+  responseFactory,
+  uninstall,
+  unusedMocks
+});
+//# sourceMappingURL=index.js.map

test/request-factory.js

 "use strict";
-
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var request_factory_exports = {};
+__export(request_factory_exports, {
+  requestFactory: () => requestFactory
 });
-exports.requestFactory = void 0;
-var _request = require("../request");
-var _methodDescriptor = require("../method-descriptor");
-var _excluded = ["method", "host", "path", "auth", "body", "headers", "params", "timeout", "context"];
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-/**
- * Create a request to use in tests
- * @returns Request
- */
-var requestFactory = function requestFactory() {
-  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var _ref$method = _ref.method,
-    method = _ref$method === void 0 ? 'GET' : _ref$method,
-    _ref$host = _ref.host,
-    host = _ref$host === void 0 ? 'http://example.org' : _ref$host,
-    _ref$path = _ref.path,
-    path = _ref$path === void 0 ? '/path' : _ref$path,
-    auth = _ref.auth,
-    body = _ref.body,
-    headers = _ref.headers,
-    params = _ref.params,
-    timeout = _ref.timeout,
-    context = _ref.context,
-    rest = _objectWithoutProperties(_ref, _excluded);
-  var methodDescriptor = new _methodDescriptor.MethodDescriptor({
-    method: method,
-    host: host,
-    path: path
-  });
-  return new _request.Request(methodDescriptor, _objectSpread({
-    auth: auth,
-    body: body,
-    headers: headers,
-    params: params,
-    timeout: timeout
-  }, rest), context);
+module.exports = __toCommonJS(request_factory_exports);
+var import_request = require("../request");
+var import_method_descriptor = require("../method-descriptor");
+const requestFactory = ({
+  method = "GET",
+  host = "http://example.org",
+  path = "/path",
+  auth,
+  body,
+  headers,
+  params,
+  timeout,
+  context,
+  ...rest
+} = {}) => {
+  const methodDescriptor = new import_method_descriptor.MethodDescriptor({ method, host, path });
+  return new import_request.Request(
+    methodDescriptor,
+    {
+      auth,
+      body,
+      headers,
+      params,
+      timeout,
+      ...rest
+    },
+    context
+  );
 };
-exports.requestFactory = requestFactory;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  requestFactory
+});
+//# sourceMappingURL=request-factory.js.map

test/response-factory.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var response_factory_exports = {};
+__export(response_factory_exports, {
+  responseFactory: () => responseFactory
 });
-exports.responseFactory = void 0;
-var _response = require("../response");
-var _requestFactory = require("./request-factory");
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-/**
- * Create a response to use in tests
- * @returns Response
- */
-var responseFactory = function responseFactory() {
-  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-    _ref$method = _ref.method,
-    method = _ref$method === void 0 ? 'GET' : _ref$method,
-    _ref$host = _ref.host,
-    host = _ref$host === void 0 ? 'http://example.org' : _ref$host,
-    _ref$path = _ref.path,
-    path = _ref$path === void 0 ? '/path' : _ref$path,
-    _ref$request = _ref.request,
-    request = _ref$request === void 0 ? (0, _requestFactory.requestFactory)({
-      method: method,
-      host: host,
-      path: path
-    }) : _ref$request,
-    _ref$status = _ref.status,
-    status = _ref$status === void 0 ? 200 : _ref$status,
-    _ref$data = _ref.data,
-    data = _ref$data === void 0 ? {} : _ref$data,
-    _ref$headers = _ref.headers,
-    headers = _ref$headers === void 0 ? {} : _ref$headers,
-    _ref$errors = _ref.errors,
-    errors = _ref$errors === void 0 ? [] : _ref$errors;
-  var responseData;
-  var contentType;
-  if (typeof data === 'string') {
-    contentType = 'text/plain';
+module.exports = __toCommonJS(response_factory_exports);
+var import_response = require("../response");
+var import_request_factory = require("./request-factory");
+const responseFactory = ({
+  method = "GET",
+  host = "http://example.org",
+  path = "/path",
+  request = (0, import_request_factory.requestFactory)({ method, host, path }),
+  status = 200,
+  data = {},
+  headers = {},
+  errors = []
+} = {}) => {
+  let responseData;
+  let contentType;
+  if (typeof data === "string") {
+    contentType = "text/plain";
     responseData = data;
   } else {
-    contentType = 'application/json';
+    contentType = "application/json";
     responseData = JSON.stringify(data);
   }
-  return new _response.Response(request, status, responseData, _objectSpread({
-    'content-type': contentType
-  }, headers), errors);
+  return new import_response.Response(
+    request,
+    status,
+    responseData,
+    { "content-type": contentType, ...headers },
+    errors
+  );
 };
-exports.responseFactory = responseFactory;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  responseFactory
+});
+//# sourceMappingURL=response-factory.js.map

types.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

utils/clone.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clone_exports = {};
+__export(clone_exports, {
+  clone: () => clone
 });
-exports.clone = void 0;
-var _index = require("./index");
-var clone = function clone(obj) {
-  if ((0, _index.isPlainObject)(obj)) {
+module.exports = __toCommonJS(clone_exports);
+var import_index = require("./index");
+const clone = (obj) => {
+  if ((0, import_index.isPlainObject)(obj)) {
     return cloneObject(obj);
@@ -17,30 +34,34 @@ } else if (Array.isArray(obj)) {
 };
-exports.clone = clone;
-var cloneObject = function cloneObject(obj) {
-  var clone = {};
-  for (var i in obj) {
-    var value = obj[i];
-    if ((0, _index.isObject)(value)) {
-      clone[i] = cloneObject(value);
+const cloneObject = (obj) => {
+  const clone2 = {};
+  for (const i in obj) {
+    const value = obj[i];
+    if ((0, import_index.isObject)(value)) {
+      clone2[i] = cloneObject(value);
     } else if (Array.isArray(value)) {
-      clone[i] = cloneArray(value);
+      clone2[i] = cloneArray(value);
     } else {
-      clone[i] = value;
+      clone2[i] = value;
     }
   }
-  return clone;
+  return clone2;
 };
-var cloneArray = function cloneArray(obj) {
-  var clone = [];
-  for (var i in obj) {
-    var value = obj[i];
-    if ((0, _index.isObject)(value)) {
-      clone.push(cloneObject(value));
+const cloneArray = (obj) => {
+  const clone2 = [];
+  for (const i in obj) {
+    const value = obj[i];
+    if ((0, import_index.isObject)(value)) {
+      clone2.push(cloneObject(value));
     } else if (Array.isArray(value)) {
-      clone.push(cloneArray(value));
+      clone2.push(cloneArray(value));
     } else {
-      clone.push(value);
+      clone2.push(value);
     }
   }
-  return clone;
-};
+  return clone2;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clone
+});
+//# sourceMappingURL=clone.js.map

utils/index.js

 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  assign: () => assign,
+  btoa: () => btoa,
+  buildRecursive: () => buildRecursive,
+  isObject: () => isObject,
+  isPlainObject: () => isPlainObject,
+  lowerCaseObjectKeys: () => lowerCaseObjectKeys,
+  parseResponseHeaders: () => parseResponseHeaders,
+  performanceNow: () => performanceNow,
+  toQueryString: () => toQueryString,
+  validKeys: () => validKeys
 });
-exports.validKeys = exports.toQueryString = exports.performanceNow = exports.parseResponseHeaders = exports.lowerCaseObjectKeys = exports.isPlainObject = exports.isObject = exports.buildRecursive = exports.btoa = exports.assign = void 0;
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-var _process, getNanoSeconds, loadTime;
+module.exports = __toCommonJS(utils_exports);
+let _process, getNanoSeconds, loadTime;
 try {
-  // eslint-disable-next-line no-eval
-  _process = eval('typeof __TEST_WEB__ === "undefined" && typeof process === "object" ? process : undefined');
-} catch (e) {} // eslint-disable-line no-empty
-
-var hasProcessHrtime = function hasProcessHrtime() {
-  return typeof _process !== 'undefined' && _process !== null && _process.hrtime;
+  _process = eval(
+    'typeof __TEST_WEB__ === "undefined" && typeof process === "object" ? process : undefined'
+  );
+} catch (e) {
+}
+const hasProcessHrtime = () => {
+  return typeof _process !== "undefined" && _process !== null && _process.hrtime;
 };
 if (hasProcessHrtime()) {
-  getNanoSeconds = function getNanoSeconds() {
-    var hr = _process.hrtime();
+  getNanoSeconds = () => {
+    const hr = _process.hrtime();
     return hr[0] * 1e9 + hr[1];
@@ -24,55 +50,36 @@ };
 }
-var R20 = /%20/g;
-var isNeitherNullNorUndefined = function isNeitherNullNorUndefined(x) {
-  return x !== null && x !== undefined;
-};
-var validKeys = function validKeys(entry) {
-  return Object.keys(entry).filter(function (key) {
-    return isNeitherNullNorUndefined(entry[key]);
-  });
-};
-exports.validKeys = validKeys;
-var buildRecursive = function buildRecursive(key, value) {
-  var suffix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
-  var encoderFn = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : encodeURIComponent;
+const R20 = /%20/g;
+const isNeitherNullNorUndefined = (x) => x !== null && x !== void 0;
+const validKeys = (entry) => Object.keys(entry).filter((key) => isNeitherNullNorUndefined(entry[key]));
+const buildRecursive = (key, value, suffix = "", encoderFn = encodeURIComponent) => {
   if (Array.isArray(value)) {
-    return value.map(function (v) {
-      return buildRecursive(key, v, suffix + '[]', encoderFn);
-    }).join('&');
+    return value.map((v) => buildRecursive(key, v, suffix + "[]", encoderFn)).join("&");
   }
-  if (_typeof(value) !== 'object') {
-    return "".concat(encoderFn(key + suffix), "=").concat(encoderFn(value));
+  if (typeof value !== "object") {
+    return `${encoderFn(key + suffix)}=${encoderFn(value)}`;
   }
-  return Object.keys(value).map(function (nestedKey) {
-    var nestedValue = value[nestedKey];
+  return Object.keys(value).map((nestedKey) => {
+    const nestedValue = value[nestedKey];
     if (isNeitherNullNorUndefined(nestedValue)) {
-      return buildRecursive(key, nestedValue, suffix + '[' + nestedKey + ']', encoderFn);
+      return buildRecursive(key, nestedValue, suffix + "[" + nestedKey + "]", encoderFn);
     }
     return null;
-  }).filter(isNeitherNullNorUndefined).join('&');
+  }).filter(isNeitherNullNorUndefined).join("&");
 };
-exports.buildRecursive = buildRecursive;
-var toQueryString = function toQueryString(entry) {
-  var encoderFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : encodeURIComponent;
+const toQueryString = (entry, encoderFn = encodeURIComponent) => {
   if (!isPlainObject(entry)) {
     return entry;
   }
-  return Object.keys(entry).map(function (key) {
-    var value = entry[key];
+  return Object.keys(entry).map((key) => {
+    const value = entry[key];
     if (isNeitherNullNorUndefined(value)) {
-      return buildRecursive(key, value, '', encoderFn);
+      return buildRecursive(key, value, "", encoderFn);
     }
     return null;
-  }).filter(isNeitherNullNorUndefined).join('&').replace(R20, '+');
+  }).filter(isNeitherNullNorUndefined).join("&").replace(R20, "+");
 };
-
-/**
- * Gives time in milliseconds, but with sub-millisecond precision for Browser
- * and Nodejs
- */
-exports.toQueryString = toQueryString;
-var performanceNow = function performanceNow() {
-  if (hasProcessHrtime() && getNanoSeconds !== undefined) {
-    var now = getNanoSeconds();
-    if (now !== undefined && loadTime !== undefined) {
+const performanceNow = () => {
+  if (hasProcessHrtime() && getNanoSeconds !== void 0) {
+    const now = getNanoSeconds();
+    if (now !== void 0 && loadTime !== void 0) {
       return (now - loadTime) / 1e6;
@@ -83,25 +90,14 @@ }
 };
-
-/**
- * borrowed from: {@link https://gist.github.com/monsur/706839}
- * XmlHttpRequest's getAllResponseHeaders() method returns a string of response
- * headers according to the format described here:
- * {@link http://www.w3.org/TR/XMLHttpRequest/#the-getallresponseheaders-method}
- * This method parses that string into a user-friendly key/value pair object.
- */
-exports.performanceNow = performanceNow;
-var parseResponseHeaders = function parseResponseHeaders(headerStr) {
-  var headers = {};
+const parseResponseHeaders = (headerStr) => {
+  const headers = {};
   if (!headerStr) {
     return headers;
   }
-  var headerPairs = headerStr.split("\r\n");
-  for (var i = 0; i < headerPairs.length; i++) {
-    var headerPair = headerPairs[i];
-    // Can't use split() here because it does the wrong thing
-    // if the header value has the string ": " in it.
-    var index = headerPair.indexOf(": ");
+  const headerPairs = headerStr.split("\r\n");
+  for (let i = 0; i < headerPairs.length; i++) {
+    const headerPair = headerPairs[i];
+    const index = headerPair.indexOf(": ");
     if (index > 0) {
-      var key = headerPair.substring(0, index).toLowerCase().trim();
-      var val = headerPair.substring(index + 2).trim();
+      const key = headerPair.substring(0, index).toLowerCase().trim();
+      const val = headerPair.substring(index + 2).trim();
       headers[key] = val;
@@ -112,5 +108,4 @@ }
 };
-exports.parseResponseHeaders = parseResponseHeaders;
-var lowerCaseObjectKeys = function lowerCaseObjectKeys(obj) {
-  return Object.keys(obj).reduce(function (target, key) {
+const lowerCaseObjectKeys = (obj) => {
+  return Object.keys(obj).reduce((target, key) => {
     target[key.toLowerCase()] = obj[key];
@@ -120,9 +115,7 @@ return target;
 };
-exports.lowerCaseObjectKeys = lowerCaseObjectKeys;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-var assign = Object.assign || function (target) {
-  for (var i = 1; i < arguments.length; i++) {
-    // eslint-disable-next-line prefer-rest-params
-    var source = arguments[i];
-    for (var key in source) {
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const assign = Object.assign || function(target) {
+  for (let i = 1; i < arguments.length; i++) {
+    const source = arguments[i];
+    for (const key in source) {
       if (hasOwnProperty.call(source, key)) {
@@ -135,33 +128,28 @@ target[key] = source[key];
 };
-exports.assign = assign;
-var toString = Object.prototype.toString;
-var isPlainObject = function isPlainObject(value) {
-  return toString.call(value) === '[object Object]' && Object.getPrototypeOf(value) === Object.getPrototypeOf({});
+const toString = Object.prototype.toString;
+const isPlainObject = (value) => {
+  return toString.call(value) === "[object Object]" && Object.getPrototypeOf(value) === Object.getPrototypeOf({});
 };
-exports.isPlainObject = isPlainObject;
-var isObject = function isObject(value) {
-  return _typeof(value) === 'object' && value !== null && !Array.isArray(value);
+const isObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 };
-
-/**
- * borrowed from: {@link https://github.com/davidchambers/Base64.js}
- */
-exports.isObject = isObject;
-var CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-var btoa = function btoa(input) {
-  var output = '';
-  var map = CHARS;
-  var str = String(input);
+const CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+const btoa = (input) => {
+  let output = "";
+  let map = CHARS;
+  const str = String(input);
   for (
-  // initialize result and counter
-  var block = 0, charCode, idx = 0;
-  // if the next str index does not exist:
-  //   change the mapping table to "="
-  //   check if d has no fractional digits
-  str.charAt(idx | 0) || (map = '=', idx % 1);
-  // "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8
-  output += map.charAt(63 & block >> 8 - idx % 1 * 8)) {
+    let block = 0, charCode, idx = 0;
+    // if the next str index does not exist:
+    //   change the mapping table to "="
+    //   check if d has no fractional digits
+    str.charAt(idx | 0) || (map = "=", idx % 1);
+    // "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8
+    output += map.charAt(63 & block >> 8 - idx % 1 * 8)
+  ) {
     charCode = str.charCodeAt(idx += 3 / 4);
-    if (charCode > 0xff) {
-      throw new Error("[Mappersmith] 'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.");
+    if (charCode > 255) {
+      throw new Error(
+        "[Mappersmith] 'btoa' failed: The string to be encoded contains characters outside of the Latin1 range."
+      );
     }
@@ -172,2 +160,15 @@ block = block << 8 | charCode;
 };
-exports.btoa = btoa;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assign,
+  btoa,
+  buildRecursive,
+  isObject,
+  isPlainObject,
+  lowerCaseObjectKeys,
+  parseResponseHeaders,
+  performanceNow,
+  toQueryString,
+  validKeys
+});
+//# sourceMappingURL=index.js.map

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

981288

increased by281.15%

Number of package files

342

increased by332.91%

Lines of code

13117

increased by198.25%

Number of lines in readme file

1482

increased by0.88%

Worsened metrics

Dev dependency count

62

increased by6.9%

Number of low quality alerts

1

increased byInfinity%

Number of low supply chain risk alerts

1

increased byInfinity%

Number of medium supply chain risk alerts

17

increased by142.86%

No dependency changes