@opengeoweb/warnings 6.0.2 → 6.0.3

package/index.esm.js

@@ -1,3 +1,3531 @@
+import * as React from 'react';
+import React__default, { useContext, useRef, useCallback, useDebugValue, Fragment, useState, useEffect } from 'react';
+import 'react-dom';
+import { Polygons, Edit, Delete } from '@opengeoweb/theme';
+import { uiTypes, uiSelectors, uiActions, layerSelectors, drawSelectors, mapStoreActions, drawActions, snackbarActions } from '@opengeoweb/store';
+import { MapControlButton, useSetupDialog } from '@opengeoweb/core';
+import { dateUtils, ToggleMenu, ToolContainerDraggable, calculateDialogSizeAndPosition } from '@opengeoweb/shared';
+import { List, Typography, ListItem, MenuItem, ListItemText, Paper, ListItemButton, Box, Stack } from '@mui/material';
+import { getApi, createApiInstance, createNonAuthApiInstance, createFakeApiInstance, ApiProvider } from '@opengeoweb/api';
+
+var shim = {exports: {}};
+
+var useSyncExternalStoreShim_production_min = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var e$2=React__default;function h$3(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var k$2="function"===typeof Object.is?Object.is:h$3,l$2=e$2.useState,m$2=e$2.useEffect,n$3=e$2.useLayoutEffect,p$3=e$2.useDebugValue;function q$3(a,b){var d=b(),f=l$2({inst:{value:d,getSnapshot:b}}),c=f[0].inst,g=f[1];n$3(function(){c.value=d;c.getSnapshot=b;r$2(c)&&g({inst:c});},[a,d,b]);m$2(function(){r$2(c)&&g({inst:c});return a(function(){r$2(c)&&g({inst:c});})},[a]);p$3(d);return d}
+function r$2(a){var b=a.getSnapshot;a=a.value;try{var d=b();return !k$2(a,d)}catch(f){return !0}}function t$3(a,b){return b()}var u$2="undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement?t$3:q$3;useSyncExternalStoreShim_production_min.useSyncExternalStore=void 0!==e$2.useSyncExternalStore?e$2.useSyncExternalStore:u$2;
+
+var useSyncExternalStoreShim_development = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+
+/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+}
+          var React = React__default;
+
+var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function error(format) {
+  {
+    {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+
+      printWarning('error', format, args);
+    }
+  }
+}
+
+function printWarning(level, format, args) {
+  // When changing this logic, you might want to also
+  // update consoleWithStackDev.www.js as well.
+  {
+    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+    var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+    if (stack !== '') {
+      format += '%s';
+      args = args.concat([stack]);
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    var argsWithFormat = args.map(function (item) {
+      return String(item);
+    }); // Careful: RN currently depends on this prefix
+
+    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+    // breaks IE9: https://github.com/facebook/react/issues/13610
+    // eslint-disable-next-line react-internal/no-production-logging
+
+    Function.prototype.apply.call(console[level], console, argsWithFormat);
+  }
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+var objectIs = typeof Object.is === 'function' ? Object.is : is;
+
+// dispatch for CommonJS interop named imports.
+
+var useState = React.useState,
+    useEffect = React.useEffect,
+    useLayoutEffect = React.useLayoutEffect,
+    useDebugValue = React.useDebugValue;
+var didWarnOld18Alpha = false;
+var didWarnUncachedGetSnapshot = false; // Disclaimer: This shim breaks many of the rules of React, and only works
+// because of a very particular set of implementation details and assumptions
+// -- change any one of them and it will break. The most important assumption
+// is that updates are always synchronous, because concurrent rendering is
+// only available in versions of React that also have a built-in
+// useSyncExternalStore API. And we only use this shim when the built-in API
+// does not exist.
+//
+// Do not assume that the clever hacks used by this hook also work in general.
+// The point of this shim is to replace the need for hacks by other libraries.
+
+function useSyncExternalStore(subscribe, getSnapshot, // Note: The shim does not use getServerSnapshot, because pre-18 versions of
+// React do not expose a way to check if we're hydrating. So users of the shim
+// will need to track that themselves and return the correct value
+// from `getSnapshot`.
+getServerSnapshot) {
+  {
+    if (!didWarnOld18Alpha) {
+      if (React.startTransition !== undefined) {
+        didWarnOld18Alpha = true;
+
+        error('You are using an outdated, pre-release alpha of React 18 that ' + 'does not support useSyncExternalStore. The ' + 'use-sync-external-store shim will not work correctly. Upgrade ' + 'to a newer pre-release.');
+      }
+    }
+  } // Read the current snapshot from the store on every render. Again, this
+  // breaks the rules of React, and only works here because of specific
+  // implementation details, most importantly that updates are
+  // always synchronous.
+
+
+  var value = getSnapshot();
+
+  {
+    if (!didWarnUncachedGetSnapshot) {
+      var cachedValue = getSnapshot();
+
+      if (!objectIs(value, cachedValue)) {
+        error('The result of getSnapshot should be cached to avoid an infinite loop');
+
+        didWarnUncachedGetSnapshot = true;
+      }
+    }
+  } // Because updates are synchronous, we don't queue them. Instead we force a
+  // re-render whenever the subscribed state changes by updating an some
+  // arbitrary useState hook. Then, during render, we call getSnapshot to read
+  // the current value.
+  //
+  // Because we don't actually use the state returned by the useState hook, we
+  // can save a bit of memory by storing other stuff in that slot.
+  //
+  // To implement the early bailout, we need to track some things on a mutable
+  // object. Usually, we would put that in a useRef hook, but we can stash it in
+  // our useState hook instead.
+  //
+  // To force a re-render, we call forceUpdate({inst}). That works because the
+  // new object always fails an equality check.
+
+
+  var _useState = useState({
+    inst: {
+      value: value,
+      getSnapshot: getSnapshot
+    }
+  }),
+      inst = _useState[0].inst,
+      forceUpdate = _useState[1]; // Track the latest getSnapshot function with a ref. This needs to be updated
+  // in the layout phase so we can access it during the tearing check that
+  // happens on subscribe.
+
+
+  useLayoutEffect(function () {
+    inst.value = value;
+    inst.getSnapshot = getSnapshot; // Whenever getSnapshot or subscribe changes, we need to check in the
+    // commit phase if there was an interleaved mutation. In concurrent mode
+    // this can happen all the time, but even in synchronous mode, an earlier
+    // effect may have mutated the store.
+
+    if (checkIfSnapshotChanged(inst)) {
+      // Force a re-render.
+      forceUpdate({
+        inst: inst
+      });
+    }
+  }, [subscribe, value, getSnapshot]);
+  useEffect(function () {
+    // Check for changes right before subscribing. Subsequent changes will be
+    // detected in the subscription handler.
+    if (checkIfSnapshotChanged(inst)) {
+      // Force a re-render.
+      forceUpdate({
+        inst: inst
+      });
+    }
+
+    var handleStoreChange = function () {
+      // TODO: Because there is no cross-renderer API for batching updates, it's
+      // up to the consumer of this library to wrap their subscription event
+      // with unstable_batchedUpdates. Should we try to detect when this isn't
+      // the case and print a warning in development?
+      // The store changed. Check if the snapshot changed since the last time we
+      // read from the store.
+      if (checkIfSnapshotChanged(inst)) {
+        // Force a re-render.
+        forceUpdate({
+          inst: inst
+        });
+      }
+    }; // Subscribe to the store and return a clean-up function.
+
+
+    return subscribe(handleStoreChange);
+  }, [subscribe]);
+  useDebugValue(value);
+  return value;
+}
+
+function checkIfSnapshotChanged(inst) {
+  var latestGetSnapshot = inst.getSnapshot;
+  var prevValue = inst.value;
+
+  try {
+    var nextValue = latestGetSnapshot();
+    return !objectIs(prevValue, nextValue);
+  } catch (error) {
+    return true;
+  }
+}
+
+function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
+  // Note: The shim does not use getServerSnapshot, because pre-18 versions of
+  // React do not expose a way to check if we're hydrating. So users of the shim
+  // will need to track that themselves and return the correct value
+  // from `getSnapshot`.
+  return getSnapshot();
+}
+
+var canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
+
+var isServerEnvironment = !canUseDOM;
+
+var shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
+var useSyncExternalStore$2 = React.useSyncExternalStore !== undefined ? React.useSyncExternalStore : shim;
+
+useSyncExternalStoreShim_development.useSyncExternalStore = useSyncExternalStore$2;
+          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+}
+        
+  })();
+}
+
+if (process.env.NODE_ENV === 'production') {
+  shim.exports = useSyncExternalStoreShim_production_min;
+} else {
+  shim.exports = useSyncExternalStoreShim_development;
+}
+
+var withSelector = {exports: {}};
+
+var withSelector_production_min = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var h$2=React__default,n$2=shim.exports;function p$2(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var q$2="function"===typeof Object.is?Object.is:p$2,r$1=n$2.useSyncExternalStore,t$2=h$2.useRef,u$1=h$2.useEffect,v$2=h$2.useMemo,w$1=h$2.useDebugValue;
+withSelector_production_min.useSyncExternalStoreWithSelector=function(a,b,e,l,g){var c=t$2(null);if(null===c.current){var f={hasValue:!1,value:null};c.current=f;}else f=c.current;c=v$2(function(){function a(a){if(!c){c=!0;d=a;a=l(a);if(void 0!==g&&f.hasValue){var b=f.value;if(g(b,a))return k=b}return k=a}b=k;if(q$2(d,a))return b;var e=l(a);if(void 0!==g&&g(b,e))return b;d=a;return k=e}var c=!1,d,k,m=void 0===e?null:e;return [function(){return a(b())},null===m?void 0:function(){return a(m())}]},[b,e,l,g]);var d=r$1(a,c[0],c[1]);
+u$1(function(){f.hasValue=!0;f.value=d;},[d]);w$1(d);return d};
+
+var withSelector_development = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+
+/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+}
+          var React = React__default;
+var shim$1 = shim.exports;
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+var objectIs = typeof Object.is === 'function' ? Object.is : is;
+
+var useSyncExternalStore = shim$1.useSyncExternalStore;
+
+// for CommonJS interop.
+
+var useRef = React.useRef,
+    useEffect = React.useEffect,
+    useMemo = React.useMemo,
+    useDebugValue = React.useDebugValue; // Same as useSyncExternalStore, but supports selector and isEqual arguments.
+
+function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+  // Use this to track the rendered snapshot.
+  var instRef = useRef(null);
+  var inst;
+
+  if (instRef.current === null) {
+    inst = {
+      hasValue: false,
+      value: null
+    };
+    instRef.current = inst;
+  } else {
+    inst = instRef.current;
+  }
+
+  var _useMemo = useMemo(function () {
+    // Track the memoized state using closure variables that are local to this
+    // memoized instance of a getSnapshot function. Intentionally not using a
+    // useRef hook, because that state would be shared across all concurrent
+    // copies of the hook/component.
+    var hasMemo = false;
+    var memoizedSnapshot;
+    var memoizedSelection;
+
+    var memoizedSelector = function (nextSnapshot) {
+      if (!hasMemo) {
+        // The first time the hook is called, there is no memoized result.
+        hasMemo = true;
+        memoizedSnapshot = nextSnapshot;
+
+        var _nextSelection = selector(nextSnapshot);
+
+        if (isEqual !== undefined) {
+          // Even if the selector has changed, the currently rendered selection
+          // may be equal to the new selection. We should attempt to reuse the
+          // current value if possible, to preserve downstream memoizations.
+          if (inst.hasValue) {
+            var currentSelection = inst.value;
+
+            if (isEqual(currentSelection, _nextSelection)) {
+              memoizedSelection = currentSelection;
+              return currentSelection;
+            }
+          }
+        }
+
+        memoizedSelection = _nextSelection;
+        return _nextSelection;
+      } // We may be able to reuse the previous invocation's result.
+
+
+      // We may be able to reuse the previous invocation's result.
+      var prevSnapshot = memoizedSnapshot;
+      var prevSelection = memoizedSelection;
+
+      if (objectIs(prevSnapshot, nextSnapshot)) {
+        // The snapshot is the same as last time. Reuse the previous selection.
+        return prevSelection;
+      } // The snapshot has changed, so we need to compute a new selection.
+
+
+      // The snapshot has changed, so we need to compute a new selection.
+      var nextSelection = selector(nextSnapshot); // If a custom isEqual function is provided, use that to check if the data
+      // has changed. If it hasn't, return the previous selection. That signals
+      // to React that the selections are conceptually equal, and we can bail
+      // out of rendering.
+
+      // If a custom isEqual function is provided, use that to check if the data
+      // has changed. If it hasn't, return the previous selection. That signals
+      // to React that the selections are conceptually equal, and we can bail
+      // out of rendering.
+      if (isEqual !== undefined && isEqual(prevSelection, nextSelection)) {
+        return prevSelection;
+      }
+
+      memoizedSnapshot = nextSnapshot;
+      memoizedSelection = nextSelection;
+      return nextSelection;
+    }; // Assigning this to a constant so that Flow knows it can't change.
+
+
+    // Assigning this to a constant so that Flow knows it can't change.
+    var maybeGetServerSnapshot = getServerSnapshot === undefined ? null : getServerSnapshot;
+
+    var getSnapshotWithSelector = function () {
+      return memoizedSelector(getSnapshot());
+    };
+
+    var getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? undefined : function () {
+      return memoizedSelector(maybeGetServerSnapshot());
+    };
+    return [getSnapshotWithSelector, getServerSnapshotWithSelector];
+  }, [getSnapshot, getServerSnapshot, selector, isEqual]),
+      getSelection = _useMemo[0],
+      getServerSelection = _useMemo[1];
+
+  var value = useSyncExternalStore(subscribe, getSelection, getServerSelection);
+  useEffect(function () {
+    inst.hasValue = true;
+    inst.value = value;
+  }, [value]);
+  useDebugValue(value);
+  return value;
+}
+
+withSelector_development.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector;
+          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+}
+        
+  })();
+}
+
+if (process.env.NODE_ENV === 'production') {
+  withSelector.exports = withSelector_production_min;
+} else {
+  withSelector.exports = withSelector_development;
+}
+
+const ContextKey = Symbol.for(`react-redux-context`);
+const gT = typeof globalThis !== "undefined" ? globalThis :
+/* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */
+{};
+
+function getContext() {
+  var _gT$ContextKey;
+
+  if (!React.createContext) return {};
+  const contextMap = (_gT$ContextKey = gT[ContextKey]) != null ? _gT$ContextKey : gT[ContextKey] = new Map();
+  let realContext = contextMap.get(React.createContext);
+
+  if (!realContext) {
+    realContext = React.createContext(null);
+
+    if (process.env.NODE_ENV !== 'production') {
+      realContext.displayName = 'ReactRedux';
+    }
+
+    contextMap.set(React.createContext, realContext);
+  }
+
+  return realContext;
+}
+
+const ReactReduxContext = /*#__PURE__*/getContext();
+
+/**
+ * Hook factory, which creates a `useReduxContext` hook bound to a given context. This is a low-level
+ * hook that you should usually not need to call directly.
+ *
+ * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.
+ * @returns {Function} A `useReduxContext` hook bound to the specified context.
+ */
+function createReduxContextHook(context = ReactReduxContext) {
+  return function useReduxContext() {
+    const contextValue = useContext(context);
+
+    if (process.env.NODE_ENV !== 'production' && !contextValue) {
+      throw new Error('could not find react-redux context value; please ensure the component is wrapped in a <Provider>');
+    }
+
+    return contextValue;
+  };
+}
+/**
+ * A hook to access the value of the `ReactReduxContext`. This is a low-level
+ * hook that you should usually not need to call directly.
+ *
+ * @returns {any} the value of the `ReactReduxContext`
+ *
+ * @example
+ *
+ * import React from 'react'
+ * import { useReduxContext } from 'react-redux'
+ *
+ * export const CounterComponent = () => {
+ *   const { store } = useReduxContext()
+ *   return <div>{store.getState()}</div>
+ * }
+ */
+
+const useReduxContext = /*#__PURE__*/createReduxContextHook();
+
+const notInitialized = () => {
+  throw new Error('uSES not initialized!');
+};
+
+let useSyncExternalStoreWithSelector = notInitialized;
+const initializeUseSelector = fn => {
+  useSyncExternalStoreWithSelector = fn;
+};
+
+const refEquality = (a, b) => a === b;
+/**
+ * Hook factory, which creates a `useSelector` hook bound to a given context.
+ *
+ * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.
+ * @returns {Function} A `useSelector` hook bound to the specified context.
+ */
+
+
+function createSelectorHook(context = ReactReduxContext) {
+  const useReduxContext$1 = context === ReactReduxContext ? useReduxContext : createReduxContextHook(context);
+  return function useSelector(selector, equalityFnOrOptions = {}) {
+    const {
+      equalityFn = refEquality,
+      stabilityCheck = undefined,
+      noopCheck = undefined
+    } = typeof equalityFnOrOptions === 'function' ? {
+      equalityFn: equalityFnOrOptions
+    } : equalityFnOrOptions;
+
+    if (process.env.NODE_ENV !== 'production') {
+      if (!selector) {
+        throw new Error(`You must pass a selector to useSelector`);
+      }
+
+      if (typeof selector !== 'function') {
+        throw new Error(`You must pass a function as a selector to useSelector`);
+      }
+
+      if (typeof equalityFn !== 'function') {
+        throw new Error(`You must pass a function as an equality function to useSelector`);
+      }
+    }
+
+    const {
+      store,
+      subscription,
+      getServerState,
+      stabilityCheck: globalStabilityCheck,
+      noopCheck: globalNoopCheck
+    } = useReduxContext$1();
+    const firstRun = useRef(true);
+    const wrappedSelector = useCallback({
+      [selector.name](state) {
+        const selected = selector(state);
+
+        if (process.env.NODE_ENV !== 'production') {
+          const finalStabilityCheck = typeof stabilityCheck === 'undefined' ? globalStabilityCheck : stabilityCheck;
+
+          if (finalStabilityCheck === 'always' || finalStabilityCheck === 'once' && firstRun.current) {
+            const toCompare = selector(state);
+
+            if (!equalityFn(selected, toCompare)) {
+              console.warn('Selector ' + (selector.name || 'unknown') + ' returned a different result when called with the same parameters. This can lead to unnecessary rerenders.' + '\nSelectors that return a new reference (such as an object or an array) should be memoized: https://redux.js.org/usage/deriving-data-selectors#optimizing-selectors-with-memoization', {
+                state,
+                selected,
+                selected2: toCompare
+              });
+            }
+          }
+
+          const finalNoopCheck = typeof noopCheck === 'undefined' ? globalNoopCheck : noopCheck;
+
+          if (finalNoopCheck === 'always' || finalNoopCheck === 'once' && firstRun.current) {
+            // @ts-ignore
+            if (selected === state) {
+              console.warn('Selector ' + (selector.name || 'unknown') + ' returned the root state when called. This can lead to unnecessary rerenders.' + '\nSelectors that return the entire state are almost certainly a mistake, as they will cause a rerender whenever *anything* in state changes.');
+            }
+          }
+
+          if (firstRun.current) firstRun.current = false;
+        }
+
+        return selected;
+      }
+
+    }[selector.name], [selector, globalStabilityCheck, stabilityCheck]);
+    const selectedState = useSyncExternalStoreWithSelector(subscription.addNestedSub, store.getState, getServerState || store.getState, wrappedSelector, equalityFn);
+    useDebugValue(selectedState);
+    return selectedState;
+  };
+}
+/**
+ * A hook to access the redux store's state. This hook takes a selector function
+ * as an argument. The selector is called with the store state.
+ *
+ * This hook takes an optional equality comparison function as the second parameter
+ * that allows you to customize the way the selected state is compared to determine
+ * whether the component needs to be re-rendered.
+ *
+ * @param {Function} selector the selector function
+ * @param {Function=} equalityFn the function that will be used to determine equality
+ *
+ * @returns {any} the selected state
+ *
+ * @example
+ *
+ * import React from 'react'
+ * import { useSelector } from 'react-redux'
+ *
+ * export const CounterComponent = () => {
+ *   const counter = useSelector(state => state.counter)
+ *   return <div>{counter}</div>
+ * }
+ */
+
+const useSelector = /*#__PURE__*/createSelectorHook();
+
+var reactIs$1 = {exports: {}};
+
+var reactIs_production_min$1 = {};
+
+/** @license React v16.13.1
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var b$1="function"===typeof Symbol&&Symbol.for,c$1=b$1?Symbol.for("react.element"):60103,d$1=b$1?Symbol.for("react.portal"):60106,e$1=b$1?Symbol.for("react.fragment"):60107,f$1=b$1?Symbol.for("react.strict_mode"):60108,g$1=b$1?Symbol.for("react.profiler"):60114,h$1=b$1?Symbol.for("react.provider"):60109,k$1=b$1?Symbol.for("react.context"):60110,l$1=b$1?Symbol.for("react.async_mode"):60111,m$1=b$1?Symbol.for("react.concurrent_mode"):60111,n$1=b$1?Symbol.for("react.forward_ref"):60112,p$1=b$1?Symbol.for("react.suspense"):60113,q$1=b$1?
+Symbol.for("react.suspense_list"):60120,r=b$1?Symbol.for("react.memo"):60115,t$1=b$1?Symbol.for("react.lazy"):60116,v$1=b$1?Symbol.for("react.block"):60121,w=b$1?Symbol.for("react.fundamental"):60117,x=b$1?Symbol.for("react.responder"):60118,y=b$1?Symbol.for("react.scope"):60119;
+function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c$1:switch(a=a.type,a){case l$1:case m$1:case e$1:case g$1:case f$1:case p$1:return a;default:switch(a=a&&a.$$typeof,a){case k$1:case n$1:case t$1:case r:case h$1:return a;default:return u}}case d$1:return u}}}function A(a){return z(a)===m$1}reactIs_production_min$1.AsyncMode=l$1;reactIs_production_min$1.ConcurrentMode=m$1;reactIs_production_min$1.ContextConsumer=k$1;reactIs_production_min$1.ContextProvider=h$1;reactIs_production_min$1.Element=c$1;reactIs_production_min$1.ForwardRef=n$1;reactIs_production_min$1.Fragment=e$1;reactIs_production_min$1.Lazy=t$1;reactIs_production_min$1.Memo=r;reactIs_production_min$1.Portal=d$1;
+reactIs_production_min$1.Profiler=g$1;reactIs_production_min$1.StrictMode=f$1;reactIs_production_min$1.Suspense=p$1;reactIs_production_min$1.isAsyncMode=function(a){return A(a)||z(a)===l$1};reactIs_production_min$1.isConcurrentMode=A;reactIs_production_min$1.isContextConsumer=function(a){return z(a)===k$1};reactIs_production_min$1.isContextProvider=function(a){return z(a)===h$1};reactIs_production_min$1.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===c$1};reactIs_production_min$1.isForwardRef=function(a){return z(a)===n$1};reactIs_production_min$1.isFragment=function(a){return z(a)===e$1};reactIs_production_min$1.isLazy=function(a){return z(a)===t$1};
+reactIs_production_min$1.isMemo=function(a){return z(a)===r};reactIs_production_min$1.isPortal=function(a){return z(a)===d$1};reactIs_production_min$1.isProfiler=function(a){return z(a)===g$1};reactIs_production_min$1.isStrictMode=function(a){return z(a)===f$1};reactIs_production_min$1.isSuspense=function(a){return z(a)===p$1};
+reactIs_production_min$1.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===e$1||a===m$1||a===g$1||a===f$1||a===p$1||a===q$1||"object"===typeof a&&null!==a&&(a.$$typeof===t$1||a.$$typeof===r||a.$$typeof===h$1||a.$$typeof===k$1||a.$$typeof===n$1||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v$1)};reactIs_production_min$1.typeOf=z;
+
+var reactIs_development$1 = {};
+
+/** @license React v16.13.1
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+
+// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+// nor polyfill, then a plain number is used for performance.
+var hasSymbol = typeof Symbol === 'function' && Symbol.for;
+var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
+var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
+var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
+var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
+var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
+var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
+var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
+// (unstable) APIs that have been removed. Can we remove the symbols?
+
+var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
+var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
+var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
+var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
+var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
+var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
+var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
+var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
+var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
+var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
+var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
+
+function isValidElementType(type) {
+  return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+}
+
+function typeOf(object) {
+  if (typeof object === 'object' && object !== null) {
+    var $$typeof = object.$$typeof;
+
+    switch ($$typeof) {
+      case REACT_ELEMENT_TYPE:
+        var type = object.type;
+
+        switch (type) {
+          case REACT_ASYNC_MODE_TYPE:
+          case REACT_CONCURRENT_MODE_TYPE:
+          case REACT_FRAGMENT_TYPE:
+          case REACT_PROFILER_TYPE:
+          case REACT_STRICT_MODE_TYPE:
+          case REACT_SUSPENSE_TYPE:
+            return type;
+
+          default:
+            var $$typeofType = type && type.$$typeof;
+
+            switch ($$typeofType) {
+              case REACT_CONTEXT_TYPE:
+              case REACT_FORWARD_REF_TYPE:
+              case REACT_LAZY_TYPE:
+              case REACT_MEMO_TYPE:
+              case REACT_PROVIDER_TYPE:
+                return $$typeofType;
+
+              default:
+                return $$typeof;
+            }
+
+        }
+
+      case REACT_PORTAL_TYPE:
+        return $$typeof;
+    }
+  }
+
+  return undefined;
+} // AsyncMode is deprecated along with isAsyncMode
+
+var AsyncMode = REACT_ASYNC_MODE_TYPE;
+var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+var ContextConsumer = REACT_CONTEXT_TYPE;
+var ContextProvider = REACT_PROVIDER_TYPE;
+var Element = REACT_ELEMENT_TYPE;
+var ForwardRef = REACT_FORWARD_REF_TYPE;
+var Fragment = REACT_FRAGMENT_TYPE;
+var Lazy = REACT_LAZY_TYPE;
+var Memo = REACT_MEMO_TYPE;
+var Portal = REACT_PORTAL_TYPE;
+var Profiler = REACT_PROFILER_TYPE;
+var StrictMode = REACT_STRICT_MODE_TYPE;
+var Suspense = REACT_SUSPENSE_TYPE;
+var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
+
+function isAsyncMode(object) {
+  {
+    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
+    }
+  }
+
+  return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+}
+function isConcurrentMode(object) {
+  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+}
+function isContextConsumer(object) {
+  return typeOf(object) === REACT_CONTEXT_TYPE;
+}
+function isContextProvider(object) {
+  return typeOf(object) === REACT_PROVIDER_TYPE;
+}
+function isElement(object) {
+  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+}
+function isForwardRef(object) {
+  return typeOf(object) === REACT_FORWARD_REF_TYPE;
+}
+function isFragment(object) {
+  return typeOf(object) === REACT_FRAGMENT_TYPE;
+}
+function isLazy(object) {
+  return typeOf(object) === REACT_LAZY_TYPE;
+}
+function isMemo(object) {
+  return typeOf(object) === REACT_MEMO_TYPE;
+}
+function isPortal(object) {
+  return typeOf(object) === REACT_PORTAL_TYPE;
+}
+function isProfiler(object) {
+  return typeOf(object) === REACT_PROFILER_TYPE;
+}
+function isStrictMode(object) {
+  return typeOf(object) === REACT_STRICT_MODE_TYPE;
+}
+function isSuspense(object) {
+  return typeOf(object) === REACT_SUSPENSE_TYPE;
+}
+
+reactIs_development$1.AsyncMode = AsyncMode;
+reactIs_development$1.ConcurrentMode = ConcurrentMode;
+reactIs_development$1.ContextConsumer = ContextConsumer;
+reactIs_development$1.ContextProvider = ContextProvider;
+reactIs_development$1.Element = Element;
+reactIs_development$1.ForwardRef = ForwardRef;
+reactIs_development$1.Fragment = Fragment;
+reactIs_development$1.Lazy = Lazy;
+reactIs_development$1.Memo = Memo;
+reactIs_development$1.Portal = Portal;
+reactIs_development$1.Profiler = Profiler;
+reactIs_development$1.StrictMode = StrictMode;
+reactIs_development$1.Suspense = Suspense;
+reactIs_development$1.isAsyncMode = isAsyncMode;
+reactIs_development$1.isConcurrentMode = isConcurrentMode;
+reactIs_development$1.isContextConsumer = isContextConsumer;
+reactIs_development$1.isContextProvider = isContextProvider;
+reactIs_development$1.isElement = isElement;
+reactIs_development$1.isForwardRef = isForwardRef;
+reactIs_development$1.isFragment = isFragment;
+reactIs_development$1.isLazy = isLazy;
+reactIs_development$1.isMemo = isMemo;
+reactIs_development$1.isPortal = isPortal;
+reactIs_development$1.isProfiler = isProfiler;
+reactIs_development$1.isStrictMode = isStrictMode;
+reactIs_development$1.isSuspense = isSuspense;
+reactIs_development$1.isValidElementType = isValidElementType;
+reactIs_development$1.typeOf = typeOf;
+  })();
+}
+
+if (process.env.NODE_ENV === 'production') {
+  reactIs$1.exports = reactIs_production_min$1;
+} else {
+  reactIs$1.exports = reactIs_development$1;
+}
+
+var reactIs = reactIs$1.exports;
+var FORWARD_REF_STATICS = {
+  '$$typeof': true,
+  render: true,
+  defaultProps: true,
+  displayName: true,
+  propTypes: true
+};
+var MEMO_STATICS = {
+  '$$typeof': true,
+  compare: true,
+  defaultProps: true,
+  displayName: true,
+  propTypes: true,
+  type: true
+};
+var TYPE_STATICS = {};
+TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
+TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
+
+var reactIs_production_min = {};
+
+/**
+ * @license React
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var b=Symbol.for("react.element"),c=Symbol.for("react.portal"),d=Symbol.for("react.fragment"),e=Symbol.for("react.strict_mode"),f=Symbol.for("react.profiler"),g=Symbol.for("react.provider"),h=Symbol.for("react.context"),k=Symbol.for("react.server_context"),l=Symbol.for("react.forward_ref"),m=Symbol.for("react.suspense"),n=Symbol.for("react.suspense_list"),p=Symbol.for("react.memo"),q=Symbol.for("react.lazy"),t=Symbol.for("react.offscreen"),u;u=Symbol.for("react.module.reference");
+function v(a){if("object"===typeof a&&null!==a){var r=a.$$typeof;switch(r){case b:switch(a=a.type,a){case d:case f:case e:case m:case n:return a;default:switch(a=a&&a.$$typeof,a){case k:case h:case l:case q:case p:case g:return a;default:return r}}case c:return r}}}reactIs_production_min.ContextConsumer=h;reactIs_production_min.ContextProvider=g;reactIs_production_min.Element=b;reactIs_production_min.ForwardRef=l;reactIs_production_min.Fragment=d;reactIs_production_min.Lazy=q;reactIs_production_min.Memo=p;reactIs_production_min.Portal=c;reactIs_production_min.Profiler=f;reactIs_production_min.StrictMode=e;reactIs_production_min.Suspense=m;
+reactIs_production_min.SuspenseList=n;reactIs_production_min.isAsyncMode=function(){return !1};reactIs_production_min.isConcurrentMode=function(){return !1};reactIs_production_min.isContextConsumer=function(a){return v(a)===h};reactIs_production_min.isContextProvider=function(a){return v(a)===g};reactIs_production_min.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===b};reactIs_production_min.isForwardRef=function(a){return v(a)===l};reactIs_production_min.isFragment=function(a){return v(a)===d};reactIs_production_min.isLazy=function(a){return v(a)===q};reactIs_production_min.isMemo=function(a){return v(a)===p};
+reactIs_production_min.isPortal=function(a){return v(a)===c};reactIs_production_min.isProfiler=function(a){return v(a)===f};reactIs_production_min.isStrictMode=function(a){return v(a)===e};reactIs_production_min.isSuspense=function(a){return v(a)===m};reactIs_production_min.isSuspenseList=function(a){return v(a)===n};
+reactIs_production_min.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===d||a===f||a===e||a===m||a===n||a===t||"object"===typeof a&&null!==a&&(a.$$typeof===q||a.$$typeof===p||a.$$typeof===g||a.$$typeof===h||a.$$typeof===l||a.$$typeof===u||void 0!==a.getModuleId)?!0:!1};reactIs_production_min.typeOf=v;
+
+var reactIs_development = {};
+
+/**
+ * @license React
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types.
+var REACT_ELEMENT_TYPE = Symbol.for('react.element');
+var REACT_PORTAL_TYPE = Symbol.for('react.portal');
+var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+var REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+var REACT_CONTEXT_TYPE = Symbol.for('react.context');
+var REACT_SERVER_CONTEXT_TYPE = Symbol.for('react.server_context');
+var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+var REACT_MEMO_TYPE = Symbol.for('react.memo');
+var REACT_LAZY_TYPE = Symbol.for('react.lazy');
+var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+
+// -----------------------------------------------------------------------------
+
+var enableScopeAPI = false; // Experimental Create Event Handle API.
+var enableCacheElement = false;
+var enableTransitionTracing = false; // No known bugs, but needs performance testing
+
+var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+// stuff. Intended to enable React core members to more easily debug scheduling
+// issues in DEV builds.
+
+var enableDebugTracing = false; // Track which Fiber(s) schedule render work.
+
+var REACT_MODULE_REFERENCE;
+
+{
+  REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
+}
+
+function isValidElementType(type) {
+  if (typeof type === 'string' || typeof type === 'function') {
+    return true;
+  } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
+
+
+  if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing  || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden  || type === REACT_OFFSCREEN_TYPE || enableScopeAPI  || enableCacheElement  || enableTransitionTracing ) {
+    return true;
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
+    // types supported by any Flight configuration anywhere since
+    // we don't know which Flight build this will end up being used
+    // with.
+    type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function typeOf(object) {
+  if (typeof object === 'object' && object !== null) {
+    var $$typeof = object.$$typeof;
+
+    switch ($$typeof) {
+      case REACT_ELEMENT_TYPE:
+        var type = object.type;
+
+        switch (type) {
+          case REACT_FRAGMENT_TYPE:
+          case REACT_PROFILER_TYPE:
+          case REACT_STRICT_MODE_TYPE:
+          case REACT_SUSPENSE_TYPE:
+          case REACT_SUSPENSE_LIST_TYPE:
+            return type;
+
+          default:
+            var $$typeofType = type && type.$$typeof;
+
+            switch ($$typeofType) {
+              case REACT_SERVER_CONTEXT_TYPE:
+              case REACT_CONTEXT_TYPE:
+              case REACT_FORWARD_REF_TYPE:
+              case REACT_LAZY_TYPE:
+              case REACT_MEMO_TYPE:
+              case REACT_PROVIDER_TYPE:
+                return $$typeofType;
+
+              default:
+                return $$typeof;
+            }
+
+        }
+
+      case REACT_PORTAL_TYPE:
+        return $$typeof;
+    }
+  }
+
+  return undefined;
+}
+var ContextConsumer = REACT_CONTEXT_TYPE;
+var ContextProvider = REACT_PROVIDER_TYPE;
+var Element = REACT_ELEMENT_TYPE;
+var ForwardRef = REACT_FORWARD_REF_TYPE;
+var Fragment = REACT_FRAGMENT_TYPE;
+var Lazy = REACT_LAZY_TYPE;
+var Memo = REACT_MEMO_TYPE;
+var Portal = REACT_PORTAL_TYPE;
+var Profiler = REACT_PROFILER_TYPE;
+var StrictMode = REACT_STRICT_MODE_TYPE;
+var Suspense = REACT_SUSPENSE_TYPE;
+var SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+var hasWarnedAboutDeprecatedIsAsyncMode = false;
+var hasWarnedAboutDeprecatedIsConcurrentMode = false; // AsyncMode should be deprecated
+
+function isAsyncMode(object) {
+  {
+    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 18+.');
+    }
+  }
+
+  return false;
+}
+function isConcurrentMode(object) {
+  {
+    if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
+      hasWarnedAboutDeprecatedIsConcurrentMode = true; // Using console['warn'] to evade Babel and ESLint
+
+      console['warn']('The ReactIs.isConcurrentMode() alias has been deprecated, ' + 'and will be removed in React 18+.');
+    }
+  }
+
+  return false;
+}
+function isContextConsumer(object) {
+  return typeOf(object) === REACT_CONTEXT_TYPE;
+}
+function isContextProvider(object) {
+  return typeOf(object) === REACT_PROVIDER_TYPE;
+}
+function isElement(object) {
+  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+}
+function isForwardRef(object) {
+  return typeOf(object) === REACT_FORWARD_REF_TYPE;
+}
+function isFragment(object) {
+  return typeOf(object) === REACT_FRAGMENT_TYPE;
+}
+function isLazy(object) {
+  return typeOf(object) === REACT_LAZY_TYPE;
+}
+function isMemo(object) {
+  return typeOf(object) === REACT_MEMO_TYPE;
+}
+function isPortal(object) {
+  return typeOf(object) === REACT_PORTAL_TYPE;
+}
+function isProfiler(object) {
+  return typeOf(object) === REACT_PROFILER_TYPE;
+}
+function isStrictMode(object) {
+  return typeOf(object) === REACT_STRICT_MODE_TYPE;
+}
+function isSuspense(object) {
+  return typeOf(object) === REACT_SUSPENSE_TYPE;
+}
+function isSuspenseList(object) {
+  return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
+}
+
+reactIs_development.ContextConsumer = ContextConsumer;
+reactIs_development.ContextProvider = ContextProvider;
+reactIs_development.Element = Element;
+reactIs_development.ForwardRef = ForwardRef;
+reactIs_development.Fragment = Fragment;
+reactIs_development.Lazy = Lazy;
+reactIs_development.Memo = Memo;
+reactIs_development.Portal = Portal;
+reactIs_development.Profiler = Profiler;
+reactIs_development.StrictMode = StrictMode;
+reactIs_development.Suspense = Suspense;
+reactIs_development.SuspenseList = SuspenseList;
+reactIs_development.isAsyncMode = isAsyncMode;
+reactIs_development.isConcurrentMode = isConcurrentMode;
+reactIs_development.isContextConsumer = isContextConsumer;
+reactIs_development.isContextProvider = isContextProvider;
+reactIs_development.isElement = isElement;
+reactIs_development.isForwardRef = isForwardRef;
+reactIs_development.isFragment = isFragment;
+reactIs_development.isLazy = isLazy;
+reactIs_development.isMemo = isMemo;
+reactIs_development.isPortal = isPortal;
+reactIs_development.isProfiler = isProfiler;
+reactIs_development.isStrictMode = isStrictMode;
+reactIs_development.isSuspense = isSuspense;
+reactIs_development.isSuspenseList = isSuspenseList;
+reactIs_development.isValidElementType = isValidElementType;
+reactIs_development.typeOf = typeOf;
+  })();
+}
+
+if (process.env.NODE_ENV === 'production') ;
+
+/**
+ * Hook factory, which creates a `useStore` hook bound to a given context.
+ *
+ * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.
+ * @returns {Function} A `useStore` hook bound to the specified context.
+ */
+
+function createStoreHook(context = ReactReduxContext) {
+  const useReduxContext$1 = // @ts-ignore
+  context === ReactReduxContext ? useReduxContext : // @ts-ignore
+  createReduxContextHook(context);
+  return function useStore() {
+    const {
+      store
+    } = useReduxContext$1(); // @ts-ignore
+
+    return store;
+  };
+}
+/**
+ * A hook to access the redux store.
+ *
+ * @returns {any} the redux store
+ *
+ * @example
+ *
+ * import React from 'react'
+ * import { useStore } from 'react-redux'
+ *
+ * export const ExampleComponent = () => {
+ *   const store = useStore()
+ *   return <div>{store.getState()}</div>
+ * }
+ */
+
+const useStore = /*#__PURE__*/createStoreHook();
+
+/**
+ * Hook factory, which creates a `useDispatch` hook bound to a given context.
+ *
+ * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.
+ * @returns {Function} A `useDispatch` hook bound to the specified context.
+ */
+
+function createDispatchHook(context = ReactReduxContext) {
+  const useStore$1 = // @ts-ignore
+  context === ReactReduxContext ? useStore : createStoreHook(context);
+  return function useDispatch() {
+    const store = useStore$1(); // @ts-ignore
+
+    return store.dispatch;
+  };
+}
+/**
+ * A hook to access the redux `dispatch` function.
+ *
+ * @returns {any|function} redux store's `dispatch` function
+ *
+ * @example
+ *
+ * import React, { useCallback } from 'react'
+ * import { useDispatch } from 'react-redux'
+ *
+ * export const CounterComponent = ({ value }) => {
+ *   const dispatch = useDispatch()
+ *   const increaseCounter = useCallback(() => dispatch({ type: 'increase-counter' }), [])
+ *   return (
+ *     <div>
+ *       <span>{value}</span>
+ *       <button onClick={increaseCounter}>Increase counter</button>
+ *     </div>
+ *   )
+ * }
+ */
+
+const useDispatch = /*#__PURE__*/createDispatchHook();
+
+// The primary entry point assumes we're working with standard ReactDOM/RN, but
+initializeUseSelector(withSelector.exports.useSyncExternalStoreWithSelector);
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2023 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2023 - Finnish Meteorological Institute (FMI)
+ * */
+var dialogType$1 = uiTypes.DialogTypes.AreaManager;
+var AreaManagerMapButtonConnect = function AreaManagerMapButtonConnect(_ref) {
+  var mapId = _ref.mapId,
+    _ref$source = _ref.source,
+    source = _ref$source === void 0 ? 'app' : _ref$source;
+  var dispatch = useDispatch();
+  var mapIdForCurrentlyOpenDialog = useSelector(function (store) {
+    return uiSelectors.getDialogMapId(store, dialogType$1);
+  });
+  var dialogIsOpen = useSelector(function (store) {
+    return uiSelectors.getisDialogOpen(store, dialogType$1);
+  });
+  return /*#__PURE__*/React__default.createElement(MapControlButton, {
+    "aria-label": "Area Manager Button for ".concat(mapId),
+    title: "Area Manager",
+    onClick: function onClick() {
+      var openDialogForAnotherMap = mapIdForCurrentlyOpenDialog !== mapId;
+      var shouldOpen = openDialogForAnotherMap || !dialogIsOpen;
+      dispatch(uiActions.setActiveMapIdForDialog({
+        type: dialogType$1,
+        mapId: mapId,
+        setOpen: shouldOpen,
+        source: source
+      }));
+    },
+    isActive: mapIdForCurrentlyOpenDialog === mapId && dialogIsOpen
+  }, /*#__PURE__*/React__default.createElement(Polygons, null));
+};
+
+function _iterableToArrayLimit(arr, i) {
+  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+  if (null != _i) {
+    var _s,
+      _e,
+      _x,
+      _r,
+      _arr = [],
+      _n = !0,
+      _d = !1;
+    try {
+      if (_x = (_i = _i.call(arr)).next, 0 === i) {
+        if (Object(_i) !== _i) return;
+        _n = !1;
+      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return 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 (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 (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 {
+          value: void 0,
+          done: !0
+        };
+      }
+      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 methodName = context.method,
+      method = delegate.iterator[methodName];
+    if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), 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 || "" === 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;
+      }
+    }
+    throw new TypeError(typeof iterable + " is not iterable");
+  }
+  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 (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 () {
+      this.done = !0;
+      var rootRecord = this.tryEntries[0].completion;
+      if ("throw" === rootRecord.type) throw rootRecord.arg;
+      return this.rval;
+    },
+    dispatchException: function (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 (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 (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 (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 (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 (iterable, resultName, nextLoc) {
+      return this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+    }
+  }, exports;
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _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.");
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2023 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2023 - Finnish Meteorological Institute (FMI)
+ * */
+var Drawings = function Drawings(_ref) {
+  var drawings = _ref.drawings,
+    onClickDrawing = _ref.onClickDrawing,
+    onClickEdit = _ref.onClickEdit,
+    activeDrawing = _ref.activeDrawing;
+  var lastHeaderRef = React__default.useRef('');
+  return /*#__PURE__*/React__default.createElement(List, null, drawings.map(function (drawing) {
+    var drawingDate = dateUtils.isoStringToDate(drawing.lastUpdatedTime);
+    var header = dateUtils.dateToString(drawingDate, 'EEEE, MMMM dd', true);
+    var isNewDay = lastHeaderRef.current !== header;
+    lastHeaderRef.current = header;
+    return /*#__PURE__*/React__default.createElement(Fragment, {
+      key: drawing.id
+    }, isNewDay && /*#__PURE__*/React__default.createElement(Typography, {
+      sx: {
+        paddingLeft: '20px'
+      },
+      variant: "caption"
+    }, header), /*#__PURE__*/React__default.createElement(ListItem, {
+      disablePadding: true,
+      secondaryAction: /*#__PURE__*/React__default.createElement(ToggleMenu, {
+        menuTitle: "Area options",
+        tooltipTitle: "Area options",
+        menuPosition: "bottom",
+        "aria-label": "Options"
+      }, /*#__PURE__*/React__default.createElement(MenuItem, {
+        onClick: function onClick() {
+          return onClickEdit(drawing.id);
+        }
+      }, /*#__PURE__*/React__default.createElement(ListItemText, null, "Edit"), /*#__PURE__*/React__default.createElement(Edit, null)), /*#__PURE__*/React__default.createElement(MenuItem, null, /*#__PURE__*/React__default.createElement(ListItemText, null, "Delete"), " ", /*#__PURE__*/React__default.createElement(Delete, null)))
+    }, /*#__PURE__*/React__default.createElement(Paper, {
+      elevation: 1,
+      sx: {
+        width: '100%',
+        margin: 0.5,
+        backgroundColor: 'geowebColors.background.surface'
+      }
+    }, /*#__PURE__*/React__default.createElement(ListItemButton, {
+      onClick: function onClick() {
+        onClickDrawing(drawing);
+      }
+    }, activeDrawing === drawing.id && /*#__PURE__*/React__default.createElement(Box, {
+      sx: {
+        backgroundColor: 'geowebColors.captions.captionInformation.color',
+        width: '4px',
+        height: '100%',
+        position: 'absolute',
+        left: 0
+      },
+      className: "active"
+    }), /*#__PURE__*/React__default.createElement(Stack, null, /*#__PURE__*/React__default.createElement(Typography, {
+      variant: "caption"
+    }, drawing.name), /*#__PURE__*/React__default.createElement(Typography, {
+      variant: "body2"
+    }, dateUtils.dateToString(drawingDate, 'dd/MM/yyyy HH:ss', true), ' ', "UTC"))))));
+  }));
+};
+
+var calculateStartSize = function calculateStartSize(minSize, prefSize, startPosition) {
+  var _calculateDialogSizeA = calculateDialogSizeAndPosition(),
+    calcWidth = _calculateDialogSizeA.width,
+    calcHeight = _calculateDialogSizeA.height;
+  return {
+    width: Math.max(minSize.width, Math.min(prefSize.width, calcWidth)),
+    height: Math.max(minSize.height, Math.min(prefSize.height, calcHeight - startPosition.top))
+  };
+};
+var DEFAULT_AREA_MANAGER_SIZE = {
+  width: 320,
+  height: 542
+};
+var DEFAULT_AREA_MANAGER_POSITION = {
+  top: 120,
+  left: 50
+};
+var DEFAULT_AREA_MANAGER_MIN_SIZE = {
+  width: 160,
+  height: 300
+};
+var AreaManager = function AreaManager(_ref) {
+  var bounds = _ref.bounds,
+    onClose = _ref.onClose,
+    _ref$title = _ref.title,
+    title = _ref$title === void 0 ? 'Area Manager' : _ref$title,
+    isOpen = _ref.isOpen,
+    _ref$onMouseDown = _ref.onMouseDown,
+    onMouseDown = _ref$onMouseDown === void 0 ? function () {} : _ref$onMouseDown,
+    _ref$order = _ref.order,
+    order = _ref$order === void 0 ? 0 : _ref$order,
+    _ref$source = _ref.source,
+    source = _ref$source === void 0 ? 'app' : _ref$source,
+    _ref$size = _ref.size,
+    size = _ref$size === void 0 ? DEFAULT_AREA_MANAGER_SIZE : _ref$size,
+    _ref$startPosition = _ref.startPosition,
+    startPosition = _ref$startPosition === void 0 ? DEFAULT_AREA_MANAGER_POSITION : _ref$startPosition,
+    _ref$setFocused = _ref.setFocused,
+    setFocused = _ref$setFocused === void 0 ? function () {} : _ref$setFocused,
+    _ref$headerSize = _ref.headerSize,
+    headerSize = _ref$headerSize === void 0 ? 'xs' : _ref$headerSize,
+    drawingListItems = _ref.drawingListItems,
+    _ref$onClickDrawing = _ref.onClickDrawing,
+    onClickDrawing = _ref$onClickDrawing === void 0 ? function () {} : _ref$onClickDrawing,
+    _ref$onUnMount = _ref.onUnMount,
+    onUnMount = _ref$onUnMount === void 0 ? function () {} : _ref$onUnMount,
+    _ref$onEditDrawing = _ref.onEditDrawing,
+    onEditDrawing = _ref$onEditDrawing === void 0 ? function () {} : _ref$onEditDrawing,
+    _ref$activeDrawingId = _ref.activeDrawingId,
+    activeDrawingId = _ref$activeDrawingId === void 0 ? '' : _ref$activeDrawingId;
+  var minSize = DEFAULT_AREA_MANAGER_MIN_SIZE;
+  var startSizeCalc = calculateStartSize(minSize, size, startPosition);
+  var _React$useState = React.useState(startSizeCalc),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    sizeInState = _React$useState2[0],
+    setSizeInState = _React$useState2[1];
+  React.useEffect(function () {
+    return function () {
+      onUnMount();
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  return /*#__PURE__*/React.createElement(ToolContainerDraggable, {
+    title: title,
+    startSize: sizeInState,
+    minWidth: minSize.width,
+    minHeight: minSize.height,
+    startPosition: startPosition,
+    isOpen: isOpen,
+    onClose: onClose,
+    headerSize: headerSize,
+    bounds: bounds,
+    onMouseDown: onMouseDown,
+    onFocus: function onFocus() {
+      return setFocused(true);
+    },
+    onBlur: function onBlur() {
+      return setFocused(false);
+    },
+    order: order,
+    source: source,
+    onResizeStop: function onResizeStop(_event, _direction, node) {
+      var width = node.offsetWidth,
+        height = node.offsetHeight;
+      setSizeInState({
+        width: width,
+        height: height
+      });
+    },
+    onDragEnd: function onDragEnd(_position, dragSize) {
+      if (dragSize !== sizeInState) {
+        setSizeInState(dragSize);
+      }
+    }
+  }, /*#__PURE__*/React.createElement(Drawings, {
+    drawings: drawingListItems,
+    onClickDrawing: onClickDrawing,
+    onClickEdit: onEditDrawing,
+    activeDrawing: activeDrawingId
+  }));
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2023 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2023 - Finnish Meteorological Institute (FMI)
+ * */
+var API_NAME = 'warnings';
+var getApiRoutes$1 = function getApiRoutes(axiosInstance) {
+  return {
+    getDrawings: function getDrawings() {
+      return axiosInstance.get('/drawings');
+    },
+    getDrawingDetails: function getDrawingDetails(drawingId) {
+      return axiosInstance.get("/drawings/".concat(drawingId));
+    },
+    updateDrawing: function updateDrawing(drawingId, data) {
+      return axiosInstance.put("/drawings/".concat(drawingId, "/"), data);
+    },
+    saveDrawingAs: function saveDrawingAs(data) {
+      return axiosInstance.post("/drawings/", data);
+    },
+    deleteDrawing: function deleteDrawing(drawingId) {
+      return axiosInstance["delete"]("/drawings/".concat(drawingId));
+    }
+  };
+};
+var getWarningsApi = function getWarningsApi() {
+  return getApi(API_NAME);
+};
+var createApi$1 = function createApi(props) {
+  var authInstance = createApiInstance(props);
+  var nonAuthInstance = createNonAuthApiInstance(props);
+  return getApiRoutes$1(props.auth ? authInstance : nonAuthInstance);
+};
+
+var dialogType = uiTypes.DialogTypes.AreaManager;
+var AreaManagerConnect = function AreaManagerConnect(_ref) {
+  var bounds = _ref.bounds,
+    _ref$source = _ref.source,
+    source = _ref$source === void 0 ? 'app' : _ref$source;
+  var _useSetupDialog = useSetupDialog(dialogType, source),
+    dialogOrder = _useSetupDialog.dialogOrder,
+    setDialogOrder = _useSetupDialog.setDialogOrder,
+    onCloseDialog = _useSetupDialog.onCloseDialog,
+    isDialogOpen = _useSetupDialog.isDialogOpen,
+    uiSource = _useSetupDialog.uiSource,
+    setFocused = _useSetupDialog.setFocused;
+  var warningsApi = getWarningsApi();
+  var dispatch = useDispatch();
+  var mapId = useSelector(function (store) {
+    return uiSelectors.getDialogMapId(store, dialogType);
+  });
+  var geoJSONLayerId = "".concat(mapId, "-geosjon");
+  var currentLayer = useSelector(function (store) {
+    return layerSelectors.getLayerById(store, geoJSONLayerId);
+  });
+  var currrentDrawing = useSelector(function (store) {
+    return drawSelectors.selectDrawByMapId(store, mapId);
+  });
+  var activeDrawingId = (currrentDrawing === null || currrentDrawing === void 0 ? void 0 : currrentDrawing.id) || '';
+  var _useState = useState([]),
+    _useState2 = _slicedToArray(_useState, 2),
+    drawings = _useState2[0],
+    setDrawings = _useState2[1];
+  useEffect(function () {
+    warningsApi.getDrawings().then(function (response) {
+      setDrawings(response.data);
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  var deleteGeoJSONLayer = function deleteGeoJSONLayer() {
+    dispatch(mapStoreActions.layerDelete({
+      layerId: geoJSONLayerId,
+      mapId: mapId,
+      layerIndex: 0
+    }));
+  };
+  var showGeoJSONLayer = function showGeoJSONLayer(drawing) {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!currentLayer) {
+              dispatch(mapStoreActions.addLayer({
+                mapId: mapId,
+                layer: {
+                  geojson: drawing.area
+                },
+                layerId: geoJSONLayerId,
+                origin: 'warnings-lib'
+              }));
+            } else {
+              dispatch(mapStoreActions.layerChangeGeojson({
+                layerId: geoJSONLayerId,
+                geojson: drawing.area
+              }));
+            }
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+  };
+  var onClickDrawing = function onClickDrawing(drawing) {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+      var isActive;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            isActive = drawing.id === (currrentDrawing === null || currrentDrawing === void 0 ? void 0 : currrentDrawing.id);
+            dispatch(drawActions.setDrawValues({
+              area: drawing.area,
+              areaName: drawing.name,
+              mapId: mapId,
+              id: !isActive ? drawing.id : ''
+            }));
+            if (isActive) {
+              deleteGeoJSONLayer();
+            } else {
+              showGeoJSONLayer(drawing);
+            }
+          case 3:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+  };
+  var openDrawTools = function openDrawTools(drawingId) {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+      var _yield$warningsApi$ge, data;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.prev = 0;
+            _context3.next = 3;
+            return warningsApi.getDrawingDetails(drawingId);
+          case 3:
+            _yield$warningsApi$ge = _context3.sent;
+            data = _yield$warningsApi$ge.data;
+            // update draw tool values
+            dispatch(drawActions.setDrawValues({
+              area: data.area,
+              areaName: data.name,
+              mapId: mapId,
+              id: drawingId
+            }));
+            // open draw dialog
+            dispatch(uiActions.setActiveMapIdForDialog({
+              type: "".concat(uiTypes.DialogTypes.DockedDrawingTool, "-").concat(mapId),
+              mapId: mapId,
+              setOpen: true,
+              source: source
+            }));
+            _context3.next = 11;
+            break;
+          case 9:
+            _context3.prev = 9;
+            _context3.t0 = _context3["catch"](0);
+          case 11:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, null, [[0, 9]]);
+    }));
+  };
+  var onEditDrawing = function onEditDrawing(drawingId) {
+    // delete current redux layers
+    deleteGeoJSONLayer();
+    onCloseDialog();
+    openDrawTools(drawingId);
+  };
+  var onClose = function onClose() {
+    onCloseDialog();
+  };
+  var onHideAreaManager = function onHideAreaManager() {
+    deleteGeoJSONLayer();
+  };
+  if (!isDialogOpen) {
+    return null;
+  }
+  return /*#__PURE__*/React__default.createElement(AreaManager, {
+    title: "Area Manager for ".concat(mapId),
+    bounds: bounds,
+    isOpen: isDialogOpen,
+    onClose: onClose,
+    onMouseDown: setDialogOrder,
+    order: dialogOrder,
+    source: uiSource,
+    setFocused: setFocused,
+    headerSize: "xs",
+    startPosition: {
+      top: 104,
+      left: 50
+    },
+    drawingListItems: drawings,
+    onClickDrawing: onClickDrawing,
+    onUnMount: onHideAreaManager,
+    onEditDrawing: onEditDrawing,
+    activeDrawingId: activeDrawingId
+  });
+};
+
+var drawingList = [
+	{
+		id: "923723984872338768743",
+		name: "Drawing area 101",
+		lastUpdatedTime: "2022-06-01T12:34:27Z",
+		scope: "user",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									3.357673379394467,
+									54.021903403974555
+								],
+								[
+									6.600428193305415,
+									54.583753881732186
+								],
+								[
+									6.642909697417786,
+									50.7929736738295
+								],
+								[
+									3.357673379394467,
+									54.021903403974555
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	},
+	{
+		id: "934834893283",
+		name: "Area 89",
+		lastUpdatedTime: "2022-05-26T12:34:27Z",
+		scope: "user",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									3.3151918752820957,
+									52.58351427721301
+								],
+								[
+									4.433871483574519,
+									54.33682382687621
+								],
+								[
+									6.6287491960469955,
+									54.20451802569423
+								],
+								[
+									5.580872094608522,
+									54.063477378446876
+								],
+								[
+									5.014452039776916,
+									53.08821448043569
+								],
+								[
+									5.184378056226398,
+									50.69440676773111
+								],
+								[
+									4.263945467125037,
+									52.367886565469774
+								],
+								[
+									3.4851178917315777,
+									52.116433206467654
+								],
+								[
+									3.3151918752820957,
+									52.58351427721301
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	},
+	{
+		id: "345346456345",
+		name: "Area 88",
+		lastUpdatedTime: "2022-05-26T12:34:27Z",
+		scope: "user",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									10.481821619038993,
+									58.535200764136974
+								],
+								[
+									8.640758193817074,
+									60.346399887508504
+								],
+								[
+									13.391889613744592,
+									67.5974266962731
+								],
+								[
+									16.658292464944765,
+									66.50937700061121
+								],
+								[
+									10.481821619038993,
+									58.535200764136974
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	},
+	{
+		id: "4556657",
+		name: "Draw from Bernard 01",
+		lastUpdatedTime: "2022-05-26T12:34:27Z",
+		scope: "user",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									20.93431074287952,
+									62.25647725012774
+								],
+								[
+									31.030465010225495,
+									63.81786602783593
+								],
+								[
+									31.030465010225495,
+									62.777202248150076
+								],
+								[
+									27.348338159781672,
+									60.58061892723374
+								],
+								[
+									23.369265595592385,
+									59.99189262957603
+								],
+								[
+									21.409423884872282,
+									60.69709580628983
+								],
+								[
+									20.93431074287952,
+									62.25647725012774
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	},
+	{
+		id: "23435656567",
+		name: "Test drawing",
+		lastUpdatedTime: "2022-05-24T12:34:27Z",
+		scope: "user",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									20.93431074287952,
+									69.36114032013387
+								],
+								[
+									22.715985025352346,
+									68.74546806467802
+								],
+								[
+									24.972772449817917,
+									68.50738411845781
+								],
+								[
+									27.88284044452352,
+									70.08148816575513
+								],
+								[
+									29.18940158500359,
+									69.6315632353234
+								],
+								[
+									29.902071297992713,
+									67.55211547473719
+								],
+								[
+									24.141324451330597,
+									65.64245127864648
+								],
+								[
+									20.93431074287952,
+									69.36114032013387
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	},
+	{
+		id: "34536467568",
+		name: "Sigmet drawing 22-05",
+		lastUpdatedTime: "2022-05-22T12:34:27Z",
+		scope: "user",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									9.412817049555295,
+									59.99189262957603
+								],
+								[
+									10.897545618282647,
+									60.0215811509381
+								],
+								[
+									11.253880474777208,
+									58.87454186571334
+								],
+								[
+									9.65037362055167,
+									58.87454186571334
+								],
+								[
+									9.412817049555295,
+									59.99189262957603
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	},
+	{
+		id: "4556789789345345",
+		name: "Area 55",
+		lastUpdatedTime: "2022-05-21T12:34:27Z",
+		scope: "user",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									5.13958073010762,
+									52.378706353966585
+								],
+								[
+									5.641217196283798,
+									52.61090322290158
+								],
+								[
+									5.847369168684968,
+									52.57750901498518
+								],
+								[
+									5.806138774204734,
+									52.42272955304427
+								],
+								[
+									5.545012942496586,
+									52.35562905080307
+								],
+								[
+									5.507218414223038,
+									52.26950740893074
+								],
+								[
+									5.393834829402396,
+									52.27791689754497
+								],
+								[
+									5.270143645961694,
+									52.330440060249835
+								],
+								[
+									5.167067659761109,
+									52.33673865324146
+								],
+								[
+									5.13958073010762,
+									52.378706353966585
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	}
+];
+
+var drawingsListFullContent = [
+	{
+		id: "923723984872338768743",
+		name: "Drawing area 101",
+		lastUpdatedTime: "2022-06-01T12:34:27Z",
+		scope: "user",
+		username: "Dwight Schrute",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									3.357673379394467,
+									54.021903403974555
+								],
+								[
+									6.600428193305415,
+									54.583753881732186
+								],
+								[
+									6.642909697417786,
+									50.7929736738295
+								],
+								[
+									3.357673379394467,
+									54.021903403974555
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	},
+	{
+		id: "934834893283",
+		name: "Area 89",
+		lastUpdatedTime: "2022-05-31T12:34:27Z",
+		scope: "user",
+		username: "Dwight Schrute",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									3.3151918752820957,
+									52.58351427721301
+								],
+								[
+									4.433871483574519,
+									54.33682382687621
+								],
+								[
+									6.6287491960469955,
+									54.20451802569423
+								],
+								[
+									5.580872094608522,
+									54.063477378446876
+								],
+								[
+									5.014452039776916,
+									53.08821448043569
+								],
+								[
+									5.184378056226398,
+									50.69440676773111
+								],
+								[
+									4.263945467125037,
+									52.367886565469774
+								],
+								[
+									3.4851178917315777,
+									52.116433206467654
+								],
+								[
+									3.3151918752820957,
+									52.58351427721301
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	},
+	{
+		id: "345346456345",
+		name: "Area 88",
+		lastUpdatedTime: "2022-05-26T12:34:27Z",
+		scope: "user",
+		username: "Dwight Schrute",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									10.481821619038993,
+									58.535200764136974
+								],
+								[
+									8.640758193817074,
+									60.346399887508504
+								],
+								[
+									13.391889613744592,
+									67.5974266962731
+								],
+								[
+									16.658292464944765,
+									66.50937700061121
+								],
+								[
+									10.481821619038993,
+									58.535200764136974
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	},
+	{
+		id: "4556657",
+		name: "Draw from Bernard 01",
+		lastUpdatedTime: "2022-05-25T12:34:27Z",
+		scope: "user",
+		username: "Dwight Schrute",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									20.93431074287952,
+									62.25647725012774
+								],
+								[
+									31.030465010225495,
+									63.81786602783593
+								],
+								[
+									31.030465010225495,
+									62.777202248150076
+								],
+								[
+									27.348338159781672,
+									60.58061892723374
+								],
+								[
+									23.369265595592385,
+									59.99189262957603
+								],
+								[
+									21.409423884872282,
+									60.69709580628983
+								],
+								[
+									20.93431074287952,
+									62.25647725012774
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	},
+	{
+		id: "23435656567",
+		name: "Test drawing",
+		lastUpdatedTime: "2022-05-24T12:34:27Z",
+		scope: "user",
+		username: "Dwight Schrute",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									20.93431074287952,
+									69.36114032013387
+								],
+								[
+									22.715985025352346,
+									68.74546806467802
+								],
+								[
+									24.972772449817917,
+									68.50738411845781
+								],
+								[
+									27.88284044452352,
+									70.08148816575513
+								],
+								[
+									29.18940158500359,
+									69.6315632353234
+								],
+								[
+									29.902071297992713,
+									67.55211547473719
+								],
+								[
+									24.141324451330597,
+									65.64245127864648
+								],
+								[
+									20.93431074287952,
+									69.36114032013387
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	},
+	{
+		id: "34536467568",
+		name: "Sigmet drawing 22-05",
+		lastUpdatedTime: "2022-05-22T12:34:27Z",
+		scope: "user",
+		username: "Dwight Schrute",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									9.412817049555295,
+									59.99189262957603
+								],
+								[
+									10.897545618282647,
+									60.0215811509381
+								],
+								[
+									11.253880474777208,
+									58.87454186571334
+								],
+								[
+									9.65037362055167,
+									58.87454186571334
+								],
+								[
+									9.412817049555295,
+									59.99189262957603
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	},
+	{
+		id: "4556789789345345",
+		name: "Area 55",
+		lastUpdatedTime: "2022-05-21T12:34:27Z",
+		scope: "user",
+		username: "Dwight Schrute",
+		area: {
+			type: "FeatureCollection",
+			features: [
+				{
+					type: "Feature",
+					properties: {
+						fill: "#ff7800",
+						"fill-opacity": 0.2,
+						stroke: "#ff7800",
+						"stroke-width": 2,
+						"stroke-opacity": 1,
+						selectionType: "poly"
+					},
+					geometry: {
+						type: "Polygon",
+						coordinates: [
+							[
+								[
+									5.13958073010762,
+									52.378706353966585
+								],
+								[
+									5.641217196283798,
+									52.61090322290158
+								],
+								[
+									5.847369168684968,
+									52.57750901498518
+								],
+								[
+									5.806138774204734,
+									52.42272955304427
+								],
+								[
+									5.545012942496586,
+									52.35562905080307
+								],
+								[
+									5.507218414223038,
+									52.26950740893074
+								],
+								[
+									5.393834829402396,
+									52.27791689754497
+								],
+								[
+									5.270143645961694,
+									52.330440060249835
+								],
+								[
+									5.167067659761109,
+									52.33673865324146
+								],
+								[
+									5.13958073010762,
+									52.378706353966585
+								]
+							]
+						]
+					}
+				}
+			]
+		}
+	}
+];
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2023 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2023 - Finnish Meteorological Institute (FMI)
+ * */
+var ERROR_NOT_FOUND = 'Request failed with status code 400';
+var extractDrawingDetailsFromJSON = function extractDrawingDetailsFromJSON(drawingId) {
+  return drawingsListFullContent.find(function (element) {
+    return element.id === drawingId;
+  });
+};
+var getApiRoutes = function getApiRoutes(axiosInstance) {
+  return {
+    // drawings
+    getDrawings: function getDrawings() {
+      return axiosInstance.get('/drawings').then(function () {
+        var data = drawingList;
+        return {
+          data: data
+        };
+      });
+    },
+    getDrawingDetails: function getDrawingDetails(drawingId) {
+      return axiosInstance.get("/drawings/".concat(drawingId)).then(function () {
+        if (!extractDrawingDetailsFromJSON(drawingId)) {
+          throw new Error(ERROR_NOT_FOUND);
+        }
+        return {
+          data: extractDrawingDetailsFromJSON(drawingId)
+        };
+      });
+    },
+    updateDrawing: function updateDrawing(drawingId, data) {
+      // eslint-disable-next-line no-console
+      console.log('api: save drawing', drawingId, data);
+      return axiosInstance.put("/drawings/".concat(drawingId, "/"), data);
+    },
+    saveDrawingAs: function saveDrawingAs(data) {
+      // eslint-disable-next-line no-console
+      console.log('api: save drawing as', data);
+      return axiosInstance.post("/drawings/", data).then(function () {
+        return 'new-drawing-id';
+      });
+    },
+    deleteDrawing: function deleteDrawing(drawingId) {
+      // eslint-disable-next-line no-console
+      console.log('api: delete drawing', drawingId);
+      return axiosInstance["delete"]("/drawings/".concat(drawingId));
+    }
+  };
+};
+// used in storybook
+var createApi = function createApi() {
+  var instance = createFakeApiInstance();
+  return getApiRoutes(instance);
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2023 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2023 - Finnish Meteorological Institute (FMI)
+ * */
+var WarningsModuleProvider = function WarningsModuleProvider(_ref) {
+  var config = _ref.config,
+    auth = _ref.auth,
+    onSetAuth = _ref.onSetAuth,
+    children = _ref.children;
+  return /*#__PURE__*/React.createElement(ApiProvider, {
+    config: config,
+    auth: auth,
+    onSetAuth: onSetAuth,
+    createApi: config !== undefined ? createApi$1 : createApi,
+    name: API_NAME
+  }, children);
+};
+
+var createSymbol = function createSymbol(name) {
+  return "@@redux-saga/" + name;
+};
+
+var CANCEL$1 =
+/*#__PURE__*/
+createSymbol('CANCEL_PROMISE');
+var IO =
+/*#__PURE__*/
+createSymbol('IO');
+var MULTICAST =
+/*#__PURE__*/
+createSymbol('MULTICAST');
+var SELF_CANCELLATION =
+/*#__PURE__*/
+createSymbol('SELF_CANCELLATION');
+var TASK =
+/*#__PURE__*/
+createSymbol('TASK');
+
+var undef = function undef(v) {
+  return v === null || v === undefined;
+};
+var notUndef = function notUndef(v) {
+  return v !== null && v !== undefined;
+};
+var func = function func(f) {
+  return typeof f === 'function';
+};
+var string = function string(s) {
+  return typeof s === 'string';
+};
+var array = Array.isArray;
+var object = function object(obj) {
+  return obj && !array(obj) && typeof obj === 'object';
+};
+var task = function task(t) {
+  return t && t[TASK];
+};
+var pattern = function pattern(pat) {
+  return pat && (string(pat) || symbol(pat) || func(pat) || array(pat) && pat.every(pattern));
+};
+var channel = function channel(ch) {
+  return ch && func(ch.take) && func(ch.close);
+};
+var stringableFunc = function stringableFunc(f) {
+  return func(f) && f.hasOwnProperty('toString');
+};
+var symbol = function symbol(sym) {
+  return Boolean(sym) && typeof Symbol === 'function' && sym.constructor === Symbol && sym !== Symbol.prototype;
+};
+var multicast = function multicast(ch) {
+  return channel(ch) && ch[MULTICAST];
+};
+var effect = function effect(eff) {
+  return eff && eff[IO];
+};
+
+var MAX_SIGNED_INT = 2147483647;
+function delayP(ms, val) {
+  if (val === void 0) {
+    val = true;
+  }
+
+  // https://developer.mozilla.org/en-US/docs/Web/API/setTimeout#maximum_delay_value
+  if (process.env.NODE_ENV !== 'production' && ms > MAX_SIGNED_INT) {
+    throw new Error('delay only supports a maximum value of ' + MAX_SIGNED_INT + 'ms');
+  }
+
+  var timeoutId;
+  var promise = new Promise(function (resolve) {
+    timeoutId = setTimeout(resolve, Math.min(MAX_SIGNED_INT, ms), val);
+  });
+
+  promise[CANCEL$1] = function () {
+    clearTimeout(timeoutId);
+  };
+
+  return promise;
+}
+
+if (process.env.NODE_ENV !== 'production' && typeof Proxy !== 'undefined') ;
+var identity = function identity(v) {
+  return v;
+};
+function check(value, predicate, error) {
+  if (!predicate(value)) {
+    throw new Error(error);
+  }
+}
+
+var kThrow = function kThrow(err) {
+  throw err;
+};
+
+var kReturn = function kReturn(value) {
+  return {
+    value: value,
+    done: true
+  };
+};
+
+function makeIterator(next, thro, name) {
+  if (thro === void 0) {
+    thro = kThrow;
+  }
+
+  if (name === void 0) {
+    name = 'iterator';
+  }
+
+  var iterator = {
+    meta: {
+      name: name
+    },
+    next: next,
+    throw: thro,
+    return: kReturn,
+    isSagaIterator: true
+  };
+
+  if (typeof Symbol !== 'undefined') {
+    iterator[Symbol.iterator] = function () {
+      return iterator;
+    };
+  }
+
+  return iterator;
+}
+
+var TAKE = 'TAKE';
+var PUT = 'PUT';
+var CALL = 'CALL';
+var FORK = 'FORK';
+var CANCEL = 'CANCEL';
+var SELECT = 'SELECT';
+
+var TEST_HINT = '\n(HINT: if you are getting these errors in tests, consider using createMockTask from @redux-saga/testing-utils)';
+
+var makeEffect = function makeEffect(type, payload) {
+  var _ref;
+
+  return _ref = {}, _ref[IO] = true, _ref.combinator = false, _ref.type = type, _ref.payload = payload, _ref;
+};
+function take(patternOrChannel, multicastPattern) {
+  if (patternOrChannel === void 0) {
+    patternOrChannel = '*';
+  }
+
+  if (process.env.NODE_ENV !== 'production' && arguments.length) {
+    check(arguments[0], notUndef, 'take(patternOrChannel): patternOrChannel is undefined');
+  }
+
+  if (pattern(patternOrChannel)) {
+    if (notUndef(multicastPattern)) {
+      /* eslint-disable no-console */
+      console.warn("take(pattern) takes one argument but two were provided. Consider passing an array for listening to several action types");
+    }
+
+    return makeEffect(TAKE, {
+      pattern: patternOrChannel
+    });
+  }
+
+  if (multicast(patternOrChannel) && notUndef(multicastPattern) && pattern(multicastPattern)) {
+    return makeEffect(TAKE, {
+      channel: patternOrChannel,
+      pattern: multicastPattern
+    });
+  }
+
+  if (channel(patternOrChannel)) {
+    if (notUndef(multicastPattern)) {
+      /* eslint-disable no-console */
+      console.warn("take(channel) takes one argument but two were provided. Second argument is ignored.");
+    }
+
+    return makeEffect(TAKE, {
+      channel: patternOrChannel
+    });
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    throw new Error("take(patternOrChannel): argument " + patternOrChannel + " is not valid channel or a valid pattern");
+  }
+}
+function put(channel$1, action) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (arguments.length > 1) {
+      check(channel$1, notUndef, 'put(channel, action): argument channel is undefined');
+      check(channel$1, channel, "put(channel, action): argument " + channel$1 + " is not a valid channel");
+      check(action, notUndef, 'put(channel, action): argument action is undefined');
+    } else {
+      check(channel$1, notUndef, 'put(action): argument action is undefined');
+    }
+  }
+
+  if (undef(action)) {
+    action = channel$1; // `undefined` instead of `null` to make default parameter work
+
+    channel$1 = undefined;
+  }
+
+  return makeEffect(PUT, {
+    channel: channel$1,
+    action: action
+  });
+}
+
+var validateFnDescriptor = function validateFnDescriptor(effectName, fnDescriptor) {
+  check(fnDescriptor, notUndef, effectName + ": argument fn is undefined or null");
+
+  if (func(fnDescriptor)) {
+    return;
+  }
+
+  var context = null;
+  var fn;
+
+  if (array(fnDescriptor)) {
+    context = fnDescriptor[0];
+    fn = fnDescriptor[1];
+    check(fn, notUndef, effectName + ": argument of type [context, fn] has undefined or null `fn`");
+  } else if (object(fnDescriptor)) {
+    context = fnDescriptor.context;
+    fn = fnDescriptor.fn;
+    check(fn, notUndef, effectName + ": argument of type {context, fn} has undefined or null `fn`");
+  } else {
+    check(fnDescriptor, func, effectName + ": argument fn is not function");
+    return;
+  }
+
+  if (context && string(fn)) {
+    check(context[fn], func, effectName + ": context arguments has no such method - \"" + fn + "\"");
+    return;
+  }
+
+  check(fn, func, effectName + ": unpacked fn argument (from [context, fn] or {context, fn}) is not a function");
+};
+
+function getFnCallDescriptor(fnDescriptor, args) {
+  var context = null;
+  var fn;
+
+  if (func(fnDescriptor)) {
+    fn = fnDescriptor;
+  } else {
+    if (array(fnDescriptor)) {
+      context = fnDescriptor[0];
+      fn = fnDescriptor[1];
+    } else {
+      context = fnDescriptor.context;
+      fn = fnDescriptor.fn;
+    }
+
+    if (context && string(fn) && func(context[fn])) {
+      fn = context[fn];
+    }
+  }
+
+  return {
+    context: context,
+    fn: fn,
+    args: args
+  };
+}
+
+var isNotDelayEffect = function isNotDelayEffect(fn) {
+  return fn !== delay;
+};
+
+function call(fnDescriptor) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    var arg0 = typeof args[0] === 'number' ? args[0] : 'ms';
+    check(fnDescriptor, isNotDelayEffect, "instead of writing `yield call(delay, " + arg0 + ")` where delay is an effect from `redux-saga/effects` you should write `yield delay(" + arg0 + ")`");
+    validateFnDescriptor('call', fnDescriptor);
+  }
+
+  return makeEffect(CALL, getFnCallDescriptor(fnDescriptor, args));
+}
+function fork(fnDescriptor) {
+  if (process.env.NODE_ENV !== 'production') {
+    validateFnDescriptor('fork', fnDescriptor);
+    check(fnDescriptor, function (arg) {
+      return !effect(arg);
+    }, 'fork: argument must not be an effect');
+  }
+
+  for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+    args[_key3 - 1] = arguments[_key3];
+  }
+
+  return makeEffect(FORK, getFnCallDescriptor(fnDescriptor, args));
+}
+function cancel(taskOrTasks) {
+  if (taskOrTasks === void 0) {
+    taskOrTasks = SELF_CANCELLATION;
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    if (arguments.length > 1) {
+      throw new Error('cancel(...tasks) is not supported any more. Please use cancel([...tasks]) to cancel multiple tasks.');
+    }
+
+    if (array(taskOrTasks)) {
+      taskOrTasks.forEach(function (t) {
+        check(t, task, "cancel([...tasks]): argument " + t + " is not a valid Task object " + TEST_HINT);
+      });
+    } else if (taskOrTasks !== SELF_CANCELLATION && notUndef(taskOrTasks)) {
+      check(taskOrTasks, task, "cancel(task): argument " + taskOrTasks + " is not a valid Task object " + TEST_HINT);
+    }
+  }
+
+  return makeEffect(CANCEL, taskOrTasks);
+}
+function select(selector) {
+  if (selector === void 0) {
+    selector = identity;
+  }
+
+  for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+    args[_key5 - 1] = arguments[_key5];
+  }
+
+  if (process.env.NODE_ENV !== 'production' && arguments.length) {
+    check(arguments[0], notUndef, 'select(selector, [...]): argument selector is undefined');
+    check(selector, func, "select(selector, [...]): argument " + selector + " is not a function");
+  }
+
+  return makeEffect(SELECT, {
+    selector: selector,
+    args: args
+  });
+}
+var delay =
+/*#__PURE__*/
+call.bind(null, delayP);
+
+var done = function done(value) {
+  return {
+    done: true,
+    value: value
+  };
+};
+
+var qEnd = {};
+function safeName(patternOrChannel) {
+  if (channel(patternOrChannel)) {
+    return 'channel';
+  }
+
+  if (stringableFunc(patternOrChannel)) {
+    return String(patternOrChannel);
+  }
+
+  if (func(patternOrChannel)) {
+    return patternOrChannel.name;
+  }
+
+  return String(patternOrChannel);
+}
+function fsmIterator(fsm, startState, name) {
+  var stateUpdater,
+      errorState,
+      effect,
+      nextState = startState;
+
+  function next(arg, error) {
+    if (nextState === qEnd) {
+      return done(arg);
+    }
+
+    if (error && !errorState) {
+      nextState = qEnd;
+      throw error;
+    } else {
+      stateUpdater && stateUpdater(arg);
+      var currentState = error ? fsm[errorState](error) : fsm[nextState]();
+      nextState = currentState.nextState;
+      effect = currentState.effect;
+      stateUpdater = currentState.stateUpdater;
+      errorState = currentState.errorState;
+      return nextState === qEnd ? done(arg) : effect;
+    }
+  }
+
+  return makeIterator(next, function (error) {
+    return next(null, error);
+  }, name);
+}
+
+function takeLatest(patternOrChannel, worker) {
+  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
+
+  var yTake = {
+    done: false,
+    value: take(patternOrChannel)
+  };
+
+  var yFork = function yFork(ac) {
+    return {
+      done: false,
+      value: fork.apply(void 0, [worker].concat(args, [ac]))
+    };
+  };
+
+  var yCancel = function yCancel(task) {
+    return {
+      done: false,
+      value: cancel(task)
+    };
+  };
+
+  var task, action;
+
+  var setTask = function setTask(t) {
+    return task = t;
+  };
+
+  var setAction = function setAction(ac) {
+    return action = ac;
+  };
+
+  return fsmIterator({
+    q1: function q1() {
+      return {
+        nextState: 'q2',
+        effect: yTake,
+        stateUpdater: setAction
+      };
+    },
+    q2: function q2() {
+      return task ? {
+        nextState: 'q3',
+        effect: yCancel(task)
+      } : {
+        nextState: 'q1',
+        effect: yFork(action),
+        stateUpdater: setTask
+      };
+    },
+    q3: function q3() {
+      return {
+        nextState: 'q1',
+        effect: yFork(action),
+        stateUpdater: setTask
+      };
+    }
+  }, 'q1', "takeLatest(" + safeName(patternOrChannel) + ", " + worker.name + ")");
+}
+
+var validateTakeEffect = function validateTakeEffect(fn, patternOrChannel, worker) {
+  check(patternOrChannel, notUndef, fn.name + " requires a pattern or channel");
+  check(worker, notUndef, fn.name + " requires a saga parameter");
+};
+function takeLatest$1(patternOrChannel, worker) {
+  if (process.env.NODE_ENV !== 'production') {
+    validateTakeEffect(takeLatest$1, patternOrChannel, worker);
+  }
+
+  for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+    args[_key2 - 2] = arguments[_key2];
+  }
+
+  return fork.apply(void 0, [takeLatest, patternOrChannel, worker].concat(args));
+}
+
+var _marked = /*#__PURE__*/_regeneratorRuntime().mark(drawingSaga);
+var SUBMIT_ERROR = 'Something went wrong saving a drawing';
+var getSnackbarMessage = function getSnackbarMessage(areaName, id) {
+  return "Drawing ".concat(areaName, " has been ").concat(id ? 'updated' : 'saved', "!");
+};
+function onOpenUiDialogSaga(_ref) {
+  var payload = _ref.payload;
+  return /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    var type, mapId, drawUiType, areaManagerUiType, isDrawingOpen, isAreaManagerOpen;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          type = payload.type, mapId = payload.mapId;
+          drawUiType = "".concat(uiTypes.DialogTypes.DockedDrawingTool, "-").concat(mapId);
+          areaManagerUiType = uiTypes.DialogTypes.AreaManager;
+          if (!(type === areaManagerUiType)) {
+            _context.next = 10;
+            break;
+          }
+          _context.next = 6;
+          return select(uiSelectors.getisDialogOpen, drawUiType);
+        case 6:
+          isDrawingOpen = _context.sent;
+          if (!isDrawingOpen) {
+            _context.next = 10;
+            break;
+          }
+          _context.next = 10;
+          return put(uiActions.setToggleOpenDialog(Object.assign(Object.assign({}, payload), {
+            type: drawUiType,
+            setOpen: false
+          })));
+        case 10:
+          if (!(type === drawUiType)) {
+            _context.next = 17;
+            break;
+          }
+          _context.next = 13;
+          return select(uiSelectors.getisDialogOpen, areaManagerUiType);
+        case 13:
+          isAreaManagerOpen = _context.sent;
+          if (!isAreaManagerOpen) {
+            _context.next = 17;
+            break;
+          }
+          _context.next = 17;
+          return put(uiActions.setToggleOpenDialog(Object.assign(Object.assign({}, payload), {
+            type: areaManagerUiType,
+            setOpen: false
+          })));
+        case 17:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })();
+}
+function submitDrawValuesSaga(_ref2) {
+  var payload = _ref2.payload;
+  return /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+    var mapId, id, formValues, dialogType, warningsApi, newID;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          mapId = payload.mapId, id = payload.id, formValues = __rest(payload, ["mapId", "id"]);
+          dialogType = "".concat(uiTypes.DialogTypes.DockedDrawingTool, "-").concat(mapId);
+          _context2.prev = 2;
+          _context2.next = 5;
+          return put(uiActions.toggleIsLoadingDialog({
+            isLoading: true,
+            type: dialogType
+          }));
+        case 5:
+          _context2.next = 7;
+          return call(getWarningsApi);
+        case 7:
+          warningsApi = _context2.sent;
+          if (id) {
+            _context2.next = 16;
+            break;
+          }
+          _context2.next = 11;
+          return call(warningsApi.saveDrawingAs, formValues);
+        case 11:
+          newID = _context2.sent;
+          _context2.next = 14;
+          return put(drawActions.setDrawValues(Object.assign({
+            mapId: mapId,
+            id: newID
+          }, formValues)));
+        case 14:
+          _context2.next = 18;
+          break;
+        case 16:
+          _context2.next = 18;
+          return call(warningsApi.updateDrawing, id, formValues);
+        case 18:
+          _context2.next = 20;
+          return put(snackbarActions.openSnackbar({
+            message: getSnackbarMessage(formValues.areaName, id)
+          }));
+        case 20:
+          _context2.next = 22;
+          return put(uiActions.toggleIsLoadingDialog({
+            isLoading: false,
+            type: dialogType
+          }));
+        case 22:
+          _context2.next = 30;
+          break;
+        case 24:
+          _context2.prev = 24;
+          _context2.t0 = _context2["catch"](2);
+          _context2.next = 28;
+          return put(uiActions.toggleIsLoadingDialog({
+            isLoading: false,
+            type: dialogType
+          }));
+        case 28:
+          _context2.next = 30;
+          return put(uiActions.setErrorDialog({
+            type: dialogType,
+            error: SUBMIT_ERROR
+          }));
+        case 30:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[2, 24]]);
+  })();
+}
+function drawingSaga() {
+  return _regeneratorRuntime().wrap(function drawingSaga$(_context3) {
+    while (1) switch (_context3.prev = _context3.next) {
+      case 0:
+        _context3.next = 2;
+        return takeLatest$1(uiActions.setActiveMapIdForDialog, onOpenUiDialogSaga);
+      case 2:
+        _context3.next = 4;
+        return takeLatest$1(drawActions.submitDrawValues, submitDrawValuesSaga);
+      case 4:
+      case "end":
+        return _context3.stop();
+    }
+  }, _marked);
+}
+
 /* *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,6 +3542,10 @@
  * Copyright 2023 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
  * Copyright 2023 - Finnish Meteorological Institute (FMI)
  * */
-var TODO_DELETE_THIS_LATER = 'TODO_DELETE_THIS_LATER';
+var drawingModuleConfig = {
+  id: 'drawing-module',
+  reducersMap: {},
+  sagas: [drawingSaga]
+};
 
-export { TODO_DELETE_THIS_LATER };
+export { AreaManagerConnect, AreaManagerMapButtonConnect, WarningsModuleProvider, drawingModuleConfig };