@wix/entity-advanced-permissions 1.801.0 → 1.802.0

package/dist/statics/entity-advanced-permissions.umd.js

@@ -36017,374 +36017,6 @@ function _interopRequireDefault(obj) {
 }
 module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
 
-/***/ }),
-
-/***/ 9649:
-/*!**************************************************************************!*\
-  !*** ../../../node_modules/@babel/runtime/helpers/regeneratorRuntime.js ***!
-  \**************************************************************************/
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-var _typeof = (__webpack_require__(/*! ./typeof.js */ 8114)["default"]);
-function _regeneratorRuntime() {
-  "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
-  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
-    return exports;
-  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  var exports = {},
-    Op = Object.prototype,
-    hasOwn = Op.hasOwnProperty,
-    defineProperty = Object.defineProperty || function (obj, key, desc) {
-      obj[key] = desc.value;
-    },
-    $Symbol = "function" == typeof Symbol ? Symbol : {},
-    iteratorSymbol = $Symbol.iterator || "@@iterator",
-    asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
-    toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
-  function define(obj, key, value) {
-    return Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: !0,
-      configurable: !0,
-      writable: !0
-    }), obj[key];
-  }
-  try {
-    define({}, "");
-  } catch (err) {
-    define = function define(obj, key, value) {
-      return obj[key] = value;
-    };
-  }
-  function wrap(innerFn, outerFn, self, tryLocsList) {
-    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
-      generator = Object.create(protoGenerator.prototype),
-      context = new Context(tryLocsList || []);
-    return defineProperty(generator, "_invoke", {
-      value: makeInvokeMethod(innerFn, self, context)
-    }), generator;
-  }
-  function tryCatch(fn, obj, arg) {
-    try {
-      return {
-        type: "normal",
-        arg: fn.call(obj, arg)
-      };
-    } catch (err) {
-      return {
-        type: "throw",
-        arg: err
-      };
-    }
-  }
-  exports.wrap = wrap;
-  var ContinueSentinel = {};
-  function Generator() {}
-  function GeneratorFunction() {}
-  function GeneratorFunctionPrototype() {}
-  var IteratorPrototype = {};
-  define(IteratorPrototype, iteratorSymbol, function () {
-    return this;
-  });
-  var getProto = Object.getPrototypeOf,
-    NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
-  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
-  function defineIteratorMethods(prototype) {
-    ["next", "throw", "return"].forEach(function (method) {
-      define(prototype, method, function (arg) {
-        return this._invoke(method, arg);
-      });
-    });
-  }
-  function AsyncIterator(generator, PromiseImpl) {
-    function invoke(method, arg, resolve, reject) {
-      var record = tryCatch(generator[method], generator, arg);
-      if ("throw" !== record.type) {
-        var result = record.arg,
-          value = result.value;
-        return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
-          invoke("next", value, resolve, reject);
-        }, function (err) {
-          invoke("throw", err, resolve, reject);
-        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
-          result.value = unwrapped, resolve(result);
-        }, function (error) {
-          return invoke("throw", error, resolve, reject);
-        });
-      }
-      reject(record.arg);
-    }
-    var previousPromise;
-    defineProperty(this, "_invoke", {
-      value: function value(method, arg) {
-        function callInvokeWithMethodAndArg() {
-          return new PromiseImpl(function (resolve, reject) {
-            invoke(method, arg, resolve, reject);
-          });
-        }
-        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
-      }
-    });
-  }
-  function makeInvokeMethod(innerFn, self, context) {
-    var state = "suspendedStart";
-    return function (method, arg) {
-      if ("executing" === state) throw new Error("Generator is already running");
-      if ("completed" === state) {
-        if ("throw" === method) throw arg;
-        return doneResult();
-      }
-      for (context.method = method, context.arg = arg;;) {
-        var delegate = context.delegate;
-        if (delegate) {
-          var delegateResult = maybeInvokeDelegate(delegate, context);
-          if (delegateResult) {
-            if (delegateResult === ContinueSentinel) continue;
-            return delegateResult;
-          }
-        }
-        if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
-          if ("suspendedStart" === state) throw state = "completed", context.arg;
-          context.dispatchException(context.arg);
-        } else "return" === context.method && context.abrupt("return", context.arg);
-        state = "executing";
-        var record = tryCatch(innerFn, self, context);
-        if ("normal" === record.type) {
-          if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
-          return {
-            value: record.arg,
-            done: context.done
-          };
-        }
-        "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
-      }
-    };
-  }
-  function maybeInvokeDelegate(delegate, context) {
-    var method = delegate.iterator[context.method];
-    if (undefined === method) {
-      if (context.delegate = null, "throw" === context.method) {
-        if (delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
-        context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
-      }
-      return ContinueSentinel;
-    }
-    var record = tryCatch(method, delegate.iterator, context.arg);
-    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
-    var info = record.arg;
-    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
-  }
-  function pushTryEntry(locs) {
-    var entry = {
-      tryLoc: locs[0]
-    };
-    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
-  }
-  function resetTryEntry(entry) {
-    var record = entry.completion || {};
-    record.type = "normal", delete record.arg, entry.completion = record;
-  }
-  function Context(tryLocsList) {
-    this.tryEntries = [{
-      tryLoc: "root"
-    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
-  }
-  function values(iterable) {
-    if (iterable) {
-      var iteratorMethod = iterable[iteratorSymbol];
-      if (iteratorMethod) return iteratorMethod.call(iterable);
-      if ("function" == typeof iterable.next) return iterable;
-      if (!isNaN(iterable.length)) {
-        var i = -1,
-          next = function next() {
-            for (; ++i < iterable.length;) {
-              if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
-            }
-            return next.value = undefined, next.done = !0, next;
-          };
-        return next.next = next;
-      }
-    }
-    return {
-      next: doneResult
-    };
-  }
-  function doneResult() {
-    return {
-      value: undefined,
-      done: !0
-    };
-  }
-  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
-    value: GeneratorFunctionPrototype,
-    configurable: !0
-  }), defineProperty(GeneratorFunctionPrototype, "constructor", {
-    value: GeneratorFunction,
-    configurable: !0
-  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
-    var ctor = "function" == typeof genFun && genFun.constructor;
-    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
-  }, exports.mark = function (genFun) {
-    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
-  }, exports.awrap = function (arg) {
-    return {
-      __await: arg
-    };
-  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
-    return this;
-  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-    void 0 === PromiseImpl && (PromiseImpl = Promise);
-    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
-    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
-      return result.done ? result.value : iter.next();
-    });
-  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
-    return this;
-  }), define(Gp, "toString", function () {
-    return "[object Generator]";
-  }), exports.keys = function (val) {
-    var object = Object(val),
-      keys = [];
-    for (var key in object) {
-      keys.push(key);
-    }
-    return keys.reverse(), function next() {
-      for (; keys.length;) {
-        var key = keys.pop();
-        if (key in object) return next.value = key, next.done = !1, next;
-      }
-      return next.done = !0, next;
-    };
-  }, exports.values = values, Context.prototype = {
-    constructor: Context,
-    reset: function reset(skipTempReset) {
-      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) {
-        "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
-      }
-    },
-    stop: function stop() {
-      this.done = !0;
-      var rootRecord = this.tryEntries[0].completion;
-      if ("throw" === rootRecord.type) throw rootRecord.arg;
-      return this.rval;
-    },
-    dispatchException: function dispatchException(exception) {
-      if (this.done) throw exception;
-      var context = this;
-      function handle(loc, caught) {
-        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
-      }
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i],
-          record = entry.completion;
-        if ("root" === entry.tryLoc) return handle("end");
-        if (entry.tryLoc <= this.prev) {
-          var hasCatch = hasOwn.call(entry, "catchLoc"),
-            hasFinally = hasOwn.call(entry, "finallyLoc");
-          if (hasCatch && hasFinally) {
-            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
-            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
-          } else if (hasCatch) {
-            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
-          } else {
-            if (!hasFinally) throw new Error("try statement without catch or finally");
-            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
-          }
-        }
-      }
-    },
-    abrupt: function abrupt(type, arg) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
-          var finallyEntry = entry;
-          break;
-        }
-      }
-      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
-      var record = finallyEntry ? finallyEntry.completion : {};
-      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
-    },
-    complete: function complete(record, afterLoc) {
-      if ("throw" === record.type) throw record.arg;
-      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
-    },
-    finish: function finish(finallyLoc) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
-      }
-    },
-    "catch": function _catch(tryLoc) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        if (entry.tryLoc === tryLoc) {
-          var record = entry.completion;
-          if ("throw" === record.type) {
-            var thrown = record.arg;
-            resetTryEntry(entry);
-          }
-          return thrown;
-        }
-      }
-      throw new Error("illegal catch attempt");
-    },
-    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
-      return this.delegate = {
-        iterator: values(iterable),
-        resultName: resultName,
-        nextLoc: nextLoc
-      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
-    }
-  }, exports;
-}
-module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ 8114:
-/*!**************************************************************!*\
-  !*** ../../../node_modules/@babel/runtime/helpers/typeof.js ***!
-  \**************************************************************/
-/***/ (function(module) {
-
-function _typeof(obj) {
-  "@babel/helpers - typeof";
-
-  return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
-    return typeof obj;
-  } : function (obj) {
-    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-  }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
-}
-module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ 2975:
-/*!*****************************************************************!*\
-  !*** ../../../node_modules/@babel/runtime/regenerator/index.js ***!
-  \*****************************************************************/
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-// TODO(Babel 8): Remove this file.
-
-var runtime = __webpack_require__(/*! ../helpers/regeneratorRuntime */ 9649)();
-module.exports = runtime;
-
-// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=
-try {
-  regeneratorRuntime = runtime;
-} catch (accidentalStrictMode) {
-  if (typeof globalThis === "object") {
-    globalThis.regeneratorRuntime = runtime;
-  } else {
-    Function("r", "regeneratorRuntime = r")(runtime);
-  }
-}
-
-
 /***/ }),
 
 /***/ 191:
