@equinor/roma-framework 1.1.0 → 2.0.1

package/roma-framework.mjs

@@ -1,16 +1,30 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _config, _connections, _builderCallbacks, _endpoints, _manifests;
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { useFramework, FrameworkProvider } from "@equinor/fusion-framework-react";
 import { configureModules } from "@equinor/fusion-framework-app";
 import * as React from "react";
-import { useState, useEffect, lazy, useRef, createContext, useContext, useMemo, useDebugValue, useLayoutEffect } from "react";
+import { useState, useEffect, lazy, useRef, createContext, useContext, useMemo } from "react";
 import { ModuleProvider } from "@equinor/fusion-framework-react-module";
 import styled, { StyleSheetManager, keyframes } from "styled-components";
 import { EdsProvider, StarProgress, Typography, Card, Button, TopBar, SideSheet, Menu, Tooltip, Icon } from "@equinor/eds-core-react";
-import { O as Observable, i as isFunction, E as EmptyError, o as operate, c as createOperatorSubscriber, a as innerFrom, I as IntlProvider, b as invariant, j as joinPaths, g as getPathContributingMatches, w as warning, r as resolveTo, s as stripBasename, d as createPath, B as BehaviorSubject, S as Subject, m as map } from "./router-CrMzSazo.mjs";
+import { E as EmptyError, o as operate, c as createOperatorSubscriber, i as innerFrom, a as identity, b as isFunction, I as IntlProvider, d as invariant, j as joinPaths, g as getPathContributingMatches, w as warning, r as resolveTo, s as stripBasename, e as createPath, B as BehaviorSubject, f as firstValueFrom, h as of, k as from } from "./router-CD1QGwNJ.mjs";
 import { QueryClient, QueryClientProvider, useQueryClient, useQuery, useMutation } from "@tanstack/react-query";
 import { useCurrentApp, useApps as useApps$1 } from "@equinor/fusion-framework-react/app";
 import { App } from "@equinor/fusion-framework-module-app/app";
-import { comment_more, notifications, accessible, account_circle, help_outline } from "@equinor/eds-icons";
+import { comment_more, accessible, account_circle, help_outline } from "@equinor/eds-icons";
+import { enableAppModule } from "@equinor/fusion-framework-module-app";
+import { enableContext } from "@equinor/fusion-framework-module-context";
+import { ConsoleLogger } from "@equinor/fusion-framework-module-msal/client";
+import { enableNavigation } from "@equinor/fusion-framework-module-navigation";
+import { ModuleConfigBuilder } from "@equinor/fusion-framework-module";
+import { enableServiceDiscovery } from "@equinor/fusion-framework-module-service-discovery";
 import { tokens } from "@equinor/eds-tokens";
 import { useHttpClient } from "@equinor/fusion-framework-react-module-http";
 const createExtraScopePlugin = (scope) => {
@@ -38,9 +52,6 @@ const StyleProvider = ({ scope, children }) => {
   }
   return /* @__PURE__ */ jsx(StyleSheetManager, { stylisPlugins, children: /* @__PURE__ */ jsx("div", { id: scope, children }) });
 };
-function isObservable(obj) {
-  return !!obj && (obj instanceof Observable || isFunction(obj.lift) && isFunction(obj.subscribe));
-}
 function lastValueFrom(source, config) {
   return new Promise(function(resolve, reject) {
     var _hasValue = false;
@@ -61,6 +72,14 @@ function lastValueFrom(source, config) {
     });
   });
 }
+function map(project, thisArg) {
+  return operate(function(source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      subscriber.next(project.call(thisArg, value, index++));
+    }));
+  });
+}
 function filter(predicate, thisArg) {
   return operate(function(source, subscriber) {
     var index = 0;
@@ -69,6 +88,28 @@ function filter(predicate, thisArg) {
     }));
   });
 }
+function catchError(selector) {
+  return operate(function(source, subscriber) {
+    var innerSub = null;
+    var syncUnsub = false;
+    var handledResult;
+    innerSub = source.subscribe(createOperatorSubscriber(subscriber, void 0, void 0, function(err) {
+      handledResult = innerFrom(selector(err, catchError(selector)(source)));
+      if (innerSub) {
+        innerSub.unsubscribe();
+        innerSub = null;
+        handledResult.subscribe(subscriber);
+      } else {
+        syncUnsub = true;
+      }
+    }));
+    if (syncUnsub) {
+      innerSub.unsubscribe();
+      innerSub = null;
+      handledResult.subscribe(subscriber);
+    }
+  });
+}
 function switchMap(project, resultSelector) {
   return operate(function(source, subscriber) {
     var innerSubscriber = null;
@@ -93,6 +134,35 @@ function switchMap(project, resultSelector) {
     }));
   });
 }
+function tap(observerOrNext, error, complete) {
+  var tapObserver = isFunction(observerOrNext) || error || complete ? { next: observerOrNext, error, complete } : observerOrNext;
+  return tapObserver ? operate(function(source, subscriber) {
+    var _a;
+    (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+    var isUnsub = true;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      var _a2;
+      (_a2 = tapObserver.next) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, value);
+      subscriber.next(value);
+    }, function() {
+      var _a2;
+      isUnsub = false;
+      (_a2 = tapObserver.complete) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
+      subscriber.complete();
+    }, function(err) {
+      var _a2;
+      isUnsub = false;
+      (_a2 = tapObserver.error) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, err);
+      subscriber.error(err);
+    }, function() {
+      var _a2, _b;
+      if (isUnsub) {
+        (_a2 = tapObserver.unsubscribe) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
+      }
+      (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+    }));
+  }) : identity;
+}
 const EdsEventProvider = ({ event, children }) => {
   const [density, setDensity] = useState(
     localStorage.getItem("roma__density") ?? "comfortable"
@@ -106,11 +176,14 @@ const EdsEventProvider = ({ event, children }) => {
   }, [event]);
   return /* @__PURE__ */ jsx(EdsProvider, { density, children });
 };
