@websolutespa/bom-llm 0.0.38 → 0.0.39

package/dist/umd/index.js

@@ -8127,7 +8127,7 @@
 	    }
 	    return context;
 	  };
-	  return [useGenericContext, genericContext.Provider];
+	  return [useGenericContext, genericContext.Provider, genericContext];
 	};
 
 	const [useLayout, LayoutContextProvider] = createGenericContext();
@@ -8143,6 +8143,15 @@
 	  });
 	}
 
+	function useAutosizeTextArea(textAreaRef, value) {
+	  reactExports.useEffect(() => {
+	    if (textAreaRef) {
+	      textAreaRef.style.height = '0px';
+	      textAreaRef.style.height = textAreaRef.scrollHeight + 1 + 'px';
+	    }
+	  }, [textAreaRef, value]);
+	}
+
 	const useIsomorphicLayoutEffect$2 = isBrowser$1 ? reactExports.useLayoutEffect : reactExports.useEffect;
 
 	// Window Event based useEventListener interface
@@ -8199,70 +8208,6 @@
 	  return windowSize;
 	}
 
-	function useNumber(options, locale) {
-	  const layout = useLayout();
-	  const currentLocale = locale || layout.locale;
-	  const flatOptions = options ? Object.entries(options).map(_ref => {
-	    let [k, v] = _ref;
-	    return `${k}:${v}`;
-	  }).join('') : undefined;
-	  const formatter = reactExports.useMemo(() => {
-	    const formatter = new Intl.NumberFormat(currentLocale, options).format;
-	    return formatter;
-	    // eslint-disable-next-line react-hooks/exhaustive-deps
-	  }, [currentLocale, flatOptions]);
-	  return formatter;
-	}
-
-	function useCurrency(currency, locale) {
-	  if (currency === void 0) {
-	    currency = 'EUR';
-	  }
-	  return useNumber({
-	    style: 'currency',
-	    currency,
-	    minimumFractionDigits: 2,
-	    maximumFractionDigits: 2
-	  }, locale);
-	}
-
-	/*
-	import { useMemo } from 'react';
-	import { useNumber } from '../useNumber/useNumber';
-	import { useLayout } from '../useLayout/useLayout';
-
-	export function useCurrency(currency: string = 'EUR', locale?: string): (value: number) => string {
-	  const layout = useLayout();
-	  const currentLocale = locale || layout.locale;
-
-	  const formatter = useMemo(() => {
-	    const options = { style: 'currency', currency };
-	    const formatter = new Intl.NumberFormat(currentLocale, options).format;
-	    return formatter;
-	  }, [currency, currentLocale]);
-
-	  return formatter;
-	}
-
-	*/
-
-	/*
-
-	export function useCurrency(value: number, currency: string = 'EUR', locale?: string): string {
-
-	  const layout = useLayout();
-
-	  const currentLocale = locale || layout.locale;
-
-	  return useMemo(() => {
-	    const options = { style: 'currency', currency };
-	    const formattedValue = new Intl.NumberFormat(currentLocale, options).format(value);
-	    return formattedValue;
-	  }, [value, currency, currentLocale]);
-	}
-
-	*/
-
 	const createStoreImpl = (createState) => {
 	  let state;
 	  const listeners = /* @__PURE__ */ new Set();
@@ -8466,542 +8411,977 @@
 	  return slice;
 	}
 
