@seamly/web-ui 25.1.0 → 25.2.0-beta.2

package/build/dist/lib/index.js

@@ -3001,10 +3001,10 @@ var SHARED = '__core-js_shared__';
 var store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
 
 (store.versions || (store.versions = [])).push({
-  version: '3.45.1',
+  version: '3.46.0',
   mode: IS_PURE ? 'pure' : 'global',
-  copyright: '© 2014-2025 Denis Pushkarev (zloirock.ru)',
-  license: 'https://github.com/zloirock/core-js/blob/v3.45.1/LICENSE',
+  copyright: '© 2014-2025 Denis Pushkarev (zloirock.ru), 2025 CoreJS Company (core-js.io)',
+  license: 'https://github.com/zloirock/core-js/blob/v3.46.0/LICENSE',
   source: 'https://github.com/zloirock/core-js'
 });
 
@@ -5837,7 +5837,7 @@ class API {
     return {
       clientName: "@seamly/web-ui",
       clientVariant: this.#layoutMode,
-      clientVersion: "25.1.0",
+      clientVersion: "25.2.0-beta.2",
       currentUrl: window.location.toString(),
       screenResolution: `${window.screen.width}x${window.screen.height}`,
       timezone: getTimeZone(),
@@ -5846,608 +5846,227 @@ class API {
     };
   }
 }
