contentful 11.2.2 → 11.2.3

package/dist/contentful.cjs

@@ -12,6 +12,7 @@ var require$$0$4 = require('tty');
 var require$$0$3 = require('os');
 var require$$7 = require('zlib');
 var require$$9 = require('events');
+var process$1 = require('process');
 
 function _OverloadYield(e, d) {
   this.v = e, this.k = d;
@@ -85,15 +86,27 @@ function AsyncFromSyncIterator(r) {
 function _awaitAsyncGenerator(e) {
   return new _OverloadYield(e, 0);
 }
-function _defineProperty$1(e, r, t) {
-  return (r = _toPropertyKey$1(r)) in e ? Object.defineProperty(e, r, {
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
     value: t,
     enumerable: !0,
     configurable: !0,
     writable: !0
   }) : e[r] = t, e;
 }
-function ownKeys$1(e, r) {
+function _inherits(t, e) {
+  if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(e && e.prototype, {
+    constructor: {
+      value: t,
+      writable: !0,
+      configurable: !0
+    }
+  }), Object.defineProperty(t, "prototype", {
+    writable: !1
+  }), e && _setPrototypeOf(t, e);
+}
+function ownKeys(e, r) {
   var t = Object.keys(e);
   if (Object.getOwnPropertySymbols) {
     var o = Object.getOwnPropertySymbols(e);
@@ -103,18 +116,23 @@ function ownKeys$1(e, r) {
   }
   return t;
 }
-function _objectSpread2$1(e) {
+function _objectSpread2(e) {
   for (var r = 1; r < arguments.length; r++) {
     var t = null != arguments[r] ? arguments[r] : {};
-    r % 2 ? ownKeys$1(Object(t), !0).forEach(function (r) {
-      _defineProperty$1(e, r, t[r]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function (r) {
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
       Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
     });
   }
   return e;
 }
-function _toPrimitive$1(t, r) {
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
+function _toPrimitive(t, r) {
   if ("object" != typeof t || !t) return t;
   var e = t[Symbol.toPrimitive];
   if (void 0 !== e) {
@@ -124,8 +142,8 @@ function _toPrimitive$1(t, r) {
   }
   return ("string" === r ? String : Number)(t);
 }
-function _toPropertyKey$1(t) {
-  var i = _toPrimitive$1(t, "string");
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
   return "symbol" == typeof i ? i : i + "";
 }
 function _wrapAsyncGenerator(e) {
@@ -195,6 +213,53 @@ AsyncGenerator.prototype["function" == typeof Symbol && Symbol.asyncIterator ||
 }, AsyncGenerator.prototype.return = function (e) {
   return this._invoke("return", e);
 };
+function _wrapRegExp() {
+  _wrapRegExp = function (e, r) {
+    return new BabelRegExp(e, void 0, r);
+  };
+  var e = RegExp.prototype,
+    r = new WeakMap();
+  function BabelRegExp(e, t, p) {
+    var o = RegExp(e, t);
+    return r.set(o, p || r.get(e)), _setPrototypeOf(o, BabelRegExp.prototype);
+  }
+  function buildGroups(e, t) {
+    var p = r.get(t);
+    return Object.keys(p).reduce(function (r, t) {
+      var o = p[t];
+      if ("number" == typeof o) r[t] = e[o];else {
+        for (var i = 0; void 0 === e[o[i]] && i + 1 < o.length;) i++;
+        r[t] = e[o[i]];
+      }
+      return r;
+    }, Object.create(null));
+  }
+  return _inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (r) {
+    var t = e.exec.call(this, r);
+    if (t) {
+      t.groups = buildGroups(t, this);
+      var p = t.indices;
+      p && (p.groups = buildGroups(p, this));
+    }
+    return t;
+  }, BabelRegExp.prototype[Symbol.replace] = function (t, p) {
+    if ("string" == typeof p) {
+      var o = r.get(this);
+      return e[Symbol.replace].call(this, t, p.replace(/\$<([^>]+)>/g, function (e, r) {
+        var t = o[r];
+        return "$" + (Array.isArray(t) ? t.join("$") : t);
+      }));
+    }
+    if ("function" == typeof p) {
+      var i = this;
+      return e[Symbol.replace].call(this, t, function () {
+        var e = arguments;
+        return "object" != typeof e[e.length - 1] && (e = [].slice.call(e)).push(buildGroups(e, i)), p.apply(this, e);
+      });
+    }
+    return e[Symbol.replace].call(this, t, p);
+  }, _wrapRegExp.apply(this, arguments);
+}
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -13847,7 +13912,7 @@ const typeOfTest = type => thing => typeof thing === type;
  * @returns {boolean} True if value is an Array, otherwise false
  */
 const {
-  isArray: isArray$7
+  isArray: isArray$8
 } = Array;
 
 /**
@@ -14062,7 +14127,7 @@ function forEach(obj, fn, {
     /*eslint no-param-reassign:0*/
     obj = [obj];
   }
-  if (isArray$7(obj)) {
+  if (isArray$8(obj)) {
     // Iterate over array values
     for (i = 0, l = obj.length; i < l; i++) {
       fn.call(null, obj[i], i, obj);
@@ -14128,7 +14193,7 @@ function merge$1(/* obj1, obj2, obj3, ... */
       result[targetKey] = merge$1(result[targetKey], val);
     } else if (isPlainObject$2(val)) {
       result[targetKey] = merge$1({}, val);
-    } else if (isArray$7(val)) {
+    } else if (isArray$8(val)) {
       result[targetKey] = val.slice();
     } else {
       result[targetKey] = val;
@@ -14257,7 +14322,7 @@ const endsWith = (str, searchString, position) => {
  */
 const toArray = thing => {
   if (!thing) return null;
-  if (isArray$7(thing)) return thing;
+  if (isArray$8(thing)) return thing;
   let i = thing.length;
   if (!isNumber$1(i)) return null;
   const arr = new Array(i);
@@ -14327,7 +14392,7 @@ const toCamelCase = str => {
 };
 
 /* Creating a function that will check if an object has a property. */
-const hasOwnProperty$3 = (({
+const hasOwnProperty$4 = (({
   hasOwnProperty
 }) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);
 
@@ -14383,7 +14448,7 @@ const toObjectSet = (arrayOrString, delimiter) => {
       obj[value] = true;
     });
   };
-  isArray$7(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
+  isArray$8(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
   return obj;
 };
 const noop$1 = () => {};
@@ -14427,7 +14492,7 @@ const toJSONObject = obj => {
       }
       if (!('toJSON' in source)) {
         stack[i] = source;
-        const target = isArray$7(source) ? [] : {};
+        const target = isArray$8(source) ? [] : {};
         forEach(source, (value, key) => {
           const reducedValue = visit(value, i + 1);
           !isUndefined(reducedValue) && (target[key] = reducedValue);
@@ -14470,7 +14535,7 @@ const asap = typeof queueMicrotask !== 'undefined' ? queueMicrotask.bind(_global
 // *********************
 
 const utils$1$1 = {
-  isArray: isArray$7,
+  isArray: isArray$8,
   isArrayBuffer,
   isBuffer: isBuffer$1,
   isFormData,
@@ -14508,8 +14573,8 @@ const utils$1$1 = {
   forEachEntry,
   matchAll,
   isHTMLForm,
-  hasOwnProperty: hasOwnProperty$3,
-  hasOwnProp: hasOwnProperty$3,
+  hasOwnProperty: hasOwnProperty$4,
+  hasOwnProp: hasOwnProperty$4,
   // an alias to avoid ESLint no-prototype-builtins detection
   reduceDescriptors,
   freezeMethods,
@@ -15005,7 +15070,7 @@ const utils$3 = /*#__PURE__*/Object.freeze({
   navigator: _navigator,
   origin: origin
 });
-const platform = _objectSpread2$1(_objectSpread2$1({}, utils$3), platform$1);
+const platform = _objectSpread2(_objectSpread2({}, utils$3), platform$1);
 function toURLEncodedForm(data, options) {
   return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({
     visitor: function (value, key, path, helpers) {
@@ -16626,7 +16691,7 @@ const cookies = platform.hasStandardBrowserEnv ?
   },
   remove() {}
 };
-const headersToObject = thing => thing instanceof AxiosHeaders$1 ? _objectSpread2$1({}, thing) : thing;
+const headersToObject = thing => thing instanceof AxiosHeaders$1 ? _objectSpread2({}, thing) : thing;
 
 /**
  * Config-specific merge-function which creates a new config-object
@@ -17195,7 +17260,7 @@ const fetchAdapter = isFetchSupported && (async config => {
     // Cloudflare Workers throws when credentials are defined
     // see https://github.com/cloudflare/workerd/issues/902
     const isCredentialsSupported = "credentials" in Request.prototype;
-    request = new Request(url, _objectSpread2$1(_objectSpread2$1({}, fetchOptions), {}, {
+    request = new Request(url, _objectSpread2(_objectSpread2({}, fetchOptions), {}, {
       signal: composedSignal,
       method: method.toUpperCase(),
       headers: headers.normalize().toJSON(),
@@ -17898,161 +17963,57 @@ var axios_1 = axios;
 var axios$1 = /*@__PURE__*/getDefaultExportFromCjs(axios_1);
 
 var toStringFunction$1 = Function.prototype.toString;
-var create$2 = Object.create,
-  defineProperty$1 = Object.defineProperty,
-  getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor,
-  getOwnPropertyNames$1 = Object.getOwnPropertyNames,
-  getOwnPropertySymbols$1 = Object.getOwnPropertySymbols,
-  getPrototypeOf$1$1 = Object.getPrototypeOf;
-var _a$1 = Object.prototype,
-  hasOwnProperty$2 = _a$1.hasOwnProperty,
-  propertyIsEnumerable$1 = _a$1.propertyIsEnumerable;
-var SYMBOL_PROPERTIES$1 = typeof getOwnPropertySymbols$1 === 'function';
-var WEAK_MAP$1 = typeof WeakMap === 'function';
+var create$2 = Object.create;
+var toStringObject = Object.prototype.toString;
 /**
- * @function createCache
- *
- * @description
- * get a new cache object to prevent circular references
- *
- * @returns the new cache object
+ * @classdesc Fallback cache for when WeakMap is not natively supported
  */
-var createCache$1 = function () {
-  if (WEAK_MAP$1) {
-    return function () {
-      return new WeakMap();
-    };
+var LegacyCache = /** @class */function () {
+  function LegacyCache() {
+    this._keys = [];
+    this._values = [];
   }
-  var Cache = /** @class */function () {
-    function Cache() {
-      this._keys = [];
-      this._values = [];
-    }
-    Cache.prototype.has = function (key) {
-      return !!~this._keys.indexOf(key);
-    };
-    Cache.prototype.get = function (key) {
-      return this._values[this._keys.indexOf(key)];
-    };
-    Cache.prototype.set = function (key, value) {
-      this._keys.push(key);
-      this._values.push(value);
-    };
-    return Cache;
-  }();
-  return function () {
-    return new Cache();
+  LegacyCache.prototype.has = function (key) {
+    return !!~this._keys.indexOf(key);
+  };
+  LegacyCache.prototype.get = function (key) {
+    return this._values[this._keys.indexOf(key)];
+  };
+  LegacyCache.prototype.set = function (key, value) {
+    this._keys.push(key);
+    this._values.push(value);
   };
+  return LegacyCache;
 }();
+function createCacheLegacy() {
+  return new LegacyCache();
+}
+function createCacheModern() {
+  return new WeakMap();
+}
 /**
- * @function getCleanClone
- *
- * @description
- * get an empty version of the object with the same prototype it has
- *
- * @param object the object to build a clean clone from
- * @param realm the realm the object resides in
- * @returns the empty cloned object
+ * Get a new cache object to prevent circular references.
+ */
+var createCache$1 = typeof WeakMap !== 'undefined' ? createCacheModern : createCacheLegacy;
+/**
+ * Get an empty version of the object with the same prototype it has.
  */
-var getCleanClone$1 = function (object, realm) {
-  var prototype = object.__proto__ || getPrototypeOf$1$1(object);
+function getCleanClone$1(prototype) {
   if (!prototype) {
     return create$2(null);
   }
   var Constructor = prototype.constructor;
-  if (Constructor === realm.Object) {
-    return prototype === realm.Object.prototype ? {} : create$2(prototype);
+  if (Constructor === Object) {
+    return prototype === Object.prototype ? {} : create$2(prototype);
   }
-  if (~toStringFunction$1.call(Constructor).indexOf('[native code]')) {
+  if (Constructor && ~toStringFunction$1.call(Constructor).indexOf('[native code]')) {
     try {
       return new Constructor();
     } catch (_a) {}
   }
   return create$2(prototype);
-};
-/**
- * @function getObjectCloneLoose
- *
- * @description
- * get a copy of the object based on loose rules, meaning all enumerable keys
- * and symbols are copied, but property descriptors are not considered
- *
- * @param object the object to clone
- * @param realm the realm the object resides in
- * @param handleCopy the function that handles copying the object
- * @returns the copied object
- */
-var getObjectCloneLoose$1 = function (object, realm, handleCopy, cache) {
-  var clone = getCleanClone$1(object, realm);
-  // set in the cache immediately to be able to reuse the object recursively
-  cache.set(object, clone);
-  for (var key in object) {
-    if (hasOwnProperty$2.call(object, key)) {
-      clone[key] = handleCopy(object[key], cache);
-    }
-  }
-  if (SYMBOL_PROPERTIES$1) {
-    var symbols = getOwnPropertySymbols$1(object);
-    for (var index = 0, length_1 = symbols.length, symbol = void 0; index < length_1; ++index) {
-      symbol = symbols[index];
-      if (propertyIsEnumerable$1.call(object, symbol)) {
-        clone[symbol] = handleCopy(object[symbol], cache);
-      }
-    }
-  }
-  return clone;
-};
-/**
- * @function getObjectCloneStrict
- *
- * @description
- * get a copy of the object based on strict rules, meaning all keys and symbols
- * are copied based on the original property descriptors
- *
- * @param object the object to clone
- * @param realm the realm the object resides in
- * @param handleCopy the function that handles copying the object
- * @returns the copied object
- */
-var getObjectCloneStrict$1 = function (object, realm, handleCopy, cache) {
-  var clone = getCleanClone$1(object, realm);
-  // set in the cache immediately to be able to reuse the object recursively
-  cache.set(object, clone);
-  var properties = SYMBOL_PROPERTIES$1 ? getOwnPropertyNames$1(object).concat(getOwnPropertySymbols$1(object)) : getOwnPropertyNames$1(object);
-  for (var index = 0, length_2 = properties.length, property = void 0, descriptor = void 0; index < length_2; ++index) {
-    property = properties[index];
-    if (property !== 'callee' && property !== 'caller') {
-      descriptor = getOwnPropertyDescriptor$1(object, property);
-      if (descriptor) {
-        // Only clone the value if actually a value, not a getter / setter.
-        if (!descriptor.get && !descriptor.set) {
-          descriptor.value = handleCopy(object[property], cache);
-        }
-        try {
-          defineProperty$1(clone, property, descriptor);
-        } catch (error) {
-          // Tee above can fail on node in edge cases, so fall back to the loose assignment.
-          clone[property] = descriptor.value;
-        }
-      } else {
-        // In extra edge cases where the property descriptor cannot be retrived, fall back to
-        // the loose assignment.
-        clone[property] = handleCopy(object[property], cache);
-      }
-    }
-  }
-  return clone;
-};
-/**
- * @function getRegExpFlags
- *
- * @description
- * get the flags to apply to the copied regexp
- *
- * @param regExp the regexp to get the flags of
- * @returns the flags for the regexp
- */
-var getRegExpFlags$1 = function (regExp) {
+}
+function getRegExpFlagsLegacy(regExp) {
   var flags = '';
   if (regExp.global) {
     flags += 'g';
@@ -18070,181 +18031,332 @@ var getRegExpFlags$1 = function (regExp) {
     flags += 'y';
   }
   return flags;
-};
-
-// utils
-var isArray$6 = Array.isArray;
-var getPrototypeOf$2 = Object.getPrototypeOf;
-var GLOBAL_THIS$1 = function () {
-  if (typeof globalThis !== 'undefined') {
-    return globalThis;
-  }
-  if (typeof self !== 'undefined') {
-    return self;
-  }
-  if (typeof window !== 'undefined') {
-    return window;
-  }
-  if (typeof global !== 'undefined') {
-    return global;
+}
+function getRegExpFlagsModern(regExp) {
+  return regExp.flags;
+}
+/**
+ * Get the flags to apply to the copied regexp.
+ */
+var getRegExpFlags$1 = /test/g.flags === 'g' ? getRegExpFlagsModern : getRegExpFlagsLegacy;
+function getTagLegacy(value) {
+  var type = toStringObject.call(value);
+  return type.substring(8, type.length - 1);
+}
+function getTagModern(value) {
+  return value[Symbol.toStringTag] || getTagLegacy(value);
+}
+/**
+ * Get the tag of the value passed, so that the correct copier can be used.
+ */
+var getTag = typeof Symbol !== 'undefined' ? getTagModern : getTagLegacy;
+var defineProperty$1 = Object.defineProperty,
+  getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor,
+  getOwnPropertyNames$1 = Object.getOwnPropertyNames,
+  getOwnPropertySymbols$1 = Object.getOwnPropertySymbols;
+var _a$1 = Object.prototype,
+  hasOwnProperty$3 = _a$1.hasOwnProperty,
+  propertyIsEnumerable$1 = _a$1.propertyIsEnumerable;
+var SUPPORTS_SYMBOL = typeof getOwnPropertySymbols$1 === 'function';
+function getStrictPropertiesModern(object) {
+  return getOwnPropertyNames$1(object).concat(getOwnPropertySymbols$1(object));
+}
+/**
+ * Get the properites used when copying objects strictly. This includes both keys and symbols.
+ */
+var getStrictProperties = SUPPORTS_SYMBOL ? getStrictPropertiesModern : getOwnPropertyNames$1;
+/**
+ * Striclty copy all properties contained on the object.
+ */
+function copyOwnPropertiesStrict(value, clone, state) {
+  var properties = getStrictProperties(value);
+  for (var index = 0, length_1 = properties.length, property = void 0, descriptor = void 0; index < length_1; ++index) {
+    property = properties[index];
+    if (property === 'callee' || property === 'caller') {
+      continue;
+    }
+    descriptor = getOwnPropertyDescriptor$1(value, property);
+    if (!descriptor) {
+      // In extra edge cases where the property descriptor cannot be retrived, fall back to
+      // the loose assignment.
+      clone[property] = state.copier(value[property], state);
+      continue;
+    }
+    // Only clone the value if actually a value, not a getter / setter.
+    if (!descriptor.get && !descriptor.set) {
+      descriptor.value = state.copier(descriptor.value, state);
+    }
+    try {
+      defineProperty$1(clone, property, descriptor);
+    } catch (error) {
+      // Tee above can fail on node in edge cases, so fall back to the loose assignment.
+      clone[property] = descriptor.value;
+    }
   }
-  if (console && console.error) {
-    console.error('Unable to locate global object, returning "this".');
+  return clone;
+}
+/**
+ * Deeply copy the indexed values in the array.
+ */
+function copyArrayLoose(array, state) {
+  var clone = new state.Constructor();
+  // set in the cache immediately to be able to reuse the object recursively
+  state.cache.set(array, clone);
+  for (var index = 0, length_2 = array.length; index < length_2; ++index) {
+    clone[index] = state.copier(array[index], state);
   }
-  return this;
-}();
+  return clone;
+}
 /**
- * @function copy
- *
- * @description
- * copy an value deeply as much as possible
- *
- * If `strict` is applied, then all properties (including non-enumerable ones)
- * are copied with their original property descriptors on both objects and arrays.
- *
- * The value is compared to the global constructors in the `realm` provided,
- * and the native constructor is always used to ensure that extensions of native
- * objects (allows in ES2015+) are maintained.
+ * Deeply copy the indexed values in the array, as well as any custom properties.
+ */
+function copyArrayStrict(array, state) {
+  var clone = new state.Constructor();
+  // set in the cache immediately to be able to reuse the object recursively
+  state.cache.set(array, clone);
+  return copyOwnPropertiesStrict(array, clone, state);
+}
+/**
+ * Copy the contents of the ArrayBuffer.
+ */
+function copyArrayBuffer(arrayBuffer, _state) {
+  return arrayBuffer.slice(0);
+}
+/**
+ * Create a new Blob with the contents of the original.
+ */
+function copyBlob(blob, _state) {
+  return blob.slice(0, blob.size, blob.type);
+}
+/**
+ * Create a new DataView with the contents of the original.
+ */
+function copyDataView(dataView, state) {
+  return new state.Constructor(copyArrayBuffer(dataView.buffer));
+}
+/**
+ * Create a new Date based on the time of the original.
+ */
+function copyDate(date, state) {
+  return new state.Constructor(date.getTime());
+}
+/**
+ * Deeply copy the keys and values of the original.
+ */
+function copyMapLoose(map, state) {
+  var clone = new state.Constructor();
+  // set in the cache immediately to be able to reuse the object recursively
+  state.cache.set(map, clone);
+  map.forEach(function (value, key) {
+    clone.set(key, state.copier(value, state));
+  });
+  return clone;
+}
+/**
+ * Deeply copy the keys and values of the original, as well as any custom properties.
+ */
+function copyMapStrict(map, state) {
+  return copyOwnPropertiesStrict(map, copyMapLoose(map, state), state);
+}
+function copyObjectLooseLegacy(object, state) {
+  var clone = getCleanClone$1(state.prototype);
+  // set in the cache immediately to be able to reuse the object recursively
+  state.cache.set(object, clone);
+  for (var key in object) {
+    if (hasOwnProperty$3.call(object, key)) {
+      clone[key] = state.copier(object[key], state);
+    }
+  }
+  return clone;
+}
+function copyObjectLooseModern(object, state) {
+  var clone = getCleanClone$1(state.prototype);
+  // set in the cache immediately to be able to reuse the object recursively
+  state.cache.set(object, clone);
+  for (var key in object) {
+    if (hasOwnProperty$3.call(object, key)) {
+      clone[key] = state.copier(object[key], state);
+    }
+  }
+  var symbols = getOwnPropertySymbols$1(object);
+  for (var index = 0, length_3 = symbols.length, symbol = void 0; index < length_3; ++index) {
+    symbol = symbols[index];
+    if (propertyIsEnumerable$1.call(object, symbol)) {
+      clone[symbol] = state.copier(object[symbol], state);
+    }
+  }
+  return clone;
+}
+/**
+ * Deeply copy the properties (keys and symbols) and values of the original.
+ */
+var copyObjectLoose = SUPPORTS_SYMBOL ? copyObjectLooseModern : copyObjectLooseLegacy;
+/**
+ * Deeply copy the properties (keys and symbols) and values of the original, as well
+ * as any hidden or non-enumerable properties.
+ */
+function copyObjectStrict(object, state) {
+  var clone = getCleanClone$1(state.prototype);
+  // set in the cache immediately to be able to reuse the object recursively
+  state.cache.set(object, clone);
+  return copyOwnPropertiesStrict(object, clone, state);
+}
+/**
+ * Create a new primitive wrapper from the value of the original.
+ */
+function copyPrimitiveWrapper(primitiveObject, state) {
+  return new state.Constructor(primitiveObject.valueOf());
+}
+/**
+ * Create a new RegExp based on the value and flags of the original.
+ */
+function copyRegExp(regExp, state) {
+  var clone = new state.Constructor(regExp.source, getRegExpFlags$1(regExp));
+  clone.lastIndex = regExp.lastIndex;
+  return clone;
+}
+/**
+ * Return the original value (an identity function).
  *
- * @param value the value to copy
- * @param [options] the options for copying with
- * @param [options.isStrict] should the copy be strict
- * @param [options.realm] the realm (this) value the value is copied from
- * @returns the copied value
+ * @note
+ * THis is used for objects that cannot be copied, such as WeakMap.
  */
-function copy$1(value, options) {
-  // manually coalesced instead of default parameters for performance
-  var isStrict = !!(options && options.isStrict);
-  var realm = options && options.realm || GLOBAL_THIS$1;
-  var getObjectClone = isStrict ? getObjectCloneStrict$1 : getObjectCloneLoose$1;
-  /**
-   * @function handleCopy
-   *
-   * @description
-   * copy the value recursively based on its type
-   *
-   * @param value the value to copy
-   * @returns the copied value
-   */
-  var handleCopy = function (value, cache) {
+function copySelf(value, _state) {
+  return value;
+}
+/**
+ * Deeply copy the values of the original.
+ */
+function copySetLoose(set, state) {
+  var clone = new state.Constructor();
+  // set in the cache immediately to be able to reuse the object recursively
+  state.cache.set(set, clone);
+  set.forEach(function (value) {
+    clone.add(state.copier(value, state));
+  });
+  return clone;
+}
+/**
+ * Deeply copy the values of the original, as well as any custom properties.
+ */
+function copySetStrict(set, state) {
+  return copyOwnPropertiesStrict(set, copySetLoose(set, state), state);
+}
+var isArray$7 = Array.isArray;
+var assign$1 = Object.assign;
+var getPrototypeOf$2 = Object.getPrototypeOf || function (obj) {
+  return obj.__proto__;
+};
+var DEFAULT_LOOSE_OPTIONS = {
+  array: copyArrayLoose,
+  arrayBuffer: copyArrayBuffer,
+  blob: copyBlob,
+  dataView: copyDataView,
+  date: copyDate,
+  error: copySelf,
+  map: copyMapLoose,
+  object: copyObjectLoose,
+  regExp: copyRegExp,
+  set: copySetLoose
+};
+var DEFAULT_STRICT_OPTIONS = assign$1({}, DEFAULT_LOOSE_OPTIONS, {
+  array: copyArrayStrict,
+  map: copyMapStrict,
+  object: copyObjectStrict,
+  set: copySetStrict
+});
+/**
+ * Get the copiers used for each specific object tag.
+ */
+function getTagSpecificCopiers(options) {
+  return {
+    Arguments: options.object,
+    Array: options.array,
+    ArrayBuffer: options.arrayBuffer,
+    Blob: options.blob,
+    Boolean: copyPrimitiveWrapper,
+    DataView: options.dataView,
+    Date: options.date,
+    Error: options.error,
+    Float32Array: options.arrayBuffer,
+    Float64Array: options.arrayBuffer,
+    Int8Array: options.arrayBuffer,
+    Int16Array: options.arrayBuffer,
+    Int32Array: options.arrayBuffer,
+    Map: options.map,
+    Number: copyPrimitiveWrapper,
+    Object: options.object,
+    Promise: copySelf,
+    RegExp: options.regExp,
+    Set: options.set,
+    String: copyPrimitiveWrapper,
+    WeakMap: copySelf,
+    WeakSet: copySelf,
+    Uint8Array: options.arrayBuffer,
+    Uint8ClampedArray: options.arrayBuffer,
+    Uint16Array: options.arrayBuffer,
+    Uint32Array: options.arrayBuffer,
+    Uint64Array: options.arrayBuffer
+  };
+}
+/**
+ * Create a custom copier based on the object-specific copy methods passed.
+ */
+function createCopier(options) {
+  var normalizedOptions = assign$1({}, DEFAULT_LOOSE_OPTIONS, options);
+  var tagSpecificCopiers = getTagSpecificCopiers(normalizedOptions);
+  var array = tagSpecificCopiers.Array,
+    object = tagSpecificCopiers.Object;
+  function copier(value, state) {
+    state.prototype = state.Constructor = undefined;
     if (!value || typeof value !== 'object') {
       return value;
     }
-    if (cache.has(value)) {
-      return cache.get(value);
+    if (state.cache.has(value)) {
+      return state.cache.get(value);
     }
-    var prototype = value.__proto__ || getPrototypeOf$2(value);
-    var Constructor = prototype && prototype.constructor;
+    state.prototype = getPrototypeOf$2(value);
+    state.Constructor = state.prototype && state.prototype.constructor;
     // plain objects
-    if (!Constructor || Constructor === realm.Object) {
-      return getObjectClone(value, realm, handleCopy, cache);
+    if (!state.Constructor || state.Constructor === Object) {
+      return object(value, state);
     }
-    var clone;
     // arrays
-    if (isArray$6(value)) {
-      // if strict, include non-standard properties
-      if (isStrict) {
-        return getObjectCloneStrict$1(value, realm, handleCopy, cache);
-      }
-      clone = new Constructor();
-      cache.set(value, clone);
-      for (var index = 0, length_1 = value.length; index < length_1; ++index) {
-        clone[index] = handleCopy(value[index], cache);
-      }
-      return clone;
-    }
-    // dates
-    if (value instanceof realm.Date) {
-      return new Constructor(value.getTime());
-    }
-    // regexps
-    if (value instanceof realm.RegExp) {
-      clone = new Constructor(value.source, value.flags || getRegExpFlags$1(value));
-      clone.lastIndex = value.lastIndex;
-      return clone;
-    }
-    // maps
-    if (realm.Map && value instanceof realm.Map) {
-      clone = new Constructor();
-      cache.set(value, clone);
-      value.forEach(function (value, key) {
-        clone.set(key, handleCopy(value, cache));
-      });
-      return clone;
-    }
-    // sets
-    if (realm.Set && value instanceof realm.Set) {
-      clone = new Constructor();
-      cache.set(value, clone);
-      value.forEach(function (value) {
-        clone.add(handleCopy(value, cache));
-      });
-      return clone;
-    }
-    // blobs
-    if (realm.Blob && value instanceof realm.Blob) {
-      return value.slice(0, value.size, value.type);
-    }
-    // buffers (node-only)
-    if (realm.Buffer && realm.Buffer.isBuffer(value)) {
-      clone = realm.Buffer.allocUnsafe ? realm.Buffer.allocUnsafe(value.length) : new Constructor(value.length);
-      cache.set(value, clone);
-      value.copy(clone);
-      return clone;
-    }
-    // arraybuffers / dataviews
-    if (realm.ArrayBuffer) {
-      // dataviews
-      if (realm.ArrayBuffer.isView(value)) {
-        clone = new Constructor(value.buffer.slice(0));
-        cache.set(value, clone);
-        return clone;
-      }
-      // arraybuffers
-      if (value instanceof realm.ArrayBuffer) {
-        clone = value.slice(0);
-        cache.set(value, clone);
-        return clone;
-      }
+    if (isArray$7(value)) {
+      return array(value, state);
     }
-    // if the value cannot / should not be cloned, don't
-    if (
-    // promise-like
-    typeof value.then === 'function' ||
-    // errors
-    value instanceof Error ||
-    // weakmaps
-    realm.WeakMap && value instanceof realm.WeakMap ||
-    // weaksets
-    realm.WeakSet && value instanceof realm.WeakSet) {
-      return value;
+    var tagSpecificCopier = tagSpecificCopiers[getTag(value)];
+    if (tagSpecificCopier) {
+      return tagSpecificCopier(value, state);
     }
-    // assume anything left is a custom constructor
-    return getObjectClone(value, realm, handleCopy, cache);
+    return typeof value.then === 'function' ? value : object(value, state);
+  }
+  return function copy(value) {
+    return copier(value, {
+      Constructor: undefined,
+      cache: createCache$1(),
+      copier: copier,
+      prototype: undefined
+    });
   };
-  return handleCopy(value, createCache$1());
 }
-// Adding reference to allow usage in CommonJS libraries compiled using TSC, which
-// expects there to be a default property on the exported value. See
-// [#37](https://github.com/planttheidea/fast-copy/issues/37) for details.
-copy$1.default = copy$1;
 /**
- * @function strictCopy
- *
- * @description
- * copy the value with `strict` option pre-applied
- *
- * @param value the value to copy
- * @param [options] the options for copying with
- * @param [options.realm] the realm (this) value the value is copied from
- * @returns the copied value
+ * Create a custom copier based on the object-specific copy methods passed, defaulting to the
+ * same internals as `copyStrict`.
  */
-copy$1.strict = function strictCopy(value, options) {
-  return copy$1(value, {
-    isStrict: true,
-    realm: options ? options.realm : void 0
-  });
-};
+function createStrictCopier(options) {
+  return createCopier(assign$1({}, DEFAULT_STRICT_OPTIONS, options));
+}
+/**
+ * Copy an value deeply as much as possible, where strict recreation of object properties
+ * are maintained. All properties (including non-enumerable ones) are copied with their
+ * original property descriptors on both objects and arrays.
+ */
+createStrictCopier({});
+/**
+ * Copy an value deeply as much as possible.
+ */
+var index = createCopier({});
 
 /** @type {import('.')} */
 var esErrors = Error;
@@ -19042,7 +19154,7 @@ var objectInspect = function inspect_(obj, options, depth, seen) {
     depth = 0;
   }
   if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {
-    return isArray$5(obj) ? '[Array]' : '[Object]';
+    return isArray$6(obj) ? '[Array]' : '[Object]';
   }
   var indent = getIndent(opts, depth);
   if (typeof seen === 'undefined') {
@@ -19089,7 +19201,7 @@ var objectInspect = function inspect_(obj, options, depth, seen) {
     s += '</' + $toLowerCase.call(String(obj.nodeName)) + '>';
     return s;
   }
-  if (isArray$5(obj)) {
+  if (isArray$6(obj)) {
     if (obj.length === 0) {
       return '[]';
     }
@@ -19189,7 +19301,7 @@ function wrapQuotes(s, defaultStyle, opts) {
 function quote(s) {
   return $replace.call(String(s), /"/g, '&quot;');
 }
-function isArray$5(obj) {
+function isArray$6(obj) {
   return toStr(obj) === '[object Array]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj));
 }
 function isDate(obj) {
@@ -19411,7 +19523,7 @@ function indentedJoin(xs, indent) {
   return lineJoiner + $join.call(xs, ',' + lineJoiner) + '\n' + indent.prev;
 }
 function arrObjKeys(obj, inspect) {
-  var isArr = isArray$5(obj);
+  var isArr = isArray$6(obj);
   var xs = [];
   if (isArr) {
     xs.length = obj.length;
@@ -19612,7 +19724,7 @@ var formats$3 = {
 
 var formats$2 = formats$3;
 var has$2 = Object.prototype.hasOwnProperty;
-var isArray$4 = Array.isArray;
+var isArray$5 = Array.isArray;
 var hexTable = function () {
   var array = [];
   for (var i = 0; i < 256; ++i) {
@@ -19624,7 +19736,7 @@ var compactQueue = function compactQueue(queue) {
   while (queue.length > 1) {
     var item = queue.pop();
     var obj = item.obj[item.prop];
-    if (isArray$4(obj)) {
+    if (isArray$5(obj)) {
       var compacted = [];
       for (var j = 0; j < obj.length; ++j) {
         if (typeof obj[j] !== 'undefined') {
@@ -19650,7 +19762,7 @@ var merge = function merge(target, source, options) {
     return target;
   }
   if (typeof source !== 'object') {
-    if (isArray$4(target)) {
+    if (isArray$5(target)) {
       target.push(source);
     } else if (target && typeof target === 'object') {
       if (options && (options.plainObjects || options.allowPrototypes) || !has$2.call(Object.prototype, source)) {
@@ -19665,10 +19777,10 @@ var merge = function merge(target, source, options) {
     return [target].concat(source);
   }
   var mergeTarget = target;
-  if (isArray$4(target) && !isArray$4(source)) {
+  if (isArray$5(target) && !isArray$5(source)) {
     mergeTarget = arrayToObject(target, options);
   }
-  if (isArray$4(target) && isArray$4(source)) {
+  if (isArray$5(target) && isArray$5(source)) {
     source.forEach(function (item, i) {
       if (has$2.call(target, i)) {
         var targetItem = target[i];
@@ -19811,7 +19923,7 @@ var combine = function combine(a, b) {
   return [].concat(a, b);
 };
 var maybeMap = function maybeMap(val, fn) {
-  if (isArray$4(val)) {
+  if (isArray$5(val)) {
     var mapped = [];
     for (var i = 0; i < val.length; i += 1) {
       mapped.push(fn(val[i]));
@@ -19849,10 +19961,10 @@ var arrayPrefixGenerators = {
     return prefix;
   }
 };
-var isArray$3 = Array.isArray;
+var isArray$4 = Array.isArray;
 var push = Array.prototype.push;
 var pushToArray = function (arr, valueOrArray) {
-  push.apply(arr, isArray$3(valueOrArray) ? valueOrArray : [valueOrArray]);
+  push.apply(arr, isArray$4(valueOrArray) ? valueOrArray : [valueOrArray]);
 };
 var toISO = Date.prototype.toISOString;
 var defaultFormat = formats$1['default'];
@@ -19906,7 +20018,7 @@ var stringify$2 = function stringify(object, prefix, generateArrayPrefix, commaR
     obj = filter(prefix, obj);
   } else if (obj instanceof Date) {
     obj = serializeDate(obj);
-  } else if (generateArrayPrefix === 'comma' && isArray$3(obj)) {
+  } else if (generateArrayPrefix === 'comma' && isArray$4(obj)) {
     obj = utils$1.maybeMap(obj, function (value) {
       if (value instanceof Date) {
         return serializeDate(value);
@@ -19932,7 +20044,7 @@ var stringify$2 = function stringify(object, prefix, generateArrayPrefix, commaR
     return values;
   }
   var objKeys;
-  if (generateArrayPrefix === 'comma' && isArray$3(obj)) {
+  if (generateArrayPrefix === 'comma' && isArray$4(obj)) {
     // we need to join elements in
     if (encodeValuesOnly && encoder) {
       obj = utils$1.maybeMap(obj, encoder);
@@ -19940,15 +20052,15 @@ var stringify$2 = function stringify(object, prefix, generateArrayPrefix, commaR
     objKeys = [{
       value: obj.length > 0 ? obj.join(',') || null : void undefined
     }];
-  } else if (isArray$3(filter)) {
+  } else if (isArray$4(filter)) {
     objKeys = filter;
   } else {
     var keys = Object.keys(obj);
     objKeys = sort ? keys.sort(sort) : keys;
   }
   var encodedPrefix = encodeDotInKeys ? prefix.replace(/\./g, '%2E') : prefix;
-  var adjustedPrefix = commaRoundTrip && isArray$3(obj) && obj.length === 1 ? encodedPrefix + '[]' : encodedPrefix;
-  if (allowEmptyArrays && isArray$3(obj) && obj.length === 0) {
+  var adjustedPrefix = commaRoundTrip && isArray$4(obj) && obj.length === 1 ? encodedPrefix + '[]' : encodedPrefix;
+  if (allowEmptyArrays && isArray$4(obj) && obj.length === 0) {
     return adjustedPrefix + '[]';
   }
   for (var j = 0; j < objKeys.length; ++j) {
@@ -19958,11 +20070,11 @@ var stringify$2 = function stringify(object, prefix, generateArrayPrefix, commaR
       continue;
     }
     var encodedKey = allowDots && encodeDotInKeys ? key.replace(/\./g, '%2E') : key;
-    var keyPrefix = isArray$3(obj) ? typeof generateArrayPrefix === 'function' ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix : adjustedPrefix + (allowDots ? '.' + encodedKey : '[' + encodedKey + ']');
+    var keyPrefix = isArray$4(obj) ? typeof generateArrayPrefix === 'function' ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix : adjustedPrefix + (allowDots ? '.' + encodedKey : '[' + encodedKey + ']');
     sideChannel.set(object, step);
     var valueSideChannel = getSideChannel();
     valueSideChannel.set(sentinel, sideChannel);
-    pushToArray(values, stringify(value, keyPrefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, generateArrayPrefix === 'comma' && encodeValuesOnly && isArray$3(obj) ? null : encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, valueSideChannel));
+    pushToArray(values, stringify(value, keyPrefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, generateArrayPrefix === 'comma' && encodeValuesOnly && isArray$4(obj) ? null : encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, valueSideChannel));
   }
   return values;
 };
@@ -19992,7 +20104,7 @@ var normalizeStringifyOptions = function normalizeStringifyOptions(opts) {
   }
   var formatter = formats$1.formatters[format];
   var filter = defaults$1.filter;
-  if (typeof opts.filter === 'function' || isArray$3(opts.filter)) {
+  if (typeof opts.filter === 'function' || isArray$4(opts.filter)) {
     filter = opts.filter;
   }
   var arrayFormat;
@@ -20037,7 +20149,7 @@ var stringify_1 = function (object, opts) {
   if (typeof options.filter === 'function') {
     filter = options.filter;
     obj = filter('', obj);
-  } else if (isArray$3(options.filter)) {
+  } else if (isArray$4(options.filter)) {
     filter = options.filter;
     objKeys = filter;
   }
@@ -20077,7 +20189,7 @@ var stringify_1 = function (object, opts) {
 
 var utils = utils$2;
 var has = Object.prototype.hasOwnProperty;
-var isArray$2 = Array.isArray;
+var isArray$3 = Array.isArray;
 var defaults = {
   allowDots: false,
   allowEmptyArrays: false,
@@ -20167,7 +20279,7 @@ var parseValues = function parseQueryStringValues(str, options) {
       val = interpretNumericEntities(val);
     }
     if (part.indexOf('[]=') > -1) {
-      val = isArray$2(val) ? [val] : val;
+      val = isArray$3(val) ? [val] : val;
     }
     var existing = has.call(obj, key);
     if (existing && options.duplicates === 'combine') {
@@ -20337,253 +20449,247 @@ var lib = {
 };
 var qs = /*@__PURE__*/getDefaultExportFromCjs(lib);
 
-/**
- * lodash 4.0.1 (Custom Build) <https://lodash.com/>
- * Build: `lodash modularize exports="npm" -o ./`
- * Copyright 2012-2016 The Dojo Foundation <http://dojofoundation.org/>
- * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
- * Copyright 2009-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
- * Available under MIT license <https://lodash.com/license>
- */
-
-/** `Object#toString` result references. */
-var stringTag = '[object String]';
-
-/** Used for built-in method references. */
-var objectProto$1 = Object.prototype;
+function asyncToken(instance, getToken) {
+  instance.interceptors.request.use(function (config) {
+    return getToken().then(accessToken => {
+      config.headers.set('Authorization', `Bearer ${accessToken}`);
+      return config;
+    });
+  });
+}
 
-/**
- * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
- * of values.
- */
-var objectToString$1 = objectProto$1.toString;
+function isNode() {
+  /**
+   * Polyfills of 'process' might set process.browser === true
+   *
+   * See:
+   * https://github.com/webpack/node-libs-browser/blob/master/mock/process.js#L8
+   * https://github.com/defunctzombie/node-process/blob/master/browser.js#L156
+   **/
+  return typeof process$1 !== 'undefined' && !process$1.browser;
+}
+function isReactNative() {
+  return typeof window !== 'undefined' && 'navigator' in window && 'product' in window.navigator && window.navigator.product === 'ReactNative';
+}
+function getNodeVersion() {
+  return process$1.versions && process$1.versions.node ? `v${process$1.versions.node}` : process$1.version;
+}
+function getWindow() {
+  return window;
+}
+function noop() {
+  return undefined;
+}
 
-/**
- * Checks if `value` is classified as an `Array` object.
- *
- * @static
- * @memberOf _
- * @type Function
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
- * @example
- *
- * _.isArray([1, 2, 3]);
- * // => true
- *
- * _.isArray(document.body.children);
- * // => false
- *
- * _.isArray('abc');
- * // => false
- *
- * _.isArray(_.noop);
- * // => false
- */
-var isArray$1 = Array.isArray;
-
-/**
- * Checks if `value` is object-like. A value is object-like if it's not `null`
- * and has a `typeof` result of "object".
- *
- * @static
- * @memberOf _
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
- * @example
- *
- * _.isObjectLike({});
- * // => true
- *
- * _.isObjectLike([1, 2, 3]);
- * // => true
- *
- * _.isObjectLike(_.noop);
- * // => false
- *
- * _.isObjectLike(null);
- * // => false
- */
-function isObjectLike$1(value) {
-  return !!value && typeof value == 'object';
-}
-
-/**
- * Checks if `value` is classified as a `String` primitive or object.
- *
- * @static
- * @memberOf _
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
- * @example
- *
- * _.isString('abc');
- * // => true
- *
- * _.isString(1);
- * // => false
- */
-function isString(value) {
-  return typeof value == 'string' || !isArray$1(value) && isObjectLike$1(value) && objectToString$1.call(value) == stringTag;
-}
-var lodash_isstring = isString;
-var isString$1 = /*@__PURE__*/getDefaultExportFromCjs(lodash_isstring);
-
-var pThrottle$2 = {exports: {}};
-
-class AbortError extends Error {
-  constructor() {
-    super('Throttled function aborted');
-    this.name = 'AbortError';
-  }
-}
-const pThrottle = ({
-  limit,
-  interval,
-  strict
-}) => {
-  if (!Number.isFinite(limit)) {
-    throw new TypeError('Expected `limit` to be a finite number');
-  }
-  if (!Number.isFinite(interval)) {
-    throw new TypeError('Expected `interval` to be a finite number');
-  }
-  const queue = new Map();
-  let currentTick = 0;
-  let activeCount = 0;
-  function windowedDelay() {
-    const now = Date.now();
-    if (now - currentTick > interval) {
-      activeCount = 1;
-      currentTick = now;
-      return 0;
+const delay = ms => new Promise(resolve => {
+  setTimeout(resolve, ms);
+});
+const defaultWait = attempts => {
+  return Math.pow(Math.SQRT2, attempts);
+};
+function rateLimit(instance, maxRetry = 5) {
+  const {
+    responseLogger = noop,
+    requestLogger = noop
+  } = instance.defaults;
+  instance.interceptors.request.use(function (config) {
+    requestLogger(config);
+    return config;
+  }, function (error) {
+    requestLogger(error);
+    return Promise.reject(error);
+  });
+  instance.interceptors.response.use(function (response) {
+    // we don't need to do anything here
+    responseLogger(response);
+    return response;
+  }, async function (error) {
+    const {
+      response
+    } = error;
+    const {
+      config
+    } = error;
+    responseLogger(error);
+    // Do not retry if it is disabled or no request config exists (not an axios error)
+    if (!config || !instance.defaults.retryOnError) {
+      return Promise.reject(error);
     }
-    if (activeCount < limit) {
-      activeCount++;
-    } else {
-      currentTick += interval;
-      activeCount = 1;
+    // Retried already for max attempts
+    const doneAttempts = config.attempts || 1;
+    if (doneAttempts > maxRetry) {
+      error.attempts = config.attempts;
+      return Promise.reject(error);
     }
-    return currentTick - now;
-  }
-  const strictTicks = [];
-  function strictDelay() {
-    const now = Date.now();
-    if (strictTicks.length < limit) {
-      strictTicks.push(now);
-      return 0;
+    let retryErrorType = null;
+    let wait = defaultWait(doneAttempts);
+    // Errors without response did not receive anything from the server
+    if (!response) {
+      retryErrorType = 'Connection';
+    } else if (response.status >= 500 && response.status < 600) {
+      // 5** errors are server related
+      retryErrorType = `Server ${response.status}`;
+    } else if (response.status === 429) {
+      // 429 errors are exceeded rate limit exceptions
+      retryErrorType = 'Rate limit';
+      // all headers are lowercased by axios https://github.com/mzabriskie/axios/issues/413
+      if (response.headers && error.response.headers['x-contentful-ratelimit-reset']) {
+        wait = response.headers['x-contentful-ratelimit-reset'];
+      }
     }
-    const earliestTime = strictTicks.shift() + interval;
-    if (now >= earliestTime) {
-      strictTicks.push(now);
-      return 0;
+    if (retryErrorType) {
+      // convert to ms and add jitter
+      wait = Math.floor(wait * 1000 + Math.random() * 200 + 500);
+      instance.defaults.logHandler('warning', `${retryErrorType} error occurred. Waiting for ${wait} ms before retrying...`);
+      // increase attempts counter
+      config.attempts = doneAttempts + 1;
+      /* Somehow between the interceptor and retrying the request the httpAgent/httpsAgent gets transformed from an Agent-like object
+       to a regular object, causing failures on retries after rate limits. Removing these properties here fixes the error, but retry
+       requests still use the original http/httpsAgent property */
+      delete config.httpAgent;
+      delete config.httpsAgent;
+      return delay(wait).then(() => instance(config));
     }
-    strictTicks.push(earliestTime);
-    return earliestTime - now;
-  }
-  const getDelay = strict ? strictDelay : windowedDelay;
-  return function_ => {
-    const throttled = function (...args) {
-      if (!throttled.isEnabled) {
-        return (async () => function_.apply(this, args))();
-      }
-      let timeout;
-      return new Promise((resolve, reject) => {
-        const execute = () => {
-          resolve(function_.apply(this, args));
-          queue.delete(timeout);
-        };
-        timeout = setTimeout(execute, getDelay());
-        queue.set(timeout, reject);
-      });
-    };
-    throttled.abort = () => {
-      for (const timeout of queue.keys()) {
-        clearTimeout(timeout);
-        queue.get(timeout)(new AbortError());
-      }
-      queue.clear();
-      strictTicks.splice(0, strictTicks.length);
-    };
-    throttled.isEnabled = true;
-    return throttled;
-  };
-};
-pThrottle$2.exports = pThrottle;
-pThrottle$2.exports.AbortError = AbortError;
-var pThrottleExports = pThrottle$2.exports;
-var pThrottle$1 = /*@__PURE__*/getDefaultExportFromCjs(pThrottleExports);
+    return Promise.reject(error);
+  });
+}
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal$1 = typeof global == 'object' && global && global.Object === Object && global;
+var _freeGlobal = freeGlobal$1;
+
+var freeGlobal = _freeGlobal;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root$1 = freeGlobal || freeSelf || Function('return this')();
+var _root = root$1;
+
+var root = _root;
+
+/** Built-in value references. */
+var Symbol$3 = root.Symbol;
+var _Symbol = Symbol$3;
+
+var Symbol$2 = _Symbol;
+
+/** Used for built-in method references. */
+var objectProto$2 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
 
 /**
- * lodash (Custom Build) <https://lodash.com/>
- * Build: `lodash modularize exports="npm" -o ./`
- * Copyright jQuery Foundation and other contributors <https://jquery.org/>
- * Released under MIT license <https://lodash.com/license>
- * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
- * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
  */
+var nativeObjectToString$1 = objectProto$2.toString;
 
-/** `Object#toString` result references. */
-var objectTag = '[object Object]';
+/** Built-in value references. */
+var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : undefined;
 
 /**
- * Checks if `value` is a host object in IE < 9.
+ * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
  *
  * @private
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+ * @param {*} value The value to query.
+ * @returns {string} Returns the raw `toStringTag`.
  */
-function isHostObject(value) {
-  // Many host objects are `Object` objects that can coerce to strings
-  // despite having improperly defined `toString` methods.
-  var result = false;
-  if (value != null && typeof value.toString != 'function') {
-    try {
-      result = !!(value + '');
-    } catch (e) {}
+function getRawTag$1(value) {
+  var isOwn = hasOwnProperty$2.call(value, symToStringTag$1),
+    tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = undefined;
+    var unmasked = true;
+  } catch (e) {}
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
   }
   return result;
 }
+var _getRawTag = getRawTag$1;
+
+/** Used for built-in method references. */
+var objectProto$1 = Object.prototype;
 
 /**
- * Creates a unary function that invokes `func` with its argument transformed.
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto$1.toString;
+
+/**
+ * Converts `value` to a string using `Object.prototype.toString`.
  *
  * @private
- * @param {Function} func The function to wrap.
- * @param {Function} transform The argument transform.
- * @returns {Function} Returns the new function.
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
  */
-function overArg(func, transform) {
-  return function (arg) {
-    return func(transform(arg));
-  };
+function objectToString$1(value) {
+  return nativeObjectToString.call(value);
 }
+var _objectToString = objectToString$1;
 
-/** Used for built-in method references. */
-var funcProto = Function.prototype,
-  objectProto = Object.prototype;
-
-/** Used to resolve the decompiled source of functions. */
-var funcToString = funcProto.toString;
+var Symbol$1 = _Symbol,
+  getRawTag = _getRawTag,
+  objectToString = _objectToString;
 
-/** Used to check objects for own properties. */
-var hasOwnProperty$1 = objectProto.hasOwnProperty;
+/** `Object#toString` result references. */
+var nullTag = '[object Null]',
+  undefinedTag = '[object Undefined]';
 
-/** Used to infer the `Object` constructor. */
-var objectCtorString = funcToString.call(Object);
+/** Built-in value references. */
+var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : undefined;
 
 /**
- * Used to resolve the
- * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
- * of values.
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
  */
-var objectToString = objectProto.toString;
+function baseGetTag$2(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+var _baseGetTag = baseGetTag$2;
 
-/** Built-in value references. */
-var getPrototype = overArg(Object.getPrototypeOf, Object);
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+var isArray$2 = Array.isArray;
+var isArray_1 = isArray$2;
 
 /**
  * Checks if `value` is object-like. A value is object-like if it's not `null`
@@ -20609,767 +20715,189 @@ var getPrototype = overArg(Object.getPrototypeOf, Object);
  * _.isObjectLike(null);
  * // => false
  */
-function isObjectLike(value) {
-  return !!value && typeof value == 'object';
+function isObjectLike$2(value) {
+  return value != null && typeof value == 'object';
 }
+var isObjectLike_1 = isObjectLike$2;
+
+var baseGetTag$1 = _baseGetTag,
+  isArray$1 = isArray_1,
+  isObjectLike$1 = isObjectLike_1;
+
+/** `Object#toString` result references. */
+var stringTag = '[object String]';
 
 /**
- * Checks if `value` is a plain object, that is, an object created by the
- * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ * Checks if `value` is classified as a `String` primitive or object.
  *
  * @static
+ * @since 0.1.0
  * @memberOf _
- * @since 0.8.0
  * @category Lang
  * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
- * @example
- *
- * function Foo() {
- *   this.a = 1;
- * }
- *
- * _.isPlainObject(new Foo);
- * // => false
- *
- * _.isPlainObject([1, 2, 3]);
- * // => false
- *
- * _.isPlainObject({ 'x': 0, 'y': 0 });
- * // => true
- *
- * _.isPlainObject(Object.create(null));
- * // => true
- */
-function isPlainObject(value) {
-  if (!isObjectLike(value) || objectToString.call(value) != objectTag || isHostObject(value)) {
-    return false;
-  }
-  var proto = getPrototype(value);
-  if (proto === null) {
-    return true;
-  }
-  var Ctor = hasOwnProperty$1.call(proto, 'constructor') && proto.constructor;
-  return typeof Ctor == 'function' && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
-}
-var lodash_isplainobject = isPlainObject;
-var isPlainObject$1 = /*@__PURE__*/getDefaultExportFromCjs(lodash_isplainobject);
-
-function _arrayLikeToArray(r, a) {
-  (null == a || a > r.length) && (a = r.length);
-  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
-  return n;
-}
-function _arrayWithHoles(r) {
-  if (Array.isArray(r)) return r;
-}
-function asyncGeneratorStep(n, t, e, r, o, a, c) {
-  try {
-    var i = n[a](c),
-      u = i.value;
-  } catch (n) {
-    return void e(n);
-  }
-  i.done ? t(u) : Promise.resolve(u).then(r, o);
-}
-function _asyncToGenerator(n) {
-  return function () {
-    var t = this,
-      e = arguments;
-    return new Promise(function (r, o) {
-      var a = n.apply(t, e);
-      function _next(n) {
-        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
-      }
-      function _throw(n) {
-        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
-      }
-      _next(void 0);
-    });
-  };
-}
-function _createForOfIteratorHelper(r, e) {
-  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-  if (!t) {
-    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
-      t && (r = t);
-      var n = 0,
-        F = function () {};
-      return {
-        s: F,
-        n: function () {
-          return n >= r.length ? {
-            done: !0
-          } : {
-            done: !1,
-            value: r[n++]
-          };
-        },
-        e: function (r) {
-          throw r;
-        },
-        f: F
-      };
-    }
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-  var o,
-    a = !0,
-    u = !1;
-  return {
-    s: function () {
-      t = t.call(r);
-    },
-    n: function () {
-      var r = t.next();
-      return a = r.done, r;
-    },
-    e: function (r) {
-      u = !0, o = r;
-    },
-    f: function () {
-      try {
-        a || null == t.return || t.return();
-      } finally {
-        if (u) throw o;
-      }
-    }
-  };
-}
-function _defineProperty(e, r, t) {
-  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-    value: t,
-    enumerable: !0,
-    configurable: !0,
-    writable: !0
-  }) : e[r] = t, e;
-}
-function _inherits(t, e) {
-  if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
-  t.prototype = Object.create(e && e.prototype, {
-    constructor: {
-      value: t,
-      writable: !0,
-      configurable: !0
-    }
-  }), Object.defineProperty(t, "prototype", {
-    writable: !1
-  }), e && _setPrototypeOf(t, e);
-}
-function _iterableToArrayLimit(r, l) {
-  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
-  if (null != t) {
-    var e,
-      n,
-      i,
-      u,
-      a = [],
-      f = !0,
-      o = !1;
-    try {
-      if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
-    } catch (r) {
-      o = !0, n = r;
-    } finally {
-      try {
-        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
-      } finally {
-        if (o) throw n;
-      }
-    }
-    return a;
-  }
-}
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function ownKeys(e, r) {
-  var t = Object.keys(e);
-  if (Object.getOwnPropertySymbols) {
-    var o = Object.getOwnPropertySymbols(e);
-    r && (o = o.filter(function (r) {
-      return Object.getOwnPropertyDescriptor(e, r).enumerable;
-    })), t.push.apply(t, o);
-  }
-  return t;
-}
-function _objectSpread2(e) {
-  for (var r = 1; r < arguments.length; r++) {
-    var t = null != arguments[r] ? arguments[r] : {};
-    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
-      _defineProperty(e, r, t[r]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
-      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
-    });
-  }
-  return e;
-}
-function _regeneratorRuntime() {
-  _regeneratorRuntime = function () {
-    return e;
-  };
-  var t,
-    e = {},
-    r = Object.prototype,
-    n = r.hasOwnProperty,
-    o = Object.defineProperty || function (t, e, r) {
-      t[e] = r.value;
-    },
-    i = "function" == typeof Symbol ? Symbol : {},
-    a = i.iterator || "@@iterator",
-    c = i.asyncIterator || "@@asyncIterator",
-    u = i.toStringTag || "@@toStringTag";
-  function define(t, e, r) {
-    return Object.defineProperty(t, e, {
-      value: r,
-      enumerable: !0,
-      configurable: !0,
-      writable: !0
-    }), t[e];
-  }
-  try {
-    define({}, "");
-  } catch (t) {
-    define = function (t, e, r) {
-      return t[e] = r;
-    };
-  }
-  function wrap(t, e, r, n) {
-    var i = e && e.prototype instanceof Generator ? e : Generator,
-      a = Object.create(i.prototype),
-      c = new Context(n || []);
-    return o(a, "_invoke", {
-      value: makeInvokeMethod(t, r, c)
-    }), a;
-  }
-  function tryCatch(t, e, r) {
-    try {
-      return {
-        type: "normal",
-        arg: t.call(e, r)
-      };
-    } catch (t) {
-      return {
-        type: "throw",
-        arg: t
-      };
-    }
-  }
-  e.wrap = wrap;
-  var h = "suspendedStart",
-    l = "suspendedYield",
-    f = "executing",
-    s = "completed",
-    y = {};
-  function Generator() {}
-  function GeneratorFunction() {}
-  function GeneratorFunctionPrototype() {}
-  var p = {};
-  define(p, a, function () {
-    return this;
-  });
-  var d = Object.getPrototypeOf,
-    v = d && d(d(values([])));
-  v && v !== r && n.call(v, a) && (p = v);
-  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
-  function defineIteratorMethods(t) {
-    ["next", "throw", "return"].forEach(function (e) {
-      define(t, e, function (t) {
-        return this._invoke(e, t);
-      });
-    });
-  }
-  function AsyncIterator(t, e) {
-    function invoke(r, o, i, a) {
-      var c = tryCatch(t[r], t, o);
-      if ("throw" !== c.type) {
-        var u = c.arg,
-          h = u.value;
-        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
-          invoke("next", t, i, a);
-        }, function (t) {
-          invoke("throw", t, i, a);
-        }) : e.resolve(h).then(function (t) {
-          u.value = t, i(u);
-        }, function (t) {
-          return invoke("throw", t, i, a);
-        });
-      }
-      a(c.arg);
-    }
-    var r;
-    o(this, "_invoke", {
-      value: function (t, n) {
-        function callInvokeWithMethodAndArg() {
-          return new e(function (e, r) {
-            invoke(t, n, e, r);
-          });
-        }
-        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
-      }
-    });
-  }
-  function makeInvokeMethod(e, r, n) {
-    var o = h;
-    return function (i, a) {
-      if (o === f) throw Error("Generator is already running");
-      if (o === s) {
-        if ("throw" === i) throw a;
-        return {
-          value: t,
-          done: !0
-        };
-      }
-      for (n.method = i, n.arg = a;;) {
-        var c = n.delegate;
-        if (c) {
-          var u = maybeInvokeDelegate(c, n);
-          if (u) {
-            if (u === y) continue;
-            return u;
-          }
-        }
-        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
-          if (o === h) throw o = s, n.arg;
-          n.dispatchException(n.arg);
-        } else "return" === n.method && n.abrupt("return", n.arg);
-        o = f;
-        var p = tryCatch(e, r, n);
-        if ("normal" === p.type) {
-          if (o = n.done ? s : l, p.arg === y) continue;
-          return {
-            value: p.arg,
-            done: n.done
-          };
-        }
-        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
-      }
-    };
-  }
-  function maybeInvokeDelegate(e, r) {
-    var n = r.method,
-      o = e.iterator[n];
-    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
-    var i = tryCatch(o, e.iterator, r.arg);
-    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
-    var a = i.arg;
-    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
-  }
-  function pushTryEntry(t) {
-    var e = {
-      tryLoc: t[0]
-    };
-    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
-  }
-  function resetTryEntry(t) {
-    var e = t.completion || {};
-    e.type = "normal", delete e.arg, t.completion = e;
-  }
-  function Context(t) {
-    this.tryEntries = [{
-      tryLoc: "root"
-    }], t.forEach(pushTryEntry, this), this.reset(!0);
-  }
-  function values(e) {
-    if (e || "" === e) {
-      var r = e[a];
-      if (r) return r.call(e);
-      if ("function" == typeof e.next) return e;
-      if (!isNaN(e.length)) {
-        var o = -1,
-          i = function next() {
-            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
-            return next.value = t, next.done = !0, next;
-          };
-        return i.next = i;
-      }
-    }
-    throw new TypeError(typeof e + " is not iterable");
-  }
-  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
-    value: GeneratorFunctionPrototype,
-    configurable: !0
-  }), o(GeneratorFunctionPrototype, "constructor", {
-    value: GeneratorFunction,
-    configurable: !0
-  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
-    var e = "function" == typeof t && t.constructor;
-    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
-  }, e.mark = function (t) {
-    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
-  }, e.awrap = function (t) {
-    return {
-      __await: t
-    };
-  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
-    return this;
-  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
-    void 0 === i && (i = Promise);
-    var a = new AsyncIterator(wrap(t, r, n, o), i);
-    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
-      return t.done ? t.value : a.next();
-    });
-  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
-    return this;
-  }), define(g, "toString", function () {
-    return "[object Generator]";
-  }), e.keys = function (t) {
-    var e = Object(t),
-      r = [];
-    for (var n in e) r.push(n);
-    return r.reverse(), function next() {
-      for (; r.length;) {
-        var t = r.pop();
-        if (t in e) return next.value = t, next.done = !1, next;
-      }
-      return next.done = !0, next;
-    };
-  }, e.values = values, Context.prototype = {
-    constructor: Context,
-    reset: function (e) {
-      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
-    },
-    stop: function () {
-      this.done = !0;
-      var t = this.tryEntries[0].completion;
-      if ("throw" === t.type) throw t.arg;
-      return this.rval;
-    },
-    dispatchException: function (e) {
-      if (this.done) throw e;
-      var r = this;
-      function handle(n, o) {
-        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
-      }
-      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
-        var i = this.tryEntries[o],
-          a = i.completion;
-        if ("root" === i.tryLoc) return handle("end");
-        if (i.tryLoc <= this.prev) {
-          var c = n.call(i, "catchLoc"),
-            u = n.call(i, "finallyLoc");
-          if (c && u) {
-            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
-            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
-          } else if (c) {
-            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
-          } else {
-            if (!u) throw Error("try statement without catch or finally");
-            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
-          }
-        }
-      }
-    },
-    abrupt: function (t, e) {
-      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
-        var o = this.tryEntries[r];
-        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
-          var i = o;
-          break;
-        }
-      }
-      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
-      var a = i ? i.completion : {};
-      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
-    },
-    complete: function (t, e) {
-      if ("throw" === t.type) throw t.arg;
-      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
-    },
-    finish: function (t) {
-      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-        var r = this.tryEntries[e];
-        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
-      }
-    },
-    catch: function (t) {
-      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-        var r = this.tryEntries[e];
-        if (r.tryLoc === t) {
-          var n = r.completion;
-          if ("throw" === n.type) {
-            var o = n.arg;
-            resetTryEntry(r);
-          }
-          return o;
-        }
-      }
-      throw Error("illegal catch attempt");
-    },
-    delegateYield: function (e, r, n) {
-      return this.delegate = {
-        iterator: values(e),
-        resultName: r,
-        nextLoc: n
-      }, "next" === this.method && (this.arg = t), y;
-    }
-  }, e;
-}
-function _setPrototypeOf(t, e) {
-  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
-    return t.__proto__ = e, t;
-  }, _setPrototypeOf(t, e);
-}
-function _slicedToArray$1(r, e) {
-  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
-}
-function _toPrimitive(t, r) {
-  if ("object" != typeof t || !t) return t;
-  var e = t[Symbol.toPrimitive];
-  if (void 0 !== e) {
-    var i = e.call(t, r || "default");
-    if ("object" != typeof i) return i;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
-  }
-  return ("string" === r ? String : Number)(t);
-}
-function _toPropertyKey(t) {
-  var i = _toPrimitive(t, "string");
-  return "symbol" == typeof i ? i : i + "";
-}
-function _typeof$1(o) {
-  "@babel/helpers - typeof";
-
-  return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
-    return typeof o;
-  } : function (o) {
-    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-  }, _typeof$1(o);
+ * @returns {boolean} Returns `true` if `value` is a string, else `false`.
+ * @example
+ *
+ * _.isString('abc');
+ * // => true
+ *
+ * _.isString(1);
+ * // => false
+ */
+function isString(value) {
+  return typeof value == 'string' || !isArray$1(value) && isObjectLike$1(value) && baseGetTag$1(value) == stringTag;
 }
-function _unsupportedIterableToArray(r, a) {
-  if (r) {
-    if ("string" == typeof r) return _arrayLikeToArray(r, a);
-    var t = {}.toString.call(r).slice(8, -1);
-    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+var isString_1 = isString;
+var isString$1 = /*@__PURE__*/getDefaultExportFromCjs(isString_1);
+
+class AbortError extends Error {
+  constructor() {
+    super('Throttled function aborted');
+    this.name = 'AbortError';
   }
 }
-function _wrapRegExp() {
-  _wrapRegExp = function (e, r) {
-    return new BabelRegExp(e, void 0, r);
-  };
-  var e = RegExp.prototype,
-    r = new WeakMap();
-  function BabelRegExp(e, t, p) {
-    var o = RegExp(e, t);
-    return r.set(o, p || r.get(e)), _setPrototypeOf(o, BabelRegExp.prototype);
+function pThrottle({
+  limit,
+  interval,
+  strict,
+  onDelay
+}) {
+  if (!Number.isFinite(limit)) {
+    throw new TypeError('Expected `limit` to be a finite number');
   }
-  function buildGroups(e, t) {
-    var p = r.get(t);
-    return Object.keys(p).reduce(function (r, t) {
-      var o = p[t];
-      if ("number" == typeof o) r[t] = e[o];else {
-        for (var i = 0; void 0 === e[o[i]] && i + 1 < o.length;) i++;
-        r[t] = e[o[i]];
-      }
-      return r;
-    }, Object.create(null));
+  if (!Number.isFinite(interval)) {
+    throw new TypeError('Expected `interval` to be a finite number');
   }
-  return _inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (r) {
-    var t = e.exec.call(this, r);
-    if (t) {
-      t.groups = buildGroups(t, this);
-      var p = t.indices;
-      p && (p.groups = buildGroups(p, this));
+  const queue = new Map();
+  let currentTick = 0;
+  let activeCount = 0;
+  function windowedDelay() {
+    const now = Date.now();
+    if (now - currentTick > interval) {
+      activeCount = 1;
+      currentTick = now;
+      return 0;
     }
-    return t;
-  }, BabelRegExp.prototype[Symbol.replace] = function (t, p) {
-    if ("string" == typeof p) {
-      var o = r.get(this);
-      return e[Symbol.replace].call(this, t, p.replace(/\$<([^>]+)>/g, function (e, r) {
-        var t = o[r];
-        return "$" + (Array.isArray(t) ? t.join("$") : t);
-      }));
+    if (activeCount < limit) {
+      activeCount++;
+    } else {
+      currentTick += interval;
+      activeCount = 1;
     }
-    if ("function" == typeof p) {
-      var i = this;
-      return e[Symbol.replace].call(this, t, function () {
-        var e = arguments;
-        return "object" != typeof e[e.length - 1] && (e = [].slice.call(e)).push(buildGroups(e, i)), p.apply(this, e);
-      });
+    return currentTick - now;
+  }
+  const strictTicks = [];
+  function strictDelay() {
+    const now = Date.now();
+
+    // Clear the queue if there's a significant delay since the last execution
+    if (strictTicks.length > 0 && now - strictTicks.at(-1) > interval) {
+      strictTicks.length = 0;
     }
-    return e[Symbol.replace].call(this, t, p);
-  }, _wrapRegExp.apply(this, arguments);
-}
-function asyncToken(instance, getToken) {
-  instance.interceptors.request.use(function (config) {
-    return getToken().then(function (accessToken) {
-      config.headers.set('Authorization', "Bearer ".concat(accessToken));
-      return config;
-    });
-  });
-}
-function isNode() {
-  /**
-   * Polyfills of 'process' might set process.browser === true
-   *
-   * See:
-   * https://github.com/webpack/node-libs-browser/blob/master/mock/process.js#L8
-   * https://github.com/defunctzombie/node-process/blob/master/browser.js#L156
-   **/
-  return typeof process !== 'undefined' && !process.browser;
-}
-function isReactNative() {
-  return typeof window !== 'undefined' && 'navigator' in window && 'product' in window.navigator && window.navigator.product === 'ReactNative';
-}
-function getNodeVersion() {
-  return process.versions && process.versions.node ? "v".concat(process.versions.node) : process.version;
-}
-function getWindow() {
-  return window;
-}
-function noop() {
-  return undefined;
-}
-var delay = function delay(ms) {
-  return new Promise(function (resolve) {
-    setTimeout(resolve, ms);
-  });
-};
-var defaultWait = function defaultWait(attempts) {
-  return Math.pow(Math.SQRT2, attempts);
-};
-function rateLimit(instance) {
-  var maxRetry = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;
-  var _instance$defaults = instance.defaults,
-    _instance$defaults$re = _instance$defaults.responseLogger,
-    responseLogger = _instance$defaults$re === void 0 ? noop : _instance$defaults$re,
-    _instance$defaults$re2 = _instance$defaults.requestLogger,
-    requestLogger = _instance$defaults$re2 === void 0 ? noop : _instance$defaults$re2;
-  instance.interceptors.request.use(function (config) {
-    requestLogger(config);
-    return config;
-  }, function (error) {
-    requestLogger(error);
-    return Promise.reject(error);
-  });
-  instance.interceptors.response.use(function (response) {
-    // we don't need to do anything here
-    responseLogger(response);
-    return response;
-  }, /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(error) {
-      var response, config, doneAttempts, retryErrorType, wait;
-      return _regeneratorRuntime().wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            response = error.response;
-            config = error.config;
-            responseLogger(error);
-            // Do not retry if it is disabled or no request config exists (not an axios error)
-            if (!(!config || !instance.defaults.retryOnError)) {
-              _context.next = 5;
-              break;
-            }
-            return _context.abrupt("return", Promise.reject(error));
-          case 5:
-            // Retried already for max attempts
-            doneAttempts = config.attempts || 1;
-            if (!(doneAttempts > maxRetry)) {
-              _context.next = 9;
-              break;
-            }
-            error.attempts = config.attempts;
-            return _context.abrupt("return", Promise.reject(error));
-          case 9:
-            retryErrorType = null;
-            wait = defaultWait(doneAttempts); // Errors without response did not receive anything from the server
-            if (!response) {
-              retryErrorType = 'Connection';
-            } else if (response.status >= 500 && response.status < 600) {
-              // 5** errors are server related
-              retryErrorType = "Server ".concat(response.status);
-            } else if (response.status === 429) {
-              // 429 errors are exceeded rate limit exceptions
-              retryErrorType = 'Rate limit';
-              // all headers are lowercased by axios https://github.com/mzabriskie/axios/issues/413
-              if (response.headers && error.response.headers['x-contentful-ratelimit-reset']) {
-                wait = response.headers['x-contentful-ratelimit-reset'];
-              }
-            }
-            if (!retryErrorType) {
-              _context.next = 19;
-              break;
-            }
-            // convert to ms and add jitter
-            wait = Math.floor(wait * 1000 + Math.random() * 200 + 500);
-            instance.defaults.logHandler('warning', "".concat(retryErrorType, " error occurred. Waiting for ").concat(wait, " ms before retrying..."));
-
-            // increase attempts counter
-            config.attempts = doneAttempts + 1;
-
-            /* Somehow between the interceptor and retrying the request the httpAgent/httpsAgent gets transformed from an Agent-like object
-             to a regular object, causing failures on retries after rate limits. Removing these properties here fixes the error, but retry
-             requests still use the original http/httpsAgent property */
-            delete config.httpAgent;
-            delete config.httpsAgent;
-            return _context.abrupt("return", delay(wait).then(function () {
-              return instance(config);
-            }));
-          case 19:
-            return _context.abrupt("return", Promise.reject(error));
-          case 20:
-          case "end":
-            return _context.stop();
+
+    // If the queue is not full, add the current time and execute immediately
+    if (strictTicks.length < limit) {
+      strictTicks.push(now);
+      return 0;
+    }
+
+    // Calculate the next execution time based on the first item in the queue
+    const nextExecutionTime = strictTicks[0] + interval;
+
+    // Shift the queue and add the new execution time
+    strictTicks.shift();
+    strictTicks.push(nextExecutionTime);
+
+    // Calculate the delay for the current execution
+    return Math.max(0, nextExecutionTime - now);
+  }
+  const getDelay = strict ? strictDelay : windowedDelay;
+  return function_ => {
+    const throttled = function (...arguments_) {
+      if (!throttled.isEnabled) {
+        return (async () => function_.apply(this, arguments_))();
+      }
+      let timeoutId;
+      return new Promise((resolve, reject) => {
+        const execute = () => {
+          resolve(function_.apply(this, arguments_));
+          queue.delete(timeoutId);
+        };
+        const delay = getDelay();
+        if (delay > 0) {
+          timeoutId = setTimeout(execute, delay);
+          queue.set(timeoutId, reject);
+          onDelay === null || onDelay === void 0 || onDelay(...arguments_);
+        } else {
+          execute();
         }
-      }, _callee);
-    }));
-    return function (_x) {
-      return _ref.apply(this, arguments);
+      });
+    };
+    throttled.abort = () => {
+      for (const timeout of queue.keys()) {
+        clearTimeout(timeout);
+        queue.get(timeout)(new AbortError());
+      }
+      queue.clear();
+      strictTicks.splice(0, strictTicks.length);
     };
-  }());
+    throttled.isEnabled = true;
+    Object.defineProperty(throttled, 'queueSize', {
+      get() {
+        return queue.size;
+      }
+    });
+    return throttled;
+  };
 }
-var PERCENTAGE_REGEX = /*#__PURE__*/_wrapRegExp(/(\d+)(%)/, {
+
+const PERCENTAGE_REGEX = /*#__PURE__*/_wrapRegExp(/(\d+)(%)/, {
   value: 1
 });
-function calculateLimit(type) {
-  var max = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 7;
-  var limit = max;
+function calculateLimit(type, max = 7) {
+  let limit = max;
   if (PERCENTAGE_REGEX.test(type)) {
     var _type$match;
-    var groups = (_type$match = type.match(PERCENTAGE_REGEX)) === null || _type$match === void 0 ? void 0 : _type$match.groups;
+    const groups = (_type$match = type.match(PERCENTAGE_REGEX)) === null || _type$match === void 0 ? void 0 : _type$match.groups;
     if (groups && groups.value) {
-      var percentage = parseInt(groups.value) / 100;
+      const percentage = parseInt(groups.value) / 100;
       limit = Math.round(max * percentage);
     }
   }
   return Math.min(30, Math.max(1, limit));
 }
 function createThrottle(limit, logger) {
-  logger('info', "Throttle request to ".concat(limit, "/s"));
-  return pThrottle$1({
-    limit: limit,
+  logger('info', `Throttle request to ${limit}/s`);
+  return pThrottle({
+    limit,
     interval: 1000,
     strict: false
   });
 }
-var rateLimitThrottle = function (axiosInstance) {
-  var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'auto';
-  var _axiosInstance$defaul = axiosInstance.defaults.logHandler,
-    logHandler = _axiosInstance$defaul === void 0 ? noop : _axiosInstance$defaul;
-  var limit = isString$1(type) ? calculateLimit(type) : calculateLimit('auto', type);
-  var throttle = createThrottle(limit, logHandler);
-  var isCalculated = false;
-  var requestInterceptorId = axiosInstance.interceptors.request.use(function (config) {
-    return throttle(function () {
-      return config;
-    })();
+var rateLimitThrottle = (axiosInstance, type = 'auto') => {
+  const {
+    logHandler = noop
+  } = axiosInstance.defaults;
+  let limit = isString$1(type) ? calculateLimit(type) : calculateLimit('auto', type);
+  let throttle = createThrottle(limit, logHandler);
+  let isCalculated = false;
+  let requestInterceptorId = axiosInstance.interceptors.request.use(config => {
+    return throttle(() => config)();
   }, function (error) {
     return Promise.reject(error);
   });
-  var responseInterceptorId = axiosInstance.interceptors.response.use(function (response) {
+  const responseInterceptorId = axiosInstance.interceptors.response.use(response => {
     if (!isCalculated && isString$1(type) && (type === 'auto' || PERCENTAGE_REGEX.test(type)) && response.headers && response.headers['x-contentful-ratelimit-second-limit']) {
-      var rawLimit = parseInt(response.headers['x-contentful-ratelimit-second-limit']);
-      var nextLimit = calculateLimit(type, rawLimit);
+      const rawLimit = parseInt(response.headers['x-contentful-ratelimit-second-limit']);
+      const nextLimit = calculateLimit(type, rawLimit);
       if (nextLimit !== limit) {
         if (requestInterceptorId) {
           axiosInstance.interceptors.request.eject(requestInterceptorId);
         }
         limit = nextLimit;
         throttle = createThrottle(nextLimit, logHandler);
-        requestInterceptorId = axiosInstance.interceptors.request.use(function (config) {
-          return throttle(function () {
-            return config;
-          })();
+        requestInterceptorId = axiosInstance.interceptors.request.use(config => {
+          return throttle(() => config)();
         }, function (error) {
           return Promise.reject(error);
         });
@@ -21380,7 +20908,7 @@ var rateLimitThrottle = function (axiosInstance) {
   }, function (error) {
     return Promise.reject(error);
   });
-  return function () {
+  return () => {
     axiosInstance.interceptors.request.eject(requestInterceptorId);
     axiosInstance.interceptors.response.eject(responseInterceptorId);
   };
@@ -21388,8 +20916,14 @@ var rateLimitThrottle = function (axiosInstance) {
 
 // Matches 'sub.host:port' or 'host:port' and extracts hostname and port
 // Also enforces toplevel domain specified, no spaces and no protocol
-var HOST_REGEX = /^(?!\w+:\/\/)([^\s:]+\.?[^\s:]+)(?::(\d+))?(?!:)$/;
-
+const HOST_REGEX = /^(?!\w+:\/\/)([^\s:]+\.?[^\s:]+)(?::(\d+))?(?!:)$/;
+function copyHttpClientParams(options) {
+  const copiedOptions = index(options);
+  // httpAgent and httpsAgent cannot be copied because they can contain private fields
+  copiedOptions.httpAgent = options.httpAgent;
+  copiedOptions.httpsAgent = options.httpsAgent;
+  return copiedOptions;
+}
 /**
  * Create pre-configured axios instance
  * @private
@@ -21398,20 +20932,18 @@ var HOST_REGEX = /^(?!\w+:\/\/)([^\s:]+\.?[^\s:]+)(?::(\d+))?(?!:)$/;
  * @return {AxiosInstance} Initialized axios instance
  */
 function createHttpClient(axios, options) {
-  var defaultConfig = {
+  const defaultConfig = {
     insecure: false,
     retryOnError: true,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    logHandler: function logHandler(level, data) {
+    logHandler: (level, data) => {
       if (level === 'error' && data) {
-        var title = [data.name, data.message].filter(function (a) {
-          return a;
-        }).join(' - ');
-        console.error("[error] ".concat(title));
+        const title = [data.name, data.message].filter(a => a).join(' - ');
+        console.error(`[error] ${title}`);
         console.error(data);
         return;
       }
-      console.log("[".concat(level, "] ").concat(data));
+      console.log(`[${level}] ${data}`);
     },
     // Passed to axios
     headers: {},
@@ -21425,40 +20957,36 @@ function createHttpClient(axios, options) {
     // 1GB
     maxBodyLength: 1073741824 // 1GB
   };
-  var config = _objectSpread2(_objectSpread2({}, defaultConfig), options);
+  const config = _objectSpread2(_objectSpread2({}, defaultConfig), options);
   if (!config.accessToken) {
-    var missingAccessTokenError = new TypeError('Expected parameter accessToken');
+    const missingAccessTokenError = new TypeError('Expected parameter accessToken');
     config.logHandler('error', missingAccessTokenError);
     throw missingAccessTokenError;
   }
-
   // Construct axios baseURL option
-  var protocol = config.insecure ? 'http' : 'https';
-  var space = config.space ? "".concat(config.space, "/") : '';
-  var hostname = config.defaultHostname;
-  var port = config.insecure ? 80 : 443;
+  const protocol = config.insecure ? 'http' : 'https';
+  const space = config.space ? `${config.space}/` : '';
+  let hostname = config.defaultHostname;
+  let port = config.insecure ? 80 : 443;
   if (config.host && HOST_REGEX.test(config.host)) {
-    var parsed = config.host.split(':');
+    const parsed = config.host.split(':');
     if (parsed.length === 2) {
-      var _parsed = _slicedToArray$1(parsed, 2);
-      hostname = _parsed[0];
-      port = _parsed[1];
+      [hostname, port] = parsed;
     } else {
       hostname = parsed[0];
     }
   }
-
   // Ensure that basePath does start but not end with a slash
   if (config.basePath) {
-    config.basePath = "/".concat(config.basePath.split('/').filter(Boolean).join('/'));
+    config.basePath = `/${config.basePath.split('/').filter(Boolean).join('/')}`;
   }
-  var baseURL = options.baseURL || "".concat(protocol, "://").concat(hostname, ":").concat(port).concat(config.basePath, "/spaces/").concat(space);
+  const baseURL = options.baseURL || `${protocol}://${hostname}:${port}${config.basePath}/spaces/${space}`;
   if (!config.headers.Authorization && typeof config.accessToken !== 'function') {
     config.headers.Authorization = 'Bearer ' + config.accessToken;
   }
-  var axiosOptions = {
+  const axiosOptions = {
     // Axios
-    baseURL: baseURL,
+    baseURL,
     headers: config.headers,
     httpAgent: config.httpAgent,
     httpsAgent: config.httpsAgent,
@@ -21468,7 +20996,7 @@ function createHttpClient(axios, options) {
     maxContentLength: config.maxContentLength,
     maxBodyLength: config.maxBodyLength,
     paramsSerializer: {
-      serialize: function serialize(params) {
+      serialize: params => {
         return qs.stringify(params);
       }
     },
@@ -21478,9 +21006,8 @@ function createHttpClient(axios, options) {
     requestLogger: config.requestLogger,
     retryOnError: config.retryOnError
   };
-  var instance = axios.create(axiosOptions);
+  const instance = axios.create(axiosOptions);
   instance.httpClientParams = options;
-
   /**
    * Creates a new axios instance with the same default base parameters as the
    * current one, and with any overrides passed to the newParams object
@@ -21492,14 +21019,12 @@ function createHttpClient(axios, options) {
    * @return {AxiosInstance} Initialized axios instance
    */
   instance.cloneWithNewParams = function (newParams) {
-    return createHttpClient(axios, _objectSpread2(_objectSpread2({}, copy$1(options)), newParams));
+    return createHttpClient(axios, _objectSpread2(_objectSpread2({}, copyHttpClientParams(options)), newParams));
   };
-
   /**
    * Apply interceptors.
    * Please note that the order of interceptors is important
    */
-
   if (config.onBeforeRequest) {
     instance.interceptors.request.use(config.onBeforeRequest);
   }
@@ -21511,46 +21036,34 @@ function createHttpClient(axios, options) {
   }
   rateLimit(instance, config.retryLimit);
   if (config.onError) {
-    instance.interceptors.response.use(function (response) {
-      return response;
-    }, config.onError);
+    instance.interceptors.response.use(response => response, config.onError);
   }
   return instance;
 }
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
 /**
  * Creates request parameters configuration by parsing an existing query object
  * @private
  * @param {Object} query
  * @return {Object} Config object with `params` property, ready to be used in axios
  */
-function createRequestConfig(_ref) {
-  var query = _ref.query;
-  var config = {};
+function createRequestConfig({
+  query
+}) {
+  const config = {};
   delete query.resolveLinks;
-  config.params = copy$1(query);
+  config.params = index(query);
   return config;
 }
 
 // copied from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
-
 function deepFreeze(object) {
-  var propNames = Object.getOwnPropertyNames(object);
-  var _iterator = _createForOfIteratorHelper(propNames),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var name = _step.value;
-      var value = object[name];
-      if (value && _typeof$1(value) === 'object') {
-        deepFreeze(value);
-      }
+  const propNames = Object.getOwnPropertyNames(object);
+  for (const name of propNames) {
+    const value = object[name];
+    if (value && typeof value === 'object') {
+      deepFreeze(value);
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
   return Object.freeze(object);
 }
@@ -21558,17 +21071,18 @@ function freezeSys(obj) {
   deepFreeze(obj.sys || {});
   return obj;
 }
+
 function getBrowserOS() {
-  var win = getWindow();
+  const win = getWindow();
   if (!win) {
     return null;
   }
-  var userAgent = win.navigator.userAgent;
+  const userAgent = win.navigator.userAgent;
   // TODO: platform is deprecated.
-  var platform = win.navigator.platform;
-  var macosPlatforms = ['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'];
-  var windowsPlatforms = ['Win32', 'Win64', 'Windows', 'WinCE'];
-  var iosPlatforms = ['iPhone', 'iPad', 'iPod'];
+  const platform = win.navigator.platform;
+  const macosPlatforms = ['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'];
+  const windowsPlatforms = ['Win32', 'Win64', 'Windows', 'WinCE'];
+  const iosPlatforms = ['iPhone', 'iPad', 'iPod'];
   if (macosPlatforms.indexOf(platform) !== -1) {
     return 'macOS';
   } else if (iosPlatforms.indexOf(platform) !== -1) {
@@ -21583,9 +21097,9 @@ function getBrowserOS() {
   return null;
 }
 function getNodeOS() {
-  var platform = process.platform || 'linux';
-  var version = process.version || '0.0.0';
-  var platformMap = {
+  const platform = process$1.platform || 'linux';
+  const version = process$1.version || '0.0.0';
+  const platformMap = {
     android: 'Android',
     aix: 'Linux',
     darwin: 'macOS',
@@ -21596,27 +21110,27 @@ function getNodeOS() {
     win32: 'Windows'
   };
   if (platform in platformMap) {
-    return "".concat(platformMap[platform] || 'Linux', "/").concat(version);
+    return `${platformMap[platform] || 'Linux'}/${version}`;
   }
   return null;
 }
 function getUserAgentHeader(sdk, application, integration, feature) {
-  var headerParts = [];
+  const headerParts = [];
   if (application) {
-    headerParts.push("app ".concat(application));
+    headerParts.push(`app ${application}`);
   }
   if (integration) {
-    headerParts.push("integration ".concat(integration));
+    headerParts.push(`integration ${integration}`);
   }
-  headerParts.push("sdk ".concat(sdk));
-  var platform = null;
+  headerParts.push(`sdk ${sdk}`);
+  let platform = null;
   try {
     if (isReactNative()) {
       platform = getBrowserOS();
       headerParts.push('platform ReactNative');
     } else if (isNode()) {
       platform = getNodeOS();
-      headerParts.push("platform node.js/".concat(getNodeVersion()));
+      headerParts.push(`platform node.js/${getNodeVersion()}`);
     } else {
       platform = getBrowserOS();
       headerParts.push('platform browser');
@@ -21625,11 +21139,9 @@ function getUserAgentHeader(sdk, application, integration, feature) {
     platform = null;
   }
   if (platform) {
-    headerParts.push("os ".concat(platform));
+    headerParts.push(`os ${platform}`);
   }
-  return "".concat(headerParts.filter(function (item) {
-    return item !== '';
-  }).join('; '), ";");
+  return `${headerParts.filter(item => item !== '').join('; ')};`;
 }
 
 /**
@@ -21645,12 +21157,95 @@ function toPlainObject(data) {
     enumerable: false,
     configurable: false,
     writable: false,
-    value: function value() {
-      return copy$1(this);
+    value: function () {
+      return index(this);
     }
   });
 }
 
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg$1(func, transform) {
+  return function (arg) {
+    return func(transform(arg));
+  };
+}
+var _overArg = overArg$1;
+
+var overArg = _overArg;
+
+/** Built-in value references. */
+var getPrototype$1 = overArg(Object.getPrototypeOf, Object);
+var _getPrototype = getPrototype$1;
+
+var baseGetTag = _baseGetTag,
+  getPrototype = _getPrototype,
+  isObjectLike = isObjectLike_1;
+
+/** `Object#toString` result references. */
+var objectTag = '[object Object]';
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+  objectProto = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$1 = objectProto.hasOwnProperty;
+
+/** Used to infer the `Object` constructor. */
+var objectCtorString = funcToString.call(Object);
+
+/**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.8.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ * }
+ *
+ * _.isPlainObject(new Foo);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ *
+ * _.isPlainObject(Object.create(null));
+ * // => true
+ */
+function isPlainObject(value) {
+  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
+    return false;
+  }
+  var proto = getPrototype(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty$1.call(proto, 'constructor') && proto.constructor;
+  return typeof Ctor == 'function' && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
+}
+var isPlainObject_1 = isPlainObject;
+var isPlainObject$1 = /*@__PURE__*/getDefaultExportFromCjs(isPlainObject_1);
+
 /**
  * Handles errors received from the server. Parses the error into a more useful
  * format, places it in an exception and throws it.
@@ -21660,20 +21255,21 @@ function toPlainObject(data) {
  * @private
  */
 function errorHandler(errorResponse) {
-  var config = errorResponse.config,
-    response = errorResponse.response;
-  var errorName;
-
+  const {
+    config,
+    response
+  } = errorResponse;
+  let errorName;
   // Obscure the Management token
   if (config && config.headers && config.headers['Authorization']) {
-    var token = "...".concat(config.headers['Authorization'].toString().substr(-5));
-    config.headers['Authorization'] = "Bearer ".concat(token);
+    const token = `...${config.headers['Authorization'].toString().substr(-5)}`;
+    config.headers['Authorization'] = `Bearer ${token}`;
   }
   if (!isPlainObject$1(response) || !isPlainObject$1(config)) {
     throw errorResponse;
   }
-  var data = response === null || response === void 0 ? void 0 : response.data;
-  var errorData = {
+  const data = response === null || response === void 0 ? void 0 : response.data;
+  const errorData = {
     status: response === null || response === void 0 ? void 0 : response.status,
     statusText: response === null || response === void 0 ? void 0 : response.statusText,
     message: '',
@@ -21687,7 +21283,7 @@ function errorHandler(errorResponse) {
       payloadData: config.data
     };
   }
-  if (data && _typeof$1(data) === 'object') {
+  if (data && typeof data === 'object') {
     var _data$sys;
     if ('requestId' in data) {
       errorData.requestId = data.requestId || 'UNKNOWN';
@@ -21700,8 +21296,8 @@ function errorHandler(errorResponse) {
     }
     errorName = (_data$sys = data.sys) === null || _data$sys === void 0 ? void 0 : _data$sys.id;
   }
-  var error = new Error();
-  error.name = errorName && errorName !== 'Unknown' ? errorName : "".concat(response === null || response === void 0 ? void 0 : response.status, " ").concat(response === null || response === void 0 ? void 0 : response.statusText);
+  const error = new Error();
+  error.name = errorName && errorName !== 'Unknown' ? errorName : `${response === null || response === void 0 ? void 0 : response.status} ${response === null || response === void 0 ? void 0 : response.statusText}`;
   try {
     error.message = JSON.stringify(errorData, null, '  ');
   } catch (_unused) {
@@ -23319,7 +22915,7 @@ function createContentfulApi({
     http.defaults.baseURL = getGlobalOptions().environmentBaseUrl;
   }
   return {
-    version: "11.2.2",
+    version: "11.2.3",
     getSpace,
     getContentType,
     getContentTypes,
@@ -23438,7 +23034,7 @@ function createClient(params) {
     environment: 'master'
   };
   const config = Object.assign(Object.assign({}, defaultConfig), params);
-  const userAgentHeader = getUserAgentHeader(`contentful.js/${"11.2.2"}`, config.application, config.integration);
+  const userAgentHeader = getUserAgentHeader(`contentful.js/${"11.2.3"}`, config.application, config.integration);
   config.headers = Object.assign(Object.assign({}, config.headers), {
     'Content-Type': 'application/vnd.contentful.delivery.v1+json',
     'X-Contentful-User-Agent': userAgentHeader