contentful-management 10.21.2 → 10.21.3

package/dist/contentful-management.browser.js

@@ -2855,7 +2855,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "freezeSys", function() { return freezeSys; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getUserAgentHeader", function() { return getUserAgentHeader; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toPlainObject", function() { return toPlainObject; });
-/* harmony import */ var fast_copy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! fast-copy */ "../node_modules/fast-copy/dist/fast-copy.js");
+/* harmony import */ var fast_copy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! fast-copy */ "../node_modules/contentful-sdk-core/node_modules/fast-copy/dist/fast-copy.js");
 /* harmony import */ var fast_copy__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fast_copy__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var qs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! qs */ "../node_modules/qs/lib/index.js");
 /* harmony import */ var qs__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(qs__WEBPACK_IMPORTED_MODULE_1__);
@@ -2873,17 +2873,14 @@ __webpack_require__.r(__webpack_exports__);
 
 function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
-
   if (Object.getOwnPropertySymbols) {
     var symbols = Object.getOwnPropertySymbols(object);
     enumerableOnly && (symbols = symbols.filter(function (sym) {
       return Object.getOwnPropertyDescriptor(object, sym).enumerable;
     })), keys.push.apply(keys, symbols);
   }
-
   return keys;
 }
-
 function _objectSpread2(target) {
   for (var i = 1; i < arguments.length; i++) {
     var source = null != arguments[i] ? arguments[i] : {};
@@ -2893,10 +2890,8 @@ function _objectSpread2(target) {
       Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
     });
   }
-
   return target;
 }
-
 function _typeof(obj) {
   "@babel/helpers - typeof";
 
@@ -2906,55 +2901,47 @@ function _typeof(obj) {
     return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
   }, _typeof(obj);
 }
-
 function _wrapRegExp() {
   _wrapRegExp = function (re, groups) {
     return new BabelRegExp(re, void 0, groups);
   };
-
   var _super = RegExp.prototype,
-      _groups = new WeakMap();
-
+    _groups = new WeakMap();
   function BabelRegExp(re, flags, groups) {
     var _this = new RegExp(re, flags);
-
     return _groups.set(_this, groups || _groups.get(re)), _setPrototypeOf(_this, BabelRegExp.prototype);
   }
-
   function buildGroups(result, re) {
     var g = _groups.get(re);
-
     return Object.keys(g).reduce(function (groups, name) {
-      return groups[name] = result[g[name]], groups;
+      var i = g[name];
+      if ("number" == typeof i) groups[name] = result[i];else {
+        for (var k = 0; void 0 === result[i[k]] && k + 1 < i.length;) k++;
+        groups[name] = result[i[k]];
+      }
+      return groups;
     }, Object.create(null));
   }
-
   return _inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (str) {
     var result = _super.exec.call(this, str);
-
     return result && (result.groups = buildGroups(result, this)), result;
   }, BabelRegExp.prototype[Symbol.replace] = function (str, substitution) {
     if ("string" == typeof substitution) {
       var groups = _groups.get(this);
-
       return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) {
         return "$" + groups[name];
       }));
     }
-
     if ("function" == typeof substitution) {
       var _this = this;
-
       return _super[Symbol.replace].call(this, str, function () {
         var args = arguments;
         return "object" != typeof args[args.length - 1] && (args = [].slice.call(args)).push(buildGroups(args, _this)), substitution.apply(this, args);
       });
     }
-
     return _super[Symbol.replace].call(this, str, substitution);
   }, _wrapRegExp.apply(this, arguments);
 }
-
 function _defineProperty(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
@@ -2966,15 +2953,12 @@ function _defineProperty(obj, key, value) {
   } else {
     obj[key] = value;
   }
-
   return obj;
 }
-
 function _inherits(subClass, superClass) {
   if (typeof superClass !== "function" && superClass !== null) {
     throw new TypeError("Super expression must either be null or a function");
   }
-
   subClass.prototype = Object.create(superClass && superClass.prototype, {
     constructor: {
       value: subClass,
@@ -2987,38 +2971,29 @@ function _inherits(subClass, superClass) {
   });
   if (superClass) _setPrototypeOf(subClass, superClass);
 }
-
 function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
     o.__proto__ = p;
     return o;
   };
-
   return _setPrototypeOf(o, p);
 }
-
 function _slicedToArray(arr, i) {
   return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 }
-
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
-
 function _iterableToArrayLimit(arr, i) {
   var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-
   if (_i == null) return;
   var _arr = [];
   var _n = true;
   var _d = false;
-
   var _s, _e;
-
   try {
     for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
       _arr.push(_s.value);
-
       if (i && _arr.length === i) break;
     }
   } catch (err) {
@@ -3031,10 +3006,8 @@ function _iterableToArrayLimit(arr, i) {
       if (_d) throw _e;
     }
   }
-
   return _arr;
 }
-
 function _unsupportedIterableToArray(o, minLen) {
   if (!o) return;
   if (typeof o === "string") return _arrayLikeToArray(o, minLen);
@@ -3043,29 +3016,21 @@ function _unsupportedIterableToArray(o, minLen) {
   if (n === "Map" || n === "Set") return Array.from(o);
   if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
 }
-
 function _arrayLikeToArray(arr, len) {
   if (len == null || len > arr.length) len = arr.length;
-
   for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
   return arr2;
 }
-
 function _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 _createForOfIteratorHelper(o, allowArrayLike) {
   var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-
   if (!it) {
     if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
       if (it) o = it;
       var i = 0;
-
       var F = function () {};
-
       return {
         s: F,
         n: function () {
@@ -3083,13 +3048,11 @@ function _createForOfIteratorHelper(o, allowArrayLike) {
         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 normalCompletion = true,
-      didErr = false,
-      err;
+    didErr = false,
+    err;
   return {
     s: function () {
       it = it.call(o);
@@ -3139,25 +3102,19 @@ function noop() {
 var PERCENTAGE_REGEX = /*#__PURE__*/_wrapRegExp(/(\d+)(%)/, {
   value: 1
 });
-
 function calculateLimit(type) {
   var max = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 7;
   var 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;
-
     if (groups && groups.value) {
       var 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 p_throttle__WEBPACK_IMPORTED_MODULE_3___default()({
@@ -3166,11 +3123,10 @@ function createThrottle(limit, logger) {
     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;
+    logHandler = _axiosInstance$defaul === void 0 ? noop : _axiosInstance$defaul;
   var limit = lodash_isstring__WEBPACK_IMPORTED_MODULE_2___default()(type) ? calculateLimit(type) : calculateLimit('auto', type);
   var throttle = createThrottle(limit, logHandler);
   var isCalculated = false;
@@ -3185,12 +3141,10 @@ var rateLimitThrottle = (function (axiosInstance) {
     if (!isCalculated && lodash_isstring__WEBPACK_IMPORTED_MODULE_2___default()(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);
-
       if (nextLimit !== limit) {
         if (requestInterceptorId) {
           axiosInstance.interceptors.request.eject(requestInterceptorId);
         }
-
         limit = nextLimit;
         throttle = createThrottle(nextLimit, logHandler);
         requestInterceptorId = axiosInstance.interceptors.request.use(function (config) {
@@ -3201,10 +3155,8 @@ var rateLimitThrottle = (function (axiosInstance) {
           return Promise.reject(error);
         });
       }
-
       isCalculated = true;
     }
-
     return response;
   }, function (error) {
     return Promise.reject(error);
@@ -3220,18 +3172,16 @@ var delay = function delay(ms) {
     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$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;
@@ -3246,23 +3196,22 @@ function rateLimit(instance) {
   }, function (error) {
     var response = error.response;
     var config = error.config;
-    responseLogger(error); // Do not retry if it is disabled or no request config exists (not an axios 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);
-    } // Retried already for max attempts
-
+    }
 
+    // Retried already for max attempts
     var doneAttempts = config.attempts || 1;
-
     if (doneAttempts > maxRetry) {
       error.attempts = config.attempts;
       return Promise.reject(error);
     }
-
     var retryErrorType = null;
-    var wait = defaultWait(doneAttempts); // Errors without response did not receive anything from the server
+    var 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) {
@@ -3270,30 +3219,29 @@ function rateLimit(instance) {
       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
-
+      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) {
       // 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
+      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 delay(wait).then(function () {
         return instance(config);
       });
     }
-
     return Promise.reject(error);
   });
 }
@@ -3309,9 +3257,10 @@ function asyncToken(instance, getToken) {
   });
 }
 
+// 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+))?(?!:)$/;
+
 /**
  * Create pre configured axios instance
  * @private
@@ -3319,7 +3268,6 @@ var HOST_REGEX = /^(?!\w+:\/\/)([^\s:]+\.?[^\s:]+)(?::(\d+))?(?!:)$/;
  * @param {CreateHttpClientParams} options - Initialization parameters for the HTTP client
  * @return {ContentfulAxiosInstance} Initialized axios instance
  */
-
 function createHttpClient(axios, options) {
   var defaultConfig = {
     insecure: false,
@@ -3334,7 +3282,6 @@ function createHttpClient(axios, options) {
         console.error(data);
         return;
       }
-
       console.log("[".concat(level, "] ").concat(data));
     },
     // Passed to axios
@@ -3349,56 +3296,47 @@ function createHttpClient(axios, options) {
     maxContentLength: 1073741824,
     // 1GB
     maxBodyLength: 1073741824 // 1GB
-
   };
 
   var config = _objectSpread2(_objectSpread2({}, defaultConfig), options);
-
   if (!config.accessToken) {
     var missingAccessTokenError = new TypeError('Expected parameter accessToken');
     config.logHandler('error', missingAccessTokenError);
     throw missingAccessTokenError;
-  } // Construct axios baseURL option
-
+  }
 
+  // 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;
-
   if (config.host && HOST_REGEX.test(config.host)) {
     var parsed = config.host.split(':');
-
     if (parsed.length === 2) {
-
       var _parsed = _slicedToArray(parsed, 2);
-
       hostname = _parsed[0];
       port = _parsed[1];
     } else {
       hostname = parsed[0];
     }
-  } // Ensure that basePath does start but not end with a slash
-
+  }
 
+  // Ensure that basePath does start but not end with a slash
   if (config.basePath) {
     config.basePath = "/".concat(config.basePath.split('/').filter(Boolean).join('/'));
   }
-
   var baseURL = options.baseURL || "".concat(protocol, "://").concat(hostname, ":").concat(port).concat(config.basePath, "/spaces/").concat(space);
-
   if (!config.headers.Authorization && typeof config.accessToken !== 'function') {
     config.headers.Authorization = 'Bearer ' + config.accessToken;
-  } // Set these headers only for node because browsers don't like it when you
+  }
+
+  // Set these headers only for node because browsers don't like it when you
   // override user-agent or accept-encoding.
   // The SDKs should set their own X-Contentful-User-Agent.
-
-
   if (isNode()) {
     config.headers['user-agent'] = 'node.js/' + getNodeVersion();
     config.headers['Accept-Encoding'] = 'gzip';
   }
-
   var axiosOptions = {
     // Axios
     baseURL: baseURL,
@@ -3419,6 +3357,7 @@ function createHttpClient(axios, options) {
   };
   var 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
@@ -3429,41 +3368,34 @@ function createHttpClient(axios, options) {
    * @param {CreateHttpClientParams} httpClientParams - Initialization parameters for the HTTP client
    * @return {ContentfulAxiosInstance} Initialized axios instance
    */
-
   instance.cloneWithNewParams = function (newParams) {
     return createHttpClient(axios, _objectSpread2(_objectSpread2({}, fast_copy__WEBPACK_IMPORTED_MODULE_0___default()(options)), newParams));
   };
+
   /**
    * Apply interceptors.
    * Please note that the order of interceptors is important
    */
 
-
   if (config.onBeforeRequest) {
     instance.interceptors.request.use(config.onBeforeRequest);
   }
-
   if (typeof config.accessToken === 'function') {
     asyncToken(instance, config.accessToken);
   }
-
   if (config.throttle) {
     rateLimitThrottle(instance, config.throttle);
   }
-
   rateLimit(instance, config.retryLimit);
-
   if (config.onError) {
     instance.interceptors.response.use(function (response) {
       return response;
     }, config.onError);
   }
-
   return instance;
 }
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
-
 /**
  * Creates request parameters configuration by parsing an existing query object
  * @private
@@ -3486,22 +3418,19 @@ function enforceObjPath(obj, path) {
     err.message = "Required property ".concat(path, " missing from:\n\n").concat(JSON.stringify(obj), "\n\n");
     throw err;
   }
-
   return true;
 }
 
 // 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;
-
+    _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var name = _step.value;
       var value = object[name];
-
       if (value && _typeof(value) === 'object') {
         deepFreeze(value);
       }
@@ -3511,10 +3440,8 @@ function deepFreeze(object) {
   } finally {
     _iterator.f();
   }
-
   return Object.freeze(object);
 }
-
 function freezeSys(obj) {
   deepFreeze(obj.sys || {});
   return obj;
@@ -3522,18 +3449,15 @@ function freezeSys(obj) {
 
 function getBrowserOS() {
   var win = getWindow();
-
   if (!win) {
     return null;
   }
-
-  var userAgent = win.navigator.userAgent; // TODO: platform is deprecated.
-
+  var 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'];
-
   if (macosPlatforms.indexOf(platform) !== -1) {
     return 'macOS';
   } else if (iosPlatforms.indexOf(platform) !== -1) {
@@ -3545,10 +3469,8 @@ function getBrowserOS() {
   } else if (/Linux/.test(platform)) {
     return 'Linux';
   }
-
   return null;
 }
-
 function getNodeOS() {
   var platform = process.platform || 'linux';
   var version = process.version || '0.0.0';
@@ -3562,32 +3484,24 @@ function getNodeOS() {
     sunos: 'Linux',
     win32: 'Windows'
   };
-
   if (platform in platformMap) {
     return "".concat(platformMap[platform] || 'Linux', "/").concat(version);
   }
-
   return null;
 }
-
 function getUserAgentHeader(sdk, application, integration, feature) {
   var headerParts = [];
-
   if (application) {
     headerParts.push("app ".concat(application));
   }
-
   if (integration) {
     headerParts.push("integration ".concat(integration));
   }
-
   if (feature) {
     headerParts.push('feature ' + feature);
   }
-
   headerParts.push("sdk ".concat(sdk));
   var platform = null;
-
   try {
     if (isReactNative()) {
       platform = getBrowserOS();
@@ -3602,11 +3516,9 @@ function getUserAgentHeader(sdk, application, integration, feature) {
   } catch (e) {
     platform = null;
   }
-
   if (platform) {
     headerParts.push("os ".concat(platform));
   }
-
   return "".concat(headerParts.filter(function (item) {
     return item !== '';
   }).join('; '), ";");
@@ -3618,7 +3530,6 @@ function getUserAgentHeader(sdk, application, integration, feature) {
  * @param data - Any plain JSON response returned from the API
  * @return Enhanced object with toPlainObject method
  */
-
 function toPlainObject(data) {
   // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   // @ts-expect-error
@@ -3642,18 +3553,17 @@ function toPlainObject(data) {
  */
 function errorHandler(errorResponse) {
   var config = errorResponse.config,
-      response = errorResponse.response;
-  var errorName; // Obscure the Management token
+    response = errorResponse.response;
+  var 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);
   }
-
   if (!lodash_isplainobject__WEBPACK_IMPORTED_MODULE_4___default()(response) || !lodash_isplainobject__WEBPACK_IMPORTED_MODULE_4___default()(config)) {
     throw errorResponse;
   }
-
   var data = response === null || response === void 0 ? void 0 : response.data;
   var errorData = {
     status: response === null || response === void 0 ? void 0 : response.status,
@@ -3661,7 +3571,6 @@ function errorHandler(errorResponse) {
     message: '',
     details: {}
   };
-
   if (lodash_isplainobject__WEBPACK_IMPORTED_MODULE_4___default()(config)) {
     errorData.request = {
       url: config.url,
@@ -3670,38 +3579,30 @@ function errorHandler(errorResponse) {
       payloadData: config.data
     };
   }
-
   if (data && lodash_isplainobject__WEBPACK_IMPORTED_MODULE_4___default()(data)) {
     if ('requestId' in data) {
       errorData.requestId = data.requestId || 'UNKNOWN';
     }
-
     if ('message' in data) {
       errorData.message = data.message || '';
     }
-
     if ('details' in data) {
       errorData.details = data.details || {};
     }
-
     if ('sys' in data) {
       if ('id' in data.sys) {
         errorName = 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);
-
   try {
     error.message = JSON.stringify(errorData, null, '  ');
   } catch (_unused) {
     var _errorData$message;
-
     error.message = (_errorData$message = errorData === null || errorData === void 0 ? void 0 : errorData.message) !== null && _errorData$message !== void 0 ? _errorData$message : '';
   }
-
   throw error;
 }
 
@@ -3711,6 +3612,372 @@ function errorHandler(errorResponse) {
 
 /***/ }),
 
+/***/ "../node_modules/contentful-sdk-core/node_modules/fast-copy/dist/fast-copy.js":
+/*!************************************************************************************!*\
+  !*** ../node_modules/contentful-sdk-core/node_modules/fast-copy/dist/fast-copy.js ***!
+  \************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(global) {(function (global, factory) {
+     true ? module.exports = factory() :
+    undefined;
+})(this, (function () { 'use strict';
+
+    var toStringFunction = Function.prototype.toString;
+    var create = Object.create, defineProperty = Object.defineProperty, getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols, getPrototypeOf$1 = Object.getPrototypeOf;
+    var _a = Object.prototype, hasOwnProperty = _a.hasOwnProperty, propertyIsEnumerable = _a.propertyIsEnumerable;
+    var SYMBOL_PROPERTIES = typeof getOwnPropertySymbols === 'function';
+    var WEAK_MAP = typeof WeakMap === 'function';
+    /**
+     * @function createCache
+     *
+     * @description
+     * get a new cache object to prevent circular references
+     *
+     * @returns the new cache object
+     */
+    var createCache = (function () {
+        if (WEAK_MAP) {
+            return function () { return new WeakMap(); };
+        }
+        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(); };
+    })();
+    /**
+     * @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
+     */
+    var getCleanClone = function (object, realm) {
+        var prototype = object.__proto__ || getPrototypeOf$1(object);
+        if (!prototype) {
+            return create(null);
+        }
+        var Constructor = prototype.constructor;
+        if (Constructor === realm.Object) {
+            return prototype === realm.Object.prototype ? {} : create(prototype);
+        }
+        if (~toStringFunction.call(Constructor).indexOf('[native code]')) {
+            try {
+                return new Constructor();
+            }
+            catch (_a) { }
+        }
+        return create(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 = function (object, realm, handleCopy, cache) {
+        var clone = getCleanClone(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.call(object, key)) {
+                clone[key] = handleCopy(object[key], cache);
+            }
+        }
+        if (SYMBOL_PROPERTIES) {
+            var symbols = getOwnPropertySymbols(object);
+            for (var index = 0, length_1 = symbols.length, symbol = void 0; index < length_1; ++index) {
+                symbol = symbols[index];
+                if (propertyIsEnumerable.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 = function (object, realm, handleCopy, cache) {
+        var clone = getCleanClone(object, realm);
+        // set in the cache immediately to be able to reuse the object recursively
+        cache.set(object, clone);
+        var properties = SYMBOL_PROPERTIES
+            ? getOwnPropertyNames(object).concat(getOwnPropertySymbols(object))
+            : getOwnPropertyNames(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(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(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 = function (regExp) {
+        var flags = '';
+        if (regExp.global) {
+            flags += 'g';
+        }
+        if (regExp.ignoreCase) {
+            flags += 'i';
+        }
+        if (regExp.multiline) {
+            flags += 'm';
+        }
+        if (regExp.unicode) {
+            flags += 'u';
+        }
+        if (regExp.sticky) {
+            flags += 'y';
+        }
+        return flags;
+    };
+
+    // utils
+    var isArray = Array.isArray;
+    var getPrototypeOf = Object.getPrototypeOf;
+    var GLOBAL_THIS = (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;
+        }
+        if (console && console.error) {
+            console.error('Unable to locate global object, returning "this".');
+        }
+        return this;
+    })();
+    /**
+     * @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.
+     *
+     * @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
+     */
+    function copy(value, options) {
+        // manually coalesced instead of default parameters for performance
+        var isStrict = !!(options && options.isStrict);
+        var realm = (options && options.realm) || GLOBAL_THIS;
+        var getObjectClone = isStrict ? getObjectCloneStrict : getObjectCloneLoose;
+        /**
+         * @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) {
+            if (!value || typeof value !== 'object') {
+                return value;
+            }
+            if (cache.has(value)) {
+                return cache.get(value);
+            }
+            var prototype = value.__proto__ || getPrototypeOf(value);
+            var Constructor = prototype && prototype.constructor;
+            // plain objects
+            if (!Constructor || Constructor === realm.Object) {
+                return getObjectClone(value, realm, handleCopy, cache);
+            }
+            var clone;
+            // arrays
+            if (isArray(value)) {
+                // if strict, include non-standard properties
+                if (isStrict) {
+                    return getObjectCloneStrict(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(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 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;
+            }
+            // assume anything left is a custom constructor
+            return getObjectClone(value, realm, handleCopy, cache);
+        };
+        return handleCopy(value, createCache());
+    }
+    // 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.default = copy;
+    /**
+     * @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
+     */
+    copy.strict = function strictCopy(value, options) {
+        return copy(value, {
+            isStrict: true,
+            realm: options ? options.realm : void 0,
+        });
+    };
+
+    return copy;
+
+}));
+//# sourceMappingURL=fast-copy.js.map
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../../webpack/buildin/global.js */ "../node_modules/webpack/buildin/global.js")))
+
+/***/ }),
+
 /***/ "../node_modules/fast-copy/dist/fast-copy.js":
 /*!***************************************************!*\
   !*** ../node_modules/fast-copy/dist/fast-copy.js ***!
@@ -7801,7 +8068,7 @@ var parseObject = function (chain, val, options, valuesParsed) {
             ) {
                 obj = [];
                 obj[index] = leaf;
-            } else {
+            } else if (cleanRoot !== '__proto__') {
                 obj[cleanRoot] = leaf;
             }
         }
@@ -7959,6 +8226,7 @@ var arrayPrefixGenerators = {
 };
 
 var isArray = Array.isArray;
+var split = String.prototype.split;
 var push = Array.prototype.push;
 var pushToArray = function (arr, valueOrArray) {
     push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
@@ -7995,10 +8263,13 @@ var isNonNullishPrimitive = function isNonNullishPrimitive(v) {
         || typeof v === 'bigint';
 };
 
+var sentinel = {};
+
 var stringify = function stringify(
     object,
     prefix,
     generateArrayPrefix,
+    commaRoundTrip,
     strictNullHandling,
     skipNulls,
     encoder,
@@ -8014,8 +8285,23 @@ var stringify = function stringify(
 ) {
     var obj = object;
 
-    if (sideChannel.has(object)) {
-        throw new RangeError('Cyclic object value');
+    var tmpSc = sideChannel;
+    var step = 0;
+    var findFlag = false;
+    while ((tmpSc = tmpSc.get(sentinel)) !== void undefined && !findFlag) {
+        // Where object last appeared in the ref tree
+        var pos = tmpSc.get(object);
+        step += 1;
+        if (typeof pos !== 'undefined') {
+            if (pos === step) {
+                throw new RangeError('Cyclic object value');
+            } else {
+                findFlag = true; // Break while
+            }
+        }
+        if (typeof tmpSc.get(sentinel) === 'undefined') {
+            step = 0;
+        }
     }
 
     if (typeof filter === 'function') {
@@ -8042,6 +8328,14 @@ var stringify = function stringify(
     if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {
         if (encoder) {
             var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, 'key', format);
+            if (generateArrayPrefix === 'comma' && encodeValuesOnly) {
+                var valuesArray = split.call(String(obj), ',');
+                var valuesJoined = '';
+                for (var i = 0; i < valuesArray.length; ++i) {
+                    valuesJoined += (i === 0 ? '' : ',') + formatter(encoder(valuesArray[i], defaults.encoder, charset, 'value', format));
+                }
+                return [formatter(keyValue) + (commaRoundTrip && isArray(obj) && valuesArray.length === 1 ? '[]' : '') + '=' + valuesJoined];
+            }
             return [formatter(keyValue) + '=' + formatter(encoder(obj, defaults.encoder, charset, 'value', format))];
         }
         return [formatter(prefix) + '=' + formatter(String(obj))];
@@ -8056,7 +8350,7 @@ var stringify = function stringify(
     var objKeys;
     if (generateArrayPrefix === 'comma' && isArray(obj)) {
         // we need to join elements in
-        objKeys = [{ value: obj.length > 0 ? obj.join(',') || null : undefined }];
+        objKeys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
     } else if (isArray(filter)) {
         objKeys = filter;
     } else {
@@ -8064,24 +8358,28 @@ var stringify = function stringify(
         objKeys = sort ? keys.sort(sort) : keys;
     }
 
-    for (var i = 0; i < objKeys.length; ++i) {
-        var key = objKeys[i];
-        var value = typeof key === 'object' && key.value !== undefined ? key.value : obj[key];
+    var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? prefix + '[]' : prefix;
+
+    for (var j = 0; j < objKeys.length; ++j) {
+        var key = objKeys[j];
+        var value = typeof key === 'object' && typeof key.value !== 'undefined' ? key.value : obj[key];
 
         if (skipNulls && value === null) {
             continue;
         }
 
         var keyPrefix = isArray(obj)
-            ? typeof generateArrayPrefix === 'function' ? generateArrayPrefix(prefix, key) : prefix
-            : prefix + (allowDots ? '.' + key : '[' + key + ']');
+            ? typeof generateArrayPrefix === 'function' ? generateArrayPrefix(adjustedPrefix, key) : adjustedPrefix
+            : adjustedPrefix + (allowDots ? '.' + key : '[' + key + ']');
 
-        sideChannel.set(object, true);
+        sideChannel.set(object, step);
         var valueSideChannel = getSideChannel();
+        valueSideChannel.set(sentinel, sideChannel);
         pushToArray(values, stringify(
             value,
             keyPrefix,
             generateArrayPrefix,
+            commaRoundTrip,
             strictNullHandling,
             skipNulls,
             encoder,
@@ -8105,7 +8403,7 @@ var normalizeStringifyOptions = function normalizeStringifyOptions(opts) {
         return defaults;
     }
 
-    if (opts.encoder !== null && opts.encoder !== undefined && typeof opts.encoder !== 'function') {
+    if (opts.encoder !== null && typeof opts.encoder !== 'undefined' && typeof opts.encoder !== 'function') {
         throw new TypeError('Encoder has to be a function.');
     }
 
@@ -8178,6 +8476,10 @@ module.exports = function (object, opts) {
     }
 
     var generateArrayPrefix = arrayPrefixGenerators[arrayFormat];
+    if (opts && 'commaRoundTrip' in opts && typeof opts.commaRoundTrip !== 'boolean') {
+        throw new TypeError('`commaRoundTrip` must be a boolean, or absent');
+    }
+    var commaRoundTrip = generateArrayPrefix === 'comma' && opts && opts.commaRoundTrip;
 
     if (!objKeys) {
         objKeys = Object.keys(obj);
@@ -8198,6 +8500,7 @@ module.exports = function (object, opts) {
             obj[key],
             key,
             generateArrayPrefix,
+            commaRoundTrip,
             options.strictNullHandling,
             options.skipNulls,
             options.encode ? options.encoder : null,
@@ -8419,6 +8722,7 @@ var encode = function encode(str, defaultEncoder, charset, kind, format) {
 
         i += 1;
         c = 0x10000 + (((c & 0x3FF) << 10) | (string.charCodeAt(i) & 0x3FF));
+        /* eslint operator-linebreak: [2, "before"] */
         out += hexTable[0xF0 | (c >> 18)]
             + hexTable[0x80 | ((c >> 12) & 0x3F)]
             + hexTable[0x80 | ((c >> 6) & 0x3F)]
@@ -12620,7 +12924,7 @@ function createClient(params) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var sdkMain = opts.type === 'plain' ? 'contentful-management-plain.js' : 'contentful-management.js';
   var userAgent = Object(contentful_sdk_core__WEBPACK_IMPORTED_MODULE_0__["getUserAgentHeader"])( // @ts-expect-error
-  "".concat(sdkMain, "/").concat("10.21.2"), params.application, params.integration, params.feature);
+  "".concat(sdkMain, "/").concat("10.21.3"), params.application, params.integration, params.feature);
   var adapter = Object(_create_adapter__WEBPACK_IMPORTED_MODULE_1__["createAdapter"])(params);
 
   // Parameters<?> and ReturnType<?> only return the types of the last overload