-;// ./node_modules/redux/dist/redux.mjs
-// src/utils/formatProdErrorMessage.ts
-function formatProdErrorMessage(code) {
-  return `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
-}
-
-// src/utils/symbol-observable.ts
-var $$observable = /* @__PURE__ */ (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
-var symbol_observable_default = $$observable;
+;// ./node_modules/immer/dist/immer.mjs
+// src/utils/env.ts
+var NOTHING = Symbol.for("immer-nothing");
+var DRAFTABLE = Symbol.for("immer-draftable");
+var DRAFT_STATE = Symbol.for("immer-state");
 
-// src/utils/actionTypes.ts
-var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
-var ActionTypes = {
-  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
-  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
-  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
-};
-var actionTypes_default = ActionTypes;
+// src/utils/errors.ts
+var errors =  false ? 0 : [];
+function die(error, ...args) {
+  if (false) // removed by dead control flow
+{}
+  throw new Error(
+    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
 
-// src/utils/isPlainObject.ts
-function redux_isPlainObject(obj) {
-  if (typeof obj !== "object" || obj === null)
+// src/utils/common.ts
+var getPrototypeOf = Object.getPrototypeOf;
+function immer_isDraft(value) {
+  return !!value && !!value[DRAFT_STATE];
+}
+function isDraftable(value) {
+  if (!value)
     return false;
-  let proto = obj;
-  while (Object.getPrototypeOf(proto) !== null) {
-    proto = Object.getPrototypeOf(proto);
-  }
-  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
+  return immer_isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
 }
-
-// src/utils/kindOf.ts
-function miniKindOf(val) {
-  if (val === void 0)
-    return "undefined";
-  if (val === null)
-    return "null";
-  const type = typeof val;
-  switch (type) {
-    case "boolean":
-    case "string":
-    case "number":
-    case "symbol":
-    case "function": {
-      return type;
-    }
+var objectCtorString = Object.prototype.constructor.toString();
+var cachedCtorStrings = /* @__PURE__ */ new WeakMap();
+function immer_isPlainObject(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null || proto === Object.prototype)
+    return true;
+  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object)
+    return true;
+  if (typeof Ctor !== "function")
+    return false;
+  let ctorString = cachedCtorStrings.get(Ctor);
+  if (ctorString === void 0) {
+    ctorString = Function.toString.call(Ctor);
+    cachedCtorStrings.set(Ctor, ctorString);
   }
-  if (Array.isArray(val))
-    return "array";
-  if (isDate(val))
-    return "date";
-  if (isError(val))
-    return "error";
-  const constructorName = ctorName(val);
-  switch (constructorName) {
-    case "Symbol":
-    case "Promise":
-    case "WeakMap":
-    case "WeakSet":
-    case "Map":
-    case "Set":
-      return constructorName;
+  return ctorString === objectCtorString;
+}
+function original(value) {
+  if (!immer_isDraft(value))
+    die(15, value);
+  return value[DRAFT_STATE].base_;
+}
+function each(obj, iter, strict = true) {
+  if (getArchtype(obj) === 0 /* Object */) {
+    const keys = strict ? Reflect.ownKeys(obj) : Object.keys(obj);
+    keys.forEach((key) => {
+      iter(key, obj[key], obj);
+    });
+  } else {
+    obj.forEach((entry, index) => iter(index, entry, obj));
   }
-  return Object.prototype.toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, "");
 }
-function ctorName(val) {
-  return typeof val.constructor === "function" ? val.constructor.name : null;
+function getArchtype(thing) {
+  const state = thing[DRAFT_STATE];
+  return state ? state.type_ : Array.isArray(thing) ? 1 /* Array */ : isMap(thing) ? 2 /* Map */ : isSet(thing) ? 3 /* Set */ : 0 /* Object */;
 }
-function isError(val) {
-  return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
+function has(thing, prop) {
+  return getArchtype(thing) === 2 /* Map */ ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
 }
-function isDate(val) {
-  if (val instanceof Date)
-    return true;
-  return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
+function get(thing, prop) {
+  return getArchtype(thing) === 2 /* Map */ ? thing.get(prop) : thing[prop];
 }
-function kindOf(val) {
-  let typeOfVal = typeof val;
-  if (false) // removed by dead control flow
-{}
-  return typeOfVal;
+function set(thing, propOrOldValue, value) {
+  const t = getArchtype(thing);
+  if (t === 2 /* Map */)
+    thing.set(propOrOldValue, value);
+  else if (t === 3 /* Set */) {
+    thing.add(value);
+  } else
+    thing[propOrOldValue] = value;
 }
-
-// src/createStore.ts
-function createStore(reducer, preloadedState, enhancer) {
-  if (typeof reducer !== "function") {
-    throw new Error( true ? formatProdErrorMessage(2) : 0);
-  }
-  if (typeof preloadedState === "function" && typeof enhancer === "function" || typeof enhancer === "function" && typeof arguments[3] === "function") {
-    throw new Error( true ? formatProdErrorMessage(0) : 0);
+function is(x, y) {
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / y;
+  } else {
+    return x !== x && y !== y;
   }
-  if (typeof preloadedState === "function" && typeof enhancer === "undefined") {
-    enhancer = preloadedState;
-    preloadedState = void 0;
+}
+function isMap(target) {
+  return target instanceof Map;
+}
+function isSet(target) {
+  return target instanceof Set;
+}
+function latest(state) {
+  return state.copy_ || state.base_;
+}
+function shallowCopy(base, strict) {
+  if (isMap(base)) {
+    return new Map(base);
   }
-  if (typeof enhancer !== "undefined") {
-    if (typeof enhancer !== "function") {
-      throw new Error( true ? formatProdErrorMessage(1) : 0);
-    }
-    return enhancer(createStore)(reducer, preloadedState);
+  if (isSet(base)) {
+    return new Set(base);
   }
-  let currentReducer = reducer;
-  let currentState = preloadedState;
-  let currentListeners = /* @__PURE__ */ new Map();
-  let nextListeners = currentListeners;
-  let listenerIdCounter = 0;
-  let isDispatching = false;
-  function ensureCanMutateNextListeners() {
-    if (nextListeners === currentListeners) {
-      nextListeners = /* @__PURE__ */ new Map();
-      currentListeners.forEach((listener, key) => {
-        nextListeners.set(key, listener);
-      });
+  if (Array.isArray(base))
+    return Array.prototype.slice.call(base);
+  const isPlain = immer_isPlainObject(base);
+  if (strict === true || strict === "class_only" && !isPlain) {
+    const descriptors = Object.getOwnPropertyDescriptors(base);
+    delete descriptors[DRAFT_STATE];
+    let keys = Reflect.ownKeys(descriptors);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const desc = descriptors[key];
+      if (desc.writable === false) {
+        desc.writable = true;
+        desc.configurable = true;
+      }
+      if (desc.get || desc.set)
+        descriptors[key] = {
+          configurable: true,
+          writable: true,
+          // could live with !!desc.set as well here...
+          enumerable: desc.enumerable,
+          value: base[key]
+        };
     }
-  }
-  function getState() {
-    if (isDispatching) {
-      throw new Error( true ? formatProdErrorMessage(3) : 0);
+    return Object.create(getPrototypeOf(base), descriptors);
+  } else {
+    const proto = getPrototypeOf(base);
+    if (proto !== null && isPlain) {
+      return { ...base };
     }
-    return currentState;
+    const obj = Object.create(proto);
+    return Object.assign(obj, base);
   }
-  function subscribe(listener) {
-    if (typeof listener !== "function") {
-      throw new Error( true ? formatProdErrorMessage(4) : 0);
-    }
-    if (isDispatching) {
-      throw new Error( true ? formatProdErrorMessage(5) : 0);
-    }
-    let isSubscribed = true;
-    ensureCanMutateNextListeners();
-    const listenerId = listenerIdCounter++;
-    nextListeners.set(listenerId, listener);
-    return function unsubscribe() {
-      if (!isSubscribed) {
-        return;
-      }
-      if (isDispatching) {
-        throw new Error( true ? formatProdErrorMessage(6) : 0);
-      }
-      isSubscribed = false;
-      ensureCanMutateNextListeners();
-      nextListeners.delete(listenerId);
-      currentListeners = null;
-    };
+}
+function freeze(obj, deep = false) {
+  if (isFrozen(obj) || immer_isDraft(obj) || !isDraftable(obj))
+    return obj;
+  if (getArchtype(obj) > 1) {
+    Object.defineProperties(obj, {
+      set: dontMutateMethodOverride,
+      add: dontMutateMethodOverride,
+      clear: dontMutateMethodOverride,
+      delete: dontMutateMethodOverride
+    });
   }
-  function dispatch(action) {
-    if (!redux_isPlainObject(action)) {
-      throw new Error( true ? formatProdErrorMessage(7) : 0);
-    }
-    if (typeof action.type === "undefined") {
-      throw new Error( true ? formatProdErrorMessage(8) : 0);
-    }
-    if (typeof action.type !== "string") {
-      throw new Error( true ? formatProdErrorMessage(17) : 0);
-    }
-    if (isDispatching) {
-      throw new Error( true ? formatProdErrorMessage(9) : 0);
-    }
-    try {
-      isDispatching = true;
-      currentState = currentReducer(currentState, action);
-    } finally {
-      isDispatching = false;
-    }
-    const listeners = currentListeners = nextListeners;
-    listeners.forEach((listener) => {
-      listener();
-    });
-    return action;
-  }
-  function replaceReducer(nextReducer) {
-    if (typeof nextReducer !== "function") {
-      throw new Error( true ? formatProdErrorMessage(10) : 0);
-    }
-    currentReducer = nextReducer;
-    dispatch({
-      type: actionTypes_default.REPLACE
-    });
-  }
-  function observable() {
-    const outerSubscribe = subscribe;
-    return {
-      /**
-       * The minimal observable subscription method.
-       * @param observer Any object that can be used as an observer.
-       * The observer object should have a `next` method.
-       * @returns An object with an `unsubscribe` method that can
-       * be used to unsubscribe the observable from the store, and prevent further
-       * emission of values from the observable.
-       */
-      subscribe(observer) {
-        if (typeof observer !== "object" || observer === null) {
-          throw new Error( true ? formatProdErrorMessage(11) : 0);
-        }
-        function observeState() {
-          const observerAsObserver = observer;
-          if (observerAsObserver.next) {
-            observerAsObserver.next(getState());
-          }
-        }
-        observeState();
-        const unsubscribe = outerSubscribe(observeState);
-        return {
-          unsubscribe
-        };
-      },
-      [symbol_observable_default]() {
-        return this;
-      }
-    };
-  }
-  dispatch({
-    type: actionTypes_default.INIT
-  });
-  const store = {
-    dispatch,
-    subscribe,
-    getState,
-    replaceReducer,
-    [symbol_observable_default]: observable
-  };
-  return store;
+  Object.freeze(obj);
+  if (deep)
+    Object.values(obj).forEach((value) => freeze(value, true));
+  return obj;
 }
-function legacy_createStore(reducer, preloadedState, enhancer) {
-  return createStore(reducer, preloadedState, enhancer);
+function dontMutateFrozenCollections() {
+  die(2);
 }
-
-// src/utils/warning.ts
-function warning(message) {
-  if (typeof console !== "undefined" && typeof console.error === "function") {
-    console.error(message);
-  }
-  try {
-    throw new Error(message);
-  } catch (e) {
-  }
+var dontMutateMethodOverride = {
+  value: dontMutateFrozenCollections
+};
+function isFrozen(obj) {
+  if (obj === null || typeof obj !== "object")
+    return true;
+  return Object.isFrozen(obj);
 }
 
-// src/combineReducers.ts
-function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
-  const reducerKeys = Object.keys(reducers);
-  const argumentName = action && action.type === actionTypes_default.INIT ? "preloadedState argument passed to createStore" : "previous state received by the reducer";
-  if (reducerKeys.length === 0) {
-    return "Store does not have a valid reducer. Make sure the argument passed to combineReducers is an object whose values are reducers.";
-  }
-  if (!redux_isPlainObject(inputState)) {
-    return `The ${argumentName} has unexpected type of "${kindOf(inputState)}". Expected argument to be an object with the following keys: "${reducerKeys.join('", "')}"`;
-  }
-  const unexpectedKeys = Object.keys(inputState).filter((key) => !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]);
-  unexpectedKeys.forEach((key) => {
-    unexpectedKeyCache[key] = true;
-  });
-  if (action && action.type === actionTypes_default.REPLACE)
-    return;
-  if (unexpectedKeys.length > 0) {
-    return `Unexpected ${unexpectedKeys.length > 1 ? "keys" : "key"} "${unexpectedKeys.join('", "')}" found in ${argumentName}. Expected to find one of the known reducer keys instead: "${reducerKeys.join('", "')}". Unexpected keys will be ignored.`;
+// src/utils/plugins.ts
+var plugins = {};
+function getPlugin(pluginKey) {
+  const plugin = plugins[pluginKey];
+  if (!plugin) {
+    die(0, pluginKey);
   }
+  return plugin;
 }
-function assertReducerShape(reducers) {
-  Object.keys(reducers).forEach((key) => {
-    const reducer = reducers[key];
-    const initialState = reducer(void 0, {
-      type: actionTypes_default.INIT
-    });
-    if (typeof initialState === "undefined") {
-      throw new Error( true ? formatProdErrorMessage(12) : 0);
-    }
-    if (typeof reducer(void 0, {
-      type: actionTypes_default.PROBE_UNKNOWN_ACTION()
-    }) === "undefined") {
-      throw new Error( true ? formatProdErrorMessage(13) : 0);
-    }
-  });
-}
-function combineReducers(reducers) {
-  const reducerKeys = Object.keys(reducers);
-  const finalReducers = {};
-  for (let i = 0; i < reducerKeys.length; i++) {
-    const key = reducerKeys[i];
-    if (false) // removed by dead control flow
-{}
-    if (typeof reducers[key] === "function") {
-      finalReducers[key] = reducers[key];
-    }
-  }
-  const finalReducerKeys = Object.keys(finalReducers);
-  let unexpectedKeyCache;
-  if (false) // removed by dead control flow
-{}
-  let shapeAssertionError;
-  try {
-    assertReducerShape(finalReducers);
-  } catch (e) {
-    shapeAssertionError = e;
-  }
-  return function combination(state = {}, action) {
-    if (shapeAssertionError) {
-      throw shapeAssertionError;
-    }
-    if (false) // removed by dead control flow
-{}
-    let hasChanged = false;
-    const nextState = {};
-    for (let i = 0; i < finalReducerKeys.length; i++) {
-      const key = finalReducerKeys[i];
-      const reducer = finalReducers[key];
-      const previousStateForKey = state[key];
-      const nextStateForKey = reducer(previousStateForKey, action);
-      if (typeof nextStateForKey === "undefined") {
-        const actionType = action && action.type;
-        throw new Error( true ? formatProdErrorMessage(14) : 0);
-      }
-      nextState[key] = nextStateForKey;
-      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
-    }
-    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
-    return hasChanged ? nextState : state;
-  };
+function loadPlugin(pluginKey, implementation) {
+  if (!plugins[pluginKey])
+    plugins[pluginKey] = implementation;
 }
 
-// src/bindActionCreators.ts
-function bindActionCreator(actionCreator, dispatch) {
-  return function(...args) {
-    return dispatch(actionCreator.apply(this, args));
+// src/core/scope.ts
+var currentScope;
+function getCurrentScope() {
+  return currentScope;
+}
+function createScope(parent_, immer_) {
+  return {
+    drafts_: [],
+    parent_,
+    immer_,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: true,
+    unfinalizedDrafts_: 0
   };
 }
-function bindActionCreators(actionCreators, dispatch) {
-  if (typeof actionCreators === "function") {
-    return bindActionCreator(actionCreators, dispatch);
-  }
-  if (typeof actionCreators !== "object" || actionCreators === null) {
-    throw new Error( true ? formatProdErrorMessage(16) : 0);
-  }
-  const boundActionCreators = {};
-  for (const key in actionCreators) {
-    const actionCreator = actionCreators[key];
-    if (typeof actionCreator === "function") {
-      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);
-    }
+function usePatchesInScope(scope, patchListener) {
+  if (patchListener) {
+    getPlugin("Patches");
+    scope.patches_ = [];
+    scope.inversePatches_ = [];
+    scope.patchListener_ = patchListener;
   }
-  return boundActionCreators;
 }
-
-// src/compose.ts
-function compose(...funcs) {
-  if (funcs.length === 0) {
-    return (arg) => arg;
-  }
-  if (funcs.length === 1) {
-    return funcs[0];
+function revokeScope(scope) {
+  leaveScope(scope);
+  scope.drafts_.forEach(revokeDraft);
+  scope.drafts_ = null;
+}
+function leaveScope(scope) {
+  if (scope === currentScope) {
+    currentScope = scope.parent_;
   }
-  return funcs.reduce((a, b) => (...args) => a(b(...args)));
 }
-
-// src/applyMiddleware.ts
-function applyMiddleware(...middlewares) {
-  return (createStore2) => (reducer, preloadedState) => {
-    const store = createStore2(reducer, preloadedState);
-    let dispatch = () => {
-      throw new Error( true ? formatProdErrorMessage(15) : 0);
-    };
-    const middlewareAPI = {
-      getState: store.getState,
-      dispatch: (action, ...args) => dispatch(action, ...args)
-    };
-    const chain = middlewares.map((middleware) => middleware(middlewareAPI));
-    dispatch = compose(...chain)(store.dispatch);
-    return {
-      ...store,
-      dispatch
-    };
-  };
+function enterScope(immer2) {
+  return currentScope = createScope(currentScope, immer2);
 }
-
-// src/utils/isAction.ts
-function redux_isAction(action) {
-  return redux_isPlainObject(action) && "type" in action && typeof action.type === "string";
-}
-
-//# sourceMappingURL=redux.mjs.map
-;// ./node_modules/redux-thunk/dist/redux-thunk.mjs
-// src/index.ts
-function createThunkMiddleware(extraArgument) {
-  const middleware = ({ dispatch, getState }) => (next) => (action) => {
-    if (typeof action === "function") {
-      return action(dispatch, getState, extraArgument);
-    }
-    return next(action);
-  };
-  return middleware;
-}
-var redux_thunk_thunk = createThunkMiddleware();
-var withExtraArgument = createThunkMiddleware;
-
-
-;// ./node_modules/immer/dist/immer.mjs
-// src/utils/env.ts
-var NOTHING = Symbol.for("immer-nothing");
-var DRAFTABLE = Symbol.for("immer-draftable");
-var DRAFT_STATE = Symbol.for("immer-state");
-
-// src/utils/errors.ts
-var errors =  false ? 0 : [];
-function die(error, ...args) {
-  if (false) // removed by dead control flow
-{}
-  throw new Error(
-    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
-  );
-}
-
-// src/utils/common.ts
-var getPrototypeOf = Object.getPrototypeOf;
-function immer_isDraft(value) {
-  return !!value && !!value[DRAFT_STATE];
-}
-function isDraftable(value) {
-  if (!value)
-    return false;
-  return immer_isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
-}
-var objectCtorString = Object.prototype.constructor.toString();
-function immer_isPlainObject(value) {
-  if (!value || typeof value !== "object")
-    return false;
-  const proto = getPrototypeOf(value);
-  if (proto === null) {
-    return true;
-  }
-  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
-  if (Ctor === Object)
-    return true;
-  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
-}
-function original(value) {
-  if (!immer_isDraft(value))
-    die(15, value);
-  return value[DRAFT_STATE].base_;
-}
-function each(obj, iter) {
-  if (getArchtype(obj) === 0 /* Object */) {
-    Reflect.ownKeys(obj).forEach((key) => {
-      iter(key, obj[key], obj);
-    });
-  } else {
-    obj.forEach((entry, index) => iter(index, entry, obj));
-  }
-}
-function getArchtype(thing) {
-  const state = thing[DRAFT_STATE];
-  return state ? state.type_ : Array.isArray(thing) ? 1 /* Array */ : isMap(thing) ? 2 /* Map */ : isSet(thing) ? 3 /* Set */ : 0 /* Object */;
-}
-function has(thing, prop) {
-  return getArchtype(thing) === 2 /* Map */ ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
-}
-function get(thing, prop) {
-  return getArchtype(thing) === 2 /* Map */ ? thing.get(prop) : thing[prop];
-}
-function set(thing, propOrOldValue, value) {
-  const t = getArchtype(thing);
-  if (t === 2 /* Map */)
-    thing.set(propOrOldValue, value);
-  else if (t === 3 /* Set */) {
-    thing.add(value);
-  } else
-    thing[propOrOldValue] = value;
-}
-function is(x, y) {
-  if (x === y) {
-    return x !== 0 || 1 / x === 1 / y;
-  } else {
-    return x !== x && y !== y;
-  }
-}
-function isMap(target) {
-  return target instanceof Map;
-}
-function isSet(target) {
-  return target instanceof Set;
-}
-function latest(state) {
-  return state.copy_ || state.base_;
-}
-function shallowCopy(base, strict) {
-  if (isMap(base)) {
-    return new Map(base);
-  }
-  if (isSet(base)) {
-    return new Set(base);
-  }
-  if (Array.isArray(base))
-    return Array.prototype.slice.call(base);
-  const isPlain = immer_isPlainObject(base);
-  if (strict === true || strict === "class_only" && !isPlain) {
-    const descriptors = Object.getOwnPropertyDescriptors(base);
-    delete descriptors[DRAFT_STATE];
-    let keys = Reflect.ownKeys(descriptors);
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      const desc = descriptors[key];
-      if (desc.writable === false) {
-        desc.writable = true;
-        desc.configurable = true;
-      }
-      if (desc.get || desc.set)
-        descriptors[key] = {
-          configurable: true,
-          writable: true,
-          // could live with !!desc.set as well here...
-          enumerable: desc.enumerable,
-          value: base[key]
-        };
-    }
-    return Object.create(getPrototypeOf(base), descriptors);
-  } else {
-    const proto = getPrototypeOf(base);
-    if (proto !== null && isPlain) {
-      return { ...base };
-    }
-    const obj = Object.create(proto);
-    return Object.assign(obj, base);
-  }
-}
-function freeze(obj, deep = false) {
-  if (isFrozen(obj) || immer_isDraft(obj) || !isDraftable(obj))
-    return obj;
-  if (getArchtype(obj) > 1) {
-    Object.defineProperties(obj, {
-      set: { value: dontMutateFrozenCollections },
-      add: { value: dontMutateFrozenCollections },
-      clear: { value: dontMutateFrozenCollections },
-      delete: { value: dontMutateFrozenCollections }
-    });
-  }
-  Object.freeze(obj);
-  if (deep)
-    Object.values(obj).forEach((value) => freeze(value, true));
-  return obj;
-}
-function dontMutateFrozenCollections() {
-  die(2);
-}
-function isFrozen(obj) {
-  return Object.isFrozen(obj);
-}
-
-// src/utils/plugins.ts
-var plugins = {};
-function getPlugin(pluginKey) {
-  const plugin = plugins[pluginKey];
-  if (!plugin) {
-    die(0, pluginKey);
-  }
-  return plugin;
-}
-function loadPlugin(pluginKey, implementation) {
-  if (!plugins[pluginKey])
-    plugins[pluginKey] = implementation;
-}
-
-// src/core/scope.ts
-var currentScope;
-function getCurrentScope() {
-  return currentScope;
-}
-function createScope(parent_, immer_) {
-  return {
-    drafts_: [],
-    parent_,
-    immer_,
-    // Whenever the modified draft contains a draft from another scope, we
-    // need to prevent auto-freezing so the unowned draft can be finalized.
-    canAutoFreeze_: true,
-    unfinalizedDrafts_: 0
-  };
-}
-function usePatchesInScope(scope, patchListener) {
-  if (patchListener) {
-    getPlugin("Patches");
-    scope.patches_ = [];
-    scope.inversePatches_ = [];
-    scope.patchListener_ = patchListener;
-  }
-}
-function revokeScope(scope) {
-  leaveScope(scope);
-  scope.drafts_.forEach(revokeDraft);
-  scope.drafts_ = null;
-}
-function leaveScope(scope) {
-  if (scope === currentScope) {
-    currentScope = scope.parent_;
-  }
-}
-function enterScope(immer2) {
-  return currentScope = createScope(currentScope, immer2);
-}
-function revokeDraft(draft) {
-  const state = draft[DRAFT_STATE];
-  if (state.type_ === 0 /* Object */ || state.type_ === 1 /* Array */)
-    state.revoke_();
-  else
-    state.revoked_ = true;
+function revokeDraft(draft) {
+  const state = draft[DRAFT_STATE];
+  if (state.type_ === 0 /* Object */ || state.type_ === 1 /* Array */)
+    state.revoke_();
+  else
+    state.revoked_ = true;
 }
 
 // src/core/finalize.ts
@@ -6485,11 +6104,13 @@ function processResult(result, scope) {
 function finalize(rootScope, value, path) {
   if (isFrozen(value))
     return value;
+  const useStrictIteration = rootScope.immer_.shouldUseStrictIteration();
   const state = value[DRAFT_STATE];
   if (!state) {
     each(
       value,
-      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path)
+      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path),
+      useStrictIteration
     );
     return value;
   }
@@ -6512,7 +6133,16 @@ function finalize(rootScope, value, path) {
     }
     each(
       resultEach,
-      (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2)
+      (key, childValue) => finalizeProperty(
+        rootScope,
+        state,
+        result,
+        key,
+        childValue,
+        path,
+        isSet2
+      ),
+      useStrictIteration
     );
     maybeFreeze(rootScope, result, false);
     if (path && rootScope.patches_) {
@@ -6527,6 +6157,16 @@ function finalize(rootScope, value, path) {
   return state.copy_;
 }
 function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
+  if (childValue == null) {
+    return;
+  }
+  if (typeof childValue !== "object" && !targetIsSet) {
+    return;
+  }
+  const childIsFrozen = isFrozen(childValue);
+  if (childIsFrozen && !targetIsSet) {
+    return;
+  }
   if (false)
     // removed by dead control flow
 {}
@@ -6542,10 +6182,13 @@ function finalizeProperty(rootScope, parentState, targetObject, prop, childValue
   } else if (targetIsSet) {
     targetObject.add(childValue);
   }
-  if (isDraftable(childValue) && !isFrozen(childValue)) {
+  if (isDraftable(childValue) && !childIsFrozen) {
     if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
       return;
     }
+    if (parentState && parentState.base_ && parentState.base_[prop] === childValue && childIsFrozen) {
+      return;
+    }
     finalize(rootScope, childValue);
     if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && (isMap(targetObject) ? targetObject.has(prop) : Object.prototype.propertyIsEnumerable.call(targetObject, prop)))
       maybeFreeze(rootScope, childValue);
@@ -6748,6 +6391,7 @@ var Immer2 = class {
   constructor(config) {
     this.autoFreeze_ = true;
     this.useStrictShallowCopy_ = false;
+    this.useStrictIteration_ = true;
     /**
      * The `produce` function takes a value and a "recipe function" (whose
      * return value often depends on the base state). The recipe function is
@@ -6829,6 +6473,8 @@ var Immer2 = class {
       this.setAutoFreeze(config.autoFreeze);
     if (typeof config?.useStrictShallowCopy === "boolean")
       this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+    if (typeof config?.useStrictIteration === "boolean")
+      this.setUseStrictIteration(config.useStrictIteration);
   }
   createDraft(base) {
     if (!isDraftable(base))
@@ -6865,6 +6511,18 @@ var Immer2 = class {
   setUseStrictShallowCopy(value) {
     this.useStrictShallowCopy_ = value;
   }
+  /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */
+  setUseStrictIteration(value) {
+    this.useStrictIteration_ = value;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
   applyPatches(base, patches) {
     let i;
     for (i = patches.length - 1; i >= 0; i--) {
@@ -6905,17 +6563,23 @@ function currentImpl(value) {
     return value;
   const state = value[DRAFT_STATE];
   let copy;
+  let strict = true;
   if (state) {
     if (!state.modified_)
       return state.base_;
     state.finalized_ = true;
     copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+    strict = state.scope_.immer_.shouldUseStrictIteration();
   } else {
     copy = shallowCopy(value, true);
   }
-  each(copy, (key, childValue) => {
-    set(copy, key, currentImpl(childValue));
-  });
+  each(
+    copy,
+    (key, childValue) => {
+      set(copy, key, currentImpl(childValue));
+    },
+    strict
+  );
   if (state) {
     state.finalized_ = false;
   }
@@ -7353,81 +7017,484 @@ function enableMapSet() {
       prepareSetCopy(state);
       return state.copy_.values();
     }
-    entries() {
-      const state = this[DRAFT_STATE];
-      assertUnrevoked(state);
-      prepareSetCopy(state);
-      return state.copy_.entries();
+    entries() {
+      const state = this[DRAFT_STATE];
+      assertUnrevoked(state);
+      prepareSetCopy(state);
+      return state.copy_.entries();
+    }
+    keys() {
+      return this.values();
+    }
+    [(DRAFT_STATE, Symbol.iterator)]() {
+      return this.values();
+    }
+    forEach(cb, thisArg) {
+      const iterator = this.values();
+      let result = iterator.next();
+      while (!result.done) {
+        cb.call(thisArg, result.value, result.value, this);
+        result = iterator.next();
+      }
+    }
+  }
+  function proxySet_(target, parent) {
+    return new DraftSet(target, parent);
+  }
+  function prepareSetCopy(state) {
+    if (!state.copy_) {
+      state.copy_ = /* @__PURE__ */ new Set();
+      state.base_.forEach((value) => {
+        if (isDraftable(value)) {
+          const draft = createProxy(value, state);
+          state.drafts_.set(value, draft);
+          state.copy_.add(draft);
+        } else {
+          state.copy_.add(value);
+        }
+      });
+    }
+  }
+  function assertUnrevoked(state) {
+    if (state.revoked_)
+      die(3, JSON.stringify(latest(state)));
+  }
+  loadPlugin("MapSet", { proxyMap_, proxySet_ });
+}
+
+// src/immer.ts
+var immer = new Immer2();
+var immer_produce = immer.produce;
+var produceWithPatches = /* @__PURE__ */ (/* unused pure expression or super */ null && (immer.produceWithPatches.bind(
+  immer
+)));
+var setAutoFreeze = /* @__PURE__ */ (/* unused pure expression or super */ null && (immer.setAutoFreeze.bind(immer)));
+var setUseStrictShallowCopy = /* @__PURE__ */ (/* unused pure expression or super */ null && (immer.setUseStrictShallowCopy.bind(
+  immer
+)));
+var setUseStrictIteration = /* @__PURE__ */ immer.setUseStrictIteration.bind(
+  immer
+);
+var applyPatches = /* @__PURE__ */ (/* unused pure expression or super */ null && (immer.applyPatches.bind(immer)));
+var createDraft = /* @__PURE__ */ (/* unused pure expression or super */ null && (immer.createDraft.bind(immer)));
+var finishDraft = /* @__PURE__ */ (/* unused pure expression or super */ null && (immer.finishDraft.bind(immer)));
+function castDraft(value) {
+  return value;
+}
+function castImmutable(value) {
+  return value;
+}
+
+//# sourceMappingURL=immer.mjs.map
+;// ./node_modules/redux/dist/redux.mjs
+// src/utils/formatProdErrorMessage.ts
+function formatProdErrorMessage(code) {
+  return `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
+}
+
+// src/utils/symbol-observable.ts
+var $$observable = /* @__PURE__ */ (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
+var symbol_observable_default = $$observable;
+
+// src/utils/actionTypes.ts
+var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
+var ActionTypes = {
+  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
+  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
+  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
+};
+var actionTypes_default = ActionTypes;
+
+// src/utils/isPlainObject.ts
+function redux_isPlainObject(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  let proto = obj;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
+}
+
+// src/utils/kindOf.ts
+function miniKindOf(val) {
+  if (val === void 0)
+    return "undefined";
+  if (val === null)
+    return "null";
+  const type = typeof val;
+  switch (type) {
+    case "boolean":
+    case "string":
+    case "number":
+    case "symbol":
+    case "function": {
+      return type;
+    }
+  }
+  if (Array.isArray(val))
+    return "array";
+  if (isDate(val))
+    return "date";
+  if (isError(val))
+    return "error";
+  const constructorName = ctorName(val);
+  switch (constructorName) {
+    case "Symbol":
+    case "Promise":
+    case "WeakMap":
+    case "WeakSet":
+    case "Map":
+    case "Set":
+      return constructorName;
+  }
+  return Object.prototype.toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, "");
+}
+function ctorName(val) {
+  return typeof val.constructor === "function" ? val.constructor.name : null;
+}
+function isError(val) {
+  return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
+}
+function isDate(val) {
+  if (val instanceof Date)
+    return true;
+  return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
+}
+function kindOf(val) {
+  let typeOfVal = typeof val;
+  if (false) // removed by dead control flow
+{}
+  return typeOfVal;
+}
+
+// src/createStore.ts
+function createStore(reducer, preloadedState, enhancer) {
+  if (typeof reducer !== "function") {
+    throw new Error( true ? formatProdErrorMessage(2) : 0);
+  }
+  if (typeof preloadedState === "function" && typeof enhancer === "function" || typeof enhancer === "function" && typeof arguments[3] === "function") {
+    throw new Error( true ? formatProdErrorMessage(0) : 0);
+  }
+  if (typeof preloadedState === "function" && typeof enhancer === "undefined") {
+    enhancer = preloadedState;
+    preloadedState = void 0;
+  }
+  if (typeof enhancer !== "undefined") {
+    if (typeof enhancer !== "function") {
+      throw new Error( true ? formatProdErrorMessage(1) : 0);
+    }
+    return enhancer(createStore)(reducer, preloadedState);
+  }
+  let currentReducer = reducer;
+  let currentState = preloadedState;
+  let currentListeners = /* @__PURE__ */ new Map();
+  let nextListeners = currentListeners;
+  let listenerIdCounter = 0;
+  let isDispatching = false;
+  function ensureCanMutateNextListeners() {
+    if (nextListeners === currentListeners) {
+      nextListeners = /* @__PURE__ */ new Map();
+      currentListeners.forEach((listener, key) => {
+        nextListeners.set(key, listener);
+      });
+    }
+  }
+  function getState() {
+    if (isDispatching) {
+      throw new Error( true ? formatProdErrorMessage(3) : 0);
+    }
+    return currentState;
+  }
+  function subscribe(listener) {
+    if (typeof listener !== "function") {
+      throw new Error( true ? formatProdErrorMessage(4) : 0);
+    }
+    if (isDispatching) {
+      throw new Error( true ? formatProdErrorMessage(5) : 0);
+    }
+    let isSubscribed = true;
+    ensureCanMutateNextListeners();
+    const listenerId = listenerIdCounter++;
+    nextListeners.set(listenerId, listener);
+    return function unsubscribe() {
+      if (!isSubscribed) {
+        return;
+      }
+      if (isDispatching) {
+        throw new Error( true ? formatProdErrorMessage(6) : 0);
+      }
+      isSubscribed = false;
+      ensureCanMutateNextListeners();
+      nextListeners.delete(listenerId);
+      currentListeners = null;
+    };
+  }
+  function dispatch(action) {
+    if (!redux_isPlainObject(action)) {
+      throw new Error( true ? formatProdErrorMessage(7) : 0);
+    }
+    if (typeof action.type === "undefined") {
+      throw new Error( true ? formatProdErrorMessage(8) : 0);
+    }
+    if (typeof action.type !== "string") {
+      throw new Error( true ? formatProdErrorMessage(17) : 0);
+    }
+    if (isDispatching) {
+      throw new Error( true ? formatProdErrorMessage(9) : 0);
+    }
+    try {
+      isDispatching = true;
+      currentState = currentReducer(currentState, action);
+    } finally {
+      isDispatching = false;
+    }
+    const listeners = currentListeners = nextListeners;
+    listeners.forEach((listener) => {
+      listener();
+    });
+    return action;
+  }
+  function replaceReducer(nextReducer) {
+    if (typeof nextReducer !== "function") {
+      throw new Error( true ? formatProdErrorMessage(10) : 0);
+    }
+    currentReducer = nextReducer;
+    dispatch({
+      type: actionTypes_default.REPLACE
+    });
+  }
+  function observable() {
+    const outerSubscribe = subscribe;
+    return {
+      /**
+       * The minimal observable subscription method.
+       * @param observer Any object that can be used as an observer.
+       * The observer object should have a `next` method.
+       * @returns An object with an `unsubscribe` method that can
+       * be used to unsubscribe the observable from the store, and prevent further
+       * emission of values from the observable.
+       */
+      subscribe(observer) {
+        if (typeof observer !== "object" || observer === null) {
+          throw new Error( true ? formatProdErrorMessage(11) : 0);
+        }
+        function observeState() {
+          const observerAsObserver = observer;
+          if (observerAsObserver.next) {
+            observerAsObserver.next(getState());
+          }
+        }
+        observeState();
+        const unsubscribe = outerSubscribe(observeState);
+        return {
+          unsubscribe
+        };
+      },
+      [symbol_observable_default]() {
+        return this;
+      }
+    };
+  }
+  dispatch({
+    type: actionTypes_default.INIT
+  });
+  const store = {
+    dispatch,
+    subscribe,
+    getState,
+    replaceReducer,
+    [symbol_observable_default]: observable
+  };
+  return store;
+}
+function legacy_createStore(reducer, preloadedState, enhancer) {
+  return createStore(reducer, preloadedState, enhancer);
+}
+
+// src/utils/warning.ts
+function warning(message) {
+  if (typeof console !== "undefined" && typeof console.error === "function") {
+    console.error(message);
+  }
+  try {
+    throw new Error(message);
+  } catch (e) {
+  }
+}
+
+// src/combineReducers.ts
+function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
+  const reducerKeys = Object.keys(reducers);
+  const argumentName = action && action.type === actionTypes_default.INIT ? "preloadedState argument passed to createStore" : "previous state received by the reducer";
+  if (reducerKeys.length === 0) {
+    return "Store does not have a valid reducer. Make sure the argument passed to combineReducers is an object whose values are reducers.";
+  }
+  if (!redux_isPlainObject(inputState)) {
+    return `The ${argumentName} has unexpected type of "${kindOf(inputState)}". Expected argument to be an object with the following keys: "${reducerKeys.join('", "')}"`;
+  }
+  const unexpectedKeys = Object.keys(inputState).filter((key) => !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]);
+  unexpectedKeys.forEach((key) => {
+    unexpectedKeyCache[key] = true;
+  });
+  if (action && action.type === actionTypes_default.REPLACE)
+    return;
+  if (unexpectedKeys.length > 0) {
+    return `Unexpected ${unexpectedKeys.length > 1 ? "keys" : "key"} "${unexpectedKeys.join('", "')}" found in ${argumentName}. Expected to find one of the known reducer keys instead: "${reducerKeys.join('", "')}". Unexpected keys will be ignored.`;
+  }
+}
+function assertReducerShape(reducers) {
+  Object.keys(reducers).forEach((key) => {
+    const reducer = reducers[key];
+    const initialState = reducer(void 0, {
+      type: actionTypes_default.INIT
+    });
+    if (typeof initialState === "undefined") {
+      throw new Error( true ? formatProdErrorMessage(12) : 0);
+    }
+    if (typeof reducer(void 0, {
+      type: actionTypes_default.PROBE_UNKNOWN_ACTION()
+    }) === "undefined") {
+      throw new Error( true ? formatProdErrorMessage(13) : 0);
     }
-    keys() {
-      return this.values();
+  });
+}
+function combineReducers(reducers) {
+  const reducerKeys = Object.keys(reducers);
+  const finalReducers = {};
+  for (let i = 0; i < reducerKeys.length; i++) {
+    const key = reducerKeys[i];
+    if (false) // removed by dead control flow
+{}
+    if (typeof reducers[key] === "function") {
+      finalReducers[key] = reducers[key];
     }
-    [(DRAFT_STATE, Symbol.iterator)]() {
-      return this.values();
+  }
+  const finalReducerKeys = Object.keys(finalReducers);
+  let unexpectedKeyCache;
+  if (false) // removed by dead control flow
+{}
+  let shapeAssertionError;
+  try {
+    assertReducerShape(finalReducers);
+  } catch (e) {
+    shapeAssertionError = e;
+  }
+  return function combination(state = {}, action) {
+    if (shapeAssertionError) {
+      throw shapeAssertionError;
     }
-    forEach(cb, thisArg) {
-      const iterator = this.values();
-      let result = iterator.next();
-      while (!result.done) {
-        cb.call(thisArg, result.value, result.value, this);
-        result = iterator.next();
+    if (false) // removed by dead control flow
+{}
+    let hasChanged = false;
+    const nextState = {};
+    for (let i = 0; i < finalReducerKeys.length; i++) {
+      const key = finalReducerKeys[i];
+      const reducer = finalReducers[key];
+      const previousStateForKey = state[key];
+      const nextStateForKey = reducer(previousStateForKey, action);
+      if (typeof nextStateForKey === "undefined") {
+        const actionType = action && action.type;
+        throw new Error( true ? formatProdErrorMessage(14) : 0);
       }
+      nextState[key] = nextStateForKey;
+      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
     }
+    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
+    return hasChanged ? nextState : state;
+  };
+}
+
+// src/bindActionCreators.ts
+function bindActionCreator(actionCreator, dispatch) {
+  return function(...args) {
+    return dispatch(actionCreator.apply(this, args));
+  };
+}
+function bindActionCreators(actionCreators, dispatch) {
+  if (typeof actionCreators === "function") {
+    return bindActionCreator(actionCreators, dispatch);
   }
-  function proxySet_(target, parent) {
-    return new DraftSet(target, parent);
+  if (typeof actionCreators !== "object" || actionCreators === null) {
+    throw new Error( true ? formatProdErrorMessage(16) : 0);
   }
-  function prepareSetCopy(state) {
-    if (!state.copy_) {
-      state.copy_ = /* @__PURE__ */ new Set();
-      state.base_.forEach((value) => {
-        if (isDraftable(value)) {
-          const draft = createProxy(value, state);
-          state.drafts_.set(value, draft);
-          state.copy_.add(draft);
-        } else {
-          state.copy_.add(value);
-        }
-      });
+  const boundActionCreators = {};
+  for (const key in actionCreators) {
+    const actionCreator = actionCreators[key];
+    if (typeof actionCreator === "function") {
+      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);
     }
   }
-  function assertUnrevoked(state) {
-    if (state.revoked_)
-      die(3, JSON.stringify(latest(state)));
+  return boundActionCreators;
+}
+
+// src/compose.ts
+function redux_compose(...funcs) {
+  if (funcs.length === 0) {
+    return (arg) => arg;
   }
-  loadPlugin("MapSet", { proxyMap_, proxySet_ });
+  if (funcs.length === 1) {
+    return funcs[0];
+  }
+  return funcs.reduce((a, b) => (...args) => a(b(...args)));
 }
 
-// src/immer.ts
-var immer = new Immer2();
-var produce = immer.produce;
-var produceWithPatches = /* @__PURE__ */ (/* unused pure expression or super */ null && (immer.produceWithPatches.bind(
-  immer
-)));
-var setAutoFreeze = /* @__PURE__ */ (/* unused pure expression or super */ null && (immer.setAutoFreeze.bind(immer)));
-var setUseStrictShallowCopy = /* @__PURE__ */ (/* unused pure expression or super */ null && (immer.setUseStrictShallowCopy.bind(
-  immer
-)));
-var applyPatches = /* @__PURE__ */ (/* unused pure expression or super */ null && (immer.applyPatches.bind(immer)));
-var createDraft = /* @__PURE__ */ (/* unused pure expression or super */ null && (immer.createDraft.bind(immer)));
-var finishDraft = /* @__PURE__ */ (/* unused pure expression or super */ null && (immer.finishDraft.bind(immer)));
-function castDraft(value) {
-  return value;
+// src/applyMiddleware.ts
+function applyMiddleware(...middlewares) {
+  return (createStore2) => (reducer, preloadedState) => {
+    const store = createStore2(reducer, preloadedState);
+    let dispatch = () => {
+      throw new Error( true ? formatProdErrorMessage(15) : 0);
+    };
+    const middlewareAPI = {
+      getState: store.getState,
+      dispatch: (action, ...args) => dispatch(action, ...args)
+    };
+    const chain = middlewares.map((middleware) => middleware(middlewareAPI));
+    dispatch = redux_compose(...chain)(store.dispatch);
+    return {
+      ...store,
+      dispatch
+    };
+  };
 }
-function castImmutable(value) {
-  return value;
+
+// src/utils/isAction.ts
+function redux_isAction(action) {
+  return redux_isPlainObject(action) && "type" in action && typeof action.type === "string";
 }
 
-//# sourceMappingURL=immer.mjs.map
+//# sourceMappingURL=redux.mjs.map
+;// ./node_modules/redux-thunk/dist/redux-thunk.mjs
+// src/index.ts
+function createThunkMiddleware(extraArgument) {
+  const middleware = ({ dispatch, getState }) => (next) => (action) => {
+    if (typeof action === "function") {
+      return action(dispatch, getState, extraArgument);
+    }
+    return next(action);
+  };
+  return middleware;
+}
+var redux_thunk_thunk = createThunkMiddleware();
+var withExtraArgument = createThunkMiddleware;
+
+
 ;// ./node_modules/@reduxjs/toolkit/dist/redux-toolkit.modern.mjs
 // src/index.ts
 
 
 
+// src/immerImports.ts
 
-// src/createDraftSafeSelector.ts
+
+// src/index.ts
 
 
+// src/reselectImports.ts
+
+
+// src/createDraftSafeSelector.ts
 var createDraftSafeSelectorCreator = (...args) => {
   const createSelector2 = createSelectorCreator(...args);
   const createDraftSafeSelector2 = Object.assign((...args2) => {
@@ -7442,15 +7509,14 @@ var createDraftSafeSelectorCreator = (...args) => {
 };
 var createDraftSafeSelector = /* @__PURE__ */ (/* unused pure expression or super */ null && (createDraftSafeSelectorCreator(weakMapMemoize)));
 
-// src/configureStore.ts
+// src/reduxImports.ts
 
 
 // src/devtoolsExtension.ts
-
 var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {
   if (arguments.length === 0) return void 0;
-  if (typeof arguments[0] === "object") return compose;
-  return compose.apply(null, arguments);
+  if (typeof arguments[0] === "object") return redux_compose;
+  return redux_compose.apply(null, arguments);
 };
 var devToolsEnhancer = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function() {
   return function(noop3) {
@@ -7461,9 +7527,6 @@ var devToolsEnhancer = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_
 // src/getDefaultMiddleware.ts
 
 
-// src/createAction.ts
-
-
 // src/tsHelpers.ts
 var hasMatchFunction = (v) => {
   return v && typeof v.match === "function";
@@ -7527,7 +7590,6 @@ function createActionCreatorInvariantMiddleware(options = {}) {
 }
 
 // src/utils.ts
-
 function getTimeMeasureUtils(maxDelay, fnName) {
   let elapsed = 0;
   return {
@@ -7568,7 +7630,7 @@ var Tuple = class _Tuple extends Array {
   }
 };
 function freezeDraftable(val) {
-  return isDraftable(val) ? produce(val, () => {
+  return isDraftable(val) ? immer_produce(val, () => {
   }) : val;
 }
 function getOrInsertComputed(map, key, compute) {
@@ -7657,7 +7719,6 @@ function createImmutableStateInvariantMiddleware(options = {}) {
 }
 
 // src/serializableStateInvariantMiddleware.ts
-
 function isPlain(val) {
   const type = typeof val;
   return val == null || type === "string" || type === "boolean" || type === "number" || Array.isArray(val) || isPlainObject(val);
@@ -7853,7 +7914,7 @@ function configureStore(options) {
 {}
   if (false) // removed by dead control flow
 {}
-  let finalCompose = compose;
+  let finalCompose = redux_compose;
   if (devTools) {
     finalCompose = composeWithDevTools({
       // Enable capture of stack traces for dispatched Redux actions
@@ -7876,9 +7937,6 @@ function configureStore(options) {
   return createStore(rootReducer, preloadedState, composedEnhancer);
 }
 
-// src/createReducer.ts
-
-
 // src/mapBuilders.ts
 function executeReducerBuilderCallback(builderCallback) {
   const actionsMap = {};
@@ -7931,6 +7989,7 @@ function executeReducerBuilderCallback(builderCallback) {
 }
 
 // src/createReducer.ts
+setUseStrictIteration(false);
 function isStateFunction(x) {
   return typeof x === "function";
 }
@@ -7973,7 +8032,7 @@ function createReducer(initialState, mapOrBuilderCallback) {
           }
           return result;
         } else {
-          return produce(previousState, (draft) => {
+          return immer_produce(previousState, (draft) => {
             return caseReducer(draft, action);
           });
         }
@@ -8595,8 +8654,7 @@ function createSelectorsFactory() {
 }
 
 // src/entities/state_adapter.ts
-
-var isDraftTyped = (/* unused pure expression or super */ null && (isDraft3));
+var isDraftTyped = (/* unused pure expression or super */ null && (isDraft));
 function createSingleArgumentStateOperator(mutator) {
   const operator = createStateOperator((_, state) => mutator(state));
   return function operation(state) {
@@ -8619,12 +8677,11 @@ function createStateOperator(mutator) {
       runMutator(state);
       return state;
     }
-    return createNextState3(state, runMutator);
+    return produce(state, runMutator);
   };
 }
 
 // src/entities/utils.ts
-
 function selectIdValue(entity, selectId) {
   const key = selectId(entity);
   if (false) // removed by dead control flow
@@ -8638,7 +8695,7 @@ function ensureEntitiesArray(entities) {
   return entities;
 }
 function getCurrent(value) {
-  return isDraft4(value) ? current2(value) : value;
+  return isDraft(value) ? current(value) : value;
 }
 function splitAddedUpdatedEntities(newEntities, selectId, state) {
   newEntities = ensureEntitiesArray(newEntities);
@@ -8820,7 +8877,13 @@ function createSortedStateAdapter(selectId, comparer) {
   function addManyMutably(newEntities, state, existingIds) {
     newEntities = ensureEntitiesArray(newEntities);
     const existingKeys = new Set(existingIds ?? getCurrent(state.ids));
-    const models = newEntities.filter((model) => !existingKeys.has(selectIdValue(model, selectId)));
+    const addedKeys = /* @__PURE__ */ new Set();
+    const models = newEntities.filter((model) => {
+      const modelId = selectIdValue(model, selectId);
+      const notAdded = !addedKeys.has(modelId);
+      if (notAdded) addedKeys.add(modelId);
+      return !existingKeys.has(modelId) && notAdded;
+    });
     if (models.length !== 0) {
       mergeFunction(state, models);
     }
@@ -8829,11 +8892,15 @@ function createSortedStateAdapter(selectId, comparer) {
     return setManyMutably([entity], state);
   }
   function setManyMutably(newEntities, state) {
+    let deduplicatedEntities = {};
     newEntities = ensureEntitiesArray(newEntities);
     if (newEntities.length !== 0) {
       for (const item of newEntities) {
-        delete state.entities[selectId(item)];
+        const entityId = selectId(item);
+        deduplicatedEntities[entityId] = item;
+        delete state.entities[entityId];
       }
+      newEntities = ensureEntitiesArray(deduplicatedEntities);
       mergeFunction(state, newEntities);
     }
   }
@@ -8963,9 +9030,6 @@ function createEntityAdapter(options = {}) {
   };
 }
 
-// src/listenerMiddleware/index.ts
-
-
 // src/listenerMiddleware/exceptions.ts
 var task = "task";
 var listener = "listener";
@@ -9202,9 +9266,11 @@ var cancelActiveListeners = (entry) => {
     abortControllerWithReason(controller, listenerCancelled);
   });
 };
-var createClearListenerMiddleware = (listenerMap) => {
+var createClearListenerMiddleware = (listenerMap, executingListeners) => {
   return () => {
-    listenerMap.forEach(cancelActiveListeners);
+    for (const listener2 of executingListeners.keys()) {
+      cancelActiveListeners(listener2);
+    }
     listenerMap.clear();
   };
 };
@@ -9229,6 +9295,19 @@ var defaultErrorHandler = (...args) => {
 };
 var createListenerMiddleware = (middlewareOptions = {}) => {
   const listenerMap = /* @__PURE__ */ new Map();
+  const executingListeners = /* @__PURE__ */ new Map();
+  const trackExecutingListener = (entry) => {
+    const count = executingListeners.get(entry) ?? 0;
+    executingListeners.set(entry, count + 1);
+  };
+  const untrackExecutingListener = (entry) => {
+    const count = executingListeners.get(entry) ?? 1;
+    if (count === 1) {
+      executingListeners.delete(entry);
+    } else {
+      executingListeners.set(entry, count - 1);
+    }
+  };
   const {
     extra,
     onError = defaultErrorHandler
@@ -9270,6 +9349,7 @@ var createListenerMiddleware = (middlewareOptions = {}) => {
     const autoJoinPromises = [];
     try {
       entry.pending.add(internalTaskController);
+      trackExecutingListener(entry);
       await Promise.resolve(entry.effect(
         action,
         // Use assign() rather than ... to avoid extra helper functions added to bundle
@@ -9312,12 +9392,13 @@ var createListenerMiddleware = (middlewareOptions = {}) => {
     } finally {
       await Promise.all(autoJoinPromises);
       abortControllerWithReason(internalTaskController, listenerCompleted);
+      untrackExecutingListener(entry);
       entry.pending.delete(internalTaskController);
     }
   };
-  const clearListenerMiddleware = createClearListenerMiddleware(listenerMap);
+  const clearListenerMiddleware = createClearListenerMiddleware(listenerMap, executingListeners);
   const middleware = (api) => (next) => (action) => {
-    if (!isAction3(action)) {
+    if (!isAction(action)) {
       return next(action);
     }
     if (addListener.match(action)) {
@@ -9373,7 +9454,6 @@ var createListenerMiddleware = (middlewareOptions = {}) => {
 };
 
 // src/dynamicMiddleware/index.ts
-
 var createMiddlewareEntry = (middleware) => ({
   middleware,
   applied: /* @__PURE__ */ new Map()
@@ -9399,7 +9479,7 @@ var createDynamicMiddleware = () => {
   });
   const getFinalMiddleware = (api) => {
     const appliedMiddleware = Array.from(middlewareMap.values()).map((entry) => getOrInsertComputed(entry.applied, api, entry.middleware));
-    return compose3(...appliedMiddleware);
+    return compose(...appliedMiddleware);
   };
   const isWithMiddleware = isAllOf(withMiddleware, matchInstance(instanceId));
   const middleware = (api) => (next) => (action) => {
@@ -11600,7 +11680,8 @@ const useSeamlyIsLoading = () => useSeamlyStateContext().isLoading;
 const useSeamlyHeaderData = () => useSeamlyStateContext().headerTitles;
 const useSeamlyUnreadCount = () => useSeamlyStateContext().unreadEvents;
 const useLoadedImageEventIds = () => useSeamlyStateContext().loadedImageEventIds;
-const useSkiplink = () => useSeamlyStateContext().skiplinkTargetId;
+const useSkiplinkElement = () => useSeamlyStateContext().skiplinkElementId;
+const useSkiplinkTarget = () => useSeamlyStateContext().skiplinkTargetId;
 const useSeamlyParticipant = participantId => useSeamlyStateContext().participantInfo.participants[participantId];
 const useSeamlyServiceInfo = () => useSeamlyStateContext().serviceInfo;
 const selectLastMessageEventId = createSelector(selectEvents, events => {
@@ -12554,6 +12635,7 @@ const initialStoreState = {
     subTitle: ''
   },
   historyLoaded: false,
+  skiplinkElementId: randomId(),
   skiplinkTargetId: randomId(),
   optionsButtonId: randomId(),
   headerCollapseButtonId: randomId(),
@@ -14580,8 +14662,12 @@ const useSeamlyContainerElement = () => {
 const useElementFocusingById = elementId => (0,hooks_.useCallback)(() => {
   focusWithRaf(elementId);
 }, [elementId]);
+const useSkiplinkElementFocusing = () => {
+  const skiplinkElementId = useSkiplinkElement();
+  return useElementFocusingById(skiplinkElementId);
+};
 const useSkiplinkTargetFocusing = () => {
-  const skiplinkTargetId = useSkiplink();
+  const skiplinkTargetId = useSkiplinkTarget();
   return useElementFocusingById(skiplinkTargetId);
 };
 const useWindowOpenButtonFocusing = () => {
@@ -16451,7 +16537,7 @@ const TimeIndicator = ({
 /* harmony default export */ const time_indicator = (TimeIndicator);
 ;// ./node_modules/tabbable/dist/index.esm.js
 /*!
-* tabbable 6.2.0
+* tabbable 6.3.0
 * @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
 */
 // NOTE: separate `:not()` selectors has broader browser support than the newer
@@ -16478,7 +16564,7 @@ var getRootNode = !NoElement && Element.prototype.getRootNode ? function (elemen
  * @returns {boolean} True if inert itself or by way of being in an inert ancestor.
  *  False if `node` is falsy.
  */
-var isInert = function isInert(node, lookUp) {
+var _isInert = function isInert(node, lookUp) {
   var _node$getAttribute;
   if (lookUp === void 0) {
     lookUp = true;
@@ -16494,7 +16580,7 @@ var isInert = function isInert(node, lookUp) {
   //  code works for any kind of node
   // CAREFUL: JSDom does not appear to support certain selectors like `:not([inert] *)`
   //  so it likely would not support `:is([inert] *)` either...
-  var result = inert || lookUp && node && isInert(node.parentNode); // recursive
+  var result = inert || lookUp && node && _isInert(node.parentNode); // recursive
 
   return result;
 };
@@ -16522,7 +16608,7 @@ var isContentEditable = function isContentEditable(node) {
 var getCandidates = function getCandidates(el, includeContainer, filter) {
   // even if `includeContainer=false`, we still have to check it for inertness because
   //  if it's inert, all its children are inert
-  if (isInert(el)) {
+  if (_isInert(el)) {
     return [];
   }
   var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
@@ -16567,12 +16653,12 @@ var getCandidates = function getCandidates(el, includeContainer, filter) {
  * @param {IterativeOptions} options
  * @returns {Array.<Element|CandidateScope>}
  */
-var getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {
+var _getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {
   var candidates = [];
   var elementsToCheck = Array.from(elements);
   while (elementsToCheck.length) {
     var element = elementsToCheck.shift();
-    if (isInert(element, false)) {
+    if (_isInert(element, false)) {
       // no need to look up since we're drilling down
       // anything inside this container will also be inert
       continue;
@@ -16581,7 +16667,7 @@ var getCandidatesIteratively = function getCandidatesIteratively(elements, inclu
       // add shadow dom slot scope (slot itself cannot be focusable)
       var assigned = element.assignedElements();
       var content = assigned.length ? assigned : element.children;
-      var nestedCandidates = getCandidatesIteratively(content, true, options);
+      var nestedCandidates = _getCandidatesIteratively(content, true, options);
       if (options.flatten) {
         candidates.push.apply(candidates, nestedCandidates);
       } else {
@@ -16605,7 +16691,7 @@ var getCandidatesIteratively = function getCandidatesIteratively(elements, inclu
       // no inert look up because we're already drilling down and checking for inertness
       //  on the way down, so all containers to this root node should have already been
       //  vetted as non-inert
-      var validShadowRoot = !isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));
+      var validShadowRoot = !_isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));
       if (shadowRoot && validShadowRoot) {
         // add shadow dom scope IIF a shadow root node was given; otherwise, an undisclosed
         //  shadow exists, so look at light dom children as fallback BUT create a scope for any
@@ -16613,7 +16699,7 @@ var getCandidatesIteratively = function getCandidatesIteratively(elements, inclu
         //  children of the web component element (which has the shadow), in the light dom, but
         //  slotted somewhere _inside_ the undisclosed shadow) -- the scope is created below,
         //  _after_ we return from this recursive call
-        var _nestedCandidates = getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);
+        var _nestedCandidates = _getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);
         if (options.flatten) {
           candidates.push.apply(candidates, _nestedCandidates);
         } else {
@@ -16790,6 +16876,28 @@ var isZeroArea = function isZeroArea(node) {
 var isHidden = function isHidden(node, _ref) {
   var displayCheck = _ref.displayCheck,
     getShadowRoot = _ref.getShadowRoot;
+  if (displayCheck === 'full-native') {
+    if ('checkVisibility' in node) {
+      // Chrome >= 105, Edge >= 105, Firefox >= 106, Safari >= 17.4
+      // @see https://developer.mozilla.org/en-US/docs/Web/API/Element/checkVisibility#browser_compatibility
+      var visible = node.checkVisibility({
+        // Checking opacity might be desirable for some use cases, but natively,
+        // opacity zero elements _are_ focusable and tabbable.
+        checkOpacity: false,
+        opacityProperty: false,
+        contentVisibilityAuto: true,
+        visibilityProperty: true,
+        // This is an alias for `visibilityProperty`. Contemporary browsers
+        // support both. However, this alias has wider browser support (Chrome
+        // >= 105 and Firefox >= 106, vs. Chrome >= 121 and Firefox >= 122), so
+        // we include it anyway.
+        checkVisibilityCSS: true
+      });
+      return !visible;
+    }
+    // Fall through to manual visibility checks
+  }
+
   // NOTE: visibility will be `undefined` if node is detached from the document
   //  (see notes about this further down), which means we will consider it visible
   //  (this is legacy behavior from a very long way back)
@@ -16803,7 +16911,10 @@ var isHidden = function isHidden(node, _ref) {
   if (index_esm_matches.call(nodeUnderDetails, 'details:not([open]) *')) {
     return true;
   }
-  if (!displayCheck || displayCheck === 'full' || displayCheck === 'legacy-full') {
+  if (!displayCheck || displayCheck === 'full' ||
+  // full-native can run this branch when it falls through in case
+  // Element#checkVisibility is unsupported
+  displayCheck === 'full-native' || displayCheck === 'legacy-full') {
     if (typeof getShadowRoot === 'function') {
       // figure out if we should consider the node to be in an undisclosed shadow and use the
       //  'non-zero-area' fallback
@@ -16916,7 +17027,7 @@ var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable(o
   // we must do an inert look up to filter out any elements inside an inert ancestor
   //  because we're limited in the type of selectors we can use in JSDom (see related
   //  note related to `candidateSelectors`)
-  isInert(node) || isHiddenInput(node) || isHidden(node, options) ||
+  _isInert(node) || isHiddenInput(node) || isHidden(node, options) ||
   // For a details element with a summary, the summary element gets the focus
   isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {
     return false;
@@ -16929,7 +17040,7 @@ var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable(opt
   }
   return true;
 };
-var isValidShadowRootTabbable = function isValidShadowRootTabbable(shadowHostNode) {
+var isShadowRootTabbable = function isShadowRootTabbable(shadowHostNode) {
   var tabIndex = parseInt(shadowHostNode.getAttribute('tabindex'), 10);
   if (isNaN(tabIndex) || tabIndex >= 0) {
     return true;
@@ -16943,14 +17054,14 @@ var isValidShadowRootTabbable = function isValidShadowRootTabbable(shadowHostNod
  * @param {Array.<Element|CandidateScope>} candidates
  * @returns Element[]
  */
-var sortByOrder = function sortByOrder(candidates) {
+var _sortByOrder = function sortByOrder(candidates) {
   var regularTabbables = [];
   var orderedTabbables = [];
   candidates.forEach(function (item, i) {
     var isScope = !!item.scopeParent;
     var element = isScope ? item.scopeParent : item;
     var candidateTabindex = getSortOrderTabIndex(element, isScope);
-    var elements = isScope ? sortByOrder(item.candidates) : element;
+    var elements = isScope ? _sortByOrder(item.candidates) : element;
     if (candidateTabindex === 0) {
       isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);
     } else {
@@ -16972,22 +17083,22 @@ var tabbable = function tabbable(container, options) {
   options = options || {};
   var candidates;
   if (options.getShadowRoot) {
-    candidates = getCandidatesIteratively([container], options.includeContainer, {
+    candidates = _getCandidatesIteratively([container], options.includeContainer, {
       filter: isNodeMatchingSelectorTabbable.bind(null, options),
       flatten: false,
       getShadowRoot: options.getShadowRoot,
-      shadowRootFilter: isValidShadowRootTabbable
+      shadowRootFilter: isShadowRootTabbable
     });
   } else {
     candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
   }
-  return sortByOrder(candidates);
+  return _sortByOrder(candidates);
 };
 var focusable = function focusable(container, options) {
   options = options || {};
   var candidates;
   if (options.getShadowRoot) {
-    candidates = getCandidatesIteratively([container], options.includeContainer, {
+    candidates = _getCandidatesIteratively([container], options.includeContainer, {
       filter: isNodeMatchingSelectorFocusable.bind(null, options),
       flatten: true,
       getShadowRoot: options.getShadowRoot
@@ -17024,7 +17135,7 @@ var isFocusable = function isFocusable(node, options) {
 
 ;// ./node_modules/focus-trap/dist/focus-trap.esm.js
 /*!
-* focus-trap 7.6.5
+* focus-trap 7.6.6
 * @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE
 */
 
@@ -20011,10 +20122,26 @@ const event_Event = ({
 
 
 
+
+
 const Loader = () => {
   const {
-    id
+    t
+  } = useI18n();
+  const {
+    sendPolite
+  } = useLiveRegion();
+  const {
+    id,
+    name
   } = useSeamlyCurrentAgent() || {};
+  (0,hooks_.useEffect)(() => {
+    if (name) {
+      sendPolite(t('typing.srText', {
+        name
+      }));
+    }
+  }, [name, sendPolite, t]);
   return /*#__PURE__*/(0,jsx_runtime_namespaceObject.jsx)("li", {
     className: css_className('conversation__item', 'conversation__item--source-agent'),
     children: /*#__PURE__*/(0,jsx_runtime_namespaceObject.jsxs)("div", {
@@ -20095,7 +20222,8 @@ const Conversation = () => {
   const {
     isOpen
   } = useVisibility();
-  const skiplinkTargetId = useSkiplink();
+  const skiplinkElementId = useSkiplinkElement();
+  const skiplinkTargetId = useSkiplinkTarget();
   const focusSkiplinkTarget = useSkiplinkTargetFocusing();
   const onClickHandler = e => {
     e.preventDefault();
@@ -20103,6 +20231,7 @@ const Conversation = () => {
   };
   return /*#__PURE__*/(0,jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
     children: [isOpen && /*#__PURE__*/(0,jsx_runtime_namespaceObject.jsx)("a", {
+      id: skiplinkElementId,
       className: css_className('skip-link'),
       href: `#${skiplinkTargetId}`,
       onClick: onClickHandler,
@@ -20442,10 +20571,12 @@ const Suggestions = ({
 
 
 
+
 const Chat = (0,compat_namespaceObject.forwardRef)(({
   children,
   className: givenClassName = ''
 }, forwardedRef) => {
+  const focusTrap = (0,compat_namespaceObject.useRef)(null);
   const {
     closeChat,
     isOpen,
@@ -20460,6 +20591,7 @@ const Chat = (0,compat_namespaceObject.forwardRef)(({
     isInline
   } = useSeamlyLayoutMode();
   const appContainerClassNames = useSeamlyAppContainerClassNames();
+  const chatSectionId = useGeneratedId();
   const headingId = useGeneratedId();
   const userHasResponded = useUserHasResponded();
   const {
@@ -20482,7 +20614,22 @@ const Chat = (0,compat_namespaceObject.forwardRef)(({
       focusWindowOpenButton();
     }
   };
+  (0,compat_namespaceObject.useEffect)(() => {
+    if (isVisible && layoutMode === 'window') {
+      focusTrap.current = createFocusTrap(`#${chatSectionId}`, {
+        // We set the initialFocus to false, as the `WindowOpenButton` takes care of that
+        initialFocus: false
+      });
+      focusTrap.current.activate();
+    }
+    return () => {
+      if (focusTrap.current) {
+        focusTrap.current.deactivate();
+      }
+    };
+  }, [chatSectionId, isVisible, layoutMode]);
   return isVisible && /*#__PURE__*/(0,jsx_runtime_namespaceObject.jsxs)("section", {
+    id: chatSectionId,
     className: css_className(classNames),
     onKeyDown: onKeyDownHandler,
     tabIndex: -1,
@@ -21835,7 +21982,7 @@ const Prompt = ({
   children,
   title
 }) => {
-  const skiplinkTargetId = useSkiplink();
+  const skiplinkTargetId = useSkiplinkTarget();
   const containerHeadingId = useGeneratedId();
   return /*#__PURE__*/(0,jsx_runtime_namespaceObject.jsxs)("section", {
     id: skiplinkTargetId,
@@ -22191,7 +22338,7 @@ function TextEntry({
     isOpen,
     setVisibility
   } = useVisibility();
-  const skipLinkId = useSkiplink();
+  const skipLinkId = useSkiplinkTarget();
   const focusSkipLinkTarget = useSkiplinkTargetFocusing();
   const {
     sendMessage
@@ -22484,7 +22631,7 @@ const upload_Upload = () => {
     sendPolite,
     sendAssertive
   } = useLiveRegion();
-  const skiplinkTargetId = useSkiplink();
+  const skiplinkTargetId = useSkiplinkTarget();
   const focusSkiplinkTarget = useSkiplinkTargetFocusing();
   // This hook should be refactored at some point
   const {
@@ -23113,6 +23260,7 @@ const WindowOpenButton = ({
     t
   } = useI18n();
   const ariaLabel = hasConversation() ? t('window.openButton.srContinue') : t('window.openButton.srStart');
+  const focusSkipLinkELement = useSkiplinkElementFocusing();
   const focusSkiplinkTarget = useSkiplinkTargetFocusing();
   const {
     isOpen
@@ -23121,10 +23269,17 @@ const WindowOpenButton = ({
     windowOpenButtonId
   } = useSeamlyStateContext();
   const count = useSeamlyUnreadCount();
-  const handleClick = (0,hooks_.useCallback)(() => {
+  const handleClick = (0,hooks_.useCallback)(event => {
     onClick();
-    focusSkiplinkTarget();
-  }, [focusSkiplinkTarget, onClick]);
+    if (event.detail > 0) {
+      // Mouse was used: focus the input element
+      focusSkiplinkTarget();
+    } else {
+      // Keyboard was used: focus the skiplink element instead to improve
+      // accessibility for keyboard users.
+      focusSkipLinkELement();
+    }
+  }, [focusSkipLinkELement, focusSkiplinkTarget, onClick]);
   return /*#__PURE__*/(0,jsx_runtime_namespaceObject.jsx)(in_out_transition, {
     isActive: !isOpen,
     transitionStartState: transitionStartStates.rendered,