-const makeComponent = (Component, args, configure) => lazy(async () => {
-  const init = configureModules(configure);
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+const makeComponent = (Component, args, configure2) => lazy(async () => {
+  const init = configureModules(configure2);
   const modules = await init(args);
   const manifest = args.env.manifest;
-  const appKey = manifest.key;
+  const appKey = manifest.appKey;
   const { fusion } = args;
   modules.event.dispatchEvent("onReactAppLoaded", {
     detail: { modules, fusion },
@@ -122,7 +195,7 @@ const makeComponent = (Component, args, configure) => lazy(async () => {
   };
 });
 const withStyleIsolation = (children, args) => lazy(async () => {
-  const appKey = args.env.manifest.key;
+  const appKey = args.env.manifest.appKey;
   return {
     default: () => /* @__PURE__ */ jsx(StyleProvider, { scope: `roma-${appKey}`, children })
   };
@@ -180,7 +253,7 @@ const RomaErrorViewer = ({
 };
 function getAppModule(app, framework) {
   const initializeData = {
-    appKey: app.key,
+    appKey: app.appKey,
     manifest: app,
     config: {
       environment: "development",
@@ -233,7 +306,7 @@ function AppLoader({
         }
       });
       if (kind === "app") {
-        setCurrentApp(app.key);
+        setCurrentApp(app.appKey);
       }
     });
     return appModule;
@@ -372,7 +445,7 @@ function useLocation() {
   return React.useContext(LocationContext).location;
 }
 const navigateEffectWarning = "You should call navigate() in a React.useEffect(), not when your component is first rendered.";
-function useIsomorphicLayoutEffect$1(cb) {
+function useIsomorphicLayoutEffect(cb) {
   let isStatic = React.useContext(NavigationContext).static;
   if (!isStatic) {
     React.useLayoutEffect(cb);
@@ -404,7 +477,7 @@ function useNavigateUnstable() {
   } = useLocation();
   let routePathnamesJson = JSON.stringify(getPathContributingMatches(matches).map((match) => match.pathnameBase));
   let activeRef = React.useRef(false);
-  useIsomorphicLayoutEffect$1(() => {
+  useIsomorphicLayoutEffect(() => {
     activeRef.current = true;
   });
   let navigate = React.useCallback(function(to, options) {
@@ -492,7 +565,7 @@ function useNavigateStable() {
   } = useDataRouterContext$1(DataRouterHook$1.UseNavigateStable);
   let id = useCurrentRouteId(DataRouterStateHook$1.UseNavigateStable);
   let activeRef = React.useRef(false);
-  useIsomorphicLayoutEffect$1(() => {
+  useIsomorphicLayoutEffect(() => {
     activeRef.current = true;
   });
   let navigate = React.useCallback(function(to, options) {
@@ -551,17 +624,17 @@ function _objectWithoutPropertiesLoose(source, excluded) {
 }
 const defaultMethod = "get";
 const defaultEncType = "application/x-www-form-urlencoded";
-function isHtmlElement(object) {
-  return object != null && typeof object.tagName === "string";
+function isHtmlElement(object2) {
+  return object2 != null && typeof object2.tagName === "string";
 }
-function isButtonElement(object) {
-  return isHtmlElement(object) && object.tagName.toLowerCase() === "button";
+function isButtonElement(object2) {
+  return isHtmlElement(object2) && object2.tagName.toLowerCase() === "button";
 }
-function isFormElement(object) {
-  return isHtmlElement(object) && object.tagName.toLowerCase() === "form";
+function isFormElement(object2) {
+  return isHtmlElement(object2) && object2.tagName.toLowerCase() === "form";
 }
-function isInputElement(object) {
-  return isHtmlElement(object) && object.tagName.toLowerCase() === "input";
+function isInputElement(object2) {
+  return isHtmlElement(object2) && object2.tagName.toLowerCase() === "input";
 }
 function isModifiedEvent(event) {
   return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
@@ -964,7 +1037,8 @@ function AppLoadError({
   ] });
 }
 const AppProvider = ({ children }) => {
-  const { apps, isLoading, error } = useApps$1({ includeHidden: true });
+  const { apps: _apps, isLoading, error } = useApps$1();
+  const apps = _apps;
   return /* @__PURE__ */ jsx(
     AppContext.Provider,
     {
@@ -977,9 +1051,7 @@ const AppProvider = ({ children }) => {
     }
   );
 };
-const useApps = ({
-  includeHidden
-} = {}) => {
+const useApps = ({ includeHidden } = {}) => {
   const { apps: allApps, isLoading, error } = useContext(AppContext);
   return useMemo(() => {
     if (!allApps) return { isLoading, apps: [], error };
@@ -994,7 +1066,7 @@ const AppViewer = () => {
   const { appKey } = useParams();
   const { apps } = useApps({ includeHidden: true });
   const app = useMemo(() => {
-    return apps == null ? void 0 : apps.find((app2) => app2.key === appKey);
+    return apps == null ? void 0 : apps.find((app2) => app2.appKey === appKey);
   }, [appKey, apps]);
   if (!apps) {
     return /* @__PURE__ */ jsx(EquinorLoader, { text: "Loading apps..." });
@@ -1074,7 +1146,7 @@ const SideSheets = ({
           children: apps && apps.length > 0 ? /* @__PURE__ */ jsx(
             AppLoader,
             {
-              app: apps.find((app) => app.key === "activity-feed") ?? null
+              app: apps.find((app) => app.appKey === "activity-feed") ?? null
             }
           ) : null
         }
@@ -1083,177 +1155,6 @@ const SideSheets = ({
     "sheet-activity"
   );
 };
-const useSseModule = () => {
-  return useFramework().modules.sse;
-};
-function useObservableInternal(useCustomEffect, init, inputs) {
-  if (!inputs) {
-    return useState(init)[0];
-  }
-  const [inputs$] = useState(() => new BehaviorSubject(inputs));
-  const [source$] = useState(() => init(inputs$));
-  const firstEffectRef = useRef(true);
-  useCustomEffect(() => {
-    if (firstEffectRef.current) {
-      firstEffectRef.current = false;
-      return;
-    }
-    inputs$.next(inputs);
-  }, inputs);
-  return source$;
-}
-function useObservable(init, inputs) {
-  return useObservableInternal(useEffect, init, inputs);
-}
-var getEmptySubject = () => new Subject();
-var useIsomorphicLayoutEffect = /* @__PURE__ */ (() => (
-  /* istanbul ignore next */
-  typeof window === "undefined" ? useEffect : useLayoutEffect
-))();
-var toObserver = (args) => {
-  var _a;
-  return ((_a = args[1]) == null ? void 0 : _a.next) ? args[1] : {
-    next: args[1],
-    error: args[2],
-    complete: args[3]
-  };
-};
-function useSubscriptionInternal(useCustomEffect, args) {
-  const argsRef = useRef(args);
-  const observerRef = useRef();
-  const subscriptionRef = useRef();
-  useIsomorphicLayoutEffect(() => {
-    argsRef.current = args;
-    observerRef.current = toObserver(args);
-  });
-  useCustomEffect(() => {
-    const input$ = argsRef.current[0];
-    if (!observerRef.current) {
-      observerRef.current = toObserver(argsRef.current);
-    }
-    const subscription = input$.subscribe({
-      next: (value) => {
-        var _a, _b;
-        if (input$ === argsRef.current[0]) {
-          (_b = (_a = observerRef.current).next) == null ? void 0 : _b.call(_a, value);
-        }
-      },
-      error: (error) => {
-        if (input$ === argsRef.current[0]) {
-          observerRef.current.error ? observerRef.current.error(error) : console.error(error);
-        }
-      },
-      complete: () => {
-        var _a, _b;
-        if (input$ === argsRef.current[0]) {
-          (_b = (_a = observerRef.current).complete) == null ? void 0 : _b.call(_a);
-        }
-      }
-    });
-    subscriptionRef.current = subscription;
-    return () => {
-      subscription.unsubscribe();
-    };
-  }, [args[0]]);
-  return subscriptionRef;
-}
-function useSubscription(input$, observerOrNext$, error, complete) {
-  return useSubscriptionInternal(useEffect, [
-    input$,
-    observerOrNext$,
-    error,
-    complete
-  ]);
-}
-function useObservableStateInternal(useSubscription2, state$OrInit, initialState) {
-  if (isObservable(state$OrInit)) {
-    const state$ = state$OrInit;
-    const [state, setState] = useState(() => {
-      if (state$ instanceof BehaviorSubject || state$.value !== void 0) {
-        return state$.value;
-      }
-      if (typeof initialState === "function") {
-        return initialState();
-      }
-      return initialState;
-    });
-    useSubscription2(state$, setState);
-    useDebugValue(state);
-    return state;
-  } else {
-    const init = state$OrInit;
-    const [state, setState] = useState(initialState);
-    const [input$] = useState(getEmptySubject);
-    const [state$] = useState(() => init(input$, state));
-    const callback = useRef((state2) => input$.next(state2)).current;
-    useSubscription2(state$, setState);
-    useDebugValue(state);
-    return [state, callback];
-  }
-}
-function useObservableState(state$OrInit, initialState) {
-  return useObservableStateInternal(
-    useSubscription,
-    state$OrInit,
-    initialState
-  );
-}
-const mapEvents = (opts = {
-  limit: 10
-}) => map((allEvents) => {
-  const value = allEvents.filter((v, i, arr) => {
-    return arr.slice(0, i).every((x) => x.id !== v.id);
-  });
-  if (!opts.filter) {
-    return value;
-  } else {
-    return value.filter((v) => {
-      const filters = opts.filter;
-      return Object.keys(filters.attributes).every((key) => {
-        const currentValue = v[key];
-        const filterValue = filters.attributes[key];
-        if (filterValue === null || filterValue === void 0) return true;
-        if (key === "payload") {
-          let valueStr;
-          try {
-            valueStr = JSON.stringify(currentValue);
-          } catch {
-          }
-          if (valueStr === void 0) return true;
-          const re = new RegExp(filters.attributes[key], "ig");
-          return re.test(valueStr ?? "");
-        } else if (Array.isArray(filters.attributes[key])) {
-          if (filters.attributes[key].length === 0) return true;
-          return filters.attributes[key].includes(
-            currentValue
-          );
-        } else {
-          return filters.attributes[key] == currentValue;
-        }
-      });
-    });
-  }
-});
-const useSse = (name, opts) => {
-  const limit = ((opts == null ? void 0 : opts.limit) ?? 10) > 100 ? 100 : opts == null ? void 0 : opts.limit;
-  const module = useSseModule();
-  const connection = module.connect(name);
-  const stream$ = connection.messageList$.pipe();
-  const safeStream$ = useObservable(
-    (options) => options.pipe(
-      switchMap((opt) => {
-        return stream$.pipe(mapEvents(opt[0]));
-      })
-    ),
-    [opts]
-  );
-  const messages = useObservableState(safeStream$, []);
-  return {
-    messages: messages.slice(0, limit),
-    setReadState: connection.setReadState,
-    setAllRead: connection.setAllRead
-  };
-};
 const HeaderMenu = ({ menuState }) => {
   const { currentApp } = useCurrentApp();
   const { apps: applications } = useApps({ includeHidden: true });
@@ -1272,13 +1173,15 @@ const HeaderMenu = ({ menuState }) => {
     return ((_a = user == null ? void 0 : user.idTokenClaims) == null ? void 0 : _a.roles) ?? ["No access role"];
   }, [user]);
   const getFeedbackAreaFromTags = (currentApp2, applications2) => {
-    const manifest = applications2.find((app) => app.key === (currentApp2 == null ? void 0 : currentApp2.appKey));
-    const tags = (manifest == null ? void 0 : manifest.tags) ?? [];
+    const manifest = applications2.find(
+      (app) => app.appKey === (currentApp2 == null ? void 0 : currentApp2.appKey)
+    );
+    const tags = (manifest == null ? void 0 : manifest.keywords) ?? [];
     if (tags.includes("trading")) return "10543";
     if (tags.includes("liquids-operations")) return "10511";
     return "10540";
   };
-  const opts = useMemo(
+  useMemo(
     () => ({
       limit: 10,
       filter: {
@@ -1296,7 +1199,10 @@ const HeaderMenu = ({ menuState }) => {
     const e = new CustomEvent("onDensityChanged", { detail: newDensity });
     event.dispatchEvent("onDensityChanged", e);
   };
-  const { messages } = useSse("activity", opts);
+  const quickLinks = applications.find((app) => app.appKey === "quick-links");
+  const notificationCenter = applications.find(
+    (app) => app.appKey === "notifications"
+  );
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsx(Tooltip, { title: "Submit and view your previous feedback", children: /* @__PURE__ */ jsxs(
       Button,
@@ -1311,127 +1217,2784 @@ const HeaderMenu = ({ menuState }) => {
         ]
       }
     ) }),
-    /* @__PURE__ */ jsx(Tooltip, { title: "View notifications and notification settings", children: /* @__PURE__ */ jsxs(
+    /* @__PURE__ */ jsx(Tooltip, { title: "Switch between compact and comfortable view", children: /* @__PURE__ */ jsx(
       Button,
       {
-        variant: "ghost",
-        onClick: () => menuState.setActivityLogOpen(true),
+        onClick: () => menuState.setA11yOpen(true),
+        ref: a11yRef,
+        variant: "ghost_icon",
+        children: /* @__PURE__ */ jsx(Icon, { data: accessible })
+      }
+    ) }),
+    /* @__PURE__ */ jsx(
+      StyledMenu,
+      {
+        onClose: () => menuState.setA11yOpen(false),
+        anchorEl: a11yRef.current,
+        open: menuState.a11yOpen,
+        children: /* @__PURE__ */ jsxs(Menu.Section, { title: "Density", children: [
+          /* @__PURE__ */ jsx(
+            Menu.Item,
+            {
+              active: density === "comfortable",
+              onClick: () => toggleDensity("comfortable"),
+              children: "Comfortable"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Menu.Item,
+            {
+              active: density === "compact",
+              onClick: () => toggleDensity("compact"),
+              children: "Compact"
+            }
+          )
+        ] })
+      }
+    ),
+    notificationCenter && /* @__PURE__ */ jsx(AppLoader, { app: notificationCenter, kind: "widget" }),
+    quickLinks && /* @__PURE__ */ jsx(AppLoader, { app: quickLinks, kind: "widget" }),
+    /* @__PURE__ */ jsx(Tooltip, { title: "View user settings", children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        onClick: () => menuState.setUserMenuOpen(true),
+        ref: userRef,
+        variant: "ghost_icon",
+        children: /* @__PURE__ */ jsx(Icon, { data: account_circle })
+      }
+    ) }),
+    /* @__PURE__ */ jsxs(
+      StyledMenu,
+      {
+        onClose: () => menuState.setUserMenuOpen(false),
+        anchorEl: userRef.current,
+        open: menuState.userMenuOpen,
         children: [
-          /* @__PURE__ */ jsx(Icon, { data: notifications }),
-          /* @__PURE__ */ jsx(Typography, { variant: "chip__badge", group: "ui", children: (messages == null ? void 0 : messages.filter((m) => !m.read).length) ?? 0 })
+          /* @__PURE__ */ jsxs(Menu.Section, { title: "Profile", children: [
+            /* @__PURE__ */ jsx(Menu.Item, { children: user.name }),
+            /* @__PURE__ */ jsx(
+              Menu.Item,
+              {
+                onClick: () => auth.defaultClient.logoutRedirect({
+                  postLogoutRedirectUri: window.location.origin
+                }),
+                children: "Sign out"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(Menu.Section, { title: "Roles", children: roles.map((r) => /* @__PURE__ */ jsx(Menu.Item, { children: r }, r)) })
         ]
       }
-    ) }),
-    /* @__PURE__ */ jsx(Tooltip, { title: "Switch between compact and comfortable view", children: /* @__PURE__ */ jsx(
-      Button,
-      {
-        onClick: () => menuState.setA11yOpen(true),
-        ref: a11yRef,
-        variant: "ghost_icon",
-        children: /* @__PURE__ */ jsx(Icon, { data: accessible })
+    ),
+    /* @__PURE__ */ jsx(Tooltip, { title: "Release notes", children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        variant: "ghost_icon",
+        as: "a",
+        href: `https://statoilsrm.sharepoint.com/sites/Roma/Lists/Releases/AllItems.aspx`,
+        target: "_blank",
+        children: /* @__PURE__ */ jsx(Icon, { data: help_outline })
+      }
+    ) })
+  ] });
+};
+const Header = () => {
+  const [a11yOpen, setA11yOpen] = useState(false);
+  const [userMenuOpen, setUserMenuOpen] = useState(false);
+  const [activityLogOpen, setActivityLogOpen] = useState(false);
+  const { apps: allApps } = useApps({ includeHidden: true });
+  const headerMenuState = {
+    a11yOpen,
+    setA11yOpen,
+    userMenuOpen,
+    setUserMenuOpen,
+    activityLogOpen,
+    setActivityLogOpen
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(TopBarFadeIn, { id: "cli-top-bar", children: [
+      /* @__PURE__ */ jsx(TopBar.Header, { children: /* @__PURE__ */ jsxs(Styled.Title, { children: [
+        /* @__PURE__ */ jsx(Icon, { color: "#eb0037", data: logoIcon, viewBox: "0 0 42 48" }),
+        /* @__PURE__ */ jsx("span", { children: "Roma" })
+      ] }) }),
+      /* @__PURE__ */ jsx(TopBar.CustomContent, {}),
+      /* @__PURE__ */ jsx(TopBar.Actions, { children: /* @__PURE__ */ jsx(HeaderMenu, { menuState: headerMenuState }) })
+    ] }),
+    /* @__PURE__ */ jsx(SideSheets, { apps: allApps, menuState: headerMenuState })
+  ] });
+};
+async function getBytes(stream, onChunk) {
+  const reader = stream.getReader();
+  let result;
+  while (!(result = await reader.read()).done) {
+    onChunk(result.value);
+  }
+}
+function getLines(onLine) {
+  let buffer;
+  let position;
+  let fieldLength;
+  let discardTrailingNewline = false;
+  return function onChunk(arr) {
+    if (buffer === void 0) {
+      buffer = arr;
+      position = 0;
+      fieldLength = -1;
+    } else {
+      buffer = concat(buffer, arr);
+    }
+    const bufLength = buffer.length;
+    let lineStart = 0;
+    while (position < bufLength) {
+      if (discardTrailingNewline) {
+        if (buffer[position] === 10) {
+          lineStart = ++position;
+        }
+        discardTrailingNewline = false;
+      }
+      let lineEnd = -1;
+      for (; position < bufLength && lineEnd === -1; ++position) {
+        switch (buffer[position]) {
+          case 58:
+            if (fieldLength === -1) {
+              fieldLength = position - lineStart;
+            }
+            break;
+          case 13:
+            discardTrailingNewline = true;
+          case 10:
+            lineEnd = position;
+            break;
+        }
+      }
+      if (lineEnd === -1) {
+        break;
+      }
+      onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+      lineStart = position;
+      fieldLength = -1;
+    }
+    if (lineStart === bufLength) {
+      buffer = void 0;
+    } else if (lineStart !== 0) {
+      buffer = buffer.subarray(lineStart);
+      position -= lineStart;
+    }
+  };
+}
+function getMessages(onId, onRetry, onMessage) {
+  let message = newMessage();
+  const decoder = new TextDecoder();
+  return function onLine(line, fieldLength) {
+    if (line.length === 0) {
+      onMessage === null || onMessage === void 0 ? void 0 : onMessage(message);
+      message = newMessage();
+    } else if (fieldLength > 0) {
+      const field = decoder.decode(line.subarray(0, fieldLength));
+      const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
+      const value = decoder.decode(line.subarray(valueOffset));
+      switch (field) {
+        case "data":
+          message.data = message.data ? message.data + "\n" + value : value;
+          break;
+        case "event":
+          message.event = value;
+          break;
+        case "id":
+          onId(message.id = value);
+          break;
+        case "retry":
+          const retry = parseInt(value, 10);
+          if (!isNaN(retry)) {
+            onRetry(message.retry = retry);
+          }
+          break;
+      }
+    }
+  };
+}
+function concat(a, b) {
+  const res = new Uint8Array(a.length + b.length);
+  res.set(a);
+  res.set(b, a.length);
+  return res;
+}
+function newMessage() {
+  return {
+    data: "",
+    event: "",
+    id: "",
+    retry: void 0
+  };
+}
+var __rest = function(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+const EventStreamContentType = "text/event-stream";
+const DefaultRetryInterval = 1e3;
+const LastEventId = "last-event-id";
+function fetchEventSource(input, _a) {
+  var { signal: inputSignal, headers: inputHeaders, onopen: inputOnOpen, onmessage, onclose, onerror, openWhenHidden, fetch: inputFetch } = _a, rest = __rest(_a, ["signal", "headers", "onopen", "onmessage", "onclose", "onerror", "openWhenHidden", "fetch"]);
+  return new Promise((resolve, reject) => {
+    const headers = Object.assign({}, inputHeaders);
+    if (!headers.accept) {
+      headers.accept = EventStreamContentType;
+    }
+    let curRequestController;
+    function onVisibilityChange() {
+      curRequestController.abort();
+      if (!document.hidden) {
+        create();
+      }
+    }
+    if (!openWhenHidden) {
+      document.addEventListener("visibilitychange", onVisibilityChange);
+    }
+    let retryInterval = DefaultRetryInterval;
+    let retryTimer = 0;
+    function dispose() {
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+      window.clearTimeout(retryTimer);
+      curRequestController.abort();
+    }
+    inputSignal === null || inputSignal === void 0 ? void 0 : inputSignal.addEventListener("abort", () => {
+      dispose();
+      resolve();
+    });
+    const fetch2 = inputFetch !== null && inputFetch !== void 0 ? inputFetch : window.fetch;
+    const onopen = inputOnOpen !== null && inputOnOpen !== void 0 ? inputOnOpen : defaultOnOpen;
+    async function create() {
+      var _a2;
+      curRequestController = new AbortController();
+      try {
+        const response = await fetch2(input, Object.assign(Object.assign({}, rest), { headers, signal: curRequestController.signal }));
+        await onopen(response);
+        await getBytes(response.body, getLines(getMessages((id) => {
+          if (id) {
+            headers[LastEventId] = id;
+          } else {
+            delete headers[LastEventId];
+          }
+        }, (retry) => {
+          retryInterval = retry;
+        }, onmessage)));
+        onclose === null || onclose === void 0 ? void 0 : onclose();
+        dispose();
+        resolve();
+      } catch (err) {
+        if (!curRequestController.signal.aborted) {
+          try {
+            const interval = (_a2 = onerror === null || onerror === void 0 ? void 0 : onerror(err)) !== null && _a2 !== void 0 ? _a2 : retryInterval;
+            window.clearTimeout(retryTimer);
+            retryTimer = window.setTimeout(create, interval);
+          } catch (innerErr) {
+            dispose();
+            reject(innerErr);
+          }
+        }
+      }
+    }
+    create();
+  });
+}
+function defaultOnOpen(response) {
+  const contentType = response.headers.get("content-type");
+  if (!(contentType === null || contentType === void 0 ? void 0 : contentType.startsWith(EventStreamContentType))) {
+    throw new Error(`Expected content-type to be ${EventStreamContentType}, Actual: ${contentType}`);
+  }
+}
+function promisifyRequest(request) {
+  return new Promise((resolve, reject) => {
+    request.oncomplete = request.onsuccess = () => resolve(request.result);
+    request.onabort = request.onerror = () => reject(request.error);
+  });
+}
+function createStore(dbName, storeName) {
+  const request = indexedDB.open(dbName);
+  request.onupgradeneeded = () => request.result.createObjectStore(storeName);
+  const dbp = promisifyRequest(request);
+  return (txMode, callback) => dbp.then((db) => callback(db.transaction(storeName, txMode).objectStore(storeName)));
+}
+let defaultGetStoreFunc;
+function defaultGetStore() {
+  if (!defaultGetStoreFunc) {
+    defaultGetStoreFunc = createStore("keyval-store", "keyval");
+  }
+  return defaultGetStoreFunc;
+}
+function get(key, customStore = defaultGetStore()) {
+  return customStore("readonly", (store) => promisifyRequest(store.get(key)));
+}
+function set(key, value, customStore = defaultGetStore()) {
+  return customStore("readwrite", (store) => {
+    store.put(value, key);
+    return promisifyRequest(store.transaction);
+  });
+}
+function del(key, customStore = defaultGetStore()) {
+  return customStore("readwrite", (store) => {
+    store.delete(key);
+    return promisifyRequest(store.transaction);
+  });
+}
+const setupEventSource = async (config, subject, abort, consecutiveErrors = 0) => {
+  let messages = [];
+  let token = await config.options.accessTokenFactory();
+  if (consecutiveErrors > 5) return;
+  fetchEventSource(config.url, {
+    headers: {
+      Authorization: `Bearer ${token}`
+    },
+    openWhenHidden: true,
+    signal: abort.signal,
+    onmessage: async (eventSourceMessage) => {
+      const data = eventSourceMessage.data;
+      consecutiveErrors = 0;
+      try {
+        const parsed = JSON.parse(data);
+        if (parsed.subject === "keep-alive") return;
+        const eventReadState = await get("eventReadState") ?? {};
+        messages = [
+          {
+            ...parsed,
+            // @ts-expect-error nothing to see here
+            eventSourceId: eventSourceMessage.id,
+            read: eventReadState[parsed.id] ?? false
+          },
+          ...messages
+        ];
+        subject.next(messages);
+      } catch (ex) {
+        console.error("Failed to parse message: ", ex);
+      }
+    },
+    onerror: (err) => {
+      console.log("Closing event source due to error", err);
+      throw err;
+    }
+  }).then(() => {
+    config.options.accessTokenFactory().then((t) => token = t);
+    if (config.options.reconnect) {
+      setTimeout(
+        () => setupEventSource(config, subject, abort, consecutiveErrors + 1),
+        5e3
+      );
+    }
+  }).catch(() => {
+    config.options.accessTokenFactory().then((t) => token = t);
+    if (config.options.reconnect) {
+      setTimeout(
+        () => setupEventSource(config, subject, abort, consecutiveErrors + 1),
+        5e3
+      );
+    }
+  });
+  return {
+    abort,
+    subject
+  };
+};
+class Connection {
+  constructor() {
+    this.abort = new AbortController();
+    this.messageList = new BehaviorSubject([]);
+    this.setReadState = async (eventId, read) => {
+      const currentValues = await firstValueFrom(this.messageList);
+      const newValues = [...currentValues];
+      const currentEventIndex = newValues.findIndex((e) => e.id === eventId);
+      if (currentEventIndex >= 0) {
+        newValues[currentEventIndex] = {
+          ...newValues[currentEventIndex],
+          read
+        };
+      } else {
+        newValues.push({
+          ...newValues[currentEventIndex],
+          read
+        });
+      }
+      const eventReadState = await get("eventReadState") ?? {};
+      const currentState = newValues.reduce(
+        (a, b) => ({
+          ...a,
+          [b.id]: b.read
+        }),
+        {}
+      );
+      await set("eventReadState", {
+        ...eventReadState,
+        ...currentState
+      });
+      this.messageList.next(newValues);
+    };
+    this.setAllRead = async () => {
+      const currentValues = await firstValueFrom(this.messageList);
+      const newValues = [...currentValues].map((v) => ({ ...v, read: true }));
+      const eventReadState = await get("eventReadState") ?? {};
+      const currentState = newValues.reduce(
+        (a, b) => ({
+          ...a,
+          [b.id]: b.read
+        }),
+        {}
+      );
+      await set("eventReadState", {
+        ...eventReadState,
+        ...currentState
+      });
+      this.messageList.next(newValues);
+    };
+  }
+  get messageList$() {
+    return this.messageList.asObservable();
+  }
+}
+class SseModuleProvider {
+  constructor(config) {
+    __privateAdd(this, _config);
+    __privateAdd(this, _connections, {});
+    __privateSet(this, _config, config);
+  }
+  connect(name) {
+    if (!(name in __privateGet(this, _connections))) {
+      __privateGet(this, _connections)[name] = new Connection();
+      const options = __privateGet(this, _config).endpoints[name];
+      this.createConnection(name, options);
+    }
+    return __privateGet(this, _connections)[name];
+  }
+  createConnection(name, options) {
+    const config = __privateGet(this, _connections)[name];
+    setupEventSource(options, config.messageList, config.abort).catch(
+      (err) => console.error(`Failed to set up connection for ${name}:`, err)
+    );
+  }
+}
+_config = new WeakMap();
+_connections = new WeakMap();
+class SseModuleConfigBuilder extends ModuleConfigBuilder {
+  addEndpoint(name, config) {
+    this._config.addEndpoint(name, config);
+  }
+}
+class SseConfigurator {
+  constructor() {
+    __privateAdd(this, _builderCallbacks, []);
+    __privateAdd(this, _endpoints, {});
+  }
+  /**
+   * register SSE endpoint configuration.
+   */
+  addEndpoint(name, config) {
+    __privateGet(this, _endpoints)[name] = config;
+  }
+  /**
+   * add callback for building config on when configurator is creating config.
+   * {@link SseConfigurator.createConfig}
+   */
+  onCreateConfig(cb) {
+    __privateGet(this, _builderCallbacks).push(cb);
+  }
+  /**
+   * normally executed in `init` phase of module, which creates configuration to the module provider.
+   * cycles threw all registered configuration builders.
+   * await all registered hub configurations.
+   */
+  async createConfig(init) {
+    for (const cb of __privateGet(this, _builderCallbacks)) {
+      const builder = new SseModuleConfigBuilder(
+        init,
+        this
+      );
+      await Promise.resolve(cb(builder));
+    }
+    return { endpoints: __privateGet(this, _endpoints) };
+  }
+}
+_builderCallbacks = new WeakMap();
+_endpoints = new WeakMap();
+const moduleKey = "sse";
+const module = {
+  name: moduleKey,
+  configure: () => new SseConfigurator(),
+  initialize: async (init) => {
+    const config = await init.config.createConfig(init);
+    return new SseModuleProvider(config);
+  }
+};
+const configureFromFramework = async (args, builder) => {
+  const authProvider = await builder.requireInstance("auth");
+  const events = await builder.requireInstance("event");
+  const serviceDiscovery = await builder.requireInstance("serviceDiscovery");
+  events.dispatchEvent(
+    "onSseActivated",
+    new CustomEvent("onSseActivated", { detail: { name: args.name } })
+  );
+  const service = await serviceDiscovery.resolveService(args.name);
+  builder.addEndpoint(args.name, {
+    url: service.uri,
+    options: {
+      accessTokenFactory: async () => {
+        const token = await authProvider.acquireAccessToken({
+          scopes: service.defaultScopes
+        });
+        if (!token) {
+          throw Error("failed to acquire access token");
+        }
+        return token;
+      },
+      reconnect: true
+    }
+  });
+};
+function enableSse(configurator, name, optionsOrCallback) {
+  {
+    configurator.addConfig({
+      module,
+      configure: (sseConfigurator) => {
+        sseConfigurator.onCreateConfig(
+          (builder) => configureFromFramework({ name }, builder)
+        );
+      }
+    });
+  }
+}
+function Cache(maxSize) {
+  this._maxSize = maxSize;
+  this.clear();
+}
+Cache.prototype.clear = function() {
+  this._size = 0;
+  this._values = /* @__PURE__ */ Object.create(null);
+};
+Cache.prototype.get = function(key) {
+  return this._values[key];
+};
+Cache.prototype.set = function(key, value) {
+  this._size >= this._maxSize && this.clear();
+  if (!(key in this._values)) this._size++;
+  return this._values[key] = value;
+};
+var SPLIT_REGEX = /[^.^\]^[]+|(?=\[\]|\.\.)/g, DIGIT_REGEX = /^\d+$/, LEAD_DIGIT_REGEX = /^\d/, SPEC_CHAR_REGEX = /[~`!#$%\^&*+=\-\[\]\\';,/{}|\\":<>\?]/g, CLEAN_QUOTES_REGEX = /^\s*(['"]?)(.*?)(\1)\s*$/, MAX_CACHE_SIZE = 512;
+var pathCache = new Cache(MAX_CACHE_SIZE), setCache = new Cache(MAX_CACHE_SIZE), getCache = new Cache(MAX_CACHE_SIZE);
+var propertyExpr = {
+  Cache,
+  split,
+  normalizePath,
+  setter: function(path) {
+    var parts = normalizePath(path);
+    return setCache.get(path) || setCache.set(path, function setter(obj, value) {
+      var index = 0;
+      var len = parts.length;
+      var data = obj;
+      while (index < len - 1) {
+        var part = parts[index];
+        if (part === "__proto__" || part === "constructor" || part === "prototype") {
+          return obj;
+        }
+        data = data[parts[index++]];
+      }
+      data[parts[index]] = value;
+    });
+  },
+  getter: function(path, safe) {
+    var parts = normalizePath(path);
+    return getCache.get(path) || getCache.set(path, function getter(data) {
+      var index = 0, len = parts.length;
+      while (index < len) {
+        if (data != null || !safe) data = data[parts[index++]];
+        else return;
+      }
+      return data;
+    });
+  },
+  join: function(segments) {
+    return segments.reduce(function(path, part) {
+      return path + (isQuoted(part) || DIGIT_REGEX.test(part) ? "[" + part + "]" : (path ? "." : "") + part);
+    }, "");
+  },
+  forEach: function(path, cb, thisArg) {
+    forEach(Array.isArray(path) ? path : split(path), cb, thisArg);
+  }
+};
+function normalizePath(path) {
+  return pathCache.get(path) || pathCache.set(
+    path,
+    split(path).map(function(part) {
+      return part.replace(CLEAN_QUOTES_REGEX, "$2");
+    })
+  );
+}
+function split(path) {
+  return path.match(SPLIT_REGEX) || [""];
+}
+function forEach(parts, iter, thisArg) {
+  var len = parts.length, part, idx, isArray, isBracket;
+  for (idx = 0; idx < len; idx++) {
+    part = parts[idx];
+    if (part) {
+      if (shouldBeQuoted(part)) {
+        part = '"' + part + '"';
+      }
+      isBracket = isQuoted(part);
+      isArray = !isBracket && /^\d+$/.test(part);
+      iter.call(thisArg, part, isBracket, isArray, idx, parts);
+    }
+  }
+}
+function isQuoted(str) {
+  return typeof str === "string" && str && ["'", '"'].indexOf(str.charAt(0)) !== -1;
+}
+function hasLeadingNumber(part) {
+  return part.match(LEAD_DIGIT_REGEX) && !part.match(DIGIT_REGEX);
+}
+function hasSpecialChars(part) {
+  return SPEC_CHAR_REGEX.test(part);
+}
+function shouldBeQuoted(part) {
+  return !isQuoted(part) && (hasLeadingNumber(part) || hasSpecialChars(part));
+}
+const reWords = /[A-Z\xc0-\xd6\xd8-\xde]?[a-z\xdf-\xf6\xf8-\xff]+(?:['’](?:d|ll|m|re|s|t|ve))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde]|$)|(?:[A-Z\xc0-\xd6\xd8-\xde]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:D|LL|M|RE|S|T|VE))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde](?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])|$)|[A-Z\xc0-\xd6\xd8-\xde]?(?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:d|ll|m|re|s|t|ve))?|[A-Z\xc0-\xd6\xd8-\xde]+(?:['’](?:D|LL|M|RE|S|T|VE))?|\d*(?:1ST|2ND|3RD|(?![123])\dTH)(?=\b|[a-z_])|\d*(?:1st|2nd|3rd|(?![123])\dth)(?=\b|[A-Z_])|\d+|(?:[\u2700-\u27bf]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff]|\ud83c[\udffb-\udfff])?(?:\u200d(?:[^\ud800-\udfff]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff]|\ud83c[\udffb-\udfff])?)*/g;
+const words = (str) => str.match(reWords) || [];
+const upperFirst = (str) => str[0].toUpperCase() + str.slice(1);
+const join = (str, d) => words(str).join(d).toLowerCase();
+const camelCase = (str) => words(str).reduce(
+  (acc, next) => `${acc}${!acc ? next.toLowerCase() : next[0].toUpperCase() + next.slice(1).toLowerCase()}`,
+  ""
+);
+const pascalCase = (str) => upperFirst(camelCase(str));
+const snakeCase = (str) => join(str, "_");
+const kebabCase = (str) => join(str, "-");
+const sentenceCase = (str) => upperFirst(join(str, " "));
+const titleCase = (str) => words(str).map(upperFirst).join(" ");
+var tinyCase = {
+  words,
+  upperFirst,
+  camelCase,
+  pascalCase,
+  snakeCase,
+  kebabCase,
+  sentenceCase,
+  titleCase
+};
+var toposort$2 = { exports: {} };
+toposort$2.exports = function(edges) {
+  return toposort(uniqueNodes(edges), edges);
+};
+toposort$2.exports.array = toposort;
+function toposort(nodes, edges) {
+  var cursor = nodes.length, sorted = new Array(cursor), visited = {}, i = cursor, outgoingEdges = makeOutgoingEdges(edges), nodesHash = makeNodesHash(nodes);
+  edges.forEach(function(edge) {
+    if (!nodesHash.has(edge[0]) || !nodesHash.has(edge[1])) {
+      throw new Error("Unknown node. There is an unknown node in the supplied edges.");
+    }
+  });
+  while (i--) {
+    if (!visited[i]) visit(nodes[i], i, /* @__PURE__ */ new Set());
+  }
+  return sorted;
+  function visit(node, i2, predecessors) {
+    if (predecessors.has(node)) {
+      var nodeRep;
+      try {
+        nodeRep = ", node was:" + JSON.stringify(node);
+      } catch (e) {
+        nodeRep = "";
+      }
+      throw new Error("Cyclic dependency" + nodeRep);
+    }
+    if (!nodesHash.has(node)) {
+      throw new Error("Found unknown node. Make sure to provided all involved nodes. Unknown node: " + JSON.stringify(node));
+    }
+    if (visited[i2]) return;
+    visited[i2] = true;
+    var outgoing = outgoingEdges.get(node) || /* @__PURE__ */ new Set();
+    outgoing = Array.from(outgoing);
+    if (i2 = outgoing.length) {
+      predecessors.add(node);
+      do {
+        var child = outgoing[--i2];
+        visit(child, nodesHash.get(child), predecessors);
+      } while (i2);
+      predecessors.delete(node);
+    }
+    sorted[--cursor] = node;
+  }
+}
+function uniqueNodes(arr) {
+  var res = /* @__PURE__ */ new Set();
+  for (var i = 0, len = arr.length; i < len; i++) {
+    var edge = arr[i];
+    res.add(edge[0]);
+    res.add(edge[1]);
+  }
+  return Array.from(res);
+}
+function makeOutgoingEdges(arr) {
+  var edges = /* @__PURE__ */ new Map();
+  for (var i = 0, len = arr.length; i < len; i++) {
+    var edge = arr[i];
+    if (!edges.has(edge[0])) edges.set(edge[0], /* @__PURE__ */ new Set());
+    if (!edges.has(edge[1])) edges.set(edge[1], /* @__PURE__ */ new Set());
+    edges.get(edge[0]).add(edge[1]);
+  }
+  return edges;
+}
+function makeNodesHash(arr) {
+  var res = /* @__PURE__ */ new Map();
+  for (var i = 0, len = arr.length; i < len; i++) {
+    res.set(arr[i], i);
+  }
+  return res;
+}
+var toposortExports = toposort$2.exports;
+const toposort$1 = /* @__PURE__ */ getDefaultExportFromCjs(toposortExports);
+const toString = Object.prototype.toString;
+const errorToString = Error.prototype.toString;
+const regExpToString = RegExp.prototype.toString;
+const symbolToString = typeof Symbol !== "undefined" ? Symbol.prototype.toString : () => "";
+const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+function printNumber(val) {
+  if (val != +val) return "NaN";
+  const isNegativeZero = val === 0 && 1 / val < 0;
+  return isNegativeZero ? "-0" : "" + val;
+}
+function printSimpleValue(val, quoteStrings = false) {
+  if (val == null || val === true || val === false) return "" + val;
+  const typeOf = typeof val;
+  if (typeOf === "number") return printNumber(val);
+  if (typeOf === "string") return quoteStrings ? `"${val}"` : val;
+  if (typeOf === "function") return "[Function " + (val.name || "anonymous") + "]";
+  if (typeOf === "symbol") return symbolToString.call(val).replace(SYMBOL_REGEXP, "Symbol($1)");
+  const tag = toString.call(val).slice(8, -1);
+  if (tag === "Date") return isNaN(val.getTime()) ? "" + val : val.toISOString(val);
+  if (tag === "Error" || val instanceof Error) return "[" + errorToString.call(val) + "]";
+  if (tag === "RegExp") return regExpToString.call(val);
+  return null;
+}
+function printValue(value, quoteStrings) {
+  let result = printSimpleValue(value, quoteStrings);
+  if (result !== null) return result;
+  return JSON.stringify(value, function(key, value2) {
+    let result2 = printSimpleValue(this[key], quoteStrings);
+    if (result2 !== null) return result2;
+    return value2;
+  }, 2);
+}
+function toArray(value) {
+  return value == null ? [] : [].concat(value);
+}
+let _Symbol$toStringTag;
+let strReg = /\$\{\s*(\w+)\s*\}/g;
+_Symbol$toStringTag = Symbol.toStringTag;
+class ValidationError extends Error {
+  static formatError(message, params) {
+    const path = params.label || params.path || "this";
+    if (path !== params.path) params = Object.assign({}, params, {
+      path
+    });
+    if (typeof message === "string") return message.replace(strReg, (_, key) => printValue(params[key]));
+    if (typeof message === "function") return message(params);
+    return message;
+  }
+  static isError(err) {
+    return err && err.name === "ValidationError";
+  }
+  constructor(errorOrErrors, value, field, type, disableStack) {
+    super();
+    this.value = void 0;
+    this.path = void 0;
+    this.type = void 0;
+    this.errors = void 0;
+    this.params = void 0;
+    this.inner = void 0;
+    this[_Symbol$toStringTag] = "Error";
+    this.name = "ValidationError";
+    this.value = value;
+    this.path = field;
+    this.type = type;
+    this.errors = [];
+    this.inner = [];
+    toArray(errorOrErrors).forEach((err) => {
+      if (ValidationError.isError(err)) {
+        this.errors.push(...err.errors);
+        const innerErrors = err.inner.length ? err.inner : [err];
+        this.inner.push(...innerErrors);
+      } else {
+        this.errors.push(err);
+      }
+    });
+    this.message = this.errors.length > 1 ? `${this.errors.length} errors occurred` : this.errors[0];
+    if (!disableStack && Error.captureStackTrace) Error.captureStackTrace(this, ValidationError);
+  }
+}
+let mixed = {
+  default: "${path} is invalid",
+  required: "${path} is a required field",
+  defined: "${path} must be defined",
+  notNull: "${path} cannot be null",
+  oneOf: "${path} must be one of the following values: ${values}",
+  notOneOf: "${path} must not be one of the following values: ${values}",
+  notType: ({
+    path,
+    type,
+    value,
+    originalValue
+  }) => {
+    const castMsg = originalValue != null && originalValue !== value ? ` (cast from the value \`${printValue(originalValue, true)}\`).` : ".";
+    return type !== "mixed" ? `${path} must be a \`${type}\` type, but the final value was: \`${printValue(value, true)}\`` + castMsg : `${path} must match the configured type. The validated value was: \`${printValue(value, true)}\`` + castMsg;
+  }
+};
+let string = {
+  length: "${path} must be exactly ${length} characters",
+  min: "${path} must be at least ${min} characters",
+  max: "${path} must be at most ${max} characters",
+  matches: '${path} must match the following: "${regex}"',
+  email: "${path} must be a valid email",
+  url: "${path} must be a valid URL",
+  uuid: "${path} must be a valid UUID",
+  trim: "${path} must be a trimmed string",
+  lowercase: "${path} must be a lowercase string",
+  uppercase: "${path} must be a upper case string"
+};
+let number = {
+  min: "${path} must be greater than or equal to ${min}",
+  max: "${path} must be less than or equal to ${max}",
+  lessThan: "${path} must be less than ${less}",
+  moreThan: "${path} must be greater than ${more}",
+  positive: "${path} must be a positive number",
+  negative: "${path} must be a negative number",
+  integer: "${path} must be an integer"
+};
+let date = {
+  min: "${path} field must be later than ${min}",
+  max: "${path} field must be at earlier than ${max}"
+};
+let boolean = {
+  isValue: "${path} field must be ${value}"
+};
+let object = {
+  noUnknown: "${path} field has unspecified keys: ${unknown}"
+};
+let array = {
+  min: "${path} field must have at least ${min} items",
+  max: "${path} field must have less than or equal to ${max} items",
+  length: "${path} must have ${length} items"
+};
+let tuple = {
+  notType: (params) => {
+    const {
+      path,
+      value,
+      spec
+    } = params;
+    const typeLen = spec.types.length;
+    if (Array.isArray(value)) {
+      if (value.length < typeLen) return `${path} tuple value has too few items, expected a length of ${typeLen} but got ${value.length} for value: \`${printValue(value, true)}\``;
+      if (value.length > typeLen) return `${path} tuple value has too many items, expected a length of ${typeLen} but got ${value.length} for value: \`${printValue(value, true)}\``;
+    }
+    return ValidationError.formatError(mixed.notType, params);
+  }
+};
+Object.assign(/* @__PURE__ */ Object.create(null), {
+  mixed,
+  string,
+  number,
+  date,
+  object,
+  array,
+  boolean,
+  tuple
+});
+const isSchema = (obj) => obj && obj.__isYupSchema__;
+class Condition {
+  static fromOptions(refs, config) {
+    if (!config.then && !config.otherwise) throw new TypeError("either `then:` or `otherwise:` is required for `when()` conditions");
+    let {
+      is,
+      then,
+      otherwise
+    } = config;
+    let check = typeof is === "function" ? is : (...values) => values.every((value) => value === is);
+    return new Condition(refs, (values, schema) => {
+      var _branch;
+      let branch = check(...values) ? then : otherwise;
+      return (_branch = branch == null ? void 0 : branch(schema)) != null ? _branch : schema;
+    });
+  }
+  constructor(refs, builder) {
+    this.fn = void 0;
+    this.refs = refs;
+    this.refs = refs;
+    this.fn = builder;
+  }
+  resolve(base, options) {
+    let values = this.refs.map((ref) => (
+      // TODO: ? operator here?
+      ref.getValue(options == null ? void 0 : options.value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context)
+    ));
+    let schema = this.fn(values, base, options);
+    if (schema === void 0 || // @ts-ignore this can be base
+    schema === base) {
+      return base;
+    }
+    if (!isSchema(schema)) throw new TypeError("conditions must return a schema object");
+    return schema.resolve(options);
+  }
+}
+const prefixes = {
+  context: "$",
+  value: "."
+};
+class Reference {
+  constructor(key, options = {}) {
+    this.key = void 0;
+    this.isContext = void 0;
+    this.isValue = void 0;
+    this.isSibling = void 0;
+    this.path = void 0;
+    this.getter = void 0;
+    this.map = void 0;
+    if (typeof key !== "string") throw new TypeError("ref must be a string, got: " + key);
+    this.key = key.trim();
+    if (key === "") throw new TypeError("ref must be a non-empty string");
+    this.isContext = this.key[0] === prefixes.context;
+    this.isValue = this.key[0] === prefixes.value;
+    this.isSibling = !this.isContext && !this.isValue;
+    let prefix = this.isContext ? prefixes.context : this.isValue ? prefixes.value : "";
+    this.path = this.key.slice(prefix.length);
+    this.getter = this.path && propertyExpr.getter(this.path, true);
+    this.map = options.map;
+  }
+  getValue(value, parent, context) {
+    let result = this.isContext ? context : this.isValue ? value : parent;
+    if (this.getter) result = this.getter(result || {});
+    if (this.map) result = this.map(result);
+    return result;
+  }
+  /**
+   *
+   * @param {*} value
+   * @param {Object} options
+   * @param {Object=} options.context
+   * @param {Object=} options.parent
+   */
+  cast(value, options) {
+    return this.getValue(value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context);
+  }
+  resolve() {
+    return this;
+  }
+  describe() {
+    return {
+      type: "ref",
+      key: this.key
+    };
+  }
+  toString() {
+    return `Ref(${this.key})`;
+  }
+  static isRef(value) {
+    return value && value.__isYupRef;
+  }
+}
+Reference.prototype.__isYupRef = true;
+const isAbsent = (value) => value == null;
+function createValidation(config) {
+  function validate({
+    value,
+    path = "",
+    options,
+    originalValue,
+    schema
+  }, panic, next) {
+    const {
+      name,
+      test,
+      params,
+      message,
+      skipAbsent
+    } = config;
+    let {
+      parent,
+      context,
+      abortEarly = schema.spec.abortEarly,
+      disableStackTrace = schema.spec.disableStackTrace
+    } = options;
+    function resolve(item) {
+      return Reference.isRef(item) ? item.getValue(value, parent, context) : item;
+    }
+    function createError(overrides = {}) {
+      var _overrides$disableSta;
+      const nextParams = Object.assign({
+        value,
+        originalValue,
+        label: schema.spec.label,
+        path: overrides.path || path,
+        spec: schema.spec
+      }, params, overrides.params);
+      for (const key of Object.keys(nextParams)) nextParams[key] = resolve(nextParams[key]);
+      const error = new ValidationError(ValidationError.formatError(overrides.message || message, nextParams), value, nextParams.path, overrides.type || name, (_overrides$disableSta = overrides.disableStackTrace) != null ? _overrides$disableSta : disableStackTrace);
+      error.params = nextParams;
+      return error;
+    }
+    const invalid = abortEarly ? panic : next;
+    let ctx = {
+      path,
+      parent,
+      type: name,
+      from: options.from,
+      createError,
+      resolve,
+      options,
+      originalValue,
+      schema
+    };
+    const handleResult = (validOrError) => {
+      if (ValidationError.isError(validOrError)) invalid(validOrError);
+      else if (!validOrError) invalid(createError());
+      else next(null);
+    };
+    const handleError2 = (err) => {
+      if (ValidationError.isError(err)) invalid(err);
+      else panic(err);
+    };
+    const shouldSkip = skipAbsent && isAbsent(value);
+    if (shouldSkip) {
+      return handleResult(true);
+    }
+    let result;
+    try {
+      var _result;
+      result = test.call(ctx, value, ctx);
+      if (typeof ((_result = result) == null ? void 0 : _result.then) === "function") {
+        if (options.sync) {
+          throw new Error(`Validation test of type: "${ctx.type}" returned a Promise during a synchronous validate. This test will finish after the validate call has returned`);
+        }
+        return Promise.resolve(result).then(handleResult, handleError2);
+      }
+    } catch (err) {
+      handleError2(err);
+      return;
+    }
+    handleResult(result);
+  }
+  validate.OPTIONS = config;
+  return validate;
+}
+function getIn(schema, path, value, context = value) {
+  let parent, lastPart, lastPartDebug;
+  if (!path) return {
+    parent,
+    parentPath: path,
+    schema
+  };
+  propertyExpr.forEach(path, (_part, isBracket, isArray) => {
+    let part = isBracket ? _part.slice(1, _part.length - 1) : _part;
+    schema = schema.resolve({
+      context,
+      parent,
+      value
+    });
+    let isTuple = schema.type === "tuple";
+    let idx = isArray ? parseInt(part, 10) : 0;
+    if (schema.innerType || isTuple) {
+      if (isTuple && !isArray) throw new Error(`Yup.reach cannot implicitly index into a tuple type. the path part "${lastPartDebug}" must contain an index to the tuple element, e.g. "${lastPartDebug}[0]"`);
+      if (value && idx >= value.length) {
+        throw new Error(`Yup.reach cannot resolve an array item at index: ${_part}, in the path: ${path}. because there is no value at that index. `);
+      }
+      parent = value;
+      value = value && value[idx];
+      schema = isTuple ? schema.spec.types[idx] : schema.innerType;
+    }
+    if (!isArray) {
+      if (!schema.fields || !schema.fields[part]) throw new Error(`The schema does not contain the path: ${path}. (failed at: ${lastPartDebug} which is a type: "${schema.type}")`);
+      parent = value;
+      value = value && value[part];
+      schema = schema.fields[part];
+    }
+    lastPart = part;
+    lastPartDebug = isBracket ? "[" + _part + "]" : "." + _part;
+  });
+  return {
+    schema,
+    parent,
+    parentPath: lastPart
+  };
+}
+class ReferenceSet extends Set {
+  describe() {
+    const description = [];
+    for (const item of this.values()) {
+      description.push(Reference.isRef(item) ? item.describe() : item);
+    }
+    return description;
+  }
+  resolveAll(resolve) {
+    let result = [];
+    for (const item of this.values()) {
+      result.push(resolve(item));
+    }
+    return result;
+  }
+  clone() {
+    return new ReferenceSet(this.values());
+  }
+  merge(newItems, removeItems) {
+    const next = this.clone();
+    newItems.forEach((value) => next.add(value));
+    removeItems.forEach((value) => next.delete(value));
+    return next;
+  }
+}
+function clone(src, seen = /* @__PURE__ */ new Map()) {
+  if (isSchema(src) || !src || typeof src !== "object") return src;
+  if (seen.has(src)) return seen.get(src);
+  let copy;
+  if (src instanceof Date) {
+    copy = new Date(src.getTime());
+    seen.set(src, copy);
+  } else if (src instanceof RegExp) {
+    copy = new RegExp(src);
+    seen.set(src, copy);
+  } else if (Array.isArray(src)) {
+    copy = new Array(src.length);
+    seen.set(src, copy);
+    for (let i = 0; i < src.length; i++) copy[i] = clone(src[i], seen);
+  } else if (src instanceof Map) {
+    copy = /* @__PURE__ */ new Map();
+    seen.set(src, copy);
+    for (const [k, v] of src.entries()) copy.set(k, clone(v, seen));
+  } else if (src instanceof Set) {
+    copy = /* @__PURE__ */ new Set();
+    seen.set(src, copy);
+    for (const v of src) copy.add(clone(v, seen));
+  } else if (src instanceof Object) {
+    copy = {};
+    seen.set(src, copy);
+    for (const [k, v] of Object.entries(src)) copy[k] = clone(v, seen);
+  } else {
+    throw Error(`Unable to clone ${src}`);
+  }
+  return copy;
+}
+class Schema {
+  constructor(options) {
+    this.type = void 0;
+    this.deps = [];
+    this.tests = void 0;
+    this.transforms = void 0;
+    this.conditions = [];
+    this._mutate = void 0;
+    this.internalTests = {};
+    this._whitelist = new ReferenceSet();
+    this._blacklist = new ReferenceSet();
+    this.exclusiveTests = /* @__PURE__ */ Object.create(null);
+    this._typeCheck = void 0;
+    this.spec = void 0;
+    this.tests = [];
+    this.transforms = [];
+    this.withMutation(() => {
+      this.typeError(mixed.notType);
+    });
+    this.type = options.type;
+    this._typeCheck = options.check;
+    this.spec = Object.assign({
+      strip: false,
+      strict: false,
+      abortEarly: true,
+      recursive: true,
+      disableStackTrace: false,
+      nullable: false,
+      optional: true,
+      coerce: true
+    }, options == null ? void 0 : options.spec);
+    this.withMutation((s) => {
+      s.nonNullable();
+    });
+  }
+  // TODO: remove
+  get _type() {
+    return this.type;
+  }
+  clone(spec) {
+    if (this._mutate) {
+      if (spec) Object.assign(this.spec, spec);
+      return this;
+    }
+    const next = Object.create(Object.getPrototypeOf(this));
+    next.type = this.type;
+    next._typeCheck = this._typeCheck;
+    next._whitelist = this._whitelist.clone();
+    next._blacklist = this._blacklist.clone();
+    next.internalTests = Object.assign({}, this.internalTests);
+    next.exclusiveTests = Object.assign({}, this.exclusiveTests);
+    next.deps = [...this.deps];
+    next.conditions = [...this.conditions];
+    next.tests = [...this.tests];
+    next.transforms = [...this.transforms];
+    next.spec = clone(Object.assign({}, this.spec, spec));
+    return next;
+  }
+  label(label) {
+    let next = this.clone();
+    next.spec.label = label;
+    return next;
+  }
+  meta(...args) {
+    if (args.length === 0) return this.spec.meta;
+    let next = this.clone();
+    next.spec.meta = Object.assign(next.spec.meta || {}, args[0]);
+    return next;
+  }
+  withMutation(fn) {
+    let before = this._mutate;
+    this._mutate = true;
+    let result = fn(this);
+    this._mutate = before;
+    return result;
+  }
+  concat(schema) {
+    if (!schema || schema === this) return this;
+    if (schema.type !== this.type && this.type !== "mixed") throw new TypeError(`You cannot \`concat()\` schema's of different types: ${this.type} and ${schema.type}`);
+    let base = this;
+    let combined = schema.clone();
+    const mergedSpec = Object.assign({}, base.spec, combined.spec);
+    combined.spec = mergedSpec;
+    combined.internalTests = Object.assign({}, base.internalTests, combined.internalTests);
+    combined._whitelist = base._whitelist.merge(schema._whitelist, schema._blacklist);
+    combined._blacklist = base._blacklist.merge(schema._blacklist, schema._whitelist);
+    combined.tests = base.tests;
+    combined.exclusiveTests = base.exclusiveTests;
+    combined.withMutation((next) => {
+      schema.tests.forEach((fn) => {
+        next.test(fn.OPTIONS);
+      });
+    });
+    combined.transforms = [...base.transforms, ...combined.transforms];
+    return combined;
+  }
+  isType(v) {
+    if (v == null) {
+      if (this.spec.nullable && v === null) return true;
+      if (this.spec.optional && v === void 0) return true;
+      return false;
+    }
+    return this._typeCheck(v);
+  }
+  resolve(options) {
+    let schema = this;
+    if (schema.conditions.length) {
+      let conditions = schema.conditions;
+      schema = schema.clone();
+      schema.conditions = [];
+      schema = conditions.reduce((prevSchema, condition) => condition.resolve(prevSchema, options), schema);
+      schema = schema.resolve(options);
+    }
+    return schema;
+  }
+  resolveOptions(options) {
+    var _options$strict, _options$abortEarly, _options$recursive, _options$disableStack;
+    return Object.assign({}, options, {
+      from: options.from || [],
+      strict: (_options$strict = options.strict) != null ? _options$strict : this.spec.strict,
+      abortEarly: (_options$abortEarly = options.abortEarly) != null ? _options$abortEarly : this.spec.abortEarly,
+      recursive: (_options$recursive = options.recursive) != null ? _options$recursive : this.spec.recursive,
+      disableStackTrace: (_options$disableStack = options.disableStackTrace) != null ? _options$disableStack : this.spec.disableStackTrace
+    });
+  }
+  /**
+   * Run the configured transform pipeline over an input value.
+   */
+  cast(value, options = {}) {
+    let resolvedSchema = this.resolve(Object.assign({
+      value
+    }, options));
+    let allowOptionality = options.assert === "ignore-optionality";
+    let result = resolvedSchema._cast(value, options);
+    if (options.assert !== false && !resolvedSchema.isType(result)) {
+      if (allowOptionality && isAbsent(result)) {
+        return result;
+      }
+      let formattedValue = printValue(value);
+      let formattedResult = printValue(result);
+      throw new TypeError(`The value of ${options.path || "field"} could not be cast to a value that satisfies the schema type: "${resolvedSchema.type}". 
+
+attempted value: ${formattedValue} 
+` + (formattedResult !== formattedValue ? `result of cast: ${formattedResult}` : ""));
+    }
+    return result;
+  }
+  _cast(rawValue, options) {
+    let value = rawValue === void 0 ? rawValue : this.transforms.reduce((prevValue, fn) => fn.call(this, prevValue, rawValue, this), rawValue);
+    if (value === void 0) {
+      value = this.getDefault(options);
+    }
+    return value;
+  }
+  _validate(_value, options = {}, panic, next) {
+    let {
+      path,
+      originalValue = _value,
+      strict = this.spec.strict
+    } = options;
+    let value = _value;
+    if (!strict) {
+      value = this._cast(value, Object.assign({
+        assert: false
+      }, options));
+    }
+    let initialTests = [];
+    for (let test of Object.values(this.internalTests)) {
+      if (test) initialTests.push(test);
+    }
+    this.runTests({
+      path,
+      value,
+      originalValue,
+      options,
+      tests: initialTests
+    }, panic, (initialErrors) => {
+      if (initialErrors.length) {
+        return next(initialErrors, value);
+      }
+      this.runTests({
+        path,
+        value,
+        originalValue,
+        options,
+        tests: this.tests
+      }, panic, next);
+    });
+  }
+  /**
+   * Executes a set of validations, either schema, produced Tests or a nested
+   * schema validate result.
+   */
+  runTests(runOptions, panic, next) {
+    let fired = false;
+    let {
+      tests,
+      value,
+      originalValue,
+      path,
+      options
+    } = runOptions;
+    let panicOnce = (arg) => {
+      if (fired) return;
+      fired = true;
+      panic(arg, value);
+    };
+    let nextOnce = (arg) => {
+      if (fired) return;
+      fired = true;
+      next(arg, value);
+    };
+    let count = tests.length;
+    let nestedErrors = [];
+    if (!count) return nextOnce([]);
+    let args = {
+      value,
+      originalValue,
+      path,
+      options,
+      schema: this
+    };
+    for (let i = 0; i < tests.length; i++) {
+      const test = tests[i];
+      test(args, panicOnce, function finishTestRun(err) {
+        if (err) {
+          Array.isArray(err) ? nestedErrors.push(...err) : nestedErrors.push(err);
+        }
+        if (--count <= 0) {
+          nextOnce(nestedErrors);
+        }
+      });
+    }
+  }
+  asNestedTest({
+    key,
+    index,
+    parent,
+    parentPath,
+    originalParent,
+    options
+  }) {
+    const k = key != null ? key : index;
+    if (k == null) {
+      throw TypeError("Must include `key` or `index` for nested validations");
+    }
+    const isIndex = typeof k === "number";
+    let value = parent[k];
+    const testOptions = Object.assign({}, options, {
+      // Nested validations fields are always strict:
+      //    1. parent isn't strict so the casting will also have cast inner values
+      //    2. parent is strict in which case the nested values weren't cast either
+      strict: true,
+      parent,
+      value,
+      originalValue: originalParent[k],
+      // FIXME: tests depend on `index` being passed around deeply,
+      //   we should not let the options.key/index bleed through
+      key: void 0,
+      // index: undefined,
+      [isIndex ? "index" : "key"]: k,
+      path: isIndex || k.includes(".") ? `${parentPath || ""}[${value ? k : `"${k}"`}]` : (parentPath ? `${parentPath}.` : "") + key
+    });
+    return (_, panic, next) => this.resolve(testOptions)._validate(value, testOptions, panic, next);
+  }
+  validate(value, options) {
+    var _options$disableStack2;
+    let schema = this.resolve(Object.assign({}, options, {
+      value
+    }));
+    let disableStackTrace = (_options$disableStack2 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack2 : schema.spec.disableStackTrace;
+    return new Promise((resolve, reject) => schema._validate(value, options, (error, parsed) => {
+      if (ValidationError.isError(error)) error.value = parsed;
+      reject(error);
+    }, (errors, validated) => {
+      if (errors.length) reject(new ValidationError(errors, validated, void 0, void 0, disableStackTrace));
+      else resolve(validated);
+    }));
+  }
+  validateSync(value, options) {
+    var _options$disableStack3;
+    let schema = this.resolve(Object.assign({}, options, {
+      value
+    }));
+    let result;
+    let disableStackTrace = (_options$disableStack3 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack3 : schema.spec.disableStackTrace;
+    schema._validate(value, Object.assign({}, options, {
+      sync: true
+    }), (error, parsed) => {
+      if (ValidationError.isError(error)) error.value = parsed;
+      throw error;
+    }, (errors, validated) => {
+      if (errors.length) throw new ValidationError(errors, value, void 0, void 0, disableStackTrace);
+      result = validated;
+    });
+    return result;
+  }
+  isValid(value, options) {
+    return this.validate(value, options).then(() => true, (err) => {
+      if (ValidationError.isError(err)) return false;
+      throw err;
+    });
+  }
+  isValidSync(value, options) {
+    try {
+      this.validateSync(value, options);
+      return true;
+    } catch (err) {
+      if (ValidationError.isError(err)) return false;
+      throw err;
+    }
+  }
+  _getDefault(options) {
+    let defaultValue = this.spec.default;
+    if (defaultValue == null) {
+      return defaultValue;
+    }
+    return typeof defaultValue === "function" ? defaultValue.call(this, options) : clone(defaultValue);
+  }
+  getDefault(options) {
+    let schema = this.resolve(options || {});
+    return schema._getDefault(options);
+  }
+  default(def) {
+    if (arguments.length === 0) {
+      return this._getDefault();
+    }
+    let next = this.clone({
+      default: def
+    });
+    return next;
+  }
+  strict(isStrict = true) {
+    return this.clone({
+      strict: isStrict
+    });
+  }
+  nullability(nullable, message) {
+    const next = this.clone({
+      nullable
+    });
+    next.internalTests.nullable = createValidation({
+      message,
+      name: "nullable",
+      test(value) {
+        return value === null ? this.schema.spec.nullable : true;
+      }
+    });
+    return next;
+  }
+  optionality(optional, message) {
+    const next = this.clone({
+      optional
+    });
+    next.internalTests.optionality = createValidation({
+      message,
+      name: "optionality",
+      test(value) {
+        return value === void 0 ? this.schema.spec.optional : true;
+      }
+    });
+    return next;
+  }
+  optional() {
+    return this.optionality(true);
+  }
+  defined(message = mixed.defined) {
+    return this.optionality(false, message);
+  }
+  nullable() {
+    return this.nullability(true);
+  }
+  nonNullable(message = mixed.notNull) {
+    return this.nullability(false, message);
+  }
+  required(message = mixed.required) {
+    return this.clone().withMutation((next) => next.nonNullable(message).defined(message));
+  }
+  notRequired() {
+    return this.clone().withMutation((next) => next.nullable().optional());
+  }
+  transform(fn) {
+    let next = this.clone();
+    next.transforms.push(fn);
+    return next;
+  }
+  /**
+   * Adds a test function to the schema's queue of tests.
+   * tests can be exclusive or non-exclusive.
+   *
+   * - exclusive tests, will replace any existing tests of the same name.
+   * - non-exclusive: can be stacked
+   *
+   * If a non-exclusive test is added to a schema with an exclusive test of the same name
+   * the exclusive test is removed and further tests of the same name will be stacked.
+   *
+   * If an exclusive test is added to a schema with non-exclusive tests of the same name
+   * the previous tests are removed and further tests of the same name will replace each other.
+   */
+  test(...args) {
+    let opts;
+    if (args.length === 1) {
+      if (typeof args[0] === "function") {
+        opts = {
+          test: args[0]
+        };
+      } else {
+        opts = args[0];
+      }
+    } else if (args.length === 2) {
+      opts = {
+        name: args[0],
+        test: args[1]
+      };
+    } else {
+      opts = {
+        name: args[0],
+        message: args[1],
+        test: args[2]
+      };
+    }
+    if (opts.message === void 0) opts.message = mixed.default;
+    if (typeof opts.test !== "function") throw new TypeError("`test` is a required parameters");
+    let next = this.clone();
+    let validate = createValidation(opts);
+    let isExclusive = opts.exclusive || opts.name && next.exclusiveTests[opts.name] === true;
+    if (opts.exclusive) {
+      if (!opts.name) throw new TypeError("Exclusive tests must provide a unique `name` identifying the test");
+    }
+    if (opts.name) next.exclusiveTests[opts.name] = !!opts.exclusive;
+    next.tests = next.tests.filter((fn) => {
+      if (fn.OPTIONS.name === opts.name) {
+        if (isExclusive) return false;
+        if (fn.OPTIONS.test === validate.OPTIONS.test) return false;
+      }
+      return true;
+    });
+    next.tests.push(validate);
+    return next;
+  }
+  when(keys, options) {
+    if (!Array.isArray(keys) && typeof keys !== "string") {
+      options = keys;
+      keys = ".";
+    }
+    let next = this.clone();
+    let deps = toArray(keys).map((key) => new Reference(key));
+    deps.forEach((dep) => {
+      if (dep.isSibling) next.deps.push(dep.key);
+    });
+    next.conditions.push(typeof options === "function" ? new Condition(deps, options) : Condition.fromOptions(deps, options));
+    return next;
+  }
+  typeError(message) {
+    let next = this.clone();
+    next.internalTests.typeError = createValidation({
+      message,
+      name: "typeError",
+      skipAbsent: true,
+      test(value) {
+        if (!this.schema._typeCheck(value)) return this.createError({
+          params: {
+            type: this.schema.type
+          }
+        });
+        return true;
+      }
+    });
+    return next;
+  }
+  oneOf(enums, message = mixed.oneOf) {
+    let next = this.clone();
+    enums.forEach((val) => {
+      next._whitelist.add(val);
+      next._blacklist.delete(val);
+    });
+    next.internalTests.whiteList = createValidation({
+      message,
+      name: "oneOf",
+      skipAbsent: true,
+      test(value) {
+        let valids = this.schema._whitelist;
+        let resolved = valids.resolveAll(this.resolve);
+        return resolved.includes(value) ? true : this.createError({
+          params: {
+            values: Array.from(valids).join(", "),
+            resolved
+          }
+        });
+      }
+    });
+    return next;
+  }
+  notOneOf(enums, message = mixed.notOneOf) {
+    let next = this.clone();
+    enums.forEach((val) => {
+      next._blacklist.add(val);
+      next._whitelist.delete(val);
+    });
+    next.internalTests.blacklist = createValidation({
+      message,
+      name: "notOneOf",
+      test(value) {
+        let invalids = this.schema._blacklist;
+        let resolved = invalids.resolveAll(this.resolve);
+        if (resolved.includes(value)) return this.createError({
+          params: {
+            values: Array.from(invalids).join(", "),
+            resolved
+          }
+        });
+        return true;
+      }
+    });
+    return next;
+  }
+  strip(strip = true) {
+    let next = this.clone();
+    next.spec.strip = strip;
+    return next;
+  }
+  /**
+   * Return a serialized description of the schema including validations, flags, types etc.
+   *
+   * @param options Provide any needed context for resolving runtime schema alterations (lazy, when conditions, etc).
+   */
+  describe(options) {
+    const next = (options ? this.resolve(options) : this).clone();
+    const {
+      label,
+      meta,
+      optional,
+      nullable
+    } = next.spec;
+    const description = {
+      meta,
+      label,
+      optional,
+      nullable,
+      default: next.getDefault(options),
+      type: next.type,
+      oneOf: next._whitelist.describe(),
+      notOneOf: next._blacklist.describe(),
+      tests: next.tests.map((fn) => ({
+        name: fn.OPTIONS.name,
+        params: fn.OPTIONS.params
+      })).filter((n, idx, list) => list.findIndex((c) => c.name === n.name) === idx)
+    };
+    return description;
+  }
+}
+Schema.prototype.__isYupSchema__ = true;
+for (const method of ["validate", "validateSync"]) Schema.prototype[`${method}At`] = function(path, value, options = {}) {
+  const {
+    parent,
+    parentPath,
+    schema
+  } = getIn(this, path, value, options.context);
+  return schema[method](parent && parent[parentPath], Object.assign({}, options, {
+    parent,
+    path
+  }));
+};
+for (const alias of ["equals", "is"]) Schema.prototype[alias] = Schema.prototype.oneOf;
+for (const alias of ["not", "nope"]) Schema.prototype[alias] = Schema.prototype.notOneOf;
+function create$7() {
+  return new BooleanSchema();
+}
+class BooleanSchema extends Schema {
+  constructor() {
+    super({
+      type: "boolean",
+      check(v) {
+        if (v instanceof Boolean) v = v.valueOf();
+        return typeof v === "boolean";
+      }
+    });
+    this.withMutation(() => {
+      this.transform((value, _raw, ctx) => {
+        if (ctx.spec.coerce && !ctx.isType(value)) {
+          if (/^(true|1)$/i.test(String(value))) return true;
+          if (/^(false|0)$/i.test(String(value))) return false;
+        }
+        return value;
+      });
+    });
+  }
+  isTrue(message = boolean.isValue) {
+    return this.test({
+      message,
+      name: "is-value",
+      exclusive: true,
+      params: {
+        value: "true"
+      },
+      test(value) {
+        return isAbsent(value) || value === true;
+      }
+    });
+  }
+  isFalse(message = boolean.isValue) {
+    return this.test({
+      message,
+      name: "is-value",
+      exclusive: true,
+      params: {
+        value: "false"
+      },
+      test(value) {
+        return isAbsent(value) || value === false;
+      }
+    });
+  }
+  default(def) {
+    return super.default(def);
+  }
+  defined(msg) {
+    return super.defined(msg);
+  }
+  optional() {
+    return super.optional();
+  }
+  required(msg) {
+    return super.required(msg);
+  }
+  notRequired() {
+    return super.notRequired();
+  }
+  nullable() {
+    return super.nullable();
+  }
+  nonNullable(msg) {
+    return super.nonNullable(msg);
+  }
+  strip(v) {
+    return super.strip(v);
+  }
+}
+create$7.prototype = BooleanSchema.prototype;
+let rEmail = (
+  // eslint-disable-next-line
+  /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
+);
+let rUrl = (
+  // eslint-disable-next-line
+  /^((https?|ftp):)?\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i
+);
+let rUUID = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+let isTrimmed = (value) => isAbsent(value) || value === value.trim();
+let objStringTag = {}.toString();
+function create$6() {
+  return new StringSchema();
+}
+class StringSchema extends Schema {
+  constructor() {
+    super({
+      type: "string",
+      check(value) {
+        if (value instanceof String) value = value.valueOf();
+        return typeof value === "string";
+      }
+    });
+    this.withMutation(() => {
+      this.transform((value, _raw, ctx) => {
+        if (!ctx.spec.coerce || ctx.isType(value)) return value;
+        if (Array.isArray(value)) return value;
+        const strValue = value != null && value.toString ? value.toString() : value;
+        if (strValue === objStringTag) return value;
+        return strValue;
+      });
+    });
+  }
+  required(message) {
+    return super.required(message).withMutation((schema) => schema.test({
+      message: message || mixed.required,
+      name: "required",
+      skipAbsent: true,
+      test: (value) => !!value.length
+    }));
+  }
+  notRequired() {
+    return super.notRequired().withMutation((schema) => {
+      schema.tests = schema.tests.filter((t) => t.OPTIONS.name !== "required");
+      return schema;
+    });
+  }
+  length(length, message = string.length) {
+    return this.test({
+      message,
+      name: "length",
+      exclusive: true,
+      params: {
+        length
+      },
+      skipAbsent: true,
+      test(value) {
+        return value.length === this.resolve(length);
+      }
+    });
+  }
+  min(min, message = string.min) {
+    return this.test({
+      message,
+      name: "min",
+      exclusive: true,
+      params: {
+        min
+      },
+      skipAbsent: true,
+      test(value) {
+        return value.length >= this.resolve(min);
+      }
+    });
+  }
+  max(max, message = string.max) {
+    return this.test({
+      name: "max",
+      exclusive: true,
+      message,
+      params: {
+        max
+      },
+      skipAbsent: true,
+      test(value) {
+        return value.length <= this.resolve(max);
+      }
+    });
+  }
+  matches(regex, options) {
+    let excludeEmptyString = false;
+    let message;
+    let name;
+    if (options) {
+      if (typeof options === "object") {
+        ({
+          excludeEmptyString = false,
+          message,
+          name
+        } = options);
+      } else {
+        message = options;
+      }
+    }
+    return this.test({
+      name: name || "matches",
+      message: message || string.matches,
+      params: {
+        regex
+      },
+      skipAbsent: true,
+      test: (value) => value === "" && excludeEmptyString || value.search(regex) !== -1
+    });
+  }
+  email(message = string.email) {
+    return this.matches(rEmail, {
+      name: "email",
+      message,
+      excludeEmptyString: true
+    });
+  }
+  url(message = string.url) {
+    return this.matches(rUrl, {
+      name: "url",
+      message,
+      excludeEmptyString: true
+    });
+  }
+  uuid(message = string.uuid) {
+    return this.matches(rUUID, {
+      name: "uuid",
+      message,
+      excludeEmptyString: false
+    });
+  }
+  //-- transforms --
+  ensure() {
+    return this.default("").transform((val) => val === null ? "" : val);
+  }
+  trim(message = string.trim) {
+    return this.transform((val) => val != null ? val.trim() : val).test({
+      message,
+      name: "trim",
+      test: isTrimmed
+    });
+  }
+  lowercase(message = string.lowercase) {
+    return this.transform((value) => !isAbsent(value) ? value.toLowerCase() : value).test({
+      message,
+      name: "string_case",
+      exclusive: true,
+      skipAbsent: true,
+      test: (value) => isAbsent(value) || value === value.toLowerCase()
+    });
+  }
+  uppercase(message = string.uppercase) {
+    return this.transform((value) => !isAbsent(value) ? value.toUpperCase() : value).test({
+      message,
+      name: "string_case",
+      exclusive: true,
+      skipAbsent: true,
+      test: (value) => isAbsent(value) || value === value.toUpperCase()
+    });
+  }
+}
+create$6.prototype = StringSchema.prototype;
+const isoReg = /^(\d{4}|[+-]\d{6})(?:-?(\d{2})(?:-?(\d{2}))?)?(?:[ T]?(\d{2}):?(\d{2})(?::?(\d{2})(?:[,.](\d{1,}))?)?(?:(Z)|([+-])(\d{2})(?::?(\d{2}))?)?)?$/;
+function toNumber(str, defaultValue = 0) {
+  return Number(str) || defaultValue;
+}
+function parseIsoDate(date2) {
+  const regexResult = isoReg.exec(date2);
+  if (!regexResult) return Date.parse ? Date.parse(date2) : Number.NaN;
+  const struct = {
+    year: toNumber(regexResult[1]),
+    month: toNumber(regexResult[2], 1) - 1,
+    day: toNumber(regexResult[3], 1),
+    hour: toNumber(regexResult[4]),
+    minute: toNumber(regexResult[5]),
+    second: toNumber(regexResult[6]),
+    millisecond: regexResult[7] ? (
+      // allow arbitrary sub-second precision beyond milliseconds
+      toNumber(regexResult[7].substring(0, 3))
+    ) : 0,
+    z: regexResult[8] || void 0,
+    plusMinus: regexResult[9] || void 0,
+    hourOffset: toNumber(regexResult[10]),
+    minuteOffset: toNumber(regexResult[11])
+  };
+  if (struct.z === void 0 && struct.plusMinus === void 0) {
+    return new Date(struct.year, struct.month, struct.day, struct.hour, struct.minute, struct.second, struct.millisecond).valueOf();
+  }
+  let totalMinutesOffset = 0;
+  if (struct.z !== "Z" && struct.plusMinus !== void 0) {
+    totalMinutesOffset = struct.hourOffset * 60 + struct.minuteOffset;
+    if (struct.plusMinus === "+") totalMinutesOffset = 0 - totalMinutesOffset;
+  }
+  return Date.UTC(struct.year, struct.month, struct.day, struct.hour, struct.minute + totalMinutesOffset, struct.second, struct.millisecond);
+}
+let invalidDate = /* @__PURE__ */ new Date("");
+let isDate = (obj) => Object.prototype.toString.call(obj) === "[object Date]";
+class DateSchema extends Schema {
+  constructor() {
+    super({
+      type: "date",
+      check(v) {
+        return isDate(v) && !isNaN(v.getTime());
+      }
+    });
+    this.withMutation(() => {
+      this.transform((value, _raw, ctx) => {
+        if (!ctx.spec.coerce || ctx.isType(value) || value === null) return value;
+        value = parseIsoDate(value);
+        return !isNaN(value) ? new Date(value) : DateSchema.INVALID_DATE;
+      });
+    });
+  }
+  prepareParam(ref, name) {
+    let param;
+    if (!Reference.isRef(ref)) {
+      let cast = this.cast(ref);
+      if (!this._typeCheck(cast)) throw new TypeError(`\`${name}\` must be a Date or a value that can be \`cast()\` to a Date`);
+      param = cast;
+    } else {
+      param = ref;
+    }
+    return param;
+  }
+  min(min, message = date.min) {
+    let limit = this.prepareParam(min, "min");
+    return this.test({
+      message,
+      name: "min",
+      exclusive: true,
+      params: {
+        min
+      },
+      skipAbsent: true,
+      test(value) {
+        return value >= this.resolve(limit);
+      }
+    });
+  }
+  max(max, message = date.max) {
+    let limit = this.prepareParam(max, "max");
+    return this.test({
+      message,
+      name: "max",
+      exclusive: true,
+      params: {
+        max
+      },
+      skipAbsent: true,
+      test(value) {
+        return value <= this.resolve(limit);
+      }
+    });
+  }
+}
+DateSchema.INVALID_DATE = invalidDate;
+DateSchema.prototype;
+function sortFields(fields, excludedEdges = []) {
+  let edges = [];
+  let nodes = /* @__PURE__ */ new Set();
+  let excludes = new Set(excludedEdges.map(([a, b]) => `${a}-${b}`));
+  function addNode(depPath, key) {
+    let node = propertyExpr.split(depPath)[0];
+    nodes.add(node);
+    if (!excludes.has(`${key}-${node}`)) edges.push([key, node]);
+  }
+  for (const key of Object.keys(fields)) {
+    let value = fields[key];
+    nodes.add(key);
+    if (Reference.isRef(value) && value.isSibling) addNode(value.path, key);
+    else if (isSchema(value) && "deps" in value) value.deps.forEach((path) => addNode(path, key));
+  }
+  return toposort$1.array(Array.from(nodes), edges).reverse();
+}
+function findIndex(arr, err) {
+  let idx = Infinity;
+  arr.some((key, ii) => {
+    var _err$path;
+    if ((_err$path = err.path) != null && _err$path.includes(key)) {
+      idx = ii;
+      return true;
+    }
+  });
+  return idx;
+}
+function sortByKeyOrder(keys) {
+  return (a, b) => {
+    return findIndex(keys, a) - findIndex(keys, b);
+  };
+}
+const parseJson = (value, _, ctx) => {
+  if (typeof value !== "string") {
+    return value;
+  }
+  let parsed = value;
+  try {
+    parsed = JSON.parse(value);
+  } catch (err) {
+  }
+  return ctx.isType(parsed) ? parsed : value;
+};
+function deepPartial(schema) {
+  if ("fields" in schema) {
+    const partial = {};
+    for (const [key, fieldSchema2] of Object.entries(schema.fields)) {
+      partial[key] = deepPartial(fieldSchema2);
+    }
+    return schema.setFields(partial);
+  }
+  if (schema.type === "array") {
+    const nextArray = schema.optional();
+    if (nextArray.innerType) nextArray.innerType = deepPartial(nextArray.innerType);
+    return nextArray;
+  }
+  if (schema.type === "tuple") {
+    return schema.optional().clone({
+      types: schema.spec.types.map(deepPartial)
+    });
+  }
+  if ("optional" in schema) {
+    return schema.optional();
+  }
+  return schema;
+}
+const deepHas = (obj, p) => {
+  const path = [...propertyExpr.normalizePath(p)];
+  if (path.length === 1) return path[0] in obj;
+  let last = path.pop();
+  let parent = propertyExpr.getter(propertyExpr.join(path), true)(obj);
+  return !!(parent && last in parent);
+};
+let isObject = (obj) => Object.prototype.toString.call(obj) === "[object Object]";
+function unknown(ctx, value) {
+  let known = Object.keys(ctx.fields);
+  return Object.keys(value).filter((key) => known.indexOf(key) === -1);
+}
+const defaultSort = sortByKeyOrder([]);
+function create$3(spec) {
+  return new ObjectSchema(spec);
+}
+class ObjectSchema extends Schema {
+  constructor(spec) {
+    super({
+      type: "object",
+      check(value) {
+        return isObject(value) || typeof value === "function";
+      }
+    });
+    this.fields = /* @__PURE__ */ Object.create(null);
+    this._sortErrors = defaultSort;
+    this._nodes = [];
+    this._excludedEdges = [];
+    this.withMutation(() => {
+      if (spec) {
+        this.shape(spec);
+      }
+    });
+  }
+  _cast(_value, options = {}) {
+    var _options$stripUnknown;
+    let value = super._cast(_value, options);
+    if (value === void 0) return this.getDefault(options);
+    if (!this._typeCheck(value)) return value;
+    let fields = this.fields;
+    let strip = (_options$stripUnknown = options.stripUnknown) != null ? _options$stripUnknown : this.spec.noUnknown;
+    let props = [].concat(this._nodes, Object.keys(value).filter((v) => !this._nodes.includes(v)));
+    let intermediateValue = {};
+    let innerOptions = Object.assign({}, options, {
+      parent: intermediateValue,
+      __validating: options.__validating || false
+    });
+    let isChanged = false;
+    for (const prop of props) {
+      let field = fields[prop];
+      let exists = prop in value;
+      if (field) {
+        let fieldValue;
+        let inputValue = value[prop];
+        innerOptions.path = (options.path ? `${options.path}.` : "") + prop;
+        field = field.resolve({
+          value: inputValue,
+          context: options.context,
+          parent: intermediateValue
+        });
+        let fieldSpec = field instanceof Schema ? field.spec : void 0;
+        let strict = fieldSpec == null ? void 0 : fieldSpec.strict;
+        if (fieldSpec != null && fieldSpec.strip) {
+          isChanged = isChanged || prop in value;
+          continue;
+        }
+        fieldValue = !options.__validating || !strict ? (
+          // TODO: use _cast, this is double resolving
+          field.cast(value[prop], innerOptions)
+        ) : value[prop];
+        if (fieldValue !== void 0) {
+          intermediateValue[prop] = fieldValue;
+        }
+      } else if (exists && !strip) {
+        intermediateValue[prop] = value[prop];
+      }
+      if (exists !== prop in intermediateValue || intermediateValue[prop] !== value[prop]) {
+        isChanged = true;
+      }
+    }
+    return isChanged ? intermediateValue : value;
+  }
+  _validate(_value, options = {}, panic, next) {
+    let {
+      from: from2 = [],
+      originalValue = _value,
+      recursive = this.spec.recursive
+    } = options;
+    options.from = [{
+      schema: this,
+      value: originalValue
+    }, ...from2];
+    options.__validating = true;
+    options.originalValue = originalValue;
+    super._validate(_value, options, panic, (objectErrors, value) => {
+      if (!recursive || !isObject(value)) {
+        next(objectErrors, value);
+        return;
+      }
+      originalValue = originalValue || value;
+      let tests = [];
+      for (let key of this._nodes) {
+        let field = this.fields[key];
+        if (!field || Reference.isRef(field)) {
+          continue;
+        }
+        tests.push(field.asNestedTest({
+          options,
+          key,
+          parent: value,
+          parentPath: options.path,
+          originalParent: originalValue
+        }));
+      }
+      this.runTests({
+        tests,
+        value,
+        originalValue,
+        options
+      }, panic, (fieldErrors) => {
+        next(fieldErrors.sort(this._sortErrors).concat(objectErrors), value);
+      });
+    });
+  }
+  clone(spec) {
+    const next = super.clone(spec);
+    next.fields = Object.assign({}, this.fields);
+    next._nodes = this._nodes;
+    next._excludedEdges = this._excludedEdges;
+    next._sortErrors = this._sortErrors;
+    return next;
+  }
+  concat(schema) {
+    let next = super.concat(schema);
+    let nextFields = next.fields;
+    for (let [field, schemaOrRef] of Object.entries(this.fields)) {
+      const target = nextFields[field];
+      nextFields[field] = target === void 0 ? schemaOrRef : target;
+    }
+    return next.withMutation((s) => (
+      // XXX: excludes here is wrong
+      s.setFields(nextFields, [...this._excludedEdges, ...schema._excludedEdges])
+    ));
+  }
+  _getDefault(options) {
+    if ("default" in this.spec) {
+      return super._getDefault(options);
+    }
+    if (!this._nodes.length) {
+      return void 0;
+    }
+    let dft = {};
+    this._nodes.forEach((key) => {
+      var _innerOptions;
+      const field = this.fields[key];
+      let innerOptions = options;
+      if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
+        innerOptions = Object.assign({}, innerOptions, {
+          parent: innerOptions.value,
+          value: innerOptions.value[key]
+        });
+      }
+      dft[key] = field && "getDefault" in field ? field.getDefault(innerOptions) : void 0;
+    });
+    return dft;
+  }
+  setFields(shape, excludedEdges) {
+    let next = this.clone();
+    next.fields = shape;
+    next._nodes = sortFields(shape, excludedEdges);
+    next._sortErrors = sortByKeyOrder(Object.keys(shape));
+    if (excludedEdges) next._excludedEdges = excludedEdges;
+    return next;
+  }
+  shape(additions, excludes = []) {
+    return this.clone().withMutation((next) => {
+      let edges = next._excludedEdges;
+      if (excludes.length) {
+        if (!Array.isArray(excludes[0])) excludes = [excludes];
+        edges = [...next._excludedEdges, ...excludes];
+      }
+      return next.setFields(Object.assign(next.fields, additions), edges);
+    });
+  }
+  partial() {
+    const partial = {};
+    for (const [key, schema] of Object.entries(this.fields)) {
+      partial[key] = "optional" in schema && schema.optional instanceof Function ? schema.optional() : schema;
+    }
+    return this.setFields(partial);
+  }
+  deepPartial() {
+    const next = deepPartial(this);
+    return next;
+  }
+  pick(keys) {
+    const picked = {};
+    for (const key of keys) {
+      if (this.fields[key]) picked[key] = this.fields[key];
+    }
+    return this.setFields(picked, this._excludedEdges.filter(([a, b]) => keys.includes(a) && keys.includes(b)));
+  }
+  omit(keys) {
+    const remaining = [];
+    for (const key of Object.keys(this.fields)) {
+      if (keys.includes(key)) continue;
+      remaining.push(key);
+    }
+    return this.pick(remaining);
+  }
+  from(from2, to, alias) {
+    let fromGetter = propertyExpr.getter(from2, true);
+    return this.transform((obj) => {
+      if (!obj) return obj;
+      let newObj = obj;
+      if (deepHas(obj, from2)) {
+        newObj = Object.assign({}, obj);
+        if (!alias) delete newObj[from2];
+        newObj[to] = fromGetter(obj);
+      }
+      return newObj;
+    });
+  }
+  /** Parse an input JSON string to an object */
+  json() {
+    return this.transform(parseJson);
+  }
+  noUnknown(noAllow = true, message = object.noUnknown) {
+    if (typeof noAllow !== "boolean") {
+      message = noAllow;
+      noAllow = true;
+    }
+    let next = this.test({
+      name: "noUnknown",
+      exclusive: true,
+      message,
+      test(value) {
+        if (value == null) return true;
+        const unknownKeys = unknown(this.schema, value);
+        return !noAllow || unknownKeys.length === 0 || this.createError({
+          params: {
+            unknown: unknownKeys.join(", ")
+          }
+        });
+      }
+    });
+    next.spec.noUnknown = noAllow;
+    return next;
+  }
+  unknown(allow = true, message = object.noUnknown) {
+    return this.noUnknown(!allow, message);
+  }
+  transformKeys(fn) {
+    return this.transform((obj) => {
+      if (!obj) return obj;
+      const result = {};
+      for (const key of Object.keys(obj)) result[fn(key)] = obj[key];
+      return result;
+    });
+  }
+  camelCase() {
+    return this.transformKeys(tinyCase.camelCase);
+  }
+  snakeCase() {
+    return this.transformKeys(tinyCase.snakeCase);
+  }
+  constantCase() {
+    return this.transformKeys((key) => tinyCase.snakeCase(key).toUpperCase());
+  }
+  describe(options) {
+    const next = (options ? this.resolve(options) : this).clone();
+    const base = super.describe(options);
+    base.fields = {};
+    for (const [key, value] of Object.entries(next.fields)) {
+      var _innerOptions2;
+      let innerOptions = options;
+      if ((_innerOptions2 = innerOptions) != null && _innerOptions2.value) {
+        innerOptions = Object.assign({}, innerOptions, {
+          parent: innerOptions.value,
+          value: innerOptions.value[key]
+        });
+      }
+      base.fields[key] = value.describe(innerOptions);
+    }
+    return base;
+  }
+}
+create$3.prototype = ObjectSchema.prototype;
+function create$2(type) {
+  return new ArraySchema(type);
+}
+class ArraySchema extends Schema {
+  constructor(type) {
+    super({
+      type: "array",
+      spec: {
+        types: type
+      },
+      check(v) {
+        return Array.isArray(v);
+      }
+    });
+    this.innerType = void 0;
+    this.innerType = type;
+  }
+  _cast(_value, _opts) {
+    const value = super._cast(_value, _opts);
+    if (!this._typeCheck(value) || !this.innerType) {
+      return value;
+    }
+    let isChanged = false;
+    const castArray = value.map((v, idx) => {
+      const castElement = this.innerType.cast(v, Object.assign({}, _opts, {
+        path: `${_opts.path || ""}[${idx}]`
+      }));
+      if (castElement !== v) {
+        isChanged = true;
+      }
+      return castElement;
+    });
+    return isChanged ? castArray : value;
+  }
+  _validate(_value, options = {}, panic, next) {
+    var _options$recursive;
+    let innerType = this.innerType;
+    let recursive = (_options$recursive = options.recursive) != null ? _options$recursive : this.spec.recursive;
+    options.originalValue != null ? options.originalValue : _value;
+    super._validate(_value, options, panic, (arrayErrors, value) => {
+      var _options$originalValu2;
+      if (!recursive || !innerType || !this._typeCheck(value)) {
+        next(arrayErrors, value);
+        return;
       }
-    ) }),
-    /* @__PURE__ */ jsx(
-      StyledMenu,
-      {
-        onClose: () => menuState.setA11yOpen(false),
-        anchorEl: a11yRef.current,
-        open: menuState.a11yOpen,
-        children: /* @__PURE__ */ jsxs(Menu.Section, { title: "Density", children: [
-          /* @__PURE__ */ jsx(
-            Menu.Item,
-            {
-              active: density === "comfortable",
-              onClick: () => toggleDensity("comfortable"),
-              children: "Comfortable"
-            }
-          ),
-          /* @__PURE__ */ jsx(
-            Menu.Item,
-            {
-              active: density === "compact",
-              onClick: () => toggleDensity("compact"),
-              children: "Compact"
-            }
-          )
-        ] })
+      let tests = new Array(value.length);
+      for (let index = 0; index < value.length; index++) {
+        var _options$originalValu;
+        tests[index] = innerType.asNestedTest({
+          options,
+          index,
+          parent: value,
+          parentPath: options.path,
+          originalParent: (_options$originalValu = options.originalValue) != null ? _options$originalValu : _value
+        });
       }
-    ),
-    /* @__PURE__ */ jsx(
-      AppLoader,
-      {
-        app: applications.find((app) => app.key === "quick-links") ?? null,
-        kind: "widget"
+      this.runTests({
+        value,
+        tests,
+        originalValue: (_options$originalValu2 = options.originalValue) != null ? _options$originalValu2 : _value,
+        options
+      }, panic, (innerTypeErrors) => next(innerTypeErrors.concat(arrayErrors), value));
+    });
+  }
+  clone(spec) {
+    const next = super.clone(spec);
+    next.innerType = this.innerType;
+    return next;
+  }
+  /** Parse an input JSON string to an object */
+  json() {
+    return this.transform(parseJson);
+  }
+  concat(schema) {
+    let next = super.concat(schema);
+    next.innerType = this.innerType;
+    if (schema.innerType)
+      next.innerType = next.innerType ? (
+        // @ts-expect-error Lazy doesn't have concat and will break
+        next.innerType.concat(schema.innerType)
+      ) : schema.innerType;
+    return next;
+  }
+  of(schema) {
+    let next = this.clone();
+    if (!isSchema(schema)) throw new TypeError("`array.of()` sub-schema must be a valid yup schema not: " + printValue(schema));
+    next.innerType = schema;
+    next.spec = Object.assign({}, next.spec, {
+      types: schema
+    });
+    return next;
+  }
+  length(length, message = array.length) {
+    return this.test({
+      message,
+      name: "length",
+      exclusive: true,
+      params: {
+        length
+      },
+      skipAbsent: true,
+      test(value) {
+        return value.length === this.resolve(length);
       }
-    ),
-    /* @__PURE__ */ jsx(Tooltip, { title: "View user settings", children: /* @__PURE__ */ jsx(
-      Button,
-      {
-        onClick: () => menuState.setUserMenuOpen(true),
-        ref: userRef,
-        variant: "ghost_icon",
-        children: /* @__PURE__ */ jsx(Icon, { data: account_circle })
+    });
+  }
+  min(min, message) {
+    message = message || array.min;
+    return this.test({
+      message,
+      name: "min",
+      exclusive: true,
+      params: {
+        min
+      },
+      skipAbsent: true,
+      // FIXME(ts): Array<typeof T>
+      test(value) {
+        return value.length >= this.resolve(min);
       }
-    ) }),
-    /* @__PURE__ */ jsxs(
-      StyledMenu,
-      {
-        onClose: () => menuState.setUserMenuOpen(false),
-        anchorEl: userRef.current,
-        open: menuState.userMenuOpen,
-        children: [
-          /* @__PURE__ */ jsxs(Menu.Section, { title: "Profile", children: [
-            /* @__PURE__ */ jsx(Menu.Item, { children: user.name }),
-            /* @__PURE__ */ jsx(
-              Menu.Item,
-              {
-                onClick: () => auth.defaultClient.logoutRedirect({
-                  postLogoutRedirectUri: window.location.origin
-                }),
-                children: "Sign out"
-              }
-            )
-          ] }),
-          /* @__PURE__ */ jsx(Menu.Section, { title: "Roles", children: roles.map((r) => /* @__PURE__ */ jsx(Menu.Item, { children: r }, r)) })
-        ]
+    });
+  }
+  max(max, message) {
+    message = message || array.max;
+    return this.test({
+      message,
+      name: "max",
+      exclusive: true,
+      params: {
+        max
+      },
+      skipAbsent: true,
+      test(value) {
+        return value.length <= this.resolve(max);
       }
-    ),
-    /* @__PURE__ */ jsx(Tooltip, { title: "Release notes", children: /* @__PURE__ */ jsx(
-      Button,
-      {
-        variant: "ghost_icon",
-        as: "a",
-        href: `https://statoilsrm.sharepoint.com/sites/Roma/Lists/Releases/AllItems.aspx`,
-        target: "_blank",
-        children: /* @__PURE__ */ jsx(Icon, { data: help_outline })
+    });
+  }
+  ensure() {
+    return this.default(() => []).transform((val, original) => {
+      if (this._typeCheck(val)) return val;
+      return original == null ? [] : [].concat(original);
+    });
+  }
+  compact(rejector) {
+    let reject = !rejector ? (v) => !!v : (v, i, a) => !rejector(v, i, a);
+    return this.transform((values) => values != null ? values.filter(reject) : values);
+  }
+  describe(options) {
+    const next = (options ? this.resolve(options) : this).clone();
+    const base = super.describe(options);
+    if (next.innerType) {
+      var _innerOptions;
+      let innerOptions = options;
+      if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
+        innerOptions = Object.assign({}, innerOptions, {
+          parent: innerOptions.value,
+          value: innerOptions.value[0]
+        });
       }
-    ) })
-  ] });
-};
-const Header = () => {
-  const [a11yOpen, setA11yOpen] = useState(false);
-  const [userMenuOpen, setUserMenuOpen] = useState(false);
-  const [activityLogOpen, setActivityLogOpen] = useState(false);
-  const { apps: allApps } = useApps({ includeHidden: true });
-  const headerMenuState = {
-    a11yOpen,
-    setA11yOpen,
-    userMenuOpen,
-    setUserMenuOpen,
-    activityLogOpen,
-    setActivityLogOpen
-  };
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsxs(TopBarFadeIn, { id: "cli-top-bar", children: [
-      /* @__PURE__ */ jsx(TopBar.Header, { children: /* @__PURE__ */ jsxs(Styled.Title, { children: [
-        /* @__PURE__ */ jsx(Icon, { color: "#eb0037", data: logoIcon, viewBox: "0 0 42 48" }),
-        /* @__PURE__ */ jsx("span", { children: "Roma" })
-      ] }) }),
-      /* @__PURE__ */ jsx(TopBar.CustomContent, {}),
-      /* @__PURE__ */ jsx(TopBar.Actions, { children: /* @__PURE__ */ jsx(HeaderMenu, { menuState: headerMenuState }) })
-    ] }),
-    /* @__PURE__ */ jsx(SideSheets, { apps: allApps, menuState: headerMenuState })
-  ] });
+      base.innerType = next.innerType.describe(innerOptions);
+    }
+    return base;
+  }
+}
+create$2.prototype = ArraySchema.prototype;
+const fieldSchema = create$3().shape({
+  fieldName: create$6().required().ensure(),
+  fieldLabel: create$6().required().ensure(),
+  fieldEnabled: create$7().default(true)
+});
+const cargoSettingsSchema = create$3().shape({
+  fields: create$3().shape({
+    contractual: create$3().shape({
+      product: fieldSchema,
+      quality: fieldSchema,
+      contrquantity: fieldSchema,
+      buyer: fieldSchema,
+      seller: fieldSchema,
+      incoterm: fieldSchema
+    }),
+    operational: create$3().shape({
+      status: fieldSchema,
+      loadingrange: fieldSchema,
+      dischargerange: fieldSchema,
+      loadport: fieldSchema,
+      dischargeport: fieldSchema,
+      qty: fieldSchema,
+      remarks: fieldSchema
+    }),
+    vessel: create$3().shape({
+      vesselname: fieldSchema,
+      eta: fieldSchema
+    })
+  }),
+  settings: create$3().shape({
+    autowatch: create$3().shape({
+      opsResponsible: create$7()
+    })
+  })
+});
+const settingSchema = create$3({
+  cargo: cargoSettingsSchema
+}).default({
+  cargo: cargoSettingsSchema.getDefault()
+});
+const watchListSchema = create$3().shape({
+  watched: create$2().of(create$6()).required().default([]),
+  unwatched: create$2().of(create$6()).required().default([])
+});
+const rootSchema = create$3({
+  notificationSettings: settingSchema,
+  watchListSettings: create$3({
+    cargo: watchListSchema
+  })
+});
+class CustomAppClient {
+  constructor(client) {
+    __privateAdd(this, _manifests, []);
+    this.client = client;
+  }
+  // eslint-disable-next-line no-empty-pattern
+  getAppConfig({}) {
+    return of({});
+  }
+  getAppManifest({ appKey }) {
+    const manifest = __privateGet(this, _manifests).find(
+      (manifest2) => manifest2.appKey === appKey
+    );
+    if (!manifest)
+      throw new Error(
+        `AppNotFoundError: Manifest for appKey "${appKey}" not found`
+      );
+    return of(manifest);
+  }
+  getAppManifests() {
+    return this.client.fetch$(`/api/apps`).pipe(
+      switchMap(
+        (r) => from(r.json())
+      ),
+      map(
+        (v) => v.map((vv) => {
+          let pathname;
+          if (vv.entry.startsWith("/")) {
+            pathname = vv.entry;
+          } else {
+            const url = new URL(vv.entry);
+            pathname = `${url.pathname}${url.search}`;
+          }
+          return {
+            ...vv,
+            entry: pathname,
+            keywords: vv.keywords ?? vv.tags,
+            appKey: vv.appKey ?? vv.key,
+            name: vv.displayName ?? vv.name,
+            visualization: {
+              icon: vv.icon,
+              sortOrder: vv.order
+            },
+            build: {
+              entryPoint: pathname,
+              assetPath: "/",
+              version: `${vv.version.major}.${vv.version.minor}.${vv.version.patch}`
+            }
+          };
+        })
+      ),
+      tap((v) => __privateSet(this, _manifests, v)),
+      catchError((err) => {
+        console.error("Error fetching app manifests", err);
+        return of([]);
+      })
+    );
+  }
+  getAppSettings() {
+    console.log("getAppSettings");
+    return of({});
+  }
+  updateAppSettings() {
+    console.log("updateAppSettings");
+    return of({});
+  }
+}
+_manifests = new WeakMap();
+class ServiceDiscoveryClient {
+  constructor() {
+    this.cacheTime = 0;
+  }
+  async resolveService(key, allow_cache) {
+    return this.resolveServices(allow_cache).then(
+      (services) => services.find((s) => s.key === key)
+    );
+  }
+  async resolveServices(allow_cache) {
+    const wait = 60 * 1e3 * 30;
+    if (this.cache && this.cacheTime > Date.now() - wait) {
+      return this.cache;
+    }
+    this.cacheTime = Date.now();
+    return fetch(`/_discovery/environments/current`).then((r) => r.json()).then((r) => {
+      const services = r.services.map((s) => ({
+        ...s,
+        scopes: s.defaultScopes
+      }));
+      this.cache = services;
+      return services;
+    });
+  }
+}
+const configure = async (config) => {
+  var _a;
+  const request = await fetch("/_discovery/environments/current");
+  const environment = await request.json();
+  const services = environment.services;
+  if (!services) {
+    throw new Error(`ServiceDiscoveryMissingError: No services found`);
+  }
+  const portalService = (_a = environment.services) == null ? void 0 : _a.find((v) => v.key === "portal");
+  if (!portalService || !environment.frontendClientId) {
+    const error = [];
+    if (!portalService) error.push(`Missing service: "portal"`);
+    if (!environment.frontendClientId) error.push(`Missing frontend clientId`);
+    throw new Error(`Missing environment information:
+${error.join("\n")}`);
+  }
+  config.logger.level = 2;
+  config.configureMsal(
+    {
+      tenantId: "3aa4a235-b6e2-48d5-9195-7fcf05b459b0",
+      clientId: environment.frontendClientId,
+      redirectUri: "/authentication/login-callback"
+    },
+    { requiresAuth: true }
+  );
+  enableServiceDiscovery(config, async (builder) => {
+    builder.setServiceDiscoveryClient(new ServiceDiscoveryClient());
+  });
+  enableContext(config);
+  enableAppModule(config, (builder) => {
+    builder.setAssetUri(`/`);
+    builder.setClient(async (client) => {
+      const http = await client.requireInstance("http");
+      const httpClient = http.createClient(portalService);
+      return new CustomAppClient(httpClient);
+    });
+  });
+  enableNavigation(config);
+  enableSse(config, "activity");
+  config.onConfigured(() => {
+    console.info("Fusion config done");
+  });
+  config.onInitialized(async (fusion) => {
+    fusion.auth.defaultClient.setLogger(new ConsoleLogger(config.logger.level));
+    window.sessionStorage.clear();
+  });
 };
 const ErrorTypography = ({
   variant,
@@ -2500,40 +5063,6 @@ const useFindUsersByShortname = (shortnames, fields = ["displayName", "mail", "g
   const emails = (shortnames ?? []).map((name) => `${name}@equinor.com`);
   return useFindUsersByMail(emails, fields);
 };
-function promisifyRequest(request) {
-  return new Promise((resolve, reject) => {
-    request.oncomplete = request.onsuccess = () => resolve(request.result);
-    request.onabort = request.onerror = () => reject(request.error);
-  });
-}
-function createStore(dbName, storeName) {
-  const request = indexedDB.open(dbName);
-  request.onupgradeneeded = () => request.result.createObjectStore(storeName);
-  const dbp = promisifyRequest(request);
-  return (txMode, callback) => dbp.then((db) => callback(db.transaction(storeName, txMode).objectStore(storeName)));
-}
-let defaultGetStoreFunc;
-function defaultGetStore() {
-  if (!defaultGetStoreFunc) {
-    defaultGetStoreFunc = createStore("keyval-store", "keyval");
-  }
-  return defaultGetStoreFunc;
-}
-function get(key, customStore = defaultGetStore()) {
-  return customStore("readonly", (store) => promisifyRequest(store.get(key)));
-}
-function set(key, value, customStore = defaultGetStore()) {
-  return customStore("readwrite", (store) => {
-    store.put(value, key);
-    return promisifyRequest(store.transaction);
-  });
-}
-function del(key, customStore = defaultGetStore()) {
-  return customStore("readwrite", (store) => {
-    store.delete(key);
-    return promisifyRequest(store.transaction);
-  });
-}
 const checkRomaApi = (queryKey) => {
   const first = (queryKey ?? []).at(0);
   if (typeof first === "string") {
@@ -2684,6 +5213,194 @@ async function handleError(req) {
     }
   }
 }
+const useWatchDefaults = {
+  notificationSettings: {
+    cargo: {
+      fields: {
+        contractual: {
+          product: {
+            fieldName: "product",
+            fieldLabel: "Product",
+            fieldEnabled: true
+          },
+          quality: {
+            fieldName: "quality",
+            fieldLabel: "Quality",
+            fieldEnabled: true
+          },
+          contrquantity: {
+            fieldName: "contrquantity",
+            fieldLabel: "Contr. Quantity",
+            fieldEnabled: true
+          },
+          buyer: {
+            fieldName: "buyer",
+            fieldLabel: "Buyer",
+            fieldEnabled: true
+          },
+          seller: {
+            fieldName: "seller",
+            fieldLabel: "Seller",
+            fieldEnabled: true
+          },
+          incoterm: {
+            fieldName: "incoterm",
+            fieldLabel: "Incoterm",
+            fieldEnabled: true
+          }
+        },
+        operational: {
+          status: {
+            fieldName: "status",
+            fieldLabel: "Status",
+            fieldEnabled: true
+          },
+          loadingrange: {
+            fieldName: "loadingrange",
+            fieldLabel: "Loading Range",
+            fieldEnabled: true
+          },
+          dischargerange: {
+            fieldName: "dischargerange",
+            fieldLabel: "Discharge Range",
+            fieldEnabled: true
+          },
+          loadport: {
+            fieldName: "loadport",
+            fieldLabel: "Load port",
+            fieldEnabled: true
+          },
+          dischargeport: {
+            fieldName: "dischargeport",
+            fieldLabel: "Discharge port",
+            fieldEnabled: true
+          },
+          qty: {
+            fieldName: "qty",
+            fieldLabel: "Qty (any unit)",
+            fieldEnabled: true
+          },
+          remarks: {
+            fieldName: "remarks",
+            fieldLabel: "Remarks",
+            fieldEnabled: true
+          }
+        },
+        vessel: {
+          vesselname: {
+            fieldName: "vesselname",
+            fieldLabel: "Vessel name",
+            fieldEnabled: true
+          },
+          eta: {
+            fieldName: "eta",
+            fieldLabel: "ETA",
+            fieldEnabled: true
+          }
+        }
+      },
+      settings: {
+        autowatch: {
+          opsResponsible: false
+        }
+      }
+    }
+  },
+  watchListSettings: {
+    cargo: {
+      watched: [],
+      unwatched: []
+    }
+  }
+};
+const useManageWatchList = (system) => {
+  const { data: setting } = useGetSettingsByAppShortName("notifications", {
+    query: {
+      meta: {
+        persist: true
+      },
+      staleTime: 6e4 * 15,
+      // Skip re-fetching if data is less than 15 minutes old
+      select: (data) => {
+        const setting2 = (data ?? []).filter(
+          (f) => f.setting === "app-notifications"
+        );
+        return setting2 && setting2.length > 0 ? setting2[0] : rootSchema.cast(useWatchDefaults, { assert: false });
+      }
+    }
+  });
+  const framework = useFramework();
+  const user = framework.modules.auth.defaultAccount;
+  const userId = (user == null ? void 0 : user.username.split("@")[0].toLowerCase()) ?? "MISSINGUSER";
+  const queryClient = useQueryClient();
+  const updateMutator = useUpdateByUserIdAndId();
+  const createMutator = useCreateSettingByUserId();
+  const saveSetting = (setting2) => {
+    if (!setting2.id) {
+      createMutator.mutate(
+        {
+          userId,
+          data: setting2
+        },
+        {
+          onSuccess: () => {
+            return queryClient.resetQueries({
+              queryKey: getGetSettingsByAppShortNameQueryKey("notifications")
+            });
+          }
+        }
+      );
+    } else {
+      updateMutator.mutate(
+        {
+          userId,
+          id: setting2.id,
+          data: setting2
+        },
+        {
+          onSuccess: () => {
+            return queryClient.resetQueries({
+              queryKey: getGetSettingsByAppShortNameQueryKey("notifications")
+            });
+          }
+        }
+      );
+    }
+  };
+  return {
+    watch(id) {
+      if (!setting) {
+        return;
+      }
+      setting.value.watchListSettings[system].unwatched = setting.value.watchListSettings[system].unwatched.filter(
+        (i) => i !== id
+      );
+      setting.value.watchListSettings[system].watched = Array.from(
+        /* @__PURE__ */ new Set([...setting.value.watchListSettings[system].watched, id])
+      );
+      saveSetting(setting);
+    },
+    unwatch(id) {
+      if (!setting) {
+        return;
+      }
+      setting.value.watchListSettings[system].watched = setting.value.watchListSettings[system].watched.filter((i) => i !== id);
+      setting.value.watchListSettings[system].unwatched = Array.from(
+        /* @__PURE__ */ new Set([...setting.value.watchListSettings[system].unwatched, id])
+      );
+      saveSetting(setting);
+    },
+    watched() {
+      if (!setting) return [];
+      return setting.value.watchListSettings[system].watched;
+    },
+    unwatched() {
+      if (!setting) return [];
+      return setting.value.watchListSettings[system].unwatched;
+    },
+    isSaving: createMutator.isPending || updateMutator.isPending
+  };
+};
 export {
   AppContext,
   AppLoadError,
@@ -2698,7 +5415,9 @@ export {
   HttpErrorViewer,
   RomaErrorViewer,
   StyleProvider,
+  configure,
   createIDBPersister,
+  findUsersByMail,
   getGetAllAppsQueryKey,
   getGetAllCategoriesQueryKey,
   getGetAllRomaConfigurationByTypeQueryKey,
@@ -2812,6 +5531,7 @@ export {
   useListFeedbacksByCurrentUser,
   useListFeedbacksByCurrentUserHook,
   useListFeedbacksByCurrentUserQueryOptions,
+  useManageWatchList,
   useStreamEvents,
   useStreamEventsHook,
   useStreamEventsQueryOptions,