@@ -36650,7 +36282,7 @@ var __webpack_exports__ = {};
 !function() {
 "use strict";
 /*!********************************!*\
-  !*** ./index.ts + 430 modules ***!
+  !*** ./index.ts + 415 modules ***!
   \********************************/
 // ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
@@ -56758,29 +56390,6 @@ var index = manageState(Select);
 /* harmony default export */ var react_select_browser_esm = (index);
 
 
-;// CONCATENATED MODULE: ../../../node_modules/@babel/runtime/helpers/esm/objectSpread2.js
-
-function objectSpread2_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] : {};
-    i % 2 ? objectSpread2_ownKeys(Object(source), !0).forEach(function (key) {
-      defineProperty_defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : objectSpread2_ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-    });
-  }
-  return target;
-}
 ;// CONCATENATED MODULE: ../../../node_modules/use-is-mounted-ref/dist/use-is-mounted-ref.es.js
 
 
@@ -56810,27 +56419,45 @@ const useLazyRef = (init) => {
 };
 
 
-;// CONCATENATED MODULE: ../../../node_modules/react-select-async-paginate/es/getInitialCache.js
-var getInitialCache = function getInitialCache(params) {
-  return {
-    isFirstLoad: true,
-    options: [],
-    hasMore: true,
-    isLoading: false,
-    additional: params.additional
-  };
-};
-;// CONCATENATED MODULE: ../../../node_modules/react-select-async-paginate/es/getInitialOptionsCache.js
-var getInitialOptionsCache = function getInitialOptionsCache(_ref) {
-  var options = _ref.options,
-      defaultOptions = _ref.defaultOptions,
-      additional = _ref.additional,
-      defaultAdditional = _ref.defaultAdditional;
-  var initialOptions = defaultOptions === true ? null : defaultOptions instanceof Array ? defaultOptions : options;
+;// CONCATENATED MODULE: ../../../node_modules/sleep-promise/build/esm.mjs
+var e=setTimeout;function t(t,n){var u=n.useCachedSetTimeout?e:setTimeout;return new Promise((function(e){u(e,t)}))}function n(e){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},u=n.useCachedSetTimeout,r=t(e,{useCachedSetTimeout:u});function o(e){return r.then((function(){return e}))}return o.then=function(){return r.then.apply(r,arguments)},o.catch=Promise.resolve().catch,o}/* harmony default export */ var esm = (n);
+
+// EXTERNAL MODULE: ../../../node_modules/@seznam/compose-react-refs/composeRefs.js
+var composeRefs = __webpack_require__(1596);
+// EXTERNAL MODULE: ../../../node_modules/react/jsx-runtime.js
+var jsx_runtime = __webpack_require__(4512);
+;// CONCATENATED MODULE: ../../../node_modules/react-select-async-paginate/dist/esm/index.js
+// src/index.ts
+
+
+// src/useAsyncPaginate.ts
+
+
+// src/useAsyncPaginateBase.ts
 