-	const [useExtra, ExtraContextProvider] = createGenericContext({});
-	function ExtraProvider(_ref) {
-	  let {
-	    children,
-	    extra
-	  } = _ref;
-	  return /*#__PURE__*/jsxRuntimeExports.jsx(ExtraContextProvider, {
-	    value: extra,
-	    children: children
-	  });
+	function createJSONStorage(getStorage, options) {
+	  let storage;
+	  try {
+	    storage = getStorage();
+	  } catch (e) {
+	    return;
+	  }
+	  const persistStorage = {
+	    getItem: (name) => {
+	      var _a;
+	      const parse = (str2) => {
+	        if (str2 === null) {
+	          return null;
+	        }
+	        return JSON.parse(str2, options == null ? void 0 : options.reviver);
+	      };
+	      const str = (_a = storage.getItem(name)) != null ? _a : null;
+	      if (str instanceof Promise) {
+	        return str.then(parse);
+	      }
+	      return parse(str);
+	    },
+	    setItem: (name, newValue) => storage.setItem(
+	      name,
+	      JSON.stringify(newValue, options == null ? void 0 : options.replacer)
+	    ),
+	    removeItem: (name) => storage.removeItem(name)
+	  };
+	  return persistStorage;
 	}
-
-	/**
-	 * KeyBinding Codes
-	 * The content of this file is based on the design of the open source project "microsoft/vscode",
-	 *   Copyright (c) Microsoft Corporation. All rights reserved.
-	 *
-	 * We inherit the KeyMod values from "microsoft/vscode",
-	 * but use the Browser's KeyboardEvent event implementation, and all values are used only as identification.
-	 */
-
-	let KeyCode = /*#__PURE__*/function (KeyCode) {
-	  KeyCode[KeyCode["Unknown"] = 0] = "Unknown";
-	  KeyCode[KeyCode["Backspace"] = 8] = "Backspace";
-	  KeyCode[KeyCode["Tab"] = 9] = "Tab";
-	  KeyCode[KeyCode["Enter"] = 13] = "Enter";
-	  KeyCode[KeyCode["Shift"] = 16] = "Shift";
-	  KeyCode[KeyCode["Ctrl"] = 17] = "Ctrl";
-	  KeyCode[KeyCode["Alt"] = 18] = "Alt";
-	  KeyCode[KeyCode["PauseBreak"] = 19] = "PauseBreak";
-	  KeyCode[KeyCode["CapsLock"] = 20] = "CapsLock";
-	  KeyCode[KeyCode["Escape"] = 27] = "Escape";
-	  KeyCode[KeyCode["Space"] = 32] = "Space";
-	  KeyCode[KeyCode["PageUp"] = 33] = "PageUp";
-	  KeyCode[KeyCode["PageDown"] = 34] = "PageDown";
-	  KeyCode[KeyCode["End"] = 35] = "End";
-	  KeyCode[KeyCode["Home"] = 36] = "Home";
-	  KeyCode[KeyCode["LeftArrow"] = 37] = "LeftArrow";
-	  KeyCode[KeyCode["UpArrow"] = 38] = "UpArrow";
-	  KeyCode[KeyCode["RightArrow"] = 39] = "RightArrow";
-	  KeyCode[KeyCode["DownArrow"] = 40] = "DownArrow";
-	  KeyCode[KeyCode["Insert"] = 45] = "Insert";
-	  KeyCode[KeyCode["Delete"] = 46] = "Delete";
-	  KeyCode[KeyCode["KEY_0"] = 48] = "KEY_0";
-	  KeyCode[KeyCode["KEY_1"] = 49] = "KEY_1";
-	  KeyCode[KeyCode["KEY_2"] = 50] = "KEY_2";
-	  KeyCode[KeyCode["KEY_3"] = 51] = "KEY_3";
-	  KeyCode[KeyCode["KEY_4"] = 52] = "KEY_4";
-	  KeyCode[KeyCode["KEY_5"] = 53] = "KEY_5";
-	  KeyCode[KeyCode["KEY_6"] = 54] = "KEY_6";
-	  KeyCode[KeyCode["KEY_7"] = 55] = "KEY_7";
-	  KeyCode[KeyCode["KEY_8"] = 56] = "KEY_8";
-	  KeyCode[KeyCode["KEY_9"] = 57] = "KEY_9";
-	  KeyCode[KeyCode["KEY_A"] = 65] = "KEY_A";
-	  KeyCode[KeyCode["KEY_B"] = 66] = "KEY_B";
-	  KeyCode[KeyCode["KEY_C"] = 67] = "KEY_C";
-	  KeyCode[KeyCode["KEY_D"] = 68] = "KEY_D";
-	  KeyCode[KeyCode["KEY_E"] = 69] = "KEY_E";
-	  KeyCode[KeyCode["KEY_F"] = 70] = "KEY_F";
-	  KeyCode[KeyCode["KEY_G"] = 71] = "KEY_G";
-	  KeyCode[KeyCode["KEY_H"] = 72] = "KEY_H";
-	  KeyCode[KeyCode["KEY_I"] = 73] = "KEY_I";
-	  KeyCode[KeyCode["KEY_J"] = 74] = "KEY_J";
-	  KeyCode[KeyCode["KEY_K"] = 75] = "KEY_K";
-	  KeyCode[KeyCode["KEY_L"] = 76] = "KEY_L";
-	  KeyCode[KeyCode["KEY_M"] = 77] = "KEY_M";
-	  KeyCode[KeyCode["KEY_N"] = 78] = "KEY_N";
-	  KeyCode[KeyCode["KEY_O"] = 79] = "KEY_O";
-	  KeyCode[KeyCode["KEY_P"] = 80] = "KEY_P";
-	  KeyCode[KeyCode["KEY_Q"] = 81] = "KEY_Q";
-	  KeyCode[KeyCode["KEY_R"] = 82] = "KEY_R";
-	  KeyCode[KeyCode["KEY_S"] = 83] = "KEY_S";
-	  KeyCode[KeyCode["KEY_T"] = 84] = "KEY_T";
-	  KeyCode[KeyCode["KEY_U"] = 85] = "KEY_U";
-	  KeyCode[KeyCode["KEY_V"] = 86] = "KEY_V";
-	  KeyCode[KeyCode["KEY_W"] = 87] = "KEY_W";
-	  KeyCode[KeyCode["KEY_X"] = 88] = "KEY_X";
-	  KeyCode[KeyCode["KEY_Y"] = 89] = "KEY_Y";
-	  KeyCode[KeyCode["KEY_Z"] = 90] = "KEY_Z";
-	  KeyCode[KeyCode["Meta"] = 91] = "Meta";
-	  KeyCode[KeyCode["F1"] = 112] = "F1";
-	  KeyCode[KeyCode["F2"] = 113] = "F2";
-	  KeyCode[KeyCode["F3"] = 114] = "F3";
-	  KeyCode[KeyCode["F4"] = 115] = "F4";
-	  KeyCode[KeyCode["F5"] = 116] = "F5";
-	  KeyCode[KeyCode["F6"] = 117] = "F6";
-	  KeyCode[KeyCode["F7"] = 118] = "F7";
-	  KeyCode[KeyCode["F8"] = 119] = "F8";
-	  KeyCode[KeyCode["F9"] = 120] = "F9";
-	  KeyCode[KeyCode["F10"] = 121] = "F10";
-	  KeyCode[KeyCode["F11"] = 122] = "F11";
-	  KeyCode[KeyCode["F12"] = 123] = "F12";
-	  KeyCode[KeyCode["NumLock"] = 144] = "NumLock";
-	  KeyCode[KeyCode["ScrollLock"] = 145] = "ScrollLock";
-	  KeyCode[KeyCode["Equal"] = 187] = "Equal";
-	  KeyCode[KeyCode["Minus"] = 189] = "Minus";
-	  KeyCode[KeyCode["Backquote"] = 192] = "Backquote";
-	  KeyCode[KeyCode["Backslash"] = 220] = "Backslash";
-	  return KeyCode;
-	}({});
-	let KeyMod = /*#__PURE__*/function (KeyMod) {
-	  KeyMod[KeyMod["CtrlCmd"] = 2048] = "CtrlCmd";
-	  KeyMod[KeyMod["Shift"] = 1024] = "Shift";
-	  KeyMod[KeyMod["Alt"] = 512] = "Alt";
-	  KeyMod[KeyMod["WinCtrl"] = 256] = "WinCtrl";
-	  return KeyMod;
-	}({});
-
-	const detectIsBrowser = () => {
-	  return Boolean(typeof window !== 'undefined' && window.document && window.document.createElement);
+	const toThenable = (fn) => (input) => {
+	  try {
+	    const result = fn(input);
+	    if (result instanceof Promise) {
+	      return result;
+	    }
+	    return {
+	      then(onFulfilled) {
+	        return toThenable(onFulfilled)(result);
+	      },
+	      catch(_onRejected) {
+	        return this;
+	      }
+	    };
+	  } catch (e) {
+	    return {
+	      then(_onFulfilled) {
+	        return this;
+	      },
+	      catch(onRejected) {
+	        return toThenable(onRejected)(e);
+	      }
+	    };
+	  }
 	};
-	function useSSR() {
-	  const [browser, setBrowser] = reactExports.useState(false);
-	  reactExports.useEffect(() => {
-	    setBrowser(detectIsBrowser());
-	  }, []);
-	  return {
-	    isBrowser: browser,
-	    isServer: !browser
+	const oldImpl = (config, baseOptions) => (set, get, api) => {
+	  let options = {
+	    getStorage: () => localStorage,
+	    serialize: JSON.stringify,
+	    deserialize: JSON.parse,
+	    partialize: (state) => state,
+	    version: 0,
+	    merge: (persistedState, currentState) => ({
+	      ...currentState,
+	      ...persistedState
+	    }),
+	    ...baseOptions
 	  };
-	}
-
-	function getCtrlKeysByPlatform() {
-	  return {
-	    CtrlCmd: isMac() ? 'metaKey' : 'ctrlKey',
-	    WinCtrl: isMac() ? 'ctrlKey' : 'metaKey'
-	  };
-	}
-	function getActiveModMap(bindings) {
-	  const modBindings = bindings.filter(item => !!KeyMod[item]);
-	  const activeModMap = {
-	    CtrlCmd: false,
-	    Shift: false,
-	    Alt: false,
-	    WinCtrl: false
-	  };
-	  modBindings.forEach(code => {
-	    const modKey = KeyMod[code];
-	    activeModMap[modKey] = true;
-	  });
-	  return activeModMap;
-	}
-	function isMac() {
-	  if (!detectIsBrowser()) {
-	    return false;
+	  let hasHydrated = false;
+	  const hydrationListeners = /* @__PURE__ */ new Set();
+	  const finishHydrationListeners = /* @__PURE__ */ new Set();
+	  let storage;
+	  try {
+	    storage = options.getStorage();
+	  } catch (e) {
 	  }
-	  return navigator.platform.toUpperCase().indexOf('MAC') >= 0;
-	}
-
-	const useKeyboard = function (handler, keyBindings, options) {
-	  if (options === void 0) {
-	    options = {};
+	  if (!storage) {
+	    return config(
+	      (...args) => {
+	        console.warn(
+	          `[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
+	        );
+	        set(...args);
+	      },
+	      get,
+	      api
+	    );
 	  }
-	  const bindings = Array.isArray(keyBindings) ? keyBindings : [keyBindings];
-	  const {
-	    disableGlobalEvent = false,
-	    capture = false,
-	    stopPropagation = false,
-	    preventDefault = true,
-	    event = 'keydown'
-	  } = options;
-	  const activeModMap = getActiveModMap(bindings);
-	  const keyCode = bindings.filter(item => !KeyMod[item]);
-	  const {
-	    CtrlCmd,
-	    WinCtrl
-	  } = getCtrlKeysByPlatform();
-	  const eventHandler = event => {
-	    if (activeModMap.Shift && !event.shiftKey) return;
-	    if (activeModMap.Alt && !event.altKey) return;
-	    if (activeModMap.CtrlCmd && !event[CtrlCmd]) return;
-	    if (activeModMap.WinCtrl && !event[WinCtrl]) return;
-	    const hitOne = keyCode.find(k => k === event.keyCode);
-	    if (keyCode && !hitOne) return;
-	    if (stopPropagation) {
-	      event.stopPropagation();
-	    }
-	    if (preventDefault) {
-	      event.preventDefault();
+	  const thenableSerialize = toThenable(options.serialize);
+	  const setItem = () => {
+	    const state = options.partialize({ ...get() });
+	    let errorInSync;
+	    const thenable = thenableSerialize({ state, version: options.version }).then(
+	      (serializedValue) => storage.setItem(options.name, serializedValue)
+	    ).catch((e) => {
+	      errorInSync = e;
+	    });
+	    if (errorInSync) {
+	      throw errorInSync;
 	    }
-	    handler && handler(event);
+	    return thenable;
 	  };
-	  reactExports.useEffect(() => {
-	    if (!disableGlobalEvent) {
-	      document.addEventListener(event, eventHandler);
-	    }
-	    return () => {
-	      document.removeEventListener(event, eventHandler);
-	    };
-	  }, [disableGlobalEvent]);
-	  const elementBindingHandler = function (elementEventType, isCapture) {
-	    if (isCapture === void 0) {
-	      isCapture = false;
-	    }
-	    if (elementEventType !== event) return () => {};
-	    if (isCapture !== capture) return () => {};
-	    return e => eventHandler(e);
+	  const savedSetState = api.setState;
+	  api.setState = (state, replace) => {
+	    savedSetState(state, replace);
+	    void setItem();
 	  };
-	  return {
-	    bindings: {
-	      onKeyDown: elementBindingHandler('keydown'),
-	      onKeyDownCapture: elementBindingHandler('keydown', true),
-	      onKeyPress: elementBindingHandler('keypress'),
-	      onKeyPressCapture: elementBindingHandler('keypress', true),
-	      onKeyUp: elementBindingHandler('keyup'),
-	      onKeyUpCapture: elementBindingHandler('keyup', true)
+	  const configResult = config(
+	    (...args) => {
+	      set(...args);
+	      void setItem();
+	    },
+	    get,
+	    api
+	  );
+	  let stateFromStorage;
+	  const hydrate = () => {
+	    var _a;
+	    if (!storage)
+	      return;
+	    hasHydrated = false;
+	    hydrationListeners.forEach((cb) => cb(get()));
+	    const postRehydrationCallback = ((_a = options.onRehydrateStorage) == null ? void 0 : _a.call(options, get())) || void 0;
+	    return toThenable(storage.getItem.bind(storage))(options.name).then((storageValue) => {
+	      if (storageValue) {
+	        return options.deserialize(storageValue);
+	      }
+	    }).then((deserializedStorageValue) => {
+	      if (deserializedStorageValue) {
+	        if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
+	          if (options.migrate) {
+	            return options.migrate(
+	              deserializedStorageValue.state,
+	              deserializedStorageValue.version
+	            );
+	          }
+	          console.error(
+	            `State loaded from storage couldn't be migrated since no migrate function was provided`
+	          );
+	        } else {
+	          return deserializedStorageValue.state;
+	        }
+	      }
+	    }).then((migratedState) => {
+	      var _a2;
+	      stateFromStorage = options.merge(
+	        migratedState,
+	        (_a2 = get()) != null ? _a2 : configResult
+	      );
+	      set(stateFromStorage, true);
+	      return setItem();
+	    }).then(() => {
+	      postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0);
+	      hasHydrated = true;
+	      finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
+	    }).catch((e) => {
+	      postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e);
+	    });
+	  };
+	  api.persist = {
+	    setOptions: (newOptions) => {
+	      options = {
+	        ...options,
+	        ...newOptions
+	      };
+	      if (newOptions.getStorage) {
+	        storage = newOptions.getStorage();
+	      }
+	    },
+	    clearStorage: () => {
+	      storage == null ? void 0 : storage.removeItem(options.name);
+	    },
+	    getOptions: () => options,
+	    rehydrate: () => hydrate(),
+	    hasHydrated: () => hasHydrated,
+	    onHydrate: (cb) => {
+	      hydrationListeners.add(cb);
+	      return () => {
+	        hydrationListeners.delete(cb);
+	      };
+	    },
+	    onFinishHydration: (cb) => {
+	      finishHydrationListeners.add(cb);
+	      return () => {
+	        finishHydrationListeners.delete(cb);
+	      };
 	    }
 	  };
+	  hydrate();
+	  return stateFromStorage || configResult;
 	};
-
-	const [useLabel, LabelContextProvider] = createGenericContext();
-	function LabelProvider(_ref) {
-	  let {
-	    children
-	  } = _ref;
-	  const {
-	    labels
-	  } = useLayout();
-	  // console.log('LabelProvider', labels);
-	  const labelService = new LabelService(labels);
-	  const getLabel = (key, params) => {
-	    return labelService.getLabel(key, params);
+	const newImpl = (config, baseOptions) => (set, get, api) => {
+	  let options = {
+	    storage: createJSONStorage(() => localStorage),
+	    partialize: (state) => state,
+	    version: 0,
+	    merge: (persistedState, currentState) => ({
+	      ...currentState,
+	      ...persistedState
+	    }),
+	    ...baseOptions
 	  };
-	  return /*#__PURE__*/jsxRuntimeExports.jsx(LabelContextProvider, {
-	    value: getLabel,
-	    children: children
-	  });
-	}
-	class LabelService {
-	  constructor(labels) {
-	    this.labels = labels;
-	    this.dictionary = Object.fromEntries(labels.map(l => [l.id, l.text]));
-	  }
-	  getLabel(key, params) {
-	    return parseLabel(this.dictionary, key, params);
-	  }
-	}
-	function parseLabel(dictionary, key, params) {
-	  const label = dictionary[key] != null ? dictionary[key] : key;
-	  if (params) {
-	    return parseParams(label, params);
+	  let hasHydrated = false;
+	  const hydrationListeners = /* @__PURE__ */ new Set();
+	  const finishHydrationListeners = /* @__PURE__ */ new Set();
+	  let storage = options.storage;
+	  if (!storage) {
+	    return config(
+	      (...args) => {
+	        console.warn(
+	          `[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
+	        );
+	        set(...args);
+	      },
+	      get,
+	      api
+	    );
 	  }
-	  return label;
-	}
-	function parseParams(label, params) {
-	  const TEMPLATE_REGEXP = /@(\w+)/g;
-	  return label.replace(TEMPLATE_REGEXP, (text, key) => {
-	    const replacer = params[key];
-	    return typeof replacer !== 'undefined' ? String(replacer) : text;
-	  });
+	  const setItem = () => {
+	    const state = options.partialize({ ...get() });
+	    return storage.setItem(options.name, {
+	      state,
+	      version: options.version
+	    });
+	  };
+	  const savedSetState = api.setState;
+	  api.setState = (state, replace) => {
+	    savedSetState(state, replace);
+	    void setItem();
+	  };
+	  const configResult = config(
+	    (...args) => {
+	      set(...args);
+	      void setItem();
+	    },
+	    get,
+	    api
+	  );
+	  api.getInitialState = () => configResult;
+	  let stateFromStorage;
+	  const hydrate = () => {
+	    var _a, _b;
+	    if (!storage)
+	      return;
+	    hasHydrated = false;
+	    hydrationListeners.forEach((cb) => {
+	      var _a2;
+	      return cb((_a2 = get()) != null ? _a2 : configResult);
+	    });
+	    const postRehydrationCallback = ((_b = options.onRehydrateStorage) == null ? void 0 : _b.call(options, (_a = get()) != null ? _a : configResult)) || void 0;
+	    return toThenable(storage.getItem.bind(storage))(options.name).then((deserializedStorageValue) => {
+	      if (deserializedStorageValue) {
+	        if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
+	          if (options.migrate) {
+	            return options.migrate(
+	              deserializedStorageValue.state,
+	              deserializedStorageValue.version
+	            );
+	          }
+	          console.error(
+	            `State loaded from storage couldn't be migrated since no migrate function was provided`
+	          );
+	        } else {
+	          return deserializedStorageValue.state;
+	        }
+	      }
+	    }).then((migratedState) => {
+	      var _a2;
+	      stateFromStorage = options.merge(
+	        migratedState,
+	        (_a2 = get()) != null ? _a2 : configResult
+	      );
+	      set(stateFromStorage, true);
+	      return setItem();
+	    }).then(() => {
+	      postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0);
+	      stateFromStorage = get();
+	      hasHydrated = true;
+	      finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
+	    }).catch((e) => {
+	      postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e);
+	    });
+	  };
+	  api.persist = {
+	    setOptions: (newOptions) => {
+	      options = {
+	        ...options,
+	        ...newOptions
+	      };
+	      if (newOptions.storage) {
+	        storage = newOptions.storage;
+	      }
+	    },
+	    clearStorage: () => {
+	      storage == null ? void 0 : storage.removeItem(options.name);
+	    },
+	    getOptions: () => options,
+	    rehydrate: () => hydrate(),
+	    hasHydrated: () => hasHydrated,
+	    onHydrate: (cb) => {
+	      hydrationListeners.add(cb);
+	      return () => {
+	        hydrationListeners.delete(cb);
+	      };
+	    },
+	    onFinishHydration: (cb) => {
+	      finishHydrationListeners.add(cb);
+	      return () => {
+	        finishHydrationListeners.delete(cb);
+	      };
+	    }
+	  };
+	  if (!options.skipHydration) {
+	    hydrate();
+	  }
+	  return stateFromStorage || configResult;
+	};
+	const persistImpl = (config, baseOptions) => {
+	  if ("getStorage" in baseOptions || "serialize" in baseOptions || "deserialize" in baseOptions) {
+	    if ((undefined ? undefined.MODE : void 0) !== "production") {
+	      console.warn(
+	        "[DEPRECATED] `getStorage`, `serialize` and `deserialize` options are deprecated. Use `storage` option instead."
+	      );
+	    }
+	    return oldImpl(config, baseOptions);
+	  }
+	  return newImpl(config, baseOptions);
+	};
+	const persist = persistImpl;
+
+	function useNumber(options, locale) {
+	  const layout = useLayout();
+	  const currentLocale = locale || layout.locale;
+	  const flatOptions = options ? Object.entries(options).map(_ref => {
+	    let [k, v] = _ref;
+	    return `${k}:${v}`;
+	  }).join('') : undefined;
+	  const formatter = reactExports.useMemo(() => {
+	    const formatter = new Intl.NumberFormat(currentLocale, options).format;
+	    return formatter;
+	    // eslint-disable-next-line react-hooks/exhaustive-deps
+	  }, [currentLocale, flatOptions]);
+	  return formatter;
+	}
+
+	function useCurrency(currency, locale) {
+	  if (currency === void 0) {
+	    currency = 'EUR';
+	  }
+	  return useNumber({
+	    style: 'currency',
+	    currency,
+	    minimumFractionDigits: 2,
+	    maximumFractionDigits: 2
+	  }, locale);
 	}
 
 	/*
-	import { useCallback, useEffect, useRef } from 'react';
+	import { useMemo } from 'react';
+	import { useNumber } from '../useNumber/useNumber';
+	import { useLayout } from '../useLayout/useLayout';
 
-	export function useMounted(): () => boolean {
-	  const ref = useRef<boolean>(false);
-	  const get = useCallback(() => ref.current, []);
-	  useEffect(() => {
-	    ref.current = true;
-	    return () => {
-	      ref.current = false;
-	    };
-	  }, []);
-	  return get;
+	export function useCurrency(currency: string = 'EUR', locale?: string): (value: number) => string {
+	  const layout = useLayout();
+	  const currentLocale = locale || layout.locale;
+
+	  const formatter = useMemo(() => {
+	    const options = { style: 'currency', currency };
+	    const formatter = new Intl.NumberFormat(currentLocale, options).format;
+	    return formatter;
+	  }, [currency, currentLocale]);
+
+	  return formatter;
 	}
+
 	*/
 
-	function useMounted() {
-	  const [mounted, setMounted] = reactExports.useState(false);
-	  reactExports.useEffect(() => {
-	    setMounted(true);
-	  }, []); // at init only
-	  return mounted;
-	}
+	/*
+
+	export function useCurrency(value: number, currency: string = 'EUR', locale?: string): string {
+
+	  const layout = useLayout();
+
+	  const currentLocale = locale || layout.locale;
+
+	  return useMemo(() => {
+	    const options = { style: 'currency', currency };
+	    const formattedValue = new Intl.NumberFormat(currentLocale, options).format(value);
+	    return formattedValue;
+	  }, [value, currency, currentLocale]);
+	}
+
+	*/
 
-	const [usePage, PageContextProvider] = createGenericContext();
-	function PageProvider(_ref) {
+	const [useExtra, ExtraContextProvider] = createGenericContext({});
+	function ExtraProvider(_ref) {
 	  let {
 	    children,
-	    page
+	    extra
 	  } = _ref;
-	  // console.log('PageProvider.context', context);
-	  return /*#__PURE__*/jsxRuntimeExports.jsx(PageContextProvider, {
-	    value: page,
+	  return /*#__PURE__*/jsxRuntimeExports.jsx(ExtraContextProvider, {
+	    value: extra,
 	    children: children
 	  });
 	}
 
-	const namespace = 'theme';
-	function usePortal(name, getContainer) {
-	  if (name === void 0) {
-	    name = getUID();
+	function useFocusTrap(ref, options) {
+	  if (options === void 0) {
+	    options = {};
 	  }
-	  const {
-	    isBrowser
-	  } = useSSR();
-	  const id = `${namespace}-${name}`;
-	  const [portal, setPortal] = reactExports.useState(isBrowser ? createElementWithId(id) : null);
-	  reactExports.useEffect(() => {
-	    const container = typeof getContainer === 'function' ? getContainer() : null;
-	    const parentElement = container || document.body;
-	    const element = parentElement.querySelector(`#${id}`) || createElementWithId(id);
-	    if (!element.parentElement) {
-	      parentElement.appendChild(element);
+	  const selectors = options.selectors || 'a[href]:not([disabled]), button:not([disabled]), textarea:not([disabled]), input[type="text"]:not([disabled]), input[type="radio"]:not([disabled]), input[type="checkbox"]:not([disabled]), select:not([disabled])';
+	  const [state, setState] = reactExports.useState(!options.disabled);
+	  useIsomorphicLayoutEffect$2(() => {
+	    const element = ref.current;
+	    if (element) {
+	      const elements = element.querySelectorAll(selectors);
+	      const first = elements[0];
+	      const last = elements[elements.length - 1];
+	      const onKeyDown = event => {
+	        // console.log(event.key, event.code, event.keyCode);
+	        const isTabPressed = event.key === 'Tab';
+	        if (!isTabPressed) {
+	          return;
+	        }
+	        if (event.shiftKey) {
+	          // shift + tab
+	          if (document.activeElement === first) {
+	            last.focus();
+	            event.preventDefault();
+	          }
+	        } else {
+	          // tab
+	          if (document.activeElement === last) {
+	            first.focus();
+	            event.preventDefault();
+	          }
+	        }
+	      };
+	      element.addEventListener('keydown', onKeyDown);
+	      return () => {
+	        element.removeEventListener('keydown', onKeyDown);
+	      };
 	    }
-	    setPortal(element);
-	  }, []);
-	  return portal;
-	}
-	function createElementWithId(id) {
-	  const element = document.createElement('div');
-	  element.setAttribute('id', id);
-	  return element;
-	}
-	function getUID() {
-	  return Math.random().toString(32).slice(2, 10);
-	}
-
-	/**
-	 * @public
-	 */
-	const MotionConfigContext = reactExports.createContext({
-	    transformPagePoint: (p) => p,
-	    isStatic: false,
-	    reducedMotion: "never",
-	});
-
-	const MotionContext = reactExports.createContext({});
-	function useVisualElementContext() {
-	    return reactExports.useContext(MotionContext).visualElement;
+	    return () => {};
+	  }, [ref.current]);
+	  return [state, setState];
 	}
 
-	/**
-	 * @public
+	/**
+	 * KeyBinding Codes
+	 * The content of this file is based on the design of the open source project "microsoft/vscode",
+	 *   Copyright (c) Microsoft Corporation. All rights reserved.
+	 *
+	 * We inherit the KeyMod values from "microsoft/vscode",
+	 * but use the Browser's KeyboardEvent event implementation, and all values are used only as identification.
 	 */
-	const PresenceContext = reactExports.createContext(null);
-
-	const isBrowser = typeof document !== "undefined";
-
-	const useIsomorphicLayoutEffect$1 = isBrowser ? reactExports.useLayoutEffect : reactExports.useEffect;
-
-	const LazyContext = reactExports.createContext({ strict: false });
-
-	function useVisualElement(Component, visualState, props, createVisualElement) {
-	    const parent = useVisualElementContext();
-	    const lazyContext = reactExports.useContext(LazyContext);
-	    const presenceContext = reactExports.useContext(PresenceContext);
-	    const reducedMotionConfig = reactExports.useContext(MotionConfigContext).reducedMotion;
-	    const visualElementRef = reactExports.useRef();
-	    /**
-	     * If we haven't preloaded a renderer, check to see if we have one lazy-loaded
-	     */
-	    createVisualElement = createVisualElement || lazyContext.renderer;
-	    if (!visualElementRef.current && createVisualElement) {
-	        visualElementRef.current = createVisualElement(Component, {
-	            visualState,
-	            parent,
-	            props,
-	            presenceId: presenceContext ? presenceContext.id : undefined,
-	            blockInitialAnimation: presenceContext
-	                ? presenceContext.initial === false
-	                : false,
-	            reducedMotionConfig,
-	        });
-	    }
-	    const visualElement = visualElementRef.current;
-	    useIsomorphicLayoutEffect$1(() => {
-	        visualElement && visualElement.render();
-	    });
-	    /**
-	     * If we have optimised appear animations to handoff from, trigger animateChanges
-	     * from a synchronous useLayoutEffect to ensure there's no flash of incorrectly
-	     * styled component in the event of a hydration error.
-	     */
-	    useIsomorphicLayoutEffect$1(() => {
-	        if (visualElement && visualElement.animationState) {
-	            visualElement.animationState.animateChanges();
-	        }
-	    });
-	    useIsomorphicLayoutEffect$1(() => () => visualElement && visualElement.notify("Unmount"), []);
-	    return visualElement;
-	}
-
-	function isRefObject(ref) {
-	    return (typeof ref === "object" &&
-	        Object.prototype.hasOwnProperty.call(ref, "current"));
-	}
 
-	/**
-	 * Creates a ref function that, when called, hydrates the provided
-	 * external ref and VisualElement.
-	 */
-	function useMotionRef(visualState, visualElement, externalRef) {
-	    return reactExports.useCallback((instance) => {
-	        instance && visualState.mount && visualState.mount(instance);
-	        if (visualElement) {
-	            instance
-	                ? visualElement.mount(instance)
-	                : visualElement.unmount();
-	        }
-	        if (externalRef) {
-	            if (typeof externalRef === "function") {
-	                externalRef(instance);
-	            }
-	            else if (isRefObject(externalRef)) {
-	                externalRef.current = instance;
-	            }
-	        }
-	    }, 
-	    /**
-	     * Only pass a new ref callback to React if we've received a visual element
-	     * factory. Otherwise we'll be mounting/remounting every time externalRef
-	     * or other dependencies change.
-	     */
-	    [visualElement]);
-	}
+	let KeyCode = /*#__PURE__*/function (KeyCode) {
+	  KeyCode[KeyCode["Unknown"] = 0] = "Unknown";
+	  KeyCode[KeyCode["Backspace"] = 8] = "Backspace";
+	  KeyCode[KeyCode["Tab"] = 9] = "Tab";
+	  KeyCode[KeyCode["Enter"] = 13] = "Enter";
+	  KeyCode[KeyCode["Shift"] = 16] = "Shift";
+	  KeyCode[KeyCode["Ctrl"] = 17] = "Ctrl";
+	  KeyCode[KeyCode["Alt"] = 18] = "Alt";
+	  KeyCode[KeyCode["PauseBreak"] = 19] = "PauseBreak";
+	  KeyCode[KeyCode["CapsLock"] = 20] = "CapsLock";
+	  KeyCode[KeyCode["Escape"] = 27] = "Escape";
+	  KeyCode[KeyCode["Space"] = 32] = "Space";
+	  KeyCode[KeyCode["PageUp"] = 33] = "PageUp";
+	  KeyCode[KeyCode["PageDown"] = 34] = "PageDown";
+	  KeyCode[KeyCode["End"] = 35] = "End";
+	  KeyCode[KeyCode["Home"] = 36] = "Home";
+	  KeyCode[KeyCode["LeftArrow"] = 37] = "LeftArrow";
+	  KeyCode[KeyCode["UpArrow"] = 38] = "UpArrow";
+	  KeyCode[KeyCode["RightArrow"] = 39] = "RightArrow";
+	  KeyCode[KeyCode["DownArrow"] = 40] = "DownArrow";
+	  KeyCode[KeyCode["Insert"] = 45] = "Insert";
+	  KeyCode[KeyCode["Delete"] = 46] = "Delete";
+	  KeyCode[KeyCode["KEY_0"] = 48] = "KEY_0";
+	  KeyCode[KeyCode["KEY_1"] = 49] = "KEY_1";
+	  KeyCode[KeyCode["KEY_2"] = 50] = "KEY_2";
+	  KeyCode[KeyCode["KEY_3"] = 51] = "KEY_3";
+	  KeyCode[KeyCode["KEY_4"] = 52] = "KEY_4";
+	  KeyCode[KeyCode["KEY_5"] = 53] = "KEY_5";
+	  KeyCode[KeyCode["KEY_6"] = 54] = "KEY_6";
+	  KeyCode[KeyCode["KEY_7"] = 55] = "KEY_7";
+	  KeyCode[KeyCode["KEY_8"] = 56] = "KEY_8";
+	  KeyCode[KeyCode["KEY_9"] = 57] = "KEY_9";
+	  KeyCode[KeyCode["KEY_A"] = 65] = "KEY_A";
+	  KeyCode[KeyCode["KEY_B"] = 66] = "KEY_B";
+	  KeyCode[KeyCode["KEY_C"] = 67] = "KEY_C";
+	  KeyCode[KeyCode["KEY_D"] = 68] = "KEY_D";
+	  KeyCode[KeyCode["KEY_E"] = 69] = "KEY_E";
+	  KeyCode[KeyCode["KEY_F"] = 70] = "KEY_F";
+	  KeyCode[KeyCode["KEY_G"] = 71] = "KEY_G";
+	  KeyCode[KeyCode["KEY_H"] = 72] = "KEY_H";
+	  KeyCode[KeyCode["KEY_I"] = 73] = "KEY_I";
+	  KeyCode[KeyCode["KEY_J"] = 74] = "KEY_J";
+	  KeyCode[KeyCode["KEY_K"] = 75] = "KEY_K";
+	  KeyCode[KeyCode["KEY_L"] = 76] = "KEY_L";
+	  KeyCode[KeyCode["KEY_M"] = 77] = "KEY_M";
+	  KeyCode[KeyCode["KEY_N"] = 78] = "KEY_N";
+	  KeyCode[KeyCode["KEY_O"] = 79] = "KEY_O";
+	  KeyCode[KeyCode["KEY_P"] = 80] = "KEY_P";
+	  KeyCode[KeyCode["KEY_Q"] = 81] = "KEY_Q";
+	  KeyCode[KeyCode["KEY_R"] = 82] = "KEY_R";
+	  KeyCode[KeyCode["KEY_S"] = 83] = "KEY_S";
+	  KeyCode[KeyCode["KEY_T"] = 84] = "KEY_T";
+	  KeyCode[KeyCode["KEY_U"] = 85] = "KEY_U";
+	  KeyCode[KeyCode["KEY_V"] = 86] = "KEY_V";
+	  KeyCode[KeyCode["KEY_W"] = 87] = "KEY_W";
+	  KeyCode[KeyCode["KEY_X"] = 88] = "KEY_X";
+	  KeyCode[KeyCode["KEY_Y"] = 89] = "KEY_Y";
+	  KeyCode[KeyCode["KEY_Z"] = 90] = "KEY_Z";
+	  KeyCode[KeyCode["Meta"] = 91] = "Meta";
+	  KeyCode[KeyCode["F1"] = 112] = "F1";
+	  KeyCode[KeyCode["F2"] = 113] = "F2";
+	  KeyCode[KeyCode["F3"] = 114] = "F3";
+	  KeyCode[KeyCode["F4"] = 115] = "F4";
+	  KeyCode[KeyCode["F5"] = 116] = "F5";
+	  KeyCode[KeyCode["F6"] = 117] = "F6";
+	  KeyCode[KeyCode["F7"] = 118] = "F7";
+	  KeyCode[KeyCode["F8"] = 119] = "F8";
+	  KeyCode[KeyCode["F9"] = 120] = "F9";
+	  KeyCode[KeyCode["F10"] = 121] = "F10";
+	  KeyCode[KeyCode["F11"] = 122] = "F11";
+	  KeyCode[KeyCode["F12"] = 123] = "F12";
+	  KeyCode[KeyCode["NumLock"] = 144] = "NumLock";
+	  KeyCode[KeyCode["ScrollLock"] = 145] = "ScrollLock";
+	  KeyCode[KeyCode["Equal"] = 187] = "Equal";
+	  KeyCode[KeyCode["Minus"] = 189] = "Minus";
+	  KeyCode[KeyCode["Backquote"] = 192] = "Backquote";
+	  KeyCode[KeyCode["Backslash"] = 220] = "Backslash";
+	  return KeyCode;
+	}({});
+	let KeyMod = /*#__PURE__*/function (KeyMod) {
+	  KeyMod[KeyMod["CtrlCmd"] = 2048] = "CtrlCmd";
+	  KeyMod[KeyMod["Shift"] = 1024] = "Shift";
+	  KeyMod[KeyMod["Alt"] = 512] = "Alt";
+	  KeyMod[KeyMod["WinCtrl"] = 256] = "WinCtrl";
+	  return KeyMod;
+	}({});
 
-	/**
-	 * Decides if the supplied variable is variant label
-	 */
-	function isVariantLabel(v) {
-	    return typeof v === "string" || Array.isArray(v);
+	const detectIsBrowser = () => {
+	  return Boolean(typeof window !== 'undefined' && window.document && window.document.createElement);
+	};
+	function useSSR() {
+	  const [browser, setBrowser] = reactExports.useState(false);
+	  reactExports.useEffect(() => {
+	    setBrowser(detectIsBrowser());
+	  }, []);
+	  return {
+	    isBrowser: browser,
+	    isServer: !browser
+	  };
 	}
 
-	function isAnimationControls(v) {
-	    return typeof v === "object" && typeof v.start === "function";
+	function getCtrlKeysByPlatform() {
+	  return {
+	    CtrlCmd: isMac() ? 'metaKey' : 'ctrlKey',
+	    WinCtrl: isMac() ? 'ctrlKey' : 'metaKey'
+	  };
 	}
-
-	const variantProps$1 = [
-	    "initial",
-	    "animate",
-	    "exit",
-	    "whileHover",
-	    "whileDrag",
-	    "whileTap",
-	    "whileFocus",
-	    "whileInView",
-	];
-	function isControllingVariants(props) {
-	    return (isAnimationControls(props.animate) ||
-	        variantProps$1.some((name) => isVariantLabel(props[name])));
+	function getActiveModMap(bindings) {
+	  const modBindings = bindings.filter(item => !!KeyMod[item]);
+	  const activeModMap = {
+	    CtrlCmd: false,
+	    Shift: false,
+	    Alt: false,
+	    WinCtrl: false
+	  };
+	  modBindings.forEach(code => {
+	    const modKey = KeyMod[code];
+	    activeModMap[modKey] = true;
+	  });
+	  return activeModMap;
 	}
-	function isVariantNode(props) {
-	    return Boolean(isControllingVariants(props) || props.variants);
+	function isMac() {
+	  if (!detectIsBrowser()) {
+	    return false;
+	  }
+	  return navigator.platform.toUpperCase().indexOf('MAC') >= 0;
 	}
 
-	function getCurrentTreeVariants(props, context) {
-	    if (isControllingVariants(props)) {
-	        const { initial, animate } = props;
-	        return {
-	            initial: initial === false || isVariantLabel(initial)
-	                ? initial
-	                : undefined,
-	            animate: isVariantLabel(animate) ? animate : undefined,
-	        };
+	const useKeyboard = function (handler, keyBindings, options) {
+	  if (options === void 0) {
+	    options = {};
+	  }
+	  const bindings = Array.isArray(keyBindings) ? keyBindings : [keyBindings];
+	  const {
+	    disableGlobalEvent = false,
+	    capture = false,
+	    stopPropagation = false,
+	    preventDefault = true,
+	    event = 'keydown'
+	  } = options;
+	  const activeModMap = getActiveModMap(bindings);
+	  const keyCode = bindings.filter(item => !KeyMod[item]);
+	  const {
+	    CtrlCmd,
+	    WinCtrl
+	  } = getCtrlKeysByPlatform();
+	  const eventHandler = event => {
+	    if (activeModMap.Shift && !event.shiftKey) return;
+	    if (activeModMap.Alt && !event.altKey) return;
+	    if (activeModMap.CtrlCmd && !event[CtrlCmd]) return;
+	    if (activeModMap.WinCtrl && !event[WinCtrl]) return;
+	    const hitOne = keyCode.find(k => k === event.keyCode);
+	    if (keyCode && !hitOne) return;
+	    if (stopPropagation) {
+	      event.stopPropagation();
 	    }
-	    return props.inherit !== false ? context : {};
-	}
+	    if (preventDefault) {
+	      event.preventDefault();
+	    }
+	    handler && handler(event);
+	  };
+	  reactExports.useEffect(() => {
+	    if (!disableGlobalEvent) {
+	      document.addEventListener(event, eventHandler);
+	    }
+	    return () => {
+	      document.removeEventListener(event, eventHandler);
+	    };
+	  }, [disableGlobalEvent]);
+	  const elementBindingHandler = function (elementEventType, isCapture) {
+	    if (isCapture === void 0) {
+	      isCapture = false;
+	    }
+	    if (elementEventType !== event) return () => {};
+	    if (isCapture !== capture) return () => {};
+	    return e => eventHandler(e);
+	  };
+	  return {
+	    bindings: {
+	      onKeyDown: elementBindingHandler('keydown'),
+	      onKeyDownCapture: elementBindingHandler('keydown', true),
+	      onKeyPress: elementBindingHandler('keypress'),
+	      onKeyPressCapture: elementBindingHandler('keypress', true),
+	      onKeyUp: elementBindingHandler('keyup'),
+	      onKeyUpCapture: elementBindingHandler('keyup', true)
+	    }
+	  };
+	};
 
-	function useCreateMotionContext(props) {
-	    const { initial, animate } = getCurrentTreeVariants(props, reactExports.useContext(MotionContext));
-	    return reactExports.useMemo(() => ({ initial, animate }), [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);
+	const [useLabel, LabelContextProvider] = createGenericContext();
+	function LabelProvider(_ref) {
+	  let {
+	    children
+	  } = _ref;
+	  const {
+	    labels
+	  } = useLayout();
+	  // console.log('LabelProvider', labels);
+	  const labelService = new LabelService(labels);
+	  const getLabel = (key, params) => {
+	    return labelService.getLabel(key, params);
+	  };
+	  return /*#__PURE__*/jsxRuntimeExports.jsx(LabelContextProvider, {
+	    value: getLabel,
+	    children: children
+	  });
 	}
-	function variantLabelsAsDependency(prop) {
-	    return Array.isArray(prop) ? prop.join(" ") : prop;
+	class LabelService {
+	  constructor(labels) {
+	    this.labels = labels;
+	    this.dictionary = Object.fromEntries(labels.map(l => [l.id, l.text]));
+	  }
+	  getLabel(key, params) {
+	    return parseLabel(this.dictionary, key, params);
+	  }
+	}
+	function parseLabel(dictionary, key, params) {
+	  const label = dictionary[key] != null ? dictionary[key] : key;
+	  if (params) {
+	    return parseParams(label, params);
+	  }
+	  return label;
+	}
+	function parseParams(label, params) {
+	  const TEMPLATE_REGEXP = /@(\w+)/g;
+	  return label.replace(TEMPLATE_REGEXP, (text, key) => {
+	    const replacer = params[key];
+	    return typeof replacer !== 'undefined' ? String(replacer) : text;
+	  });
 	}
 
-	const createDefinition = (propNames) => ({
-	    isEnabled: (props) => propNames.some((name) => !!props[name]),
-	});
-	const featureDefinitions = {
-	    measureLayout: createDefinition(["layout", "layoutId", "drag"]),
-	    animation: createDefinition([
-	        "animate",
-	        "exit",
-	        "variants",
-	        "whileHover",
-	        "whileTap",
-	        "whileFocus",
-	        "whileDrag",
-	        "whileInView",
-	    ]),
-	    exit: createDefinition(["exit"]),
-	    drag: createDefinition(["drag", "dragControls"]),
-	    focus: createDefinition(["whileFocus"]),
-	    hover: createDefinition(["whileHover", "onHoverStart", "onHoverEnd"]),
-	    tap: createDefinition(["whileTap", "onTap", "onTapStart", "onTapCancel"]),
-	    pan: createDefinition([
-	        "onPan",
-	        "onPanStart",
-	        "onPanSessionStart",
-	        "onPanEnd",
-	    ]),
-	    inView: createDefinition([
-	        "whileInView",
-	        "onViewportEnter",
-	        "onViewportLeave",
-	    ]),
-	};
+	/*
+	import { useCallback, useEffect, useRef } from 'react';
+
+	export function useMounted(): () => boolean {
+	  const ref = useRef<boolean>(false);
+	  const get = useCallback(() => ref.current, []);
+	  useEffect(() => {
+	    ref.current = true;
+	    return () => {
+	      ref.current = false;
+	    };
+	  }, []);
+	  return get;
+	}
+	*/
 
-	function loadFeatures(features) {
-	    for (const key in features) {
-	        if (key === "projectionNodeConstructor") {
-	            featureDefinitions.projectionNodeConstructor = features[key];
-	        }
-	        else {
-	            featureDefinitions[key].Component = features[key];
-	        }
+	function useMounted() {
+	  const [mounted, setMounted] = reactExports.useState(false);
+	  reactExports.useEffect(() => {
+	    setMounted(true);
+	  }, []); // at init only
+	  return mounted;
+	}
+
+	const [usePage, PageContextProvider] = createGenericContext();
+	function PageProvider(_ref) {
+	  let {
+	    children,
+	    page
+	  } = _ref;
+	  return /*#__PURE__*/jsxRuntimeExports.jsx(PageContextProvider, {
+	    value: page,
+	    children: children
+	  });
+	}
+
+	const namespace = 'theme';
+	function usePortal(name, getContainer) {
+	  if (name === void 0) {
+	    name = getUID();
+	  }
+	  const {
+	    isBrowser
+	  } = useSSR();
+	  const id = `${namespace}-${name}`;
+	  const [portal, setPortal] = reactExports.useState(isBrowser ? createElementWithId(id) : null);
+	  reactExports.useEffect(() => {
+	    const container = typeof getContainer === 'function' ? getContainer() : null;
+	    const parentElement = container || document.body;
+	    const element = parentElement.querySelector(`#${id}`) || createElementWithId(id);
+	    if (!element.parentElement) {
+	      parentElement.appendChild(element);
 	    }
+	    setPortal(element);
+	  }, []);
+	  return portal;
+	}
+	function createElementWithId(id) {
+	  const element = document.createElement('div');
+	  element.setAttribute('id', id);
+	  return element;
+	}
+	function getUID() {
+	  return Math.random().toString(32).slice(2, 10);
 	}
 
 	/**
-	 * Creates a constant value over the lifecycle of a component.
-	 *
-	 * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer
-	 * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`
-	 * you can ensure that initialisers don't execute twice or more.
+	 * @public
 	 */
-	function useConstant(init) {
-	    const ref = reactExports.useRef(null);
-	    if (ref.current === null) {
-	        ref.current = init();
-	    }
-	    return ref.current;
+	const MotionConfigContext = reactExports.createContext({
+	    transformPagePoint: (p) => p,
+	    isStatic: false,
+	    reducedMotion: "never",
+	});
+
+	const MotionContext = reactExports.createContext({});
+	function useVisualElementContext() {
+	    return reactExports.useContext(MotionContext).visualElement;
 	}
 
 	/**
-	 * This should only ever be modified on the client otherwise it'll
-	 * persist through server requests. If we need instanced states we
-	 * could lazy-init via root.
+	 * @public
 	 */
-	const globalProjectionState = {
+	const PresenceContext = reactExports.createContext(null);
+
+	const isBrowser = typeof document !== "undefined";
+
+	const useIsomorphicLayoutEffect$1 = isBrowser ? reactExports.useLayoutEffect : reactExports.useEffect;
+
+	const LazyContext = reactExports.createContext({ strict: false });
+
+	function useVisualElement(Component, visualState, props, createVisualElement) {
+	    const parent = useVisualElementContext();
+	    const lazyContext = reactExports.useContext(LazyContext);
+	    const presenceContext = reactExports.useContext(PresenceContext);
+	    const reducedMotionConfig = reactExports.useContext(MotionConfigContext).reducedMotion;
+	    const visualElementRef = reactExports.useRef();
 	    /**
-	     * Global flag as to whether the tree has animated since the last time
-	     * we resized the window
+	     * If we haven't preloaded a renderer, check to see if we have one lazy-loaded
+	     */
+	    createVisualElement = createVisualElement || lazyContext.renderer;
+	    if (!visualElementRef.current && createVisualElement) {
+	        visualElementRef.current = createVisualElement(Component, {
+	            visualState,
+	            parent,
+	            props,
+	            presenceId: presenceContext ? presenceContext.id : undefined,
+	            blockInitialAnimation: presenceContext
+	                ? presenceContext.initial === false
+	                : false,
+	            reducedMotionConfig,
+	        });
+	    }
+	    const visualElement = visualElementRef.current;
+	    useIsomorphicLayoutEffect$1(() => {
+	        visualElement && visualElement.render();
+	    });
+	    /**
+	     * If we have optimised appear animations to handoff from, trigger animateChanges
+	     * from a synchronous useLayoutEffect to ensure there's no flash of incorrectly
+	     * styled component in the event of a hydration error.
+	     */
+	    useIsomorphicLayoutEffect$1(() => {
+	        if (visualElement && visualElement.animationState) {
+	            visualElement.animationState.animateChanges();
+	        }
+	    });
+	    useIsomorphicLayoutEffect$1(() => () => visualElement && visualElement.notify("Unmount"), []);
+	    return visualElement;
+	}
+
+	function isRefObject(ref) {
+	    return (typeof ref === "object" &&
+	        Object.prototype.hasOwnProperty.call(ref, "current"));
+	}
+
+	/**
+	 * Creates a ref function that, when called, hydrates the provided
+	 * external ref and VisualElement.
+	 */
+	function useMotionRef(visualState, visualElement, externalRef) {
+	    return reactExports.useCallback((instance) => {
+	        instance && visualState.mount && visualState.mount(instance);
+	        if (visualElement) {
+	            instance
+	                ? visualElement.mount(instance)
+	                : visualElement.unmount();
+	        }
+	        if (externalRef) {
+	            if (typeof externalRef === "function") {
+	                externalRef(instance);
+	            }
+	            else if (isRefObject(externalRef)) {
+	                externalRef.current = instance;
+	            }
+	        }
+	    }, 
+	    /**
+	     * Only pass a new ref callback to React if we've received a visual element
+	     * factory. Otherwise we'll be mounting/remounting every time externalRef
+	     * or other dependencies change.
+	     */
+	    [visualElement]);
+	}
+
+	/**
+	 * Decides if the supplied variable is variant label
+	 */
+	function isVariantLabel(v) {
+	    return typeof v === "string" || Array.isArray(v);
+	}
+
+	function isAnimationControls(v) {
+	    return typeof v === "object" && typeof v.start === "function";
+	}
+
+	const variantProps$1 = [
+	    "initial",
+	    "animate",
+	    "exit",
+	    "whileHover",
+	    "whileDrag",
+	    "whileTap",
+	    "whileFocus",
+	    "whileInView",
+	];
+	function isControllingVariants(props) {
+	    return (isAnimationControls(props.animate) ||
+	        variantProps$1.some((name) => isVariantLabel(props[name])));
+	}
+	function isVariantNode(props) {
+	    return Boolean(isControllingVariants(props) || props.variants);
+	}
+
+	function getCurrentTreeVariants(props, context) {
+	    if (isControllingVariants(props)) {
+	        const { initial, animate } = props;
+	        return {
+	            initial: initial === false || isVariantLabel(initial)
+	                ? initial
+	                : undefined,
+	            animate: isVariantLabel(animate) ? animate : undefined,
+	        };
+	    }
+	    return props.inherit !== false ? context : {};
+	}
+
+	function useCreateMotionContext(props) {
+	    const { initial, animate } = getCurrentTreeVariants(props, reactExports.useContext(MotionContext));
+	    return reactExports.useMemo(() => ({ initial, animate }), [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);
+	}
+	function variantLabelsAsDependency(prop) {
+	    return Array.isArray(prop) ? prop.join(" ") : prop;
+	}
+
+	const createDefinition = (propNames) => ({
+	    isEnabled: (props) => propNames.some((name) => !!props[name]),
+	});
+	const featureDefinitions = {
+	    measureLayout: createDefinition(["layout", "layoutId", "drag"]),
+	    animation: createDefinition([
+	        "animate",
+	        "exit",
+	        "variants",
+	        "whileHover",
+	        "whileTap",
+	        "whileFocus",
+	        "whileDrag",
+	        "whileInView",
+	    ]),
+	    exit: createDefinition(["exit"]),
+	    drag: createDefinition(["drag", "dragControls"]),
+	    focus: createDefinition(["whileFocus"]),
+	    hover: createDefinition(["whileHover", "onHoverStart", "onHoverEnd"]),
+	    tap: createDefinition(["whileTap", "onTap", "onTapStart", "onTapCancel"]),
+	    pan: createDefinition([
+	        "onPan",
+	        "onPanStart",
+	        "onPanSessionStart",
+	        "onPanEnd",
+	    ]),
+	    inView: createDefinition([
+	        "whileInView",
+	        "onViewportEnter",
+	        "onViewportLeave",
+	    ]),
+	};
+
+	function loadFeatures(features) {
+	    for (const key in features) {
+	        if (key === "projectionNodeConstructor") {
+	            featureDefinitions.projectionNodeConstructor = features[key];
+	        }
+	        else {
+	            featureDefinitions[key].Component = features[key];
+	        }
+	    }
+	}
+
+	/**
+	 * Creates a constant value over the lifecycle of a component.
+	 *
+	 * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer
+	 * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`
+	 * you can ensure that initialisers don't execute twice or more.
+	 */
+	function useConstant(init) {
+	    const ref = reactExports.useRef(null);
+	    if (ref.current === null) {
+	        ref.current = init();
+	    }
+	    return ref.current;
+	}
+
+	/**
+	 * This should only ever be modified on the client otherwise it'll
+	 * persist through server requests. If we need instanced states we
+	 * could lazy-init via root.
+	 */
+	const globalProjectionState = {
+	    /**
+	     * Global flag as to whether the tree has animated since the last time
+	     * we resized the window
 	     */
 	    hasAnimatedSinceResize: true,
 	    /**
@@ -17315,448 +17695,118 @@
 	 *         animate={{ opacity: 1 }}
 	 *         exit={{ opacity: 0 }}
 	 *       />
-	 *     ))}
-	 *   </AnimatePresence>
-	 * )
-	 * ```
-	 *
-	 * You can sequence exit animations throughout a tree using variants.
-	 *
-	 * If a child contains multiple `motion` components with `exit` props, it will only unmount the child
-	 * once all `motion` components have finished animating out. Likewise, any components using
-	 * `usePresence` all need to call `safeToRemove`.
-	 *
-	 * @public
-	 */
-	const AnimatePresence = ({ children, custom, initial = true, onExitComplete, exitBeforeEnter, presenceAffectsLayout = true, mode = "sync", }) => {
-	    // Support deprecated exitBeforeEnter prop
-	    if (exitBeforeEnter) {
-	        mode = "wait";
-	        warnOnce(false, "Replace exitBeforeEnter with mode='wait'");
-	    }
-	    // We want to force a re-render once all exiting animations have finished. We
-	    // either use a local forceRender function, or one from a parent context if it exists.
-	    let [forceRender] = useForceUpdate();
-	    const forceRenderLayoutGroup = reactExports.useContext(LayoutGroupContext).forceRender;
-	    if (forceRenderLayoutGroup)
-	        forceRender = forceRenderLayoutGroup;
-	    const isMounted = useIsMounted();
-	    // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key
-	    const filteredChildren = onlyElements(children);
-	    let childrenToRender = filteredChildren;
-	    const exiting = new Set();
-	    // Keep a living record of the children we're actually rendering so we
-	    // can diff to figure out which are entering and exiting
-	    const presentChildren = reactExports.useRef(childrenToRender);
-	    // A lookup table to quickly reference components by key
-	    const allChildren = reactExports.useRef(new Map()).current;
-	    // If this is the initial component render, just deal with logic surrounding whether
-	    // we play onMount animations or not.
-	    const isInitialRender = reactExports.useRef(true);
-	    useIsomorphicLayoutEffect$1(() => {
-	        isInitialRender.current = false;
-	        updateChildLookup(filteredChildren, allChildren);
-	        presentChildren.current = childrenToRender;
-	    });
-	    useUnmountEffect(() => {
-	        isInitialRender.current = true;
-	        allChildren.clear();
-	        exiting.clear();
-	    });
-	    if (isInitialRender.current) {
-	        return (reactExports.createElement(reactExports.Fragment, null, childrenToRender.map((child) => (reactExports.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, initial: initial ? undefined : false, presenceAffectsLayout: presenceAffectsLayout, mode: mode }, child)))));
-	    }
-	    // If this is a subsequent render, deal with entering and exiting children
-	    childrenToRender = [...childrenToRender];
-	    // Diff the keys of the currently-present and target children to update our
-	    // exiting list.
-	    const presentKeys = presentChildren.current.map(getChildKey);
-	    const targetKeys = filteredChildren.map(getChildKey);
-	    // Diff the present children with our target children and mark those that are exiting
-	    const numPresent = presentKeys.length;
-	    for (let i = 0; i < numPresent; i++) {
-	        const key = presentKeys[i];
-	        if (targetKeys.indexOf(key) === -1) {
-	            exiting.add(key);
-	        }
-	    }
-	    // If we currently have exiting children, and we're deferring rendering incoming children
-	    // until after all current children have exiting, empty the childrenToRender array
-	    if (mode === "wait" && exiting.size) {
-	        childrenToRender = [];
-	    }
-	    // Loop through all currently exiting components and clone them to overwrite `animate`
-	    // with any `exit` prop they might have defined.
-	    exiting.forEach((key) => {
-	        // If this component is actually entering again, early return
-	        if (targetKeys.indexOf(key) !== -1)
-	            return;
-	        const child = allChildren.get(key);
-	        if (!child)
-	            return;
-	        const insertionIndex = presentKeys.indexOf(key);
-	        const onExit = () => {
-	            allChildren.delete(key);
-	            exiting.delete(key);
-	            // Remove this child from the present children
-	            const removeIndex = presentChildren.current.findIndex((presentChild) => presentChild.key === key);
-	            presentChildren.current.splice(removeIndex, 1);
-	            // Defer re-rendering until all exiting children have indeed left
-	            if (!exiting.size) {
-	                presentChildren.current = filteredChildren;
-	                if (isMounted.current === false)
-	                    return;
-	                forceRender();
-	                onExitComplete && onExitComplete();
-	            }
-	        };
-	        childrenToRender.splice(insertionIndex, 0, reactExports.createElement(PresenceChild, { key: getChildKey(child), isPresent: false, onExitComplete: onExit, custom: custom, presenceAffectsLayout: presenceAffectsLayout, mode: mode }, child));
-	    });
-	    // Add `MotionContext` even to children that don't need it to ensure we're rendering
-	    // the same tree between renders
-	    childrenToRender = childrenToRender.map((child) => {
-	        const key = child.key;
-	        return exiting.has(key) ? (child) : (reactExports.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, presenceAffectsLayout: presenceAffectsLayout, mode: mode }, child));
-	    });
-	    if (env !== "production" &&
-	        mode === "wait" &&
-	        childrenToRender.length > 1) {
-	        console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to "wait". This will lead to odd visual behaviour.`);
-	    }
-	    return (reactExports.createElement(reactExports.Fragment, null, exiting.size
-	        ? childrenToRender
-	        : childrenToRender.map((child) => reactExports.cloneElement(child))));
-	};
-
-	function createJSONStorage(getStorage, options) {
-	  let storage;
-	  try {
-	    storage = getStorage();
-	  } catch (e) {
-	    return;
-	  }
-	  const persistStorage = {
-	    getItem: (name) => {
-	      var _a;
-	      const parse = (str2) => {
-	        if (str2 === null) {
-	          return null;
-	        }
-	        return JSON.parse(str2, options == null ? void 0 : options.reviver);
-	      };
-	      const str = (_a = storage.getItem(name)) != null ? _a : null;
-	      if (str instanceof Promise) {
-	        return str.then(parse);
-	      }
-	      return parse(str);
-	    },
-	    setItem: (name, newValue) => storage.setItem(
-	      name,
-	      JSON.stringify(newValue, options == null ? void 0 : options.replacer)
-	    ),
-	    removeItem: (name) => storage.removeItem(name)
-	  };
-	  return persistStorage;
-	}
-	const toThenable = (fn) => (input) => {
-	  try {
-	    const result = fn(input);
-	    if (result instanceof Promise) {
-	      return result;
-	    }
-	    return {
-	      then(onFulfilled) {
-	        return toThenable(onFulfilled)(result);
-	      },
-	      catch(_onRejected) {
-	        return this;
-	      }
-	    };
-	  } catch (e) {
-	    return {
-	      then(_onFulfilled) {
-	        return this;
-	      },
-	      catch(onRejected) {
-	        return toThenable(onRejected)(e);
-	      }
-	    };
-	  }
-	};
-	const oldImpl = (config, baseOptions) => (set, get, api) => {
-	  let options = {
-	    getStorage: () => localStorage,
-	    serialize: JSON.stringify,
-	    deserialize: JSON.parse,
-	    partialize: (state) => state,
-	    version: 0,
-	    merge: (persistedState, currentState) => ({
-	      ...currentState,
-	      ...persistedState
-	    }),
-	    ...baseOptions
-	  };
-	  let hasHydrated = false;
-	  const hydrationListeners = /* @__PURE__ */ new Set();
-	  const finishHydrationListeners = /* @__PURE__ */ new Set();
-	  let storage;
-	  try {
-	    storage = options.getStorage();
-	  } catch (e) {
-	  }
-	  if (!storage) {
-	    return config(
-	      (...args) => {
-	        console.warn(
-	          `[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
-	        );
-	        set(...args);
-	      },
-	      get,
-	      api
-	    );
-	  }
-	  const thenableSerialize = toThenable(options.serialize);
-	  const setItem = () => {
-	    const state = options.partialize({ ...get() });
-	    let errorInSync;
-	    const thenable = thenableSerialize({ state, version: options.version }).then(
-	      (serializedValue) => storage.setItem(options.name, serializedValue)
-	    ).catch((e) => {
-	      errorInSync = e;
-	    });
-	    if (errorInSync) {
-	      throw errorInSync;
-	    }
-	    return thenable;
-	  };
-	  const savedSetState = api.setState;
-	  api.setState = (state, replace) => {
-	    savedSetState(state, replace);
-	    void setItem();
-	  };
-	  const configResult = config(
-	    (...args) => {
-	      set(...args);
-	      void setItem();
-	    },
-	    get,
-	    api
-	  );
-	  let stateFromStorage;
-	  const hydrate = () => {
-	    var _a;
-	    if (!storage)
-	      return;
-	    hasHydrated = false;
-	    hydrationListeners.forEach((cb) => cb(get()));
-	    const postRehydrationCallback = ((_a = options.onRehydrateStorage) == null ? void 0 : _a.call(options, get())) || void 0;
-	    return toThenable(storage.getItem.bind(storage))(options.name).then((storageValue) => {
-	      if (storageValue) {
-	        return options.deserialize(storageValue);
-	      }
-	    }).then((deserializedStorageValue) => {
-	      if (deserializedStorageValue) {
-	        if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
-	          if (options.migrate) {
-	            return options.migrate(
-	              deserializedStorageValue.state,
-	              deserializedStorageValue.version
-	            );
-	          }
-	          console.error(
-	            `State loaded from storage couldn't be migrated since no migrate function was provided`
-	          );
-	        } else {
-	          return deserializedStorageValue.state;
-	        }
-	      }
-	    }).then((migratedState) => {
-	      var _a2;
-	      stateFromStorage = options.merge(
-	        migratedState,
-	        (_a2 = get()) != null ? _a2 : configResult
-	      );
-	      set(stateFromStorage, true);
-	      return setItem();
-	    }).then(() => {
-	      postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0);
-	      hasHydrated = true;
-	      finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
-	    }).catch((e) => {
-	      postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e);
-	    });
-	  };
-	  api.persist = {
-	    setOptions: (newOptions) => {
-	      options = {
-	        ...options,
-	        ...newOptions
-	      };
-	      if (newOptions.getStorage) {
-	        storage = newOptions.getStorage();
-	      }
-	    },
-	    clearStorage: () => {
-	      storage == null ? void 0 : storage.removeItem(options.name);
-	    },
-	    getOptions: () => options,
-	    rehydrate: () => hydrate(),
-	    hasHydrated: () => hasHydrated,
-	    onHydrate: (cb) => {
-	      hydrationListeners.add(cb);
-	      return () => {
-	        hydrationListeners.delete(cb);
-	      };
-	    },
-	    onFinishHydration: (cb) => {
-	      finishHydrationListeners.add(cb);
-	      return () => {
-	        finishHydrationListeners.delete(cb);
-	      };
-	    }
-	  };
-	  hydrate();
-	  return stateFromStorage || configResult;
-	};
-	const newImpl = (config, baseOptions) => (set, get, api) => {
-	  let options = {
-	    storage: createJSONStorage(() => localStorage),
-	    partialize: (state) => state,
-	    version: 0,
-	    merge: (persistedState, currentState) => ({
-	      ...currentState,
-	      ...persistedState
-	    }),
-	    ...baseOptions
-	  };
-	  let hasHydrated = false;
-	  const hydrationListeners = /* @__PURE__ */ new Set();
-	  const finishHydrationListeners = /* @__PURE__ */ new Set();
-	  let storage = options.storage;
-	  if (!storage) {
-	    return config(
-	      (...args) => {
-	        console.warn(
-	          `[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
-	        );
-	        set(...args);
-	      },
-	      get,
-	      api
-	    );
-	  }
-	  const setItem = () => {
-	    const state = options.partialize({ ...get() });
-	    return storage.setItem(options.name, {
-	      state,
-	      version: options.version
+	 *     ))}
+	 *   </AnimatePresence>
+	 * )
+	 * ```
+	 *
+	 * You can sequence exit animations throughout a tree using variants.
+	 *
+	 * If a child contains multiple `motion` components with `exit` props, it will only unmount the child
+	 * once all `motion` components have finished animating out. Likewise, any components using
+	 * `usePresence` all need to call `safeToRemove`.
+	 *
+	 * @public
+	 */
+	const AnimatePresence = ({ children, custom, initial = true, onExitComplete, exitBeforeEnter, presenceAffectsLayout = true, mode = "sync", }) => {
+	    // Support deprecated exitBeforeEnter prop
+	    if (exitBeforeEnter) {
+	        mode = "wait";
+	        warnOnce(false, "Replace exitBeforeEnter with mode='wait'");
+	    }
+	    // We want to force a re-render once all exiting animations have finished. We
+	    // either use a local forceRender function, or one from a parent context if it exists.
+	    let [forceRender] = useForceUpdate();
+	    const forceRenderLayoutGroup = reactExports.useContext(LayoutGroupContext).forceRender;
+	    if (forceRenderLayoutGroup)
+	        forceRender = forceRenderLayoutGroup;
+	    const isMounted = useIsMounted();
+	    // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key
+	    const filteredChildren = onlyElements(children);
+	    let childrenToRender = filteredChildren;
+	    const exiting = new Set();
+	    // Keep a living record of the children we're actually rendering so we
+	    // can diff to figure out which are entering and exiting
+	    const presentChildren = reactExports.useRef(childrenToRender);
+	    // A lookup table to quickly reference components by key
+	    const allChildren = reactExports.useRef(new Map()).current;
+	    // If this is the initial component render, just deal with logic surrounding whether
+	    // we play onMount animations or not.
+	    const isInitialRender = reactExports.useRef(true);
+	    useIsomorphicLayoutEffect$1(() => {
+	        isInitialRender.current = false;
+	        updateChildLookup(filteredChildren, allChildren);
+	        presentChildren.current = childrenToRender;
 	    });
-	  };
-	  const savedSetState = api.setState;
-	  api.setState = (state, replace) => {
-	    savedSetState(state, replace);
-	    void setItem();
-	  };
-	  const configResult = config(
-	    (...args) => {
-	      set(...args);
-	      void setItem();
-	    },
-	    get,
-	    api
-	  );
-	  api.getInitialState = () => configResult;
-	  let stateFromStorage;
-	  const hydrate = () => {
-	    var _a, _b;
-	    if (!storage)
-	      return;
-	    hasHydrated = false;
-	    hydrationListeners.forEach((cb) => {
-	      var _a2;
-	      return cb((_a2 = get()) != null ? _a2 : configResult);
+	    useUnmountEffect(() => {
+	        isInitialRender.current = true;
+	        allChildren.clear();
+	        exiting.clear();
 	    });
-	    const postRehydrationCallback = ((_b = options.onRehydrateStorage) == null ? void 0 : _b.call(options, (_a = get()) != null ? _a : configResult)) || void 0;
-	    return toThenable(storage.getItem.bind(storage))(options.name).then((deserializedStorageValue) => {
-	      if (deserializedStorageValue) {
-	        if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
-	          if (options.migrate) {
-	            return options.migrate(
-	              deserializedStorageValue.state,
-	              deserializedStorageValue.version
-	            );
-	          }
-	          console.error(
-	            `State loaded from storage couldn't be migrated since no migrate function was provided`
-	          );
-	        } else {
-	          return deserializedStorageValue.state;
+	    if (isInitialRender.current) {
+	        return (reactExports.createElement(reactExports.Fragment, null, childrenToRender.map((child) => (reactExports.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, initial: initial ? undefined : false, presenceAffectsLayout: presenceAffectsLayout, mode: mode }, child)))));
+	    }
+	    // If this is a subsequent render, deal with entering and exiting children
+	    childrenToRender = [...childrenToRender];
+	    // Diff the keys of the currently-present and target children to update our
+	    // exiting list.
+	    const presentKeys = presentChildren.current.map(getChildKey);
+	    const targetKeys = filteredChildren.map(getChildKey);
+	    // Diff the present children with our target children and mark those that are exiting
+	    const numPresent = presentKeys.length;
+	    for (let i = 0; i < numPresent; i++) {
+	        const key = presentKeys[i];
+	        if (targetKeys.indexOf(key) === -1) {
+	            exiting.add(key);
 	        }
-	      }
-	    }).then((migratedState) => {
-	      var _a2;
-	      stateFromStorage = options.merge(
-	        migratedState,
-	        (_a2 = get()) != null ? _a2 : configResult
-	      );
-	      set(stateFromStorage, true);
-	      return setItem();
-	    }).then(() => {
-	      postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0);
-	      stateFromStorage = get();
-	      hasHydrated = true;
-	      finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
-	    }).catch((e) => {
-	      postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e);
-	    });
-	  };
-	  api.persist = {
-	    setOptions: (newOptions) => {
-	      options = {
-	        ...options,
-	        ...newOptions
-	      };
-	      if (newOptions.storage) {
-	        storage = newOptions.storage;
-	      }
-	    },
-	    clearStorage: () => {
-	      storage == null ? void 0 : storage.removeItem(options.name);
-	    },
-	    getOptions: () => options,
-	    rehydrate: () => hydrate(),
-	    hasHydrated: () => hasHydrated,
-	    onHydrate: (cb) => {
-	      hydrationListeners.add(cb);
-	      return () => {
-	        hydrationListeners.delete(cb);
-	      };
-	    },
-	    onFinishHydration: (cb) => {
-	      finishHydrationListeners.add(cb);
-	      return () => {
-	        finishHydrationListeners.delete(cb);
-	      };
 	    }
-	  };
-	  if (!options.skipHydration) {
-	    hydrate();
-	  }
-	  return stateFromStorage || configResult;
-	};
-	const persistImpl = (config, baseOptions) => {
-	  if ("getStorage" in baseOptions || "serialize" in baseOptions || "deserialize" in baseOptions) {
-	    if ((undefined ? undefined.MODE : void 0) !== "production") {
-	      console.warn(
-	        "[DEPRECATED] `getStorage`, `serialize` and `deserialize` options are deprecated. Use `storage` option instead."
-	      );
+	    // If we currently have exiting children, and we're deferring rendering incoming children
+	    // until after all current children have exiting, empty the childrenToRender array
+	    if (mode === "wait" && exiting.size) {
+	        childrenToRender = [];
 	    }
-	    return oldImpl(config, baseOptions);
-	  }
-	  return newImpl(config, baseOptions);
+	    // Loop through all currently exiting components and clone them to overwrite `animate`
+	    // with any `exit` prop they might have defined.
+	    exiting.forEach((key) => {
+	        // If this component is actually entering again, early return
+	        if (targetKeys.indexOf(key) !== -1)
+	            return;
+	        const child = allChildren.get(key);
+	        if (!child)
+	            return;
+	        const insertionIndex = presentKeys.indexOf(key);
+	        const onExit = () => {
+	            allChildren.delete(key);
+	            exiting.delete(key);
+	            // Remove this child from the present children
+	            const removeIndex = presentChildren.current.findIndex((presentChild) => presentChild.key === key);
+	            presentChildren.current.splice(removeIndex, 1);
+	            // Defer re-rendering until all exiting children have indeed left
+	            if (!exiting.size) {
+	                presentChildren.current = filteredChildren;
+	                if (isMounted.current === false)
+	                    return;
+	                forceRender();
+	                onExitComplete && onExitComplete();
+	            }
+	        };
+	        childrenToRender.splice(insertionIndex, 0, reactExports.createElement(PresenceChild, { key: getChildKey(child), isPresent: false, onExitComplete: onExit, custom: custom, presenceAffectsLayout: presenceAffectsLayout, mode: mode }, child));
+	    });
+	    // Add `MotionContext` even to children that don't need it to ensure we're rendering
+	    // the same tree between renders
+	    childrenToRender = childrenToRender.map((child) => {
+	        const key = child.key;
+	        return exiting.has(key) ? (child) : (reactExports.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, presenceAffectsLayout: presenceAffectsLayout, mode: mode }, child));
+	    });
+	    if (env !== "production" &&
+	        mode === "wait" &&
+	        childrenToRender.length > 1) {
+	        console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to "wait". This will lead to odd visual behaviour.`);
+	    }
+	    return (reactExports.createElement(reactExports.Fragment, null, exiting.size
+	        ? childrenToRender
+	        : childrenToRender.map((child) => reactExports.cloneElement(child))));
 	};
-	const persist = persistImpl;
 
 	var font = {
 	  primary: "Aeonik, Arial, Helvetica, sans-serif",
@@ -23862,48 +23912,6 @@ void main(void) {
 	  return /*#__PURE__*/jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, {});
 	};
 
-	function useFocusTrap(ref, options) {
-	  if (options === void 0) {
-	    options = {};
-	  }
-	  const selectors = options.selectors || 'a[href]:not([disabled]), button:not([disabled]), textarea:not([disabled]), input[type="text"]:not([disabled]), input[type="radio"]:not([disabled]), input[type="checkbox"]:not([disabled]), select:not([disabled])';
-	  const [state, setState] = reactExports.useState(!options.disabled);
-	  useIsomorphicLayoutEffect$2(() => {
-	    const element = ref.current;
-	    if (element) {
-	      const elements = element.querySelectorAll(selectors);
-	      const first = elements[0];
-	      const last = elements[elements.length - 1];
-	      const onKeyDown = event => {
-	        // console.log(event.key, event.code, event.keyCode);
-	        const isTabPressed = event.key === 'Tab';
-	        if (!isTabPressed) {
-	          return;
-	        }
-	        if (event.shiftKey) {
-	          // shift + tab
-	          if (document.activeElement === first) {
-	            last.focus();
-	            event.preventDefault();
-	          }
-	        } else {
-	          // tab
-	          if (document.activeElement === last) {
-	            first.focus();
-	            event.preventDefault();
-	          }
-	        }
-	      };
-	      element.addEventListener('keydown', onKeyDown);
-	      return () => {
-	        element.removeEventListener('keydown', onKeyDown);
-	      };
-	    }
-	    return () => {};
-	  }, [ref.current]);
-	  return [state, setState];
-	}
-
 	function Canvas() {
 	  const ref = reactExports.useRef(null);
 	  useCanvasOffscreen(ref);
@@ -23922,7 +23930,8 @@ void main(void) {
 	    className: "icon-llm-arrow-corner-right-up",
 	    width: "1em",
 	    height: "1em",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-arrow-corner-right-up",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx("path", {
@@ -23943,7 +23952,8 @@ void main(void) {
 	    className: "icon-llm-arrow-left",
 	    width: "1em",
 	    height: "1em",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-arrow-left",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx("path", {
@@ -23964,7 +23974,8 @@ void main(void) {
 	    className: "icon-llm-arrow-right",
 	    width: "1em",
 	    height: "1em",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-arrow-right",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx("path", {
@@ -23984,7 +23995,8 @@ void main(void) {
 	    className: "icon-llm-chevron-right-circle",
 	    width: "1em",
 	    height: "1em",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-chevron-right-circle",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx("path", {
@@ -24002,7 +24014,8 @@ void main(void) {
 	    className: "icon-llm-info-circle",
 	    width: "1em",
 	    height: "1em",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-info-circle",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx("path", {
@@ -24027,7 +24040,8 @@ void main(void) {
 	    strokeLinecap: "round",
 	    strokeLinejoin: "round",
 	    className: "icon-llm-maximize",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-maximize",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: [/*#__PURE__*/jsxRuntimeExports.jsx("polyline", {
@@ -24057,7 +24071,8 @@ void main(void) {
 	    className: "icon-llm-microphone",
 	    width: "1em",
 	    height: "1em",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-microphone",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx("path", {
@@ -24082,7 +24097,8 @@ void main(void) {
 	    strokeLinecap: "round",
 	    strokeLinejoin: "round",
 	    className: "icon-llm-minimize",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-minimize",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: [/*#__PURE__*/jsxRuntimeExports.jsx("polyline", {
@@ -24112,7 +24128,8 @@ void main(void) {
 	    className: "icon-llm-pin",
 	    width: "1em",
 	    height: "1em",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-pin",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx("path", {
@@ -24132,7 +24149,8 @@ void main(void) {
 	    className: "icon-llm-play",
 	    width: "1em",
 	    height: "1em",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-play",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx("path", {
@@ -24151,7 +24169,8 @@ void main(void) {
 	    className: "icon-llm-send",
 	    width: "1em",
 	    height: "1em",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-send",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx("path", {
@@ -24171,7 +24190,8 @@ void main(void) {
 	    className: "icon-llm-stop",
 	    width: "1em",
 	    height: "1em",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-stop",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx("path", {
@@ -24189,7 +24209,8 @@ void main(void) {
 	    viewBox: "0 0 18 18",
 	    xmlns: "http://www.w3.org/2000/svg",
 	    className: "icon-llm-timetable",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-timetable",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx("path", {
@@ -24212,7 +24233,8 @@ void main(void) {
 	    strokeLinecap: "round",
 	    strokeLinejoin: "round",
 	    className: "icon-llm-volume-x",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-volume-x",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: [/*#__PURE__*/jsxRuntimeExports.jsx("polygon", {
@@ -24244,7 +24266,8 @@ void main(void) {
 	    strokeLinecap: "round",
 	    strokeLinejoin: "round",
 	    className: "icon-llm-volume",
-	    "data-icon": "",
+	    "data-icon": "icon-llm-volume",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: [/*#__PURE__*/jsxRuntimeExports.jsx("polygon", {
@@ -24270,7 +24293,8 @@ void main(void) {
 	    strokeLinecap: "round",
 	    strokeLinejoin: "round",
 	    className: "icon-websolute",
-	    "data-icon": "",
+	    "data-icon": "icon-websolute",
+	    "aria-hidden": "true",
 	    ...props,
 	    ref: ref,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx("path", {
@@ -30106,16 +30130,6 @@ void main(void) {
 	  });
 	};
 
-	const useAutosizeTextArea = (textAreaRef, value) => {
-	  reactExports.useEffect(() => {
-	    if (textAreaRef) {
-	      textAreaRef.style.height = '0px';
-	      textAreaRef.style.height = textAreaRef.scrollHeight + 1 + 'px';
-	    }
-	  }, [textAreaRef, value]);
-	};
-	var useAutosizeTextArea$1 = useAutosizeTextArea;
-
 	const Suggestions = () => {
 	  useWindowSize();
 	  const app = useLlm(state => state.app);
@@ -30174,7 +30188,7 @@ void main(void) {
 	  const {
 	    send
 	  } = useLlmView(state => state.actions);
-	  useAutosizeTextArea$1(textArea.current, prompt);
+	  useAutosizeTextArea(textArea.current, prompt);
 	  const onChange = event => {
 	    const prompt = event.target?.value;
 	    setPrompt(prompt);
@@ -34114,7 +34128,8 @@ void main(void) {
 	      };
 	    }
 	  }, [locale, market]);
-	  const endpoint = typeof props.test !== 'undefined' ? 'https://bom-sample-basic-web-git-bom-llm-actarian.vercel.app' : 'https://platform.websolute.ai';
+	  const defaultEndpoint = typeof props.test !== 'undefined' ? 'https://bom-sample-basic-web-git-bom-llm-actarian.vercel.app' : 'https://platform.websolute.ai';
+	  const endpoint = props.endpoint || defaultEndpoint;
 	  const layout = {
 	    labels: getLabels(data.locale),
 	    locale: data.locale,