@dereekb/util 13.0.0 → 13.0.2

package/fetch/index.esm.js

@@ -1,151 +1,580 @@
 import { BaseError } from 'make-error';
-import 'core-js/modules/es.iterator.constructor.js';
-import 'core-js/modules/es.iterator.for-each.js';
-import 'core-js/modules/es.set.difference.v2.js';
-import 'core-js/modules/es.set.symmetric-difference.v2.js';
-import 'core-js/modules/es.set.union.v2.js';
-import { removeTrailingSlashes, asGetter, multiValueMapBuilder, filterMaybeArrayValues, isPromiseLike, isWebsiteUrlWithPrefix, fixMultiSlashesInSlashPath, cachedGetter, FIRST_PAGE, performTasksFromFactoryInParallelFunction, mapIdentityFunction, performAsyncTasks, mergeObjects, filterEmptyPojoValues, useIterableOrValue, isEmptyIterable, fixExtraQueryParameters, forEachInIterable, forEachKeyValue, isIterable } from '@dereekb/util';
+import { removeTrailingSlashes, asGetter, multiValueMapBuilder, filterMaybeArrayValues, isWebsiteUrlWithPrefix, fixMultiSlashesInSlashPath, isPromiseLike, cachedGetter, FIRST_PAGE, mapIdentityFunction, performTasksFromFactoryInParallelFunction, performAsyncTasks, mergeObjects, filterEmptyPojoValues, useIterableOrValue, isEmptyIterable, fixExtraQueryParameters, forEachInIterable, forEachKeyValue, isIterable } from '@dereekb/util';
 import { safeParse } from 'fast-content-type-parse';
-import 'core-js/modules/es.iterator.map.js';
-import 'core-js/modules/es.json.stringify.js';
 
+function _assert_this_initialized$3(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super$3(_this, derived, args) {
+    derived = _get_prototype_of$3(derived);
+    return _possible_constructor_return$3(_this, _is_native_reflect_construct$3() ? Reflect.construct(derived, args || [], _get_prototype_of$3(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property$5(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of$3(o) {
+    _get_prototype_of$3 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$3(o);
+}
+function _inherits$3(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
+        }
+    });
+    if (superClass) _set_prototype_of$3(subClass, superClass);
+}
+function _possible_constructor_return$3(self, call) {
+    if (call && (_type_of$5(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$3(self);
+}
+function _set_prototype_of$3(o, p) {
+    _set_prototype_of$3 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$3(o, p);
+}
+function _type_of$5(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$3() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$3 = function() {
+        return !!result;
+    })();
+}
 /**
  * Thrown by a FetchRequestFactory if one of the async request initialization steps fails.
- */
-class FetchRequestFactoryError extends BaseError {
-  constructor(error) {
-    super(`Fetch request failed to build due to an unexpected error: ${typeof error === 'object' ? error.message ?? '' : error}`);
-    this.error = void 0;
-    this.error = error;
-  }
-}
+ */ var FetchRequestFactoryError = /*#__PURE__*/ function(BaseError) {
+    _inherits$3(FetchRequestFactoryError, BaseError);
+    function FetchRequestFactoryError(error) {
+        _class_call_check$3(this, FetchRequestFactoryError);
+        var _this;
+        var _error_message;
+        _this = _call_super$3(this, FetchRequestFactoryError, [
+            "Fetch request failed to build due to an unexpected error: ".concat((typeof error === "undefined" ? "undefined" : _type_of$5(error)) === 'object' ? (_error_message = error.message) !== null && _error_message !== void 0 ? _error_message : '' : error)
+        ]), _define_property$5(_this, "error", void 0);
+        _this.error = error;
+        return _this;
+    }
+    return FetchRequestFactoryError;
+}(BaseError);
 /**
  * Wraps the input fetch function to always pass the fetch response promise to requireOkResponse().
  *
  * @param inputFetch
  * @returns
- */
-function fetchOk(inputFetch) {
-  return (input, init) => requireOkResponse(inputFetch(input, init));
-}
-class FetchResponseError extends BaseError {
-  constructor(response) {
-    super(`Fetch response was a non-ok status code (${response.status}): ${response.statusText}`);
-    this.response = void 0;
-    this.response = response;
-  }
+ */ function fetchOk(inputFetch) {
+    return function(input, init) {
+        return requireOkResponse(inputFetch(input, init));
+    };
 }
-function requireOkResponse(responsePromise) {
-  return responsePromise.then(response => {
-    if (!response.ok) {
-      throw new FetchResponseError(response);
+var FetchResponseError = /*#__PURE__*/ function(BaseError) {
+    _inherits$3(FetchResponseError, BaseError);
+    function FetchResponseError(response) {
+        _class_call_check$3(this, FetchResponseError);
+        var _this;
+        _this = _call_super$3(this, FetchResponseError, [
+            "Fetch response was a non-ok status code (".concat(response.status, "): ").concat(response.statusText)
+        ]), _define_property$5(_this, "response", void 0);
+        _this.response = response;
+        return _this;
     }
-    return response;
-  });
+    return FetchResponseError;
+}(BaseError);
+function requireOkResponse(responsePromise) {
+    return responsePromise.then(function(response) {
+        if (!response.ok) {
+            throw new FetchResponseError(response);
+        }
+        return response;
+    });
 }
 
-class FetchTimeoutError extends BaseError {
-  constructor(response, timeout) {
-    super(`Fetch response was timed out (${timeout})`);
-    this.response = void 0;
-    this.timeout = void 0;
-    this.response = response;
-    this.timeout = timeout;
-  }
+function _assert_this_initialized$2(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super$2(_this, derived, args) {
+    derived = _get_prototype_of$2(derived);
+    return _possible_constructor_return$2(_this, _is_native_reflect_construct$2() ? Reflect.construct(derived, args || [], _get_prototype_of$2(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property$4(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of$2(o) {
+    _get_prototype_of$2 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$2(o);
+}
+function _inherits$2(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
+        }
+    });
+    if (superClass) _set_prototype_of$2(subClass, superClass);
 }
+function _object_spread$4(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$4(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$3(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$3(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$3(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _possible_constructor_return$2(self, call) {
+    if (call && (_type_of$4(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$2(self);
+}
+function _set_prototype_of$2(o, p) {
+    _set_prototype_of$2 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$2(o, p);
+}
+function _type_of$4(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$2() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$2 = function() {
+        return !!result;
+    })();
+}
+var FetchTimeoutError = /*#__PURE__*/ function(BaseError) {
+    _inherits$2(FetchTimeoutError, BaseError);
+    function FetchTimeoutError(response, timeout) {
+        _class_call_check$2(this, FetchTimeoutError);
+        var _this;
+        _this = _call_super$2(this, FetchTimeoutError, [
+            "Fetch response was timed out (".concat(timeout, ")")
+        ]), _define_property$4(_this, "response", void 0), _define_property$4(_this, "timeout", void 0);
+        _this.response = response;
+        _this.timeout = timeout;
+        return _this;
+    }
+    return FetchTimeoutError;
+}(BaseError);
 function fetchTimeout(inputFetch) {
-  return (input, init) => {
-    let controller;
-    const timeout = init?.timeout ?? input.timeout;
-    // if signal is not provided, and a timeout is specified, configure the timeout
-    if (!init?.signal && timeout) {
-      const abortController = new AbortController();
-      controller = abortController;
-      init = {
-        ...init,
-        signal: abortController.signal // pass the abort signal
-      };
-    }
-    let responsePromise = inputFetch(input, init);
-    if (timeout) {
-      const timeoutId = setTimeout(() => {
-        controller?.abort();
-      }, timeout);
-      responsePromise = responsePromise.finally(() => {
-        clearTimeout(timeoutId);
-      });
-    }
-    return responsePromise;
-  };
+    return function(input, init) {
+        var _ref;
+        var controller;
+        var timeout = (_ref = init === null || init === void 0 ? void 0 : init.timeout) !== null && _ref !== void 0 ? _ref : input.timeout;
+        // if signal is not provided, and a timeout is specified, configure the timeout
+        if (!(init === null || init === void 0 ? void 0 : init.signal) && timeout) {
+            var abortController = new AbortController();
+            controller = abortController;
+            init = _object_spread_props$3(_object_spread$4({}, init), {
+                signal: abortController.signal // pass the abort signal
+            });
+        }
+        var responsePromise = inputFetch(input, init);
+        if (timeout) {
+            var timeoutId = setTimeout(function() {
+                controller === null || controller === void 0 ? void 0 : controller.abort();
+            }, timeout);
+            responsePromise = responsePromise.finally(function() {
+                clearTimeout(timeoutId);
+            });
+        }
+        return responsePromise;
+    };
 }
 
+function _array_like_to_array$2(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 _array_with_holes$2(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep$3(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 _async_to_generator$3(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property$3(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof$1(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit$2(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$2() {
+    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 _object_spread$3(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$3(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$2(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$2(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$2(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array$2(arr, i) {
+    return _array_with_holes$2(arr) || _iterable_to_array_limit$2(arr, i) || _unsupported_iterable_to_array$2(arr, i) || _non_iterable_rest$2();
+}
+function _type_of$3(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array$2(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$2(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(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+}
+function _ts_generator$3(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 /**
  * Used to create a FetchService.
  *
  * @param config
  * @returns
- */
-function fetchService(config) {
-  const {
-    makeFetch: inputMakeFetch,
-    makeRequest,
-    baseRequest
-  } = config;
-  const factory = {
-    fetchRequestFactory: config => fetchRequestFactory({
-      makeRequest,
-      baseRequest,
-      ...config
-    }),
-    makeFetch: (config = {}) => configureFetch({
-      makeRequest,
-      makeFetch: inputMakeFetch,
-      baseRequest,
-      ...config
-    }),
-    makeRequest: config.makeRequest
-  };
-  return factory;
+ */ function fetchService(config) {
+    var inputMakeFetch = config.makeFetch, makeRequest = config.makeRequest, baseRequest = config.baseRequest;
+    var factory = {
+        fetchRequestFactory: function fetchRequestFactory1(config) {
+            return fetchRequestFactory(_object_spread$3({
+                makeRequest: makeRequest,
+                baseRequest: baseRequest
+            }, config));
+        },
+        makeFetch: function makeFetch() {
+            var _$config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+            return configureFetch(_object_spread$3({
+                makeRequest: makeRequest,
+                makeFetch: inputMakeFetch,
+                baseRequest: baseRequest
+            }, _$config));
+        },
+        makeRequest: config.makeRequest
+    };
+    return factory;
 }
 /**
  * Default FetchHabdler
  * @param request
  * @param makeFetch
  * @returns
- */
-const DEFAULT_FETCH_HANDLER = (request, makeFetch) => makeFetch(request);
+ */ var DEFAULT_FETCH_HANDLER = function DEFAULT_FETCH_HANDLER(request, makeFetch) {
+    return makeFetch(request);
+};
 /**
  * Creates a function that wraps fetch and uses a FetchRequestFactory to generate a Request before invoking Fetch.
  *
  * @param config
  * @returns
- */
-function configureFetch(config) {
-  const {
-    makeFetch: inputMakeFetch = fetch,
-    fetchHandler = DEFAULT_FETCH_HANDLER,
-    useTimeout,
-    requireOkResponse: inputRequireOkResponse,
-    mapResponse
-  } = config;
-  let makeFetch = inputMakeFetch;
-  if (useTimeout) {
-    // add fetchTimeout
-    makeFetch = fetchTimeout(makeFetch);
-  }
-  if (inputRequireOkResponse) {
-    // Add fetchOk
-    makeFetch = fetchOk(makeFetch);
-  }
-  const makeFetchRequest = fetchRequestFactory(config);
-  return async (input, init) => {
-    const request = await makeFetchRequest(input, init);
-    let response = fetchHandler(request, makeFetch);
-    if (mapResponse) {
-      response = mapResponse(response);
-    }
-    return response;
-  };
+ */ function configureFetch(config) {
+    var tmp = config.makeFetch, inputMakeFetch = tmp === void 0 ? fetch : tmp, _config_fetchHandler = config.fetchHandler, fetchHandler = _config_fetchHandler === void 0 ? DEFAULT_FETCH_HANDLER : _config_fetchHandler, useTimeout = config.useTimeout, inputRequireOkResponse = config.requireOkResponse, mapResponse = config.mapResponse;
+    var makeFetch = inputMakeFetch;
+    if (useTimeout) {
+        // add fetchTimeout
+        makeFetch = fetchTimeout(makeFetch);
+    }
+    if (inputRequireOkResponse) {
+        // Add fetchOk
+        makeFetch = fetchOk(makeFetch);
+    }
+    var makeFetchRequest = fetchRequestFactory(config);
+    return function(input, init) {
+        return _async_to_generator$3(function() {
+            var request, response;
+            return _ts_generator$3(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            makeFetchRequest(input, init)
+                        ];
+                    case 1:
+                        request = _state.sent();
+                        response = fetchHandler(request, makeFetch);
+                        if (mapResponse) {
+                            response = mapResponse(response);
+                        }
+                        return [
+                            2,
+                            response
+                        ];
+                }
+            });
+        })();
+    };
 }
 /**
  * The deafult FetchRequestFactory implementation that uses window/global Request.
@@ -153,448 +582,1368 @@ function configureFetch(config) {
  * @param input
  * @param init
  * @returns
- */
-const DEFAULT_FETCH_REQUEST_FACTORY = (input, init) => new Request(input, init);
+ */ var DEFAULT_FETCH_REQUEST_FACTORY = function DEFAULT_FETCH_REQUEST_FACTORY(input, init) {
+    return new Request(input, init);
+};
 function fetchRequestFactory(config) {
-  const {
-    makeRequest = DEFAULT_FETCH_REQUEST_FACTORY,
-    baseUrl: inputBaseUrl,
-    baseRequest: inputBaseRequest,
-    timeout,
-    requestInitFactory,
-    useBaseUrlForConfiguredFetchRequests = false,
-    forceBaseUrlForWebsiteUrlWithPrefix = useBaseUrlForConfiguredFetchRequests
-  } = config;
-  const baseUrl = inputBaseUrl ? new URL(removeTrailingSlashes(inputBaseUrl)) : undefined;
-  const buildUrl = baseUrl ? url => {
-    let result;
-    const urlString = url.toString();
-    // retain the origin and any pathname from the base url, unless the url contains a prefix
-    if (!forceBaseUrlForWebsiteUrlWithPrefix && isWebsiteUrlWithPrefix(urlString)) {
-      result = new URL(urlString);
-    } else {
-      const urlPath = baseUrl.origin + fixMultiSlashesInSlashPath('/' + baseUrl.pathname + '/' + url);
-      result = new URL(urlPath, baseUrl);
+    var _config_makeRequest = config.makeRequest, makeRequest = _config_makeRequest === void 0 ? DEFAULT_FETCH_REQUEST_FACTORY : _config_makeRequest, inputBaseUrl = config.baseUrl, inputBaseRequest = config.baseRequest, timeout = config.timeout, requestInitFactory = config.requestInitFactory, _config_useBaseUrlForConfiguredFetchRequests = config.useBaseUrlForConfiguredFetchRequests, useBaseUrlForConfiguredFetchRequests = _config_useBaseUrlForConfiguredFetchRequests === void 0 ? false : _config_useBaseUrlForConfiguredFetchRequests, _config_forceBaseUrlForWebsiteUrlWithPrefix = config.forceBaseUrlForWebsiteUrlWithPrefix, forceBaseUrlForWebsiteUrlWithPrefix = _config_forceBaseUrlForWebsiteUrlWithPrefix === void 0 ? useBaseUrlForConfiguredFetchRequests : _config_forceBaseUrlForWebsiteUrlWithPrefix;
+    var baseUrl = inputBaseUrl ? new URL(removeTrailingSlashes(inputBaseUrl)) : undefined;
+    var buildUrl = baseUrl ? function(url) {
+        var result;
+        var urlString = url.toString();
+        // retain the origin and any pathname from the base url, unless the url contains a prefix
+        if (!forceBaseUrlForWebsiteUrlWithPrefix && isWebsiteUrlWithPrefix(urlString)) {
+            result = new URL(urlString);
+        } else {
+            var urlPath = baseUrl.origin + fixMultiSlashesInSlashPath('/' + baseUrl.pathname + '/' + url);
+            result = new URL(urlPath, baseUrl);
+        }
+        return result;
+    } : undefined;
+    function asFetchRequest(input) {
+        return _async_to_generator$3(function() {
+            var awaitedInput, _tmp;
+            return _ts_generator$3(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!isPromiseLike(input)) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            input
+                        ];
+                    case 1:
+                        _tmp = _state.sent();
+                        return [
+                            3,
+                            3
+                        ];
+                    case 2:
+                        _tmp = input;
+                        _state.label = 3;
+                    case 3:
+                        awaitedInput = _tmp;
+                        if (isFetchRequest(awaitedInput)) {
+                            return [
+                                2,
+                                awaitedInput
+                            ];
+                        } else {
+                            return [
+                                2,
+                                makeRequest(awaitedInput)
+                            ];
+                        }
+                }
+            });
+        })();
     }
-    return result;
-  } : undefined;
-  async function asFetchRequest(input) {
-    const awaitedInput = isPromiseLike(input) ? await input : input;
-    if (isFetchRequest(awaitedInput)) {
-      return awaitedInput;
+    var buildRequestWithFixedUrl = buildUrl ? function(input) {
+        return _async_to_generator$3(function() {
+            var relativeUrl, baseRequest, request, url;
+            return _ts_generator$3(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!(typeof input === 'string')) return [
+                            3,
+                            1
+                        ];
+                        relativeUrl = input;
+                        return [
+                            3,
+                            4
+                        ];
+                    case 1:
+                        if (!isFetchRequest(input)) return [
+                            3,
+                            2
+                        ];
+                        if (useBaseUrlForConfiguredFetchRequests) {
+                            relativeUrl = input.url; // copy the url, and use it as the base.
+                            baseRequest = input;
+                        } else {
+                            request = input;
+                        }
+                        return [
+                            3,
+                            4
+                        ];
+                    case 2:
+                        return [
+                            4,
+                            makeRequest(input)
+                        ];
+                    case 3:
+                        request = _state.sent();
+                        _state.label = 4;
+                    case 4:
+                        if (!!request) return [
+                            3,
+                            6
+                        ];
+                        url = buildUrl(relativeUrl);
+                        return [
+                            4,
+                            makeRequest(url.href, baseRequest)
+                        ];
+                    case 5:
+                        request = _state.sent();
+                        _state.label = 6;
+                    case 6:
+                        return [
+                            2,
+                            request
+                        ];
+                }
+            });
+        })();
+    } : asFetchRequest;
+    var buildRequestInit;
+    if (inputBaseRequest != null || timeout != null) {
+        var computeBaseRequest = function computeBaseRequest() {
+            return _async_to_generator$3(function() {
+                var computedBaseRequest, baseRequest;
+                return _ts_generator$3(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                inputBaseRequestAsGetter()
+                            ];
+                        case 1:
+                            computedBaseRequest = _state.sent();
+                            baseRequest = timeout ? _object_spread_props$2(_object_spread$3({}, computedBaseRequest), {
+                                timeout: timeout
+                            }) : computedBaseRequest;
+                            return [
+                                2,
+                                baseRequest
+                            ];
+                    }
+                });
+            })();
+        };
+        var combineRequestInits = function combineRequestInits(request, requestInit) {
+            return _async_to_generator$3(function() {
+                var baseRequest, merged, _tmp, timeout;
+                return _ts_generator$3(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                computeBaseRequest()
+                            ];
+                        case 1:
+                            baseRequest = _state.sent();
+                            _tmp = [
+                                baseRequest
+                            ];
+                            return [
+                                4,
+                                requestInit
+                            ];
+                        case 2:
+                            merged = mergeRequestInits.apply(void 0, _tmp.concat([
+                                _state.sent()
+                            ]));
+                            timeout = merged.timeout === undefined ? request.timeout : merged.timeout;
+                            return [
+                                2,
+                                _object_spread_props$2(_object_spread$3({}, merged), {
+                                    timeout: timeout
+                                })
+                            ];
+                    }
+                });
+            })();
+        };
+        var inputBaseRequestAsGetter = asGetter(inputBaseRequest);
+        if (requestInitFactory) {
+            buildRequestInit = function buildRequestInit(req, x) {
+                return requestInitFactory(req, combineRequestInits(req, x));
+            };
+        } else {
+            buildRequestInit = function buildRequestInit(req, x) {
+                return combineRequestInits(req, x);
+            };
+        }
+    } else if (requestInitFactory) {
+        buildRequestInit = requestInitFactory;
     } else {
-      return makeRequest(awaitedInput);
+        buildRequestInit = function buildRequestInit(_, x) {
+            return x;
+        };
     }
-  }
-  const buildRequestWithFixedUrl = buildUrl ? async input => {
-    let relativeUrl;
-    let baseRequest;
-    let request;
-    if (typeof input === 'string') {
-      relativeUrl = input;
-    } else if (isFetchRequest(input)) {
-      if (useBaseUrlForConfiguredFetchRequests) {
-        relativeUrl = input.url; // copy the url, and use it as the base.
-        baseRequest = input;
-      } else {
-        request = input;
-      }
-    } else {
-      request = await makeRequest(input);
-    }
-    if (!request) {
-      const url = buildUrl(relativeUrl);
-      request = await makeRequest(url.href, baseRequest);
-    }
-    return request;
-  } : asFetchRequest;
-  let buildRequestInit;
-  if (inputBaseRequest != null || timeout != null) {
-    const inputBaseRequestAsGetter = asGetter(inputBaseRequest);
-    async function computeBaseRequest() {
-      const computedBaseRequest = await inputBaseRequestAsGetter();
-      const baseRequest = timeout ? {
-        ...computedBaseRequest,
-        timeout
-      } : computedBaseRequest;
-      return baseRequest;
-    }
-    async function combineRequestInits(request, requestInit) {
-      const baseRequest = await computeBaseRequest();
-      const merged = mergeRequestInits(baseRequest, await requestInit);
-      const timeout = merged.timeout === undefined ? request.timeout : merged.timeout;
-      return {
-        ...merged,
-        timeout
-      };
-    }
-    if (requestInitFactory) {
-      buildRequestInit = (req, x) => requestInitFactory(req, combineRequestInits(req, x));
-    } else {
-      buildRequestInit = (req, x) => combineRequestInits(req, x);
-    }
-  } else if (requestInitFactory) {
-    buildRequestInit = requestInitFactory;
-  } else {
-    buildRequestInit = (_, x) => x;
-  }
-  return async (input, init) => {
-    try {
-      const fixedRequest = await buildRequestWithFixedUrl(input);
-      init = await buildRequestInit(fixedRequest, init);
-      const request = await makeRequest(fixedRequest, init);
-      request.timeout = timeout; // copy/set timeout on the request directly
-      return request;
-    } catch (e) {
-      if (e instanceof FetchRequestFactoryError) {
-        throw e;
-      } else {
-        throw new FetchRequestFactoryError(e);
-      }
-    }
-  };
+    return function(input, init) {
+        return _async_to_generator$3(function() {
+            var fixedRequest, request, e;
+            return _ts_generator$3(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            4,
+                            ,
+                            5
+                        ]);
+                        return [
+                            4,
+                            buildRequestWithFixedUrl(input)
+                        ];
+                    case 1:
+                        fixedRequest = _state.sent();
+                        return [
+                            4,
+                            buildRequestInit(fixedRequest, init)
+                        ];
+                    case 2:
+                        init = _state.sent();
+                        return [
+                            4,
+                            makeRequest(fixedRequest, init)
+                        ];
+                    case 3:
+                        request = _state.sent();
+                        request.timeout = timeout; // copy/set timeout on the request directly
+                        return [
+                            2,
+                            request
+                        ];
+                    case 4:
+                        e = _state.sent();
+                        if (_instanceof$1(e, FetchRequestFactoryError)) {
+                            throw e;
+                        } else {
+                            throw new FetchRequestFactoryError(e);
+                        }
+                    case 5:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    };
 }
 function mergeRequestInits(base, requestInit) {
-  if (requestInit) {
-    const headers = mergeRequestHeaders([base.headers, requestInit?.headers]);
-    return {
-      ...base,
-      ...requestInit,
-      headers
-    };
-  } else {
-    return base;
-  }
+    if (requestInit) {
+        var headers = mergeRequestHeaders([
+            base.headers,
+            requestInit === null || requestInit === void 0 ? void 0 : requestInit.headers
+        ]);
+        return _object_spread_props$2(_object_spread$3({}, base, requestInit), {
+            headers: headers
+        });
+    } else {
+        return base;
+    }
 }
 function mergeRequestHeaders(inputHeadersArray) {
-  const headersMap = multiValueMapBuilder();
-  filterMaybeArrayValues(inputHeadersArray).forEach(headers => {
-    const tuples = headersToHeadersTuple(headers);
-    const visitedKeysSet = new Set();
-    tuples.forEach(([key, value]) => {
-      if (!visitedKeysSet.has(key)) {
-        headersMap.delete(key); // delete all existing values to "override" them
-        visitedKeysSet.add(key);
-      }
-      if (value) {
-        headersMap.add(key, value);
-      }
+    var headersMap = multiValueMapBuilder();
+    filterMaybeArrayValues(inputHeadersArray).forEach(function(headers) {
+        var tuples = headersToHeadersTuple(headers);
+        var visitedKeysSet = new Set();
+        tuples.forEach(function(param) {
+            var _param = _sliced_to_array$2(param, 2), key = _param[0], value = _param[1];
+            if (!visitedKeysSet.has(key)) {
+                headersMap.delete(key); // delete all existing values to "override" them
+                visitedKeysSet.add(key);
+            }
+            if (value) {
+                headersMap.add(key, value);
+            }
+        });
     });
-  });
-  return headersMap.tuples();
+    return headersMap.tuples();
 }
 function headersToHeadersTuple(headers) {
-  let tuples = [];
-  if (Array.isArray(headers)) {
-    // use as tuples
-    tuples = headers;
-  } else if (typeof headers.forEach === 'function') {
-    // use as a headers object
-    headers.forEach((value, key) => {
-      tuples.push([key, value]);
-    });
-  } else if (typeof headers === 'object') {
-    // use as a normal object
-    tuples = Object.entries(headers);
-  }
-  return tuples;
+    var tuples = [];
+    if (Array.isArray(headers)) {
+        // use as tuples
+        tuples = headers;
+    } else if (typeof headers.forEach === 'function') {
+        // use as a headers object
+        headers.forEach(function(value, key) {
+            tuples.push([
+                key,
+                value
+            ]);
+        });
+    } else if ((typeof headers === "undefined" ? "undefined" : _type_of$3(headers)) === 'object') {
+        // use as a normal object
+        tuples = Object.entries(headers);
+    }
+    return tuples;
 }
 function isFetchRequest(input) {
-  return Boolean(input.url);
+    return Boolean(input.url);
 }
 
 function fetchUploadFile(input) {
-  const {
-    fetch: inputFetch,
-    url,
-    body: inputBody
-  } = input;
-  const useFetch = inputFetch ?? fetch;
-  return useFetch(url, {
-    method: input.method ?? 'POST',
-    body: inputBody.body,
-    headers: {
-      'Content-Type': inputBody.mimeType
-    }
-  });
+    var _input_method;
+    var inputFetch = input.fetch, url = input.url, inputBody = input.body;
+    var useFetch = inputFetch !== null && inputFetch !== void 0 ? inputFetch : fetch;
+    return useFetch(url, {
+        method: (_input_method = input.method) !== null && _input_method !== void 0 ? _input_method : 'POST',
+        body: inputBody.body,
+        headers: {
+            'Content-Type': inputBody.mimeType
+        }
+    });
 }
 /**
  * Parses the file response and returns the response wrapped in a FetchFileResponse object.
  *
  * @param response
  * @returns
- */
-function parseFetchFileResponse(response) {
-  const rawContentType = response.headers.get('content-type');
-  const parseContentTypeResult = safeParse(rawContentType ?? '');
-  const contentType = parseContentTypeResult.type !== '' ? parseContentTypeResult : undefined;
-  return {
-    response,
-    rawContentType,
-    contentType,
-    mimeType: contentType?.type
-  };
+ */ function parseFetchFileResponse(response) {
+    var rawContentType = response.headers.get('content-type');
+    var parseContentTypeResult = safeParse(rawContentType !== null && rawContentType !== void 0 ? rawContentType : '');
+    var contentType = parseContentTypeResult.type !== '' ? parseContentTypeResult : undefined;
+    return {
+        response: response,
+        rawContentType: rawContentType,
+        contentType: contentType,
+        mimeType: contentType === null || contentType === void 0 ? void 0 : contentType.type
+    };
 }
 
+function asyncGeneratorStep$2(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 _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$2(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 function rateLimitedFetchHandler(config) {
-  const {
-    updateWithResponse,
-    maxRetries: inputMaxRetries
-  } = config;
-  const maxRetries = inputMaxRetries ?? 1;
-  const _rateLimiter = config.rateLimiter;
-  const fetchHandler = async (request, makeFetch) => {
-    async function tryFetch(retriesAttempted) {
-      // wait for the rate limiter
-      await _rateLimiter.waitForRateLimit();
-      let response;
-      let fetchResponseError;
-      try {
-        response = await makeFetch(request.clone());
-      } catch (e) {
-        fetchResponseError = e;
-        response = fetchResponseError.response;
-      }
-      // response could be null in some cases
-      const shouldRetry = response ? await updateWithResponse(response, fetchResponseError) : false;
-      if (shouldRetry && retriesAttempted < maxRetries) {
-        response = await tryFetch(retriesAttempted + 1);
-      } else {
-        // re-throw the fetch response error if it exists and we cannot retry
-        if (fetchResponseError != null) {
-          throw fetchResponseError;
-        }
-      }
-      // if response is null at this point but fetchResponseError is not, rethrow the error
-      if (response == null && fetchResponseError != null) {
-        throw fetchResponseError;
-      }
-      return response;
-    }
-    return tryFetch(0);
-  };
-  fetchHandler._rateLimiter = _rateLimiter;
-  return fetchHandler;
+    var updateWithResponse = config.updateWithResponse, inputMaxRetries = config.maxRetries;
+    var maxRetries = inputMaxRetries !== null && inputMaxRetries !== void 0 ? inputMaxRetries : 1;
+    var _rateLimiter = config.rateLimiter;
+    var fetchHandler = function fetchHandler(request, makeFetch) {
+        return _async_to_generator$2(function() {
+            function tryFetch(retriesAttempted) {
+                return _async_to_generator$2(function() {
+                    var response, fetchResponseError, e, shouldRetry, _tmp;
+                    return _ts_generator$2(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                // wait for the rate limiter
+                                return [
+                                    4,
+                                    _rateLimiter.waitForRateLimit()
+                                ];
+                            case 1:
+                                _state.sent();
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    4,
+                                    ,
+                                    5
+                                ]);
+                                return [
+                                    4,
+                                    makeFetch(request.clone())
+                                ];
+                            case 3:
+                                response = _state.sent();
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 4:
+                                e = _state.sent();
+                                fetchResponseError = e;
+                                response = fetchResponseError.response;
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 5:
+                                if (!response) return [
+                                    3,
+                                    7
+                                ];
+                                return [
+                                    4,
+                                    updateWithResponse(response, fetchResponseError)
+                                ];
+                            case 6:
+                                _tmp = _state.sent();
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 7:
+                                _tmp = false;
+                                _state.label = 8;
+                            case 8:
+                                shouldRetry = _tmp;
+                                if (!(shouldRetry && retriesAttempted < maxRetries)) return [
+                                    3,
+                                    10
+                                ];
+                                return [
+                                    4,
+                                    tryFetch(retriesAttempted + 1)
+                                ];
+                            case 9:
+                                response = _state.sent();
+                                return [
+                                    3,
+                                    11
+                                ];
+                            case 10:
+                                // re-throw the fetch response error if it exists and we cannot retry
+                                if (fetchResponseError != null) {
+                                    throw fetchResponseError;
+                                }
+                                _state.label = 11;
+                            case 11:
+                                // if response is null at this point but fetchResponseError is not, rethrow the error
+                                if (response == null && fetchResponseError != null) {
+                                    throw fetchResponseError;
+                                }
+                                return [
+                                    2,
+                                    response
+                                ];
+                        }
+                    });
+                })();
+            }
+            return _ts_generator$2(this, function(_state) {
+                return [
+                    2,
+                    tryFetch(0)
+                ];
+            });
+        })();
+    };
+    fetchHandler._rateLimiter = _rateLimiter;
+    return fetchHandler;
 }
 
-class FetchPageNoNextPageError extends FetchRequestFactoryError {
-  constructor(page) {
-    super(`There was no next page for this.`);
-    this.page = void 0;
-    this.page = page;
-  }
-}
-class FetchPageLimitReachedError extends FetchRequestFactoryError {
-  constructor(page, limit) {
-    super(`The limit of ${limit} for the number of pages to read was reached.`);
-    this.page = void 0;
-    this.limit = void 0;
-    this.page = page;
-    this.limit = limit;
-  }
+function _assert_this_initialized$1(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep$1(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 _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super$1(_this, derived, args) {
+    derived = _get_prototype_of$1(derived);
+    return _possible_constructor_return$1(_this, _is_native_reflect_construct$1() ? Reflect.construct(derived, args || [], _get_prototype_of$1(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of$1(o) {
+    _get_prototype_of$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$1(o);
+}
+function _inherits$1(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
+        }
+    });
+    if (superClass) _set_prototype_of$1(subClass, superClass);
+}
+function _object_spread$2(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$2(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _possible_constructor_return$1(self, call) {
+    if (call && (_type_of$2(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$1(self);
+}
+function _set_prototype_of$1(o, p) {
+    _set_prototype_of$1 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$1(o, p);
+}
+function _type_of$2(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct$1() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$1 = function() {
+        return !!result;
+    })();
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var FetchPageNoNextPageError = /*#__PURE__*/ function(FetchRequestFactoryError) {
+    _inherits$1(FetchPageNoNextPageError, FetchRequestFactoryError);
+    function FetchPageNoNextPageError(page) {
+        _class_call_check$1(this, FetchPageNoNextPageError);
+        var _this;
+        _this = _call_super$1(this, FetchPageNoNextPageError, [
+            "There was no next page for this."
+        ]), _define_property$2(_this, "page", void 0);
+        _this.page = page;
+        return _this;
+    }
+    return FetchPageNoNextPageError;
+}(FetchRequestFactoryError);
+var FetchPageLimitReachedError = /*#__PURE__*/ function(FetchRequestFactoryError) {
+    _inherits$1(FetchPageLimitReachedError, FetchRequestFactoryError);
+    function FetchPageLimitReachedError(page, limit) {
+        _class_call_check$1(this, FetchPageLimitReachedError);
+        var _this;
+        _this = _call_super$1(this, FetchPageLimitReachedError, [
+            "The limit of ".concat(limit, " for the number of pages to read was reached.")
+        ]), _define_property$2(_this, "page", void 0), _define_property$2(_this, "limit", void 0);
+        _this.page = page;
+        _this.limit = limit;
+        return _this;
+    }
+    return FetchPageLimitReachedError;
+}(FetchRequestFactoryError);
 /**
  * Default max page for a FetchPageFactory.
- */
-const FETCH_PAGE_FACTORY_DEFAULT_MAX_PAGE = 100;
+ */ var FETCH_PAGE_FACTORY_DEFAULT_MAX_PAGE = 100;
 /**
  * Creates a new FetchPageFactory from the input.
  *
  * @param config
  * @returns
- */
-function fetchPageFactory(config) {
-  const {
-    fetch,
-    readFetchPageResultInfo,
-    buildInputForNextPage,
-    defaultMaxPage,
-    defaultMaxItemsPerPage
-  } = config;
-  return (initalInput, options) => {
-    const {
-      maxPage: inputMaxPage = defaultMaxPage,
-      maxItemsPerPage: inputMaxItemsPerPage
-    } = options ?? {};
-    const maxItemsPerPage = inputMaxItemsPerPage ?? defaultMaxItemsPerPage;
-    const maxPage = inputMaxPage === null ? Number.MAX_SAFE_INTEGER : inputMaxPage ?? FETCH_PAGE_FACTORY_DEFAULT_MAX_PAGE;
-    function fetchNextWithInput(input, previous = undefined) {
-      return async () => {
-        const result = await fetch(input);
-        const {
-          cursor: readCursor,
-          nextPageCursor,
-          hasNext: readHasNext
-        } = await readFetchPageResultInfo(result);
-        const cursor = readCursor ?? previous?.cursor;
-        const hasNext = readHasNext !== false;
-        const page = previous ? previous.page + 1 : FIRST_PAGE;
-        const isAtMaxPage = page >= maxPage;
-        const nextPageResult = {
-          input,
-          result,
-          page,
-          previous,
-          hasNext,
-          isAtMaxPage,
-          cursor,
-          nextPageCursor,
-          fetchNext: cachedGetter(async () => {
-            // assert max page
-            if (isAtMaxPage) {
-              throw new FetchPageLimitReachedError(nextPageResult, maxPage);
+ */ function fetchPageFactory(config) {
+    var fetch = config.fetch, readFetchPageResultInfo = config.readFetchPageResultInfo, buildInputForNextPage = config.buildInputForNextPage, defaultMaxPage = config.defaultMaxPage, defaultMaxItemsPerPage = config.defaultMaxItemsPerPage;
+    return function(initalInput, options) {
+        var _ref = options !== null && options !== void 0 ? options : {}, tmp = _ref.maxPage, inputMaxPage = tmp === void 0 ? defaultMaxPage : tmp, inputMaxItemsPerPage = _ref.maxItemsPerPage;
+        var maxItemsPerPage = inputMaxItemsPerPage !== null && inputMaxItemsPerPage !== void 0 ? inputMaxItemsPerPage : defaultMaxItemsPerPage;
+        var maxPage = inputMaxPage === null ? Number.MAX_SAFE_INTEGER : inputMaxPage !== null && inputMaxPage !== void 0 ? inputMaxPage : FETCH_PAGE_FACTORY_DEFAULT_MAX_PAGE;
+        function fetchNextWithInput(input) {
+            var previous = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : undefined;
+            return function() {
+                return _async_to_generator$1(function() {
+                    var result, _ref, readCursor, nextPageCursor, readHasNext, cursor, hasNext, page, isAtMaxPage, nextPageResult;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    fetch(input)
+                                ];
+                            case 1:
+                                result = _state.sent();
+                                return [
+                                    4,
+                                    readFetchPageResultInfo(result)
+                                ];
+                            case 2:
+                                _ref = _state.sent(), readCursor = _ref.cursor, nextPageCursor = _ref.nextPageCursor, readHasNext = _ref.hasNext;
+                                cursor = readCursor !== null && readCursor !== void 0 ? readCursor : previous === null || previous === void 0 ? void 0 : previous.cursor;
+                                hasNext = readHasNext !== false;
+                                page = previous ? previous.page + 1 : FIRST_PAGE;
+                                isAtMaxPage = page >= maxPage;
+                                nextPageResult = {
+                                    input: input,
+                                    result: result,
+                                    page: page,
+                                    previous: previous,
+                                    hasNext: hasNext,
+                                    isAtMaxPage: isAtMaxPage,
+                                    cursor: cursor,
+                                    nextPageCursor: nextPageCursor,
+                                    fetchNext: cachedGetter(function() {
+                                        return _async_to_generator$1(function() {
+                                            var nextPageInfo, _tmp;
+                                            return _ts_generator$1(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        // assert max page
+                                                        if (isAtMaxPage) {
+                                                            throw new FetchPageLimitReachedError(nextPageResult, maxPage);
+                                                        }
+                                                        if (!hasNext) return [
+                                                            3,
+                                                            2
+                                                        ];
+                                                        return [
+                                                            4,
+                                                            buildInputForNextPage(nextPageResult, input, {
+                                                                maxPage: maxPage,
+                                                                maxItemsPerPage: maxItemsPerPage
+                                                            })
+                                                        ];
+                                                    case 1:
+                                                        _tmp = _state.sent();
+                                                        return [
+                                                            3,
+                                                            3
+                                                        ];
+                                                    case 2:
+                                                        _tmp = undefined;
+                                                        _state.label = 3;
+                                                    case 3:
+                                                        nextPageInfo = _tmp;
+                                                        if (!nextPageInfo) {
+                                                            throw new FetchPageNoNextPageError(nextPageResult);
+                                                        }
+                                                        return [
+                                                            2,
+                                                            fetchNextWithInput(_object_spread$2({}, input, nextPageInfo), nextPageResult)()
+                                                        ];
+                                                }
+                                            });
+                                        })();
+                                    })
+                                };
+                                return [
+                                    2,
+                                    nextPageResult
+                                ];
+                        }
+                    });
+                })();
+            };
+        }
+        var page = {
+            input: initalInput,
+            fetchNext: cachedGetter(function() {
+                return fetchNextWithInput(initalInput)();
+            })
+        };
+        return page;
+    };
+}
+
+function _array_like_to_array$1(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 _array_with_holes$1(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+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 _async_to_generator(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);
             }
-            // assert next page
-            const nextPageInfo = hasNext ? await buildInputForNextPage(nextPageResult, input, {
-              maxPage,
-              maxItemsPerPage
-            }) : undefined;
-            if (!nextPageInfo) {
-              throw new FetchPageNoNextPageError(nextPageResult);
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
             }
-            return fetchNextWithInput({
-              ...input,
-              ...nextPageInfo
-            }, nextPageResult)();
-          })
+            _next(undefined);
+        });
+    };
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array_limit$1(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$1() {
+    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 _object_spread$1(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$1(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys$1(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props$1(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys$1(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array$1(arr, i) {
+    return _array_with_holes$1(arr) || _iterable_to_array_limit$1(arr, i) || _unsupported_iterable_to_array$1(arr, i) || _non_iterable_rest$1();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(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(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
         };
-        return nextPageResult;
-      };
     }
-    const page = {
-      input: initalInput,
-      fetchNext: cachedGetter(() => fetchNextWithInput(initalInput)())
-    };
-    return page;
-  };
 }
-
 /**
  * Iterates through the pages of a created FetchPage instance by each item individually.
  *
  * @param config
  * @returns
- */
-async function iterateFetchPagesByEachItem(config) {
-  const {
-    iterateEachPageItem,
-    iteratePerformTasksConfig
-  } = config;
-  return iterateFetchPagesByItems({
-    ...config,
-    iteratePageItems: async (items, fetchPageResult, startIndex) => {
-      const itemIndexPairs = items.map((x, i) => [x, i + startIndex]);
-      const performTasksResults = await performAsyncTasks(itemIndexPairs, ([item, i]) => {
-        return iterateEachPageItem(item, i, fetchPageResult);
-      }, {
-        sequential: true,
-        // sequential by default
-        ...iteratePerformTasksConfig
-      });
-      return performTasksResults;
-    }
-  });
+ */ function iterateFetchPagesByEachItem(config) {
+    return _async_to_generator(function() {
+        var iterateEachPageItem, iteratePerformTasksConfig;
+        return _ts_generator(this, function(_state) {
+            iterateEachPageItem = config.iterateEachPageItem, iteratePerformTasksConfig = config.iteratePerformTasksConfig;
+            return [
+                2,
+                iterateFetchPagesByItems(_object_spread_props$1(_object_spread$1({}, config), {
+                    iteratePageItems: function iteratePageItems(items, fetchPageResult, startIndex) {
+                        return _async_to_generator(function() {
+                            var itemIndexPairs, performTasksResults;
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        itemIndexPairs = items.map(function(x, i) {
+                                            return [
+                                                x,
+                                                i + startIndex
+                                            ];
+                                        });
+                                        return [
+                                            4,
+                                            performAsyncTasks(itemIndexPairs, function(param) {
+                                                var _param = _sliced_to_array$1(param, 2), item = _param[0], i = _param[1];
+                                                return iterateEachPageItem(item, i, fetchPageResult);
+                                            }, _object_spread$1({
+                                                sequential: true
+                                            }, iteratePerformTasksConfig))
+                                        ];
+                                    case 1:
+                                        performTasksResults = _state.sent();
+                                        return [
+                                            2,
+                                            performTasksResults
+                                        ];
+                                }
+                            });
+                        })();
+                    }
+                }))
+            ];
+        });
+    })();
 }
 /**
  * Iterates through the pages of a created FetchPage instance.
  *
  * @param config
  * @returns
- */
-async function iterateFetchPagesByItems(config) {
-  const {
-    readItemsFromPageResult,
-    iterateItemsLimit: inputTotalIterateItemsLimit,
-    loadItemLimit: inputTotalLoadItemLimit,
-    filterPageItems: inputFilterPageItems,
-    iteratePageItems
-  } = config;
-  const iterateItemsLimit = inputTotalIterateItemsLimit ?? Number.MAX_SAFE_INTEGER;
-  const loadItemLimit = inputTotalLoadItemLimit ?? Number.MAX_SAFE_INTEGER;
-  const filterPageItems = inputFilterPageItems ?? mapIdentityFunction();
-  let totalItemsLoaded = 0;
-  let totalItemsVisited = 0;
-  let hasReachedFinalItem = false;
-  const fetchPagesConfig = {
-    ...config,
-    iteratePage: async fetchPageResult => {
-      const items = readItemsFromPageResult(fetchPageResult);
-      const filteredItems = await filterPageItems(items, fetchPageResult);
-      const results = await iteratePageItems(filteredItems, fetchPageResult, totalItemsVisited);
-      totalItemsLoaded += items.length;
-      totalItemsVisited += filteredItems.length;
-      hasReachedFinalItem = totalItemsLoaded >= loadItemLimit || totalItemsVisited >= iterateItemsLimit;
-      return results;
-    },
-    endEarly: () => hasReachedFinalItem
-  };
-  const iterateFetchPagesResult = await iterateFetchPages(fetchPagesConfig);
-  return {
-    ...iterateFetchPagesResult,
-    totalItemsLoaded,
-    totalItemsVisited
-  };
-}
-async function iterateFetchPages(config) {
-  const {
-    iteratePage,
-    fetchPage: inputFetchPage,
-    input,
-    fetchPageFactory,
-    usePageResult,
-    maxParallelPages,
-    waitBetweenPages,
-    maxPage,
-    maxItemsPerPage,
-    endEarly
-  } = config;
-  let hasReachedEnd = false;
-  let fetchPage = inputFetchPage ?? fetchPageFactory(input, {
-    maxPage,
-    maxItemsPerPage
-  });
-  let currentNextPage;
-  async function taskInputFactory() {
-    if (hasReachedEnd) {
-      return null; // issue no more tasks
-    }
-    if (currentNextPage != null && (currentNextPage.isAtMaxPage || !currentNextPage.hasNext)) {
-      hasReachedEnd = true;
-      return null;
-    }
-    currentNextPage = await fetchPage.fetchNext();
-    fetchPage = currentNextPage;
-    return {
-      i: currentNextPage.page,
-      fetchPageResult: currentNextPage
-    };
-  }
-  const performTaskFn = performTasksFromFactoryInParallelFunction({
-    maxParallelTasks: maxParallelPages,
-    waitBetweenTasks: waitBetweenPages,
-    taskFactory: async ({
-      i,
-      fetchPageResult
-    }) => {
-      const result = await iteratePage(fetchPageResult);
-      const iterationResult = {
-        i,
-        fetchPageResult,
-        result
-      };
-      await usePageResult?.(iterationResult);
-      const shouldEndEarly = endEarly?.(iterationResult);
-      if (shouldEndEarly) {
-        hasReachedEnd = true;
-      }
-    }
-  });
-  await performTaskFn(taskInputFactory);
-  const result = {
-    totalPages: (currentNextPage?.page ?? 0) + 1,
-    totalPagesLimitReached: currentNextPage?.isAtMaxPage ?? false
-  };
-  return result;
+ */ function iterateFetchPagesByItems(config) {
+    return _async_to_generator(function() {
+        var readItemsFromPageResult, inputTotalIterateItemsLimit, inputTotalLoadItemLimit, inputFilterPageItems, iteratePageItems, iterateItemsLimit, loadItemLimit, filterPageItems, totalItemsLoaded, totalItemsVisited, hasReachedFinalItem, fetchPagesConfig, iterateFetchPagesResult;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    readItemsFromPageResult = config.readItemsFromPageResult, inputTotalIterateItemsLimit = config.iterateItemsLimit, inputTotalLoadItemLimit = config.loadItemLimit, inputFilterPageItems = config.filterPageItems, iteratePageItems = config.iteratePageItems;
+                    iterateItemsLimit = inputTotalIterateItemsLimit !== null && inputTotalIterateItemsLimit !== void 0 ? inputTotalIterateItemsLimit : Number.MAX_SAFE_INTEGER;
+                    loadItemLimit = inputTotalLoadItemLimit !== null && inputTotalLoadItemLimit !== void 0 ? inputTotalLoadItemLimit : Number.MAX_SAFE_INTEGER;
+                    filterPageItems = inputFilterPageItems !== null && inputFilterPageItems !== void 0 ? inputFilterPageItems : mapIdentityFunction();
+                    totalItemsLoaded = 0;
+                    totalItemsVisited = 0;
+                    hasReachedFinalItem = false;
+                    fetchPagesConfig = _object_spread_props$1(_object_spread$1({}, config), {
+                        iteratePage: function iteratePage(fetchPageResult) {
+                            return _async_to_generator(function() {
+                                var items, filteredItems, results;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            items = readItemsFromPageResult(fetchPageResult);
+                                            return [
+                                                4,
+                                                filterPageItems(items, fetchPageResult)
+                                            ];
+                                        case 1:
+                                            filteredItems = _state.sent();
+                                            return [
+                                                4,
+                                                iteratePageItems(filteredItems, fetchPageResult, totalItemsVisited)
+                                            ];
+                                        case 2:
+                                            results = _state.sent();
+                                            totalItemsLoaded += items.length;
+                                            totalItemsVisited += filteredItems.length;
+                                            hasReachedFinalItem = totalItemsLoaded >= loadItemLimit || totalItemsVisited >= iterateItemsLimit;
+                                            return [
+                                                2,
+                                                results
+                                            ];
+                                    }
+                                });
+                            })();
+                        },
+                        endEarly: function endEarly() {
+                            return hasReachedFinalItem;
+                        }
+                    });
+                    return [
+                        4,
+                        iterateFetchPages(fetchPagesConfig)
+                    ];
+                case 1:
+                    iterateFetchPagesResult = _state.sent();
+                    return [
+                        2,
+                        _object_spread_props$1(_object_spread$1({}, iterateFetchPagesResult), {
+                            totalItemsLoaded: totalItemsLoaded,
+                            totalItemsVisited: totalItemsVisited
+                        })
+                    ];
+            }
+        });
+    })();
+}
+function iterateFetchPages(config) {
+    return _async_to_generator(function() {
+        var _ref, _ref1, iteratePage, inputFetchPage, input, fetchPageFactory, usePageResult, maxParallelPages, waitBetweenPages, maxPage, maxItemsPerPage, endEarly, hasReachedEnd, fetchPage, currentNextPage, performTaskFn, result;
+        function taskInputFactory() {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            if (hasReachedEnd) {
+                                return [
+                                    2,
+                                    null
+                                ]; // issue no more tasks
+                            }
+                            if (currentNextPage != null && (currentNextPage.isAtMaxPage || !currentNextPage.hasNext)) {
+                                hasReachedEnd = true;
+                                return [
+                                    2,
+                                    null
+                                ];
+                            }
+                            return [
+                                4,
+                                fetchPage.fetchNext()
+                            ];
+                        case 1:
+                            currentNextPage = _state.sent();
+                            fetchPage = currentNextPage;
+                            return [
+                                2,
+                                {
+                                    i: currentNextPage.page,
+                                    fetchPageResult: currentNextPage
+                                }
+                            ];
+                    }
+                });
+            })();
+        }
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    iteratePage = config.iteratePage, inputFetchPage = config.fetchPage, input = config.input, fetchPageFactory = config.fetchPageFactory, usePageResult = config.usePageResult, maxParallelPages = config.maxParallelPages, waitBetweenPages = config.waitBetweenPages, maxPage = config.maxPage, maxItemsPerPage = config.maxItemsPerPage, endEarly = config.endEarly;
+                    hasReachedEnd = false;
+                    fetchPage = inputFetchPage !== null && inputFetchPage !== void 0 ? inputFetchPage : fetchPageFactory(input, {
+                        maxPage: maxPage,
+                        maxItemsPerPage: maxItemsPerPage
+                    });
+                    performTaskFn = performTasksFromFactoryInParallelFunction({
+                        maxParallelTasks: maxParallelPages,
+                        waitBetweenTasks: waitBetweenPages,
+                        taskFactory: function taskFactory(param) {
+                            var i = param.i, fetchPageResult = param.fetchPageResult;
+                            return _async_to_generator(function() {
+                                var result, iterationResult, shouldEndEarly;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                iteratePage(fetchPageResult)
+                                            ];
+                                        case 1:
+                                            result = _state.sent();
+                                            iterationResult = {
+                                                i: i,
+                                                fetchPageResult: fetchPageResult,
+                                                result: result
+                                            };
+                                            return [
+                                                4,
+                                                usePageResult === null || usePageResult === void 0 ? void 0 : usePageResult(iterationResult)
+                                            ];
+                                        case 2:
+                                            _state.sent();
+                                            shouldEndEarly = endEarly === null || endEarly === void 0 ? void 0 : endEarly(iterationResult);
+                                            if (shouldEndEarly) {
+                                                hasReachedEnd = true;
+                                            }
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        }
+                    });
+                    return [
+                        4,
+                        performTaskFn(taskInputFactory)
+                    ];
+                case 1:
+                    _state.sent();
+                    result = {
+                        totalPages: ((_ref = currentNextPage === null || currentNextPage === void 0 ? void 0 : currentNextPage.page) !== null && _ref !== void 0 ? _ref : 0) + 1,
+                        totalPagesLimitReached: (_ref1 = currentNextPage === null || currentNextPage === void 0 ? void 0 : currentNextPage.isAtMaxPage) !== null && _ref1 !== void 0 ? _ref1 : false
+                    };
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
 }
 
 /**
@@ -603,209 +1952,429 @@ async function iterateFetchPages(config) {
  * @param input
  * @param omitKeys
  * @returns
- */
-function makeUrlSearchParams(input, options) {
-  const {
-    omitKeys,
-    filterEmptyValues: filterValues
-  } = options ?? {};
-  const mergedInput = Array.isArray(input) ? mergeObjects(input) : input;
-  const filteredInput = filterValues ?? true ? filterEmptyPojoValues(mergedInput ?? {}) : mergedInput;
-  const searchParams = new URLSearchParams(filteredInput);
-  if (omitKeys != null) {
-    useIterableOrValue(omitKeys, key => searchParams.delete(key), false);
-  }
-  return searchParams;
+ */ function makeUrlSearchParams(input, options) {
+    var _ref = options !== null && options !== void 0 ? options : {}, omitKeys = _ref.omitKeys, filterValues = _ref.filterEmptyValues;
+    var mergedInput = Array.isArray(input) ? mergeObjects(input) : input;
+    var filteredInput = (filterValues !== null && filterValues !== void 0 ? filterValues : true) ? filterEmptyPojoValues(mergedInput !== null && mergedInput !== void 0 ? mergedInput : {}) : mergedInput;
+    var searchParams = new URLSearchParams(filteredInput);
+    if (omitKeys != null) {
+        useIterableOrValue(omitKeys, function(key) {
+            return searchParams.delete(key);
+        }, false);
+    }
+    return searchParams;
 }
 /**
  * Merges an array of MakeUrlSearchParamsOptions into a single MakeUrlSearchParamsOptions value.
- */
-function mergeMakeUrlSearchParamsOptions(options) {
-  const omitKeys = new Set();
-  useIterableOrValue(options, x => {
-    if (x?.omitKeys != null) {
-      useIterableOrValue(x.omitKeys, key => omitKeys.add(key));
-    }
-  });
-  return {
-    omitKeys: omitKeys.size > 0 ? Array.from(omitKeys) : undefined
-  };
+ */ function mergeMakeUrlSearchParamsOptions(options) {
+    var omitKeys = new Set();
+    useIterableOrValue(options, function(x) {
+        if ((x === null || x === void 0 ? void 0 : x.omitKeys) != null) {
+            useIterableOrValue(x.omitKeys, function(key) {
+                return omitKeys.add(key);
+            });
+        }
+    });
+    return {
+        omitKeys: omitKeys.size > 0 ? Array.from(omitKeys) : undefined
+    };
 }
 
+function _array_like_to_array(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 _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    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 _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(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(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
 function fetchURL(input) {
-  let url;
-  if (typeof input === 'string') {
-    url = input;
-  } else if (isURL(input)) {
-    url = input.href;
-  } else {
-    const baseUrl = fetchURL(input.url);
-    if (input.queryParams) {
-      const searchParams = queryParamsToSearchParams(input.queryParams);
-      if (!isEmptyIterable(searchParams)) {
-        url = fixExtraQueryParameters(baseUrl + `?${searchParams.toString()}`);
-      } else {
-        url = baseUrl;
-      }
+    var url;
+    if (typeof input === 'string') {
+        url = input;
+    } else if (isURL(input)) {
+        url = input.href;
     } else {
-      url = baseUrl;
+        var baseUrl = fetchURL(input.url);
+        if (input.queryParams) {
+            var searchParams = queryParamsToSearchParams(input.queryParams);
+            if (!isEmptyIterable(searchParams)) {
+                url = fixExtraQueryParameters(baseUrl + "?".concat(searchParams.toString()));
+            } else {
+                url = baseUrl;
+            }
+        } else {
+            url = baseUrl;
+        }
     }
-  }
-  return url;
+    return url;
 }
 function isURL(input) {
-  return typeof input === 'object' && input instanceof URL;
+    return (typeof input === "undefined" ? "undefined" : _type_of$1(input)) === 'object' && _instanceof(input, URL);
 }
 function isURLSearchParams(input) {
-  return typeof input === 'object' && input instanceof URLSearchParams;
+    return (typeof input === "undefined" ? "undefined" : _type_of$1(input)) === 'object' && _instanceof(input, URLSearchParams);
 }
 /**
  * Converts the input
  *
  * @param input
  * @returns
- */
-function fetchURLQueryKeyValueStringTuples(input) {
-  const paramTuples = [];
-  forEachInIterable(input, tuple => {
-    const [key, values] = tuple;
-    // ignore null/undefined keys and values
-    if (key != null && values != null) {
-      const keyString = String(key);
-      useIterableOrValue(values, value => {
-        // ignore null/undefined values
-        if (value != null) {
-          paramTuples.push([keyString, String(value)]);
-        }
-      });
-    }
-  });
-  return paramTuples;
+ */ function fetchURLQueryKeyValueStringTuples(input) {
+    var paramTuples = [];
+    forEachInIterable(input, function(tuple) {
+        var _tuple = _sliced_to_array(tuple, 2), key = _tuple[0], values = _tuple[1];
+        // ignore null/undefined keys and values
+        if (key != null && values != null) {
+            var keyString = String(key);
+            useIterableOrValue(values, function(value) {
+                // ignore null/undefined values
+                if (value != null) {
+                    paramTuples.push([
+                        keyString,
+                        String(value)
+                    ]);
+                }
+            });
+        }
+    });
+    return paramTuples;
 }
 function queryParamsToSearchParams(input) {
-  let result;
-  if (isURLSearchParams(input)) {
-    // by url search params
-    result = input;
-  } else if (typeof input === 'string') {
-    result = new URLSearchParams(input);
-  } else if (isIterable(input)) {
-    // By tuples
-    result = new URLSearchParams(fetchURLQueryKeyValueStringTuples(input));
-  } else {
-    result = fetchURLSearchParamsObjectToURLSearchParams(input);
-  }
-  return result;
+    var result;
+    if (isURLSearchParams(input)) {
+        // by url search params
+        result = input;
+    } else if (typeof input === 'string') {
+        result = new URLSearchParams(input);
+    } else if (isIterable(input)) {
+        // By tuples
+        result = new URLSearchParams(fetchURLQueryKeyValueStringTuples(input));
+    } else {
+        result = fetchURLSearchParamsObjectToURLSearchParams(input);
+    }
+    return result;
 }
 function fetchURLSearchParamsObjectToURLSearchParams(input) {
-  const paramTuples = [];
-  forEachKeyValue(input, {
-    forEach: tuple => {
-      const [key, values] = tuple;
-      // ignore null/undefined keys and values
-      if (key != null && values != null) {
-        const keyString = String(key);
-        useIterableOrValue(values, x => {
-          // ignore null/undefined values
-          if (x != null) {
-            paramTuples.push([keyString, String(x)]);
-          }
+    var paramTuples = [];
+    forEachKeyValue(input, {
+        forEach: function forEach(tuple) {
+            var _tuple = _sliced_to_array(tuple, 2), key = _tuple[0], values = _tuple[1];
+            // ignore null/undefined keys and values
+            if (key != null && values != null) {
+                var keyString = String(key);
+                useIterableOrValue(values, function(x) {
+                    // ignore null/undefined values
+                    if (x != null) {
+                        paramTuples.push([
+                            keyString,
+                            String(x)
+                        ]);
+                    }
+                });
+            }
+        }
+    });
+    return new URLSearchParams(paramTuples);
+}
+
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+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
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
         });
-      }
     }
-  });
-  return new URLSearchParams(paramTuples);
+    return target;
 }
-
-class JsonResponseParseError extends Error {
-  constructor(response) {
-    super('Failed to parse the JSON body.');
-    this.response = void 0;
-    this.response = response;
-  }
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var JsonResponseParseError = /*#__PURE__*/ function(Error1) {
+    _inherits(JsonResponseParseError, Error1);
+    function JsonResponseParseError(response) {
+        _class_call_check(this, JsonResponseParseError);
+        var _this;
+        _this = _call_super(this, JsonResponseParseError, [
+            'Failed to parse the JSON body.'
+        ]), _define_property(_this, "response", void 0);
+        _this.response = response;
+        return _this;
+    }
+    return JsonResponseParseError;
+}(_wrap_native_super(Error));
 /**
  * Converts the input to a JSON string, or undefined if not provided.
  *
  * @param body
  * @returns
- */
-function fetchJsonBodyString(body) {
-  return body != null ? typeof body === 'string' ? body : JSON.stringify(body) : undefined;
+ */ function fetchJsonBodyString(body) {
+    return body != null ? typeof body === 'string' ? body : JSON.stringify(body) : undefined;
 }
-const throwJsonResponseParseErrorFunction = response => {
-  throw new JsonResponseParseError(response);
+var throwJsonResponseParseErrorFunction = function throwJsonResponseParseErrorFunction(response) {
+    throw new JsonResponseParseError(response);
+};
+var returnNullHandleFetchJsonParseErrorFunction = function returnNullHandleFetchJsonParseErrorFunction(_) {
+    return null;
 };
-const returnNullHandleFetchJsonParseErrorFunction = _ => null;
 /**
  * Creates a FetchJsonFunction from the input ConfiguredFetch.
- */
-function fetchJsonFunction(fetch, inputConfig) {
-  let config;
-  if (typeof inputConfig === 'function') {
-    config = {
-      handleFetchJsonParseErrorFunction: inputConfig
-    };
-  } else {
-    config = inputConfig ?? {};
-  }
-  config = {
-    ...config,
-    handleFetchJsonParseErrorFunction: config.handleFetchJsonParseErrorFunction ?? throwJsonResponseParseErrorFunction
-  };
-  const {
-    handleFetchJsonParseErrorFunction,
-    interceptJsonResponse
-  } = config;
-  const configuredFetchJsonRequestInit = fetchJsonRequestInitFunction(config);
-  return (url, methodOrInput, body) => {
-    const requestUrl = fetchURL(url);
-    const requestInit = configuredFetchJsonRequestInit(methodOrInput, body);
-    const inputIntercept = typeof methodOrInput === 'object' ? methodOrInput.interceptResponse : undefined;
-    const responsePromise = fetch(requestUrl, requestInit);
-    return responsePromise.then(response => {
-      const jsonPromise = response.json().catch(handleFetchJsonParseErrorFunction);
-      const interceptedJsonResponsePromise = interceptJsonResponse ? jsonPromise.then(json => interceptJsonResponse(json, response)) : jsonPromise;
-      return inputIntercept ? interceptedJsonResponsePromise.then(result => inputIntercept(result, response)) : interceptedJsonResponsePromise;
-    });
-  };
-}
-function fetchJsonRequestInitFunction(config = {}) {
-  const {
-    defaultMethod = 'GET',
-    mapFetchJsonInput = mapIdentityFunction()
-  } = config;
-  return (methodOrInput = defaultMethod, body) => {
-    let config;
-    if (methodOrInput === null) {
-      config = {
-        method: defaultMethod
-      };
-    } else if (typeof methodOrInput === 'string') {
-      config = {
-        method: methodOrInput,
-        body
-      };
+ */ function fetchJsonFunction(fetch, inputConfig) {
+    var _config_handleFetchJsonParseErrorFunction;
+    var config;
+    if (typeof inputConfig === 'function') {
+        config = {
+            handleFetchJsonParseErrorFunction: inputConfig
+        };
     } else {
-      config = methodOrInput;
+        config = inputConfig !== null && inputConfig !== void 0 ? inputConfig : {};
     }
-    config = mapFetchJsonInput(config);
-    const requestInit = {
-      ...config,
-      method: config.method ?? defaultMethod,
-      body: fetchJsonBodyString(config.body)
+    config = _object_spread_props(_object_spread({}, config), {
+        handleFetchJsonParseErrorFunction: (_config_handleFetchJsonParseErrorFunction = config.handleFetchJsonParseErrorFunction) !== null && _config_handleFetchJsonParseErrorFunction !== void 0 ? _config_handleFetchJsonParseErrorFunction : throwJsonResponseParseErrorFunction
+    });
+    var handleFetchJsonParseErrorFunction = config.handleFetchJsonParseErrorFunction, interceptJsonResponse = config.interceptJsonResponse;
+    var configuredFetchJsonRequestInit = fetchJsonRequestInitFunction(config);
+    return function(url, methodOrInput, body) {
+        var requestUrl = fetchURL(url);
+        var requestInit = configuredFetchJsonRequestInit(methodOrInput, body);
+        var inputIntercept = (typeof methodOrInput === "undefined" ? "undefined" : _type_of(methodOrInput)) === 'object' ? methodOrInput.interceptResponse : undefined;
+        var responsePromise = fetch(requestUrl, requestInit);
+        return responsePromise.then(function(response) {
+            var jsonPromise = response.json().catch(handleFetchJsonParseErrorFunction);
+            var interceptedJsonResponsePromise = interceptJsonResponse ? jsonPromise.then(function(json) {
+                return interceptJsonResponse(json, response);
+            }) : jsonPromise;
+            return inputIntercept ? interceptedJsonResponsePromise.then(function(result) {
+                return inputIntercept(result, response);
+            }) : interceptedJsonResponsePromise;
+        });
     };
-    return requestInit;
-  };
 }
-const fetchJsonRequestInit = fetchJsonRequestInitFunction();
+function fetchJsonRequestInitFunction() {
+    var config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var _config_defaultMethod = config.defaultMethod, defaultMethod = _config_defaultMethod === void 0 ? 'GET' : _config_defaultMethod, _config_mapFetchJsonInput = config.mapFetchJsonInput, mapFetchJsonInput = _config_mapFetchJsonInput === void 0 ? mapIdentityFunction() : _config_mapFetchJsonInput;
+    return function() {
+        var methodOrInput = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : defaultMethod, body = arguments.length > 1 ? arguments[1] : void 0;
+        var _config_method;
+        var config;
+        if (methodOrInput === null) {
+            config = {
+                method: defaultMethod
+            };
+        } else if (typeof methodOrInput === 'string') {
+            config = {
+                method: methodOrInput,
+                body: body
+            };
+        } else {
+            config = methodOrInput;
+        }
+        config = mapFetchJsonInput(config);
+        var requestInit = _object_spread_props(_object_spread({}, config), {
+            method: (_config_method = config.method) !== null && _config_method !== void 0 ? _config_method : defaultMethod,
+            body: fetchJsonBodyString(config.body)
+        });
+        return requestInit;
+    };
+}
+var fetchJsonRequestInit = fetchJsonRequestInitFunction();
 
 /**
  * Default FetchService implementation that uses the native Fetch api.
- */
-const fetchApiFetchService = fetchService({
-  makeFetch: fetch,
-  makeRequest: (x, y) => new Request(x, y)
+ */ var fetchApiFetchService = fetchService({
+    makeFetch: fetch,
+    makeRequest: function makeRequest(x, y) {
+        return new Request(x, y);
+    }
 });
 
 export { DEFAULT_FETCH_HANDLER, DEFAULT_FETCH_REQUEST_FACTORY, FETCH_PAGE_FACTORY_DEFAULT_MAX_PAGE, FetchPageLimitReachedError, FetchPageNoNextPageError, FetchRequestFactoryError, FetchResponseError, FetchTimeoutError, JsonResponseParseError, configureFetch, fetchApiFetchService, fetchJsonBodyString, fetchJsonFunction, fetchJsonRequestInit, fetchJsonRequestInitFunction, fetchOk, fetchPageFactory, fetchRequestFactory, fetchService, fetchTimeout, fetchURL, fetchURLQueryKeyValueStringTuples, fetchURLSearchParamsObjectToURLSearchParams, fetchUploadFile, headersToHeadersTuple, isFetchRequest, isURL, isURLSearchParams, iterateFetchPages, iterateFetchPagesByEachItem, iterateFetchPagesByItems, makeUrlSearchParams, mergeMakeUrlSearchParamsOptions, mergeRequestHeaders, mergeRequestInits, parseFetchFileResponse, queryParamsToSearchParams, rateLimitedFetchHandler, requireOkResponse, returnNullHandleFetchJsonParseErrorFunction, throwJsonResponseParseErrorFunction };