+
+
+
+// src/getInitialCache.ts
+var getInitialCache = (params) => ({
+  isFirstLoad: true,
+  options: [],
+  hasMore: true,
+  isLoading: false,
+  additional: params.additional
+});
+
+// src/getInitialOptionsCache.ts
+var getInitialOptionsCache = ({
+  options,
+  defaultOptions,
+  additional,
+  defaultAdditional
+}) => {
+  const initialOptions = defaultOptions === true ? null : defaultOptions instanceof Array ? defaultOptions : options;
   if (initialOptions) {
     return {
-      '': {
+      "": {
         isFirstLoad: false,
         isLoading: false,
         options: initialOptions,
@@ -56839,471 +56466,350 @@ var getInitialOptionsCache = function getInitialOptionsCache(_ref) {
       }
     };
   }
-
   return {};
 };
-;// CONCATENATED MODULE: ../../../node_modules/react-select-async-paginate/es/defaultShouldLoadMore.js
+
+// src/defaultShouldLoadMore.ts
 var AVAILABLE_DELTA = 10;
-var defaultShouldLoadMore = function defaultShouldLoadMore(scrollHeight, clientHeight, scrollTop) {
-  var bottomBorder = scrollHeight - clientHeight - AVAILABLE_DELTA;
+var defaultShouldLoadMore = (scrollHeight, clientHeight, scrollTop) => {
+  const bottomBorder = scrollHeight - clientHeight - AVAILABLE_DELTA;
   return bottomBorder < scrollTop;
 };
-;// CONCATENATED MODULE: ../../../node_modules/react-select-async-paginate/es/defaultReduceOptions.js
-
-var defaultReduceOptions = function defaultReduceOptions(prevOptions, loadedOptions) {
-  return [].concat(_toConsumableArray(prevOptions), _toConsumableArray(loadedOptions));
-};
-;// CONCATENATED MODULE: ../../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
 
-function _toPrimitive(input, hint) {
-  if (_typeof(input) !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (_typeof(res) !== "object") return res;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
-  }
-  return (hint === "string" ? String : Number)(input);
-}
-;// CONCATENATED MODULE: ../../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+// src/defaultReduceOptions.ts
+var defaultReduceOptions = (prevOptions, loadedOptions) => [...prevOptions, ...loadedOptions];
 
+// src/requestOptions.ts
 
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return _typeof(key) === "symbol" ? key : String(key);
-}
-;// CONCATENATED MODULE: ../../../node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
-  }
-}
-function _asyncToGenerator(fn) {
-  return function () {
-    var self = this,
-      args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-      _next(undefined);
-    });
-  };
-}
-// EXTERNAL MODULE: ../../../node_modules/@babel/runtime/regenerator/index.js
-var regenerator = __webpack_require__(2975);
-var regenerator_default = /*#__PURE__*/__webpack_require__.n(regenerator);
-;// CONCATENATED MODULE: ../../../node_modules/sleep-promise/build/esm.mjs
-var e=setTimeout;function t(t,n){var u=n.useCachedSetTimeout?e:setTimeout;return new Promise((function(e){u(e,t)}))}function n(e){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},u=n.useCachedSetTimeout,r=t(e,{useCachedSetTimeout:u});function o(e){return r.then((function(){return e}))}return o.then=function(){return r.then.apply(r,arguments)},o.catch=Promise.resolve().catch,o}/* harmony default export */ var esm = (n);
 
-;// CONCATENATED MODULE: ../../../node_modules/react-select-async-paginate/es/validateResponse.js
+// src/validateResponse.ts
 var errorText = '[react-select-async-paginate] response of "loadOptions" should be an object with "options" prop, which contains array of options.';
-var checkIsResponse = function checkIsResponse(response) {
+var checkIsResponse = (response) => {
   if (!response) {
     return false;
   }
-
-  var _ref = response,
-      options = _ref.options,
-      hasMore = _ref.hasMore;
-
+  const {
+    options,
+    hasMore
+  } = response;
   if (!Array.isArray(options)) {
     return false;
   }
-
-  if (typeof hasMore !== 'boolean' && typeof hasMore !== 'undefined') {
+  if (typeof hasMore !== "boolean" && typeof hasMore !== "undefined") {
     return false;
   }
-
   return true;
 };
-var validateResponse = function validateResponse(response) {
+var validateResponse = (response) => {
   if (!checkIsResponse(response)) {
-    // eslint-disable-next-line no-console
-    console.error(errorText, 'Received:', response);
+    console.error(errorText, "Received:", response);
     throw new Error(errorText);
   }
-
   return true;
 };
-;// CONCATENATED MODULE: ../../../node_modules/react-select-async-paginate/es/requestOptions.js
-
-
-
-
-
-
-
-
-
-var requestOptions = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/regenerator_default().mark(function _callee(caller, paramsRef, optionsCacheRef, debounceTimeout, setOptionsCache, reduceOptions) {
-    var currentInputValue, isCacheEmpty, currentOptions, newInputValue, response, hasError, loadOptions, _response, options, hasMore, newAdditional;
-
-    return regenerator_default().wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            currentInputValue = paramsRef.current.inputValue;
-            isCacheEmpty = !optionsCacheRef.current[currentInputValue];
-            currentOptions = isCacheEmpty ? getInitialCache(paramsRef.current) : optionsCacheRef.current[currentInputValue];
-
-            if (!(currentOptions.isLoading || !currentOptions.hasMore)) {
-              _context.next = 5;
-              break;
-            }
-
-            return _context.abrupt("return");
-
-          case 5:
-            setOptionsCache(function (prevOptionsCache) {
-              return _objectSpread2(_objectSpread2({}, prevOptionsCache), {}, defineProperty_defineProperty({}, currentInputValue, _objectSpread2(_objectSpread2({}, currentOptions), {}, {
-                isLoading: true
-              })));
-            });
-
-            if (!(debounceTimeout > 0 && caller === 'input-change')) {
-              _context.next = 13;
-              break;
-            }
-
-            _context.next = 9;
-            return esm(debounceTimeout);
-
-          case 9:
-            newInputValue = paramsRef.current.inputValue;
-
-            if (!(currentInputValue !== newInputValue)) {
-              _context.next = 13;
-              break;
-            }
-
-            setOptionsCache(function (prevOptionsCache) {
-              if (isCacheEmpty) {
-                var itemForDelete = prevOptionsCache[currentInputValue],
-                    restCache = _objectWithoutProperties(prevOptionsCache, [currentInputValue].map(_toPropertyKey));
-
-                return restCache;
-              }
-
-              return _objectSpread2(_objectSpread2({}, prevOptionsCache), {}, defineProperty_defineProperty({}, currentInputValue, _objectSpread2(_objectSpread2({}, currentOptions), {}, {
-                isLoading: false
-              })));
-            });
-            return _context.abrupt("return");
-
-          case 13:
-            hasError = false;
-            _context.prev = 14;
-            loadOptions = paramsRef.current.loadOptions;
-            _context.next = 18;
-            return loadOptions(currentInputValue, currentOptions.options, currentOptions.additional);
-
-          case 18:
-            response = _context.sent;
-            _context.next = 24;
-            break;
 
-          case 21:
-            _context.prev = 21;
-            _context.t0 = _context["catch"](14);
-            hasError = true;
-
-          case 24:
-            if (!hasError) {
-              _context.next = 27;
-              break;
-            }
-
-            setOptionsCache(function (prevOptionsCache) {
-              return _objectSpread2(_objectSpread2({}, prevOptionsCache), {}, defineProperty_defineProperty({}, currentInputValue, _objectSpread2(_objectSpread2({}, currentOptions), {}, {
-                isLoading: false
-              })));
-            });
-            return _context.abrupt("return");
-
-          case 27:
-            if (validateResponse(response)) {
-              _response = response, options = _response.options, hasMore = _response.hasMore; // eslint-disable-next-line no-prototype-builtins
-
-              newAdditional = response.hasOwnProperty('additional') ? response.additional : currentOptions.additional;
-              setOptionsCache(function (prevOptionsCache) {
-                return _objectSpread2(_objectSpread2({}, prevOptionsCache), {}, defineProperty_defineProperty({}, currentInputValue, _objectSpread2(_objectSpread2({}, currentOptions), {}, {
-                  options: reduceOptions(currentOptions.options, options, newAdditional),
-                  hasMore: !!hasMore,
-                  isLoading: false,
-                  isFirstLoad: false,
-                  additional: newAdditional
-                })));
-              });
-            }
-
-          case 28:
-          case "end":
-            return _context.stop();
+// src/requestOptions.ts
+var requestOptions = async (caller, paramsRef, optionsCacheRef, debounceTimeout, setOptionsCache, reduceOptions) => {
+  const currentInputValue = paramsRef.current.inputValue;
+  const isCacheEmpty = !optionsCacheRef.current[currentInputValue];
+  const currentOptions = isCacheEmpty ? getInitialCache(paramsRef.current) : optionsCacheRef.current[currentInputValue];
+  if (currentOptions.isLoading || !currentOptions.hasMore) {
+    return;
+  }
+  setOptionsCache((prevOptionsCache) => ({
+    ...prevOptionsCache,
+    [currentInputValue]: {
+      ...currentOptions,
+      isLoading: true
+    }
+  }));
+  if (debounceTimeout > 0 && caller === "input-change") {
+    await esm(debounceTimeout);
+    const newInputValue = paramsRef.current.inputValue;
+    if (currentInputValue !== newInputValue) {
+      setOptionsCache((prevOptionsCache) => {
+        if (isCacheEmpty) {
+          const {
+            [currentInputValue]: itemForDelete,
+            ...restCache
+          } = prevOptionsCache;
+          return restCache;
         }
+        return {
+          ...prevOptionsCache,
+          [currentInputValue]: {
+            ...currentOptions,
+            isLoading: false
+          }
+        };
+      });
+      return;
+    }
+  }
+  let response;
+  let hasError = false;
+  try {
+    const {
+      loadOptions
+    } = paramsRef.current;
+    response = await loadOptions(
+      currentInputValue,
+      currentOptions.options,
+      currentOptions.additional
+    );
+  } catch (e) {
+    hasError = true;
+  }
+  if (hasError) {
+    setOptionsCache((prevOptionsCache) => ({
+      ...prevOptionsCache,
+      [currentInputValue]: {
+        ...currentOptions,
+        isLoading: false
       }
-    }, _callee, null, [[14, 21]]);
-  }));
-
-  return function requestOptions(_x, _x2, _x3, _x4, _x5, _x6) {
-    return _ref.apply(this, arguments);
-  };
-}();
-;// CONCATENATED MODULE: ../../../node_modules/react-select-async-paginate/es/useAsyncPaginateBase.js
-
-
-
-
-
-
-
-
-var increaseStateId = function increaseStateId(prevStateId) {
-  return prevStateId + 1;
+    }));
+    return;
+  }
+  if (validateResponse(response)) {
+    const {
+      options,
+      hasMore
+    } = response;
+    const newAdditional = response.hasOwnProperty("additional") ? response.additional : currentOptions.additional;
+    setOptionsCache((prevOptionsCache) => ({
+      ...prevOptionsCache,
+      [currentInputValue]: {
+        ...currentOptions,
+        options: reduceOptions(currentOptions.options, options, newAdditional),
+        hasMore: !!hasMore,
+        isLoading: false,
+        isFirstLoad: false,
+        additional: newAdditional
+      }
+    }));
+  }
 };
-var useAsyncPaginateBase = function useAsyncPaginateBase(params) {
-  var deps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-  var defaultOptions = params.defaultOptions,
-      _params$loadOptionsOn = params.loadOptionsOnMenuOpen,
-      loadOptionsOnMenuOpen = _params$loadOptionsOn === void 0 ? true : _params$loadOptionsOn,
-      _params$debounceTimeo = params.debounceTimeout,
-      debounceTimeout = _params$debounceTimeo === void 0 ? 0 : _params$debounceTimeo,
-      inputValue = params.inputValue,
-      menuIsOpen = params.menuIsOpen,
-      _params$filterOption = params.filterOption,
-      filterOption = _params$filterOption === void 0 ? null : _params$filterOption,
-      _params$reduceOptions = params.reduceOptions,
-      reduceOptions = _params$reduceOptions === void 0 ? defaultReduceOptions : _params$reduceOptions,
-      _params$shouldLoadMor = params.shouldLoadMore,
-      shouldLoadMore = _params$shouldLoadMor === void 0 ? defaultShouldLoadMore : _params$shouldLoadMor;
-  var isMountedRef = useIsMountedRef();
-  var isInitRef = (0,external_React_.useRef)(true);
-  var paramsRef = (0,external_React_.useRef)(params);
-  paramsRef.current = params;
-  var setStateId = (0,external_React_.useState)(0)[1];
-  var optionsCacheRef = useLazyRef(function () {
-    return getInitialOptionsCache(params);
-  });
-  var callRequestOptions = (0,external_React_.useCallback)(function (caller) {
-    requestOptions(caller, paramsRef, optionsCacheRef, debounceTimeout, function (reduceState) {
-      optionsCacheRef.current = reduceState(optionsCacheRef.current);
 
-      if (isMountedRef.current) {
-        setStateId(increaseStateId);
-      }
-    }, reduceOptions);
+// src/useAsyncPaginateBase.ts
+var increaseStateId = (prevStateId) => prevStateId + 1;
+var useAsyncPaginateBase = (params, deps = []) => {
+  const {
+    defaultOptions,
+    loadOptionsOnMenuOpen = true,
+    debounceTimeout = 0,
+    inputValue,
+    menuIsOpen,
+    filterOption = null,
+    reduceOptions = defaultReduceOptions,
+    shouldLoadMore = defaultShouldLoadMore
+  } = params;
+  const isMountedRef = useIsMountedRef();
+  const isInitRef = (0,external_React_.useRef)(true);
+  const paramsRef = (0,external_React_.useRef)(params);
+  paramsRef.current = params;
+  const setStateId = (0,external_React_.useState)(0)[1];
+  const optionsCacheRef = useLazyRef(() => getInitialOptionsCache(params));
+  const callRequestOptions = (0,external_React_.useCallback)((caller) => {
+    requestOptions(
+      caller,
+      paramsRef,
+      optionsCacheRef,
+      debounceTimeout,
+      (reduceState) => {
+        optionsCacheRef.current = reduceState(optionsCacheRef.current);
+        if (isMountedRef.current) {
+          setStateId(increaseStateId);
+        }
+      },
+      reduceOptions
+    );
   }, [debounceTimeout]);
-  var handleScrolledToBottom = (0,external_React_.useCallback)(function () {
-    var currentInputValue = paramsRef.current.inputValue;
-    var currentOptions = optionsCacheRef.current[currentInputValue];
-
-    if (currentOptions) {
-      callRequestOptions('menu-scroll');
+  const handleScrolledToBottom = (0,external_React_.useCallback)(() => {
+    const currentInputValue = paramsRef.current.inputValue;
+    const currentOptions2 = optionsCacheRef.current[currentInputValue];
+    if (currentOptions2) {
+      callRequestOptions("menu-scroll");
     }
   }, [callRequestOptions]);
-  (0,external_React_.useEffect)(function () {
+  (0,external_React_.useEffect)(() => {
     if (isInitRef.current) {
       isInitRef.current = false;
     } else {
       optionsCacheRef.current = {};
       setStateId(increaseStateId);
     }
-
     if (defaultOptions === true) {
-      callRequestOptions('autoload');
+      callRequestOptions("autoload");
     }
   }, deps);
-  (0,external_React_.useEffect)(function () {
+  (0,external_React_.useEffect)(() => {
     if (menuIsOpen && !optionsCacheRef.current[inputValue]) {
-      callRequestOptions('input-change');
+      callRequestOptions("input-change");
     }
   }, [inputValue]);
-  (0,external_React_.useEffect)(function () {
-    if (menuIsOpen && !optionsCacheRef.current[''] && loadOptionsOnMenuOpen) {
-      callRequestOptions('menu-toggle');
+  (0,external_React_.useEffect)(() => {
+    if (menuIsOpen && !optionsCacheRef.current[""] && loadOptionsOnMenuOpen) {
+      callRequestOptions("menu-toggle");
     }
   }, [menuIsOpen]);
-  var currentOptions = optionsCacheRef.current[inputValue] || getInitialCache(params);
+  const currentOptions = optionsCacheRef.current[inputValue] || getInitialCache(params);
   return {
-    handleScrolledToBottom: handleScrolledToBottom,
-    shouldLoadMore: shouldLoadMore,
-    filterOption: filterOption,
+    handleScrolledToBottom,
+    shouldLoadMore,
+    filterOption,
     isLoading: currentOptions.isLoading,
     isFirstLoad: currentOptions.isFirstLoad,
     options: currentOptions.options
   };
 };
-;// CONCATENATED MODULE: ../../../node_modules/react-select-async-paginate/es/useAsyncPaginate.js
-
-
 
-
-var useAsyncPaginate = function useAsyncPaginate(params) {
-  var deps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-  var inputValueParam = params.inputValue,
-      menuIsOpenParam = params.menuIsOpen,
-      defaultInputValueParam = params.defaultInputValue,
-      defaultMenuIsOpenParam = params.defaultMenuIsOpen,
-      onInputChangeParam = params.onInputChange,
-      onMenuCloseParam = params.onMenuClose,
-      onMenuOpenParam = params.onMenuOpen;
-
-  var _useState = (0,external_React_.useState)(defaultInputValueParam || ''),
-      _useState2 = _slicedToArray(_useState, 2),
-      inputValueState = _useState2[0],
-      setInputValue = _useState2[1];
-
-  var _useState3 = (0,external_React_.useState)(!!defaultMenuIsOpenParam),
-      _useState4 = _slicedToArray(_useState3, 2),
-      menuIsOpenState = _useState4[0],
-      setMenuIsOpen = _useState4[1];
-
-  var inputValue = typeof inputValueParam === 'string' ? inputValueParam : inputValueState;
-  var menuIsOpen = typeof menuIsOpenParam === 'boolean' ? menuIsOpenParam : menuIsOpenState;
-  var onInputChange = (0,external_React_.useCallback)(function (nextInputValue, actionMeta) {
+// src/useAsyncPaginate.ts
+var useAsyncPaginate = (params, deps = []) => {
+  const {
+    inputValue: inputValueParam,
+    menuIsOpen: menuIsOpenParam,
+    defaultInputValue: defaultInputValueParam,
+    defaultMenuIsOpen: defaultMenuIsOpenParam,
+    onInputChange: onInputChangeParam,
+    onMenuClose: onMenuCloseParam,
+    onMenuOpen: onMenuOpenParam
+  } = params;
+  const [inputValueState, setInputValue] = (0,external_React_.useState)(
+    defaultInputValueParam || ""
+  );
+  const [menuIsOpenState, setMenuIsOpen] = (0,external_React_.useState)(
+    !!defaultMenuIsOpenParam
+  );
+  const inputValue = typeof inputValueParam === "string" ? inputValueParam : inputValueState;
+  const menuIsOpen = typeof menuIsOpenParam === "boolean" ? menuIsOpenParam : menuIsOpenState;
+  const onInputChange = (0,external_React_.useCallback)((nextInputValue, actionMeta) => {
     if (onInputChangeParam) {
       onInputChangeParam(nextInputValue, actionMeta);
     }
-
     setInputValue(nextInputValue);
   }, [onInputChangeParam]);
-  var onMenuClose = (0,external_React_.useCallback)(function () {
+  const onMenuClose = (0,external_React_.useCallback)(() => {
     if (onMenuCloseParam) {
       onMenuCloseParam();
     }
-
     setMenuIsOpen(false);
   }, [onMenuCloseParam]);
-  var onMenuOpen = (0,external_React_.useCallback)(function () {
+  const onMenuOpen = (0,external_React_.useCallback)(() => {
     if (onMenuOpenParam) {
       onMenuOpenParam();
     }
-
     setMenuIsOpen(true);
   }, [onMenuOpenParam]);
-  var baseResult = useAsyncPaginateBase(_objectSpread2(_objectSpread2({}, params), {}, {
-    inputValue: inputValue,
-    menuIsOpen: menuIsOpen
-  }), deps);
-  return _objectSpread2(_objectSpread2({}, baseResult), {}, {
-    inputValue: inputValue,
-    menuIsOpen: menuIsOpen,
-    onInputChange: onInputChange,
-    onMenuClose: onMenuClose,
-    onMenuOpen: onMenuOpen
-  });
+  const baseResult = useAsyncPaginateBase(
+    {
+      ...params,
+      inputValue,
+      menuIsOpen
+    },
+    deps
+  );
+  return {
+    ...baseResult,
+    inputValue,
+    menuIsOpen,
+    onInputChange,
+    onMenuClose,
+    onMenuOpen
+  };
 };
-// EXTERNAL MODULE: ../../../node_modules/@seznam/compose-react-refs/composeRefs.js
-var composeRefs = __webpack_require__(1596);
-// EXTERNAL MODULE: ../../../node_modules/react/jsx-runtime.js
-var jsx_runtime = __webpack_require__(4512);
-;// CONCATENATED MODULE: ../../../node_modules/react-select-async-paginate/es/wrapMenuList.js
+
+// src/useComponents.ts
 
 
 
+// src/wrapMenuList.tsx
+
+
 
 var CHECK_TIMEOUT = 300;
-function wrapMenuList( // eslint-disable-next-line @typescript-eslint/naming-convention
-MenuList) {
+function wrapMenuList(MenuList2) {
   function WrappedMenuList(props) {
-    var selectProps = props.selectProps,
-        innerRef = props.innerRef;
-    var _ref = selectProps,
-        handleScrolledToBottom = _ref.handleScrolledToBottom,
-        shouldLoadMore = _ref.shouldLoadMore;
-    var checkTimeoutRef = (0,external_React_.useRef)();
-    var menuListRef = (0,external_React_.useRef)(null);
-    var shouldHandle = (0,external_React_.useCallback)(function () {
-      var el = menuListRef.current; // menu is not rendered
-
+    const {
+      selectProps,
+      innerRef
+    } = props;
+    const {
+      handleScrolledToBottom,
+      shouldLoadMore
+    } = selectProps;
+    const checkTimeoutRef = (0,external_React_.useRef)();
+    const menuListRef = (0,external_React_.useRef)(null);
+    const shouldHandle = (0,external_React_.useCallback)(() => {
+      const el = menuListRef.current;
       if (!el) {
         return false;
       }
-
-      var scrollTop = el.scrollTop,
-          scrollHeight = el.scrollHeight,
-          clientHeight = el.clientHeight;
+      const {
+        scrollTop,
+        scrollHeight,
+        clientHeight
+      } = el;
       return shouldLoadMore(scrollHeight, clientHeight, scrollTop);
     }, [shouldLoadMore]);
-    var checkAndHandle = (0,external_React_.useCallback)(function () {
+    const checkAndHandle = (0,external_React_.useCallback)(() => {
       if (shouldHandle()) {
         if (handleScrolledToBottom) {
           handleScrolledToBottom();
         }
       }
     }, [shouldHandle, handleScrolledToBottom]);
-    var setCheckAndHandleTimeout = (0,external_React_.useCallback)(function () {
+    const setCheckAndHandleTimeout = (0,external_React_.useCallback)(() => {
       checkAndHandle();
       checkTimeoutRef.current = setTimeout(setCheckAndHandleTimeout, CHECK_TIMEOUT);
     }, [checkAndHandle]);
-    (0,external_React_.useEffect)(function () {
+    (0,external_React_.useEffect)(() => {
       setCheckAndHandleTimeout();
-      return function () {
+      return () => {
         if (checkTimeoutRef.current) {
           clearTimeout(checkTimeoutRef.current);
         }
       };
     }, []);
-    return /*#__PURE__*/(0,jsx_runtime.jsx)(MenuList, _objectSpread2(_objectSpread2({}, props), {}, {
+    return /* @__PURE__ */ (0,jsx_runtime.jsx)(MenuList2, {
+      ...props,
       innerRef: (0,composeRefs/* default */.Z)(innerRef, menuListRef)
-    }));
+    });
   }
-
   return WrappedMenuList;
 }
-;// CONCATENATED MODULE: ../../../node_modules/react-select-async-paginate/es/useComponents.js
-
-
-
-
-var useComponents_MenuList = wrapMenuList(components.MenuList);
-var useComponents = function useComponents(components) {
-  return (0,external_React_.useMemo)(function () {
-    return _objectSpread2({
-      MenuList: useComponents_MenuList
-    }, components);
-  }, [components]);
-};
-;// CONCATENATED MODULE: ../../../node_modules/react-select-async-paginate/es/withAsyncPaginate.js
-
 
-var withAsyncPaginate_excluded = ["components", "selectRef", "isLoading", "cacheUniqs"];
+// src/useComponents.ts
+var esm_MenuList = wrapMenuList(components.MenuList);
+var useComponents = (components) => (0,external_React_.useMemo)(() => ({
+  MenuList: esm_MenuList,
+  ...components
+}), [components]);
 
+// src/withAsyncPaginate.tsx
 
-
-function withAsyncPaginate( // eslint-disable-next-line @typescript-eslint/naming-convention
-SelectComponent) {
+function withAsyncPaginate(SelectComponent) {
   function WithAsyncPaginate(props) {
-    var components = props.components,
-        selectRef = props.selectRef,
-        isLoadingProp = props.isLoading,
-        cacheUniqs = props.cacheUniqs,
-        rest = _objectWithoutProperties(props, withAsyncPaginate_excluded);
-
-    var asyncPaginateProps = useAsyncPaginate(rest, cacheUniqs);
-    var processedComponents = useComponents(components);
-    var isLoading = typeof isLoadingProp === 'boolean' ? isLoadingProp : asyncPaginateProps.isLoading;
-    return /*#__PURE__*/(0,jsx_runtime.jsx)(SelectComponent, _objectSpread2(_objectSpread2(_objectSpread2({}, props), asyncPaginateProps), {}, {
-      isLoading: isLoading,
+    const {
+      components,
+      selectRef,
+      isLoading: isLoadingProp,
+      cacheUniqs,
+      ...rest
+    } = props;
+    const asyncPaginateProps = useAsyncPaginate(
+      rest,
+      cacheUniqs
+    );
+    const processedComponents = useComponents(components);
+    const isLoading = typeof isLoadingProp === "boolean" ? isLoadingProp : asyncPaginateProps.isLoading;
+    return /* @__PURE__ */ (0,jsx_runtime.jsx)(SelectComponent, {
+      ...props,
+      ...asyncPaginateProps,
+      isLoading,
       components: processedComponents,
       ref: selectRef
-    }));
+    });
   }
-
   WithAsyncPaginate.defaultProps = {
     selectRef: null,
     cacheUniqs: [],
@@ -57311,18 +56817,63 @@ SelectComponent) {
   };
   return WithAsyncPaginate;
 }
-;// CONCATENATED MODULE: ../../../node_modules/react-select-async-paginate/es/index.js
-
-
-
-
-
-
-
 
+// src/reduceGroupedOptions.ts
+var checkGroup = (group) => {
+  if (!group) {
+    return false;
+  }
+  const {
+    label,
+    options
+  } = group;
+  if (typeof label !== "string" && typeof label !== "undefined") {
+    return false;
+  }
+  if (!Array.isArray(options)) {
+    return false;
+  }
+  return true;
+};
+var reduceGroupedOptions = (prevOptions, loadedOptions) => {
+  const res = prevOptions.slice();
+  const mapLabelToIndex = {};
+  let prevOptionsIndex = 0;
+  const prevOptionsLength = prevOptions.length;
+  loadedOptions.forEach((optionOrGroup) => {
+    const group = checkGroup(optionOrGroup) ? optionOrGroup : {
+      options: [optionOrGroup]
+    };
+    const {
+      label = ""
+    } = group;
+    let groupIndex = mapLabelToIndex[label];
+    if (typeof groupIndex !== "number") {
+      for (; prevOptionsIndex < prevOptionsLength && typeof mapLabelToIndex[label] !== "number"; ++prevOptionsIndex) {
+        const prevGroup = prevOptions[prevOptionsIndex];
+        if (checkGroup(prevGroup)) {
+          mapLabelToIndex[prevGroup.label || ""] = prevOptionsIndex;
+        }
+      }
+      groupIndex = mapLabelToIndex[label];
+    }
+    if (typeof groupIndex !== "number") {
+      mapLabelToIndex[label] = res.length;
+      res.push(group);
+      return;
+    }
+    res[groupIndex] = {
+      ...res[groupIndex],
+      options: [...res[groupIndex].options, ...group.options]
+    };
+  });
+  return res;
+};
 
+// src/index.ts
 var AsyncPaginate = withAsyncPaginate(react_select_browser_esm);
 
+//# sourceMappingURL=index.js.map
 ;// CONCATENATED MODULE: ../../../node_modules/cnbuilder/esm/cnb.js
 var cnb_isArray = Array.isArray;
 var toClassName = function (val) {