@retailcrm/datalens-ui 0.0.0

package/main.js

@@ -0,0 +1,5018 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { TextInput, useThemeType, Flex, Icon, Alert, Button, Label, Popup, User, Switch as Switch$1, Dialog, TextArea, SegmentedRadioGroup, Link as Link$1, Loader, ThemeProvider, MobileProvider } from "@gravity-ui/uikit";
+import React__default from "react";
+import ReactDOM from "react-dom";
+import { useLocation, useHistory, Switch, Route, Redirect, Link, useParams, withRouter, Router } from "react-router-dom";
+import { useSelector, useDispatch, connect, Provider } from "react-redux";
+import { HotkeysProvider } from "react-hotkeys-hook";
+import { a as DialogManagerContainer } from "./components/DialogManager.js";
+import { bp as SET_WORKBOOK, bq as RESET_WORKBOOK_PERMISSIONS, br as ADD_COLLECTION_BREADCRUMBS, bs as ADD_WORKBOOK_INFO, bt as CHANGE_FILTERS, bu as DELETE_ENTRY_INLINE, bv as DELETE_ENTRY_FAILED, bw as DELETE_ENTRY_SUCCESS, bx as DELETE_ENTRY_LOADING, by as CHANGE_FAVORITE_ENTRY_INLINE, bz as CHANGE_FAVORITE_ENTRY_FAILED, bA as CHANGE_FAVORITE_ENTRY_SUCCESS, bB as CHANGE_FAVORITE_ENTRY_LOADING, bC as RENAME_ENTRY_INLINE, bD as RENAME_ENTRY_FAILED, bE as RENAME_ENTRY_SUCCESS, bF as RENAME_ENTRY_LOADING, bG as RESET_CREATE_WORKBOOK_ENTRY_TYPE, bH as SET_CREATE_WORKBOOK_ENTRY_TYPE, bI as RESET_WORKBOOK_ENTRIES_BY_SCOPE, bJ as RESET_WORKBOOK_SHARED_ENTRIES, bK as RESET_WORKBOOK_ENTRIES, bL as BIND_SHARED_ENTRY_TO_WORKBOOK_FAILED, bM as BIND_SHARED_ENTRY_TO_WORKBOOK_SUCCESS, bN as BIND_SHARED_ENTRY_TO_WORKBOOK_LOADING, bO as GET_WORKBOOK_SHARED_ENTRIES_FAILED, bP as GET_WORKBOOK_SHARED_ENTRIES_SUCCESS, bQ as GET_WORKBOOK_SHARED_ENTRIES_LOADING, bR as GET_WORKBOOK_ENTRIES_FAILED, bS as GET_ALL_WORKBOOK_ENTRIES_SEPARATELY_SUCCESS, bT as GET_WORKBOOK_ENTRIES_SUCCESS, bU as GET_WORKBOOK_ENTRIES_LOADING, bV as GET_WORKBOOK_BREADCRUMBS_FAILED, bW as GET_WORKBOOK_BREADCRUMBS_SUCCESS, bX as GET_WORKBOOK_BREADCRUMBS_LOADING, bY as GET_WORKBOOK_FAILED, bZ as GET_WORKBOOK_SUCCESS, b_ as GET_WORKBOOK_LOADING, b$ as RESET_WORKBOOK_STATE, c0 as PARTIAL_UPDATE_DIALOG_PROPS, c1 as UPDATE_DIALOG_PROPS, c2 as CLOSE_DIALOG, c3 as OPEN_DIALOG, a9 as RevisionsListMode, R as RevisionsMode, c4 as SET_IS_RENAME_WITHOUT_RELOAD, c5 as REVISIONS_LOADING_STATUS, c6 as SET_ENTRY_CURRENT_REVID, c7 as CLEAN_REVISIONS, c8 as SET_REVISIONS, c9 as TOGGLE_REVISIONS_MODE, ca as SET_REVISIONS_LIST_MODE, cb as SET_REVISIONS_MODE, cc as SET_ENTRY, cd as SET_ITEM, ce as fireMetricaHit, L as CounterName, V as useEffectOnce, cf as initSdk, g as getSdk, l as logger$1, e as isSdkError, d as showToast, i as isEnabledFeature, o as openDialog, c as closeDialog, cg as setIsRenameWithoutReload, aq as setCreateWorkbookEntryType, ch as getUIEntryRoute, ci as getIconDataById, D as sdk, U as Utils, O as navigateHelper_default, f as openDialogErrorWithTabs, cj as CHARTKIT_LOGGER, r as getLocation, ck as setHistory, cl as getHistory, cm as registerSDKDispatch } from "./components/ActionPanel.js";
+import { D as DL, r as registry, eH as isHeaderWithoutNavigationError, eI as isHeaderWithoutHelpCenterError, eJ as SYSTEM_USER, eK as DATALENS_IFRAME_CLASSNAME, l as I18n, eL as SignInQa, F as Feature, eM as EXAMPLE_FUNCTION, eN as RESTRICTED_PARAM_NAMES, d as EntryScope, c as ENTRY_TYPES, u as DashTabItemType, eO as DashboardAddWidgetQa, j as i18n$c, eP as extractEntryId, cM as isEntryId, aj as formatNumber, de as QLChartType, eQ as ViewSetupQA, c7 as PLACE, n as ErrorCode, aN as ChartkitMenuDialogsQA, eR as DISABLE_JSONFN_SWITCH_MODE_COOKIE_NAME, eS as DISABLE, A as ACCEPT_LANGUAGE_HEADER, p as TENANT_ID_HEADER, eT as DISPLAY_MODE_HEADER, S as SUPERUSER_SWITCH_MODE_COOKIE_NAME, q as SuperuserHeader, E as ENABLE, eU as ALLOW_THEMES } from "./components/AccessRights.js";
+import { f as SET_THEME, U as UPDATE_USER_SETTINGS, h as getLocalTheme, j as SET_IS_HIDDEN, k as SET_IS_COMPACT, R as RESET_ASIDE_HEADER_SETTINGS, l as SET_ASIDE_HEADER_SETTINGS, m as SET_CURRENT_PAGE_ENTRY, n as SET_ASIDE_HEADER_DATA, C as CLOSE_NAVIGATION, O as OPEN_NAVIGATION, g as getIsAsideHeaderEnabled, A as AsideHeaderAdapter, o as getUpdatedUserSettings, p as selectThemeSettings } from "./components/AsideHeaderAdapter.js";
+import { S as SET_IS_LANDING } from "./components/LandingPage.js";
+import { S as SET_COLOR_PALETTES, g as SET_CURRENT_COLOR_PALETTE } from "./components/ColorPaletteEditorContainer.js";
+import { R as RESET_EXPORT_RESULT, G as GET_EXPORT_RESULT_FAILED, y as GET_EXPORT_RESULT_SUCCESS, z as GET_EXPORT_RESULT_LOADING, A as RESET_EXPORT_PROGRESS, B as GET_EXPORT_PROGRESS_FAILED, C as GET_EXPORT_PROGRESS_SUCCESS, E as GET_EXPORT_PROGRESS_LOADING, F as RESET_IMPORT_PROGRESS, H as GET_IMPORT_PROGRESS_FAILED, I as GET_IMPORT_PROGRESS_SUCCESS, J as GET_IMPORT_PROGRESS_LOADING, K as RESET_IMPORT_WORKBOOK, L as IMPORT_WORKBOOK_FAILED, M as IMPORT_WORKBOOK_SUCCESS, N as IMPORT_WORKBOOK_LOADING, O as RESET_EXPORT_WORKBOOK, P as EXPORT_WORKBOOK_FAILED, Q as EXPORT_WORKBOOK_SUCCESS, T as EXPORT_WORKBOOK_LOADING, U as DELETE_WORKBOOKS_FAILED, V as DELETE_WORKBOOKS_SUCCESS, W as DELETE_WORKBOOKS_LOADING, X as DELETE_WORKBOOK_FAILED, Y as DELETE_WORKBOOK_SUCCESS, Z as DELETE_WORKBOOK_LOADING, _ as DELETE_COLLECTIONS_FAILED, $ as DELETE_COLLECTIONS_SUCCESS, a0 as DELETE_COLLECTIONS_LOADING, a1 as DELETE_COLLECTION_FAILED, a2 as DELETE_COLLECTION_SUCCESS, a3 as DELETE_COLLECTION_LOADING, a4 as UPDATE_COLLECTION_FAILED, a5 as UPDATE_COLLECTION_SUCCESS, a6 as UPDATE_COLLECTION_LOADING, a7 as UPDATE_WORKBOOK_FAILED, a8 as UPDATE_WORKBOOK_SUCCESS, a9 as UPDATE_WORKBOOK_LOADING, aa as COPY_WORKBOOK_FAILED, ab as COPY_WORKBOOK_SUCCESS, ac as COPY_WORKBOOK_LOADING, ad as MOVE_SHARED_ENTRY_FAILED, ae as MOVE_SHARED_ENTRY_SUCCESS, af as MOVE_SHARED_ENTRY_LOADING, ag as MOVE_WORKBOOKS_FAILED, ah as MOVE_WORKBOOKS_SUCCESS, ai as MOVE_WORKBOOKS_LOADING, aj as MOVE_WORKBOOK_FAILED, ak as MOVE_WORKBOOK_SUCCESS, al as MOVE_WORKBOOK_LOADING, am as MOVE_COLLECTIONS_FAILED, an as MOVE_COLLECTIONS_SUCCESS, ao as MOVE_COLLECTIONS_LOADING, ap as MOVE_COLLECTION_FAILED, aq as MOVE_COLLECTION_SUCCESS, ar as MOVE_COLLECTION_LOADING, as as CREATE_WORKBOOK_FAILED, at as CREATE_WORKBOOK_SUCCESS, au as CREATE_WORKBOOK_LOADING, av as CREATE_COLLECTION_FAILED, aw as CREATE_COLLECTION_SUCCESS, ax as CREATE_COLLECTION_LOADING, ay as COPY_TEMPLATE_FAILED, az as COPY_TEMPLATE_SUCCESS, aA as COPY_TEMPLATE_LOADING, aB as GET_STRUCTURE_ITEMS_FAILED, aC as GET_STRUCTURE_ITEMS_SUCCESS, aD as GET_STRUCTURE_ITEMS_LOADING, aE as RESET_STRUCTURE_ITEMS, aF as GET_COLLECTION_FAILED, aG as GET_COLLECTION_SUCCESS, aH as GET_COLLECTION_LOADING, aI as GET_COLLECTION_BREADCRUMBS_FAILED, aJ as GET_COLLECTION_BREADCRUMBS_SUCCESS, aK as GET_COLLECTION_BREADCRUMBS_LOADING, aL as RESET_COLLECTION_BREADCRUMBS, aM as GET_ROOT_COLLECTION_PERMISSIONS_FAILED, aN as GET_ROOT_COLLECTION_PERMISSIONS_SUCCESS, aO as GET_ROOT_COLLECTION_PERMISSIONS_LOADING, aP as RESET_STATE, aQ as DIALOG_CREATE_WORKBOOK } from "./components/CollectionsStructure.js";
+import { M as MIGRATE_ENTRIES_TO_WORKBOOK_FAILED, a as MIGRATE_ENTRIES_TO_WORKBOOK_SUCCESS, b as MIGRATE_ENTRIES_TO_WORKBOOK_LOADING, G as GET_RELATIONS_FAILED, c as GET_RELATIONS_SUCCESS, d as GET_RELATIONS_LOADING, e as GET_RELATIONS_GRAPH_FAILED, f as GET_RELATIONS_GRAPH_SUCCESS, g as GET_RELATIONS_GRAPH_LOADING, h as GET_ENTRY_FAILED, i as GET_ENTRY_SUCCESS, j as GET_ENTRY_LOADING, R as RESET_STATE$1 } from "./components/MigrateToWorkbookDialog.js";
+import { C as COPY_ENTRIES_TO_WORKBOOK_FAILED, a as COPY_ENTRIES_TO_WORKBOOK_SUCCESS, b as COPY_ENTRIES_TO_WORKBOOK_LOADING, G as GET_RELATIONS_FAILED$1, c as GET_RELATIONS_SUCCESS$1, d as GET_RELATIONS_LOADING$1, e as GET_ENTRY_FAILED$1, f as GET_ENTRY_SUCCESS$1, g as GET_ENTRY_LOADING$1, R as RESET_STATE$2 } from "./components/CopyEntriesToWorkbookDialog.js";
+import isObject from "lodash/isObject";
+import isSet from "lodash/isSet";
+import isFunction from "lodash/isFunction";
+import transform from "lodash/transform";
+import { hh as SET_EDIT_HISTORY_CURRENT_STATE, hi as SET_EDIT_HISTORY_POINT_INDEX, hj as ADD_EDIT_HISTORY_POINT, hk as RESET_EDIT_HISTORY_UNIT, hl as INIT_EDIT_HISTORY_UNIT, hm as controlDialog, cq as isIframe, bl as isEmbeddedMode, cf as isTvMode, bp as reducerRegistry, hn as chartkitApi, ho as getChartkitType, hf as getStore, hp as renameDataset, hq as renameDash, I as ITEM_TYPE, hr as requestCollectChartkitStats, hs as requestCollectDashStats, ht as fetchDistinctsByApi, hu as fetchBatchRenderedMarkdown, hv as fetchRenderedMarkdown, hw as getExtendedItemData, hx as getCaptionText, hy as isEmbeddedEntry, h as CHARTS_ERROR_CODE, b4 as ERROR_CODE, b as CHARTKIT_ERROR_NODE_CLASSNAME, u as unwrapFromArrayAndSkipOperation, c as CONTROL_TYPE, j as CLICK_ACTION_TYPE, w as wrapToArray, f as addOperationForValue, C as CHARTKIT_SCROLLABLE_NODE_CLASSNAME, hz as Markdown, hA as CHARTKIT_WIDGET_TYPE, hB as Table, cE as ChartKitWithCharts, g as chartsDataProvider, hC as resetStore } from "./components/ControlComponents.js";
+import { L as LocationChange } from "./components/LocationChange.js";
+import { F as FallbackPage } from "./pages/FallbackPage.js";
+import { D as DashAndWizardQLPages, d as dashAndWizardQLRoutes } from "./pages/DashAndWizardQLPages.js";
+import { M as MobileHeaderComponent } from "./components/MobileHeader.js";
+import { R as RELOADED_URL_QUERY, S as SET_AUTH_PAGE_INITED, d as RESET_FORM, e as RESET_FORM_VALIDATION, U as UPDATE_FORM_VALIDATION, f as UPDATE_FORM_VALUES$1, g as RESET_AUTH_STATE, A as AUTH_ROUTE } from "./pages/AuthPage.js";
+import { combineReducers, bindActionCreators } from "redux";
+import { g as getUsersRoles, U as UPDATE_USER_ROLE_FAILED, a as UPDATE_USER_ROLE_SUCCESS, b as UPDATE_USER_ROLE_LOADING, R as RESET_UPDATE_USER_PASSWORD_STATE, c as UPDATE_USER_PASSWORD_FAILED, d as UPDATE_USER_PASSWORD_SUCCESS, e as UPDATE_USER_PASSWORD_LOADING, E as EDIT_USER_PROFILE_FAILED, f as EDIT_USER_PROFILE_SUCCESS, h as EDIT_USER_PROFILE_LOADING, D as DELETE_USER_PROFILE_FAILED, i as DELETE_USER_PROFILE_SUCCESS, j as DELETE_USER_PROFILE_LOADING, k as RESET_USER_PROFILE_STATE, G as GET_USER_PROFILE_FAILED, l as GET_USER_PROFILE_SUCCESS, m as GET_USER_PROFILE_LOADING, n as UserRoleLabel } from "./pages/OwnUserProfilePage.js";
+import { S as SET_USERS, a as SET_QUEUE, L as LoginById, U as UserAvatarById, r as resolveUsersByIds } from "./components/UserAvatar.js";
+import { u as useCapabilities, a as Capability, c as capabilities } from "./components/Breadcrumbs.js";
+import block from "bem-cn-lite";
+import { GravityChartsPlugin } from "@gravity-ui/chartkit/gravity-charts";
+import { HighchartsPlugin } from "@gravity-ui/chartkit/highcharts";
+import { IndicatorPlugin } from "@gravity-ui/chartkit/indicator";
+import { YagrPlugin } from "@gravity-ui/chartkit/yagr";
+import { g as getChartkitMenuByType, b as getDefaultChartMenu, c as getPanePreviewChartMenu, d as getWizardChartMenu, e as getChartkitMenu, X as X_CSRF_TOKEN_HEADER$1, D as DATALENS_DEBUG_MODE_KEY$1 } from "./components/Widgets.js";
+import { W as WORKBOOKS_PATH, M as MOBILE_SIZE } from "./components/CollectionFilters.js";
+import { g as getEntryScopesWithRevisionsList } from "./components/RevisionsPanel.js";
+import { cx as setWizardWidgetKey, cy as setQlEntryKey, cz as setError, cA as setStatus, b6 as performManualConfiguration, aW as getEntry, aY as getDefaultPath, bC as AppStatus, cB as AVAILABLE_CONNECTION_TYPES_BY_CHART_TYPE } from "./pages/DashPage.js";
+import { s as setConnectionKey, c as changeInnerForm, b as changeForm, I as InnerFieldKey, L as Label$1, R as RadioButton, d as Input, f as formSelector, e as RadioGroup, g as getIsShowCreateConnectionButton, h as getNewConnectionDestination, j as getFakeEntry } from "./pages/ConnectionsPage.js";
+import { E as EntryBreadcrumbs } from "./components/EntryBreadcrumbs.js";
+import { f as getAdditionalEntryContextMenuItems, h as getMenuGroupConfig, j as getEntryMenuConfig } from "./components/EntryContextMenu.js";
+import { g as getAdditionalEntryDialoguesMap } from "./components/EntryDialogues.js";
+import { g as getEntryName } from "./components/EntryTitle.js";
+import { I as Illustration, g as getIllustrationStore } from "./components/Illustration.js";
+import { M as MarkdownControl } from "./components/MarkdownControl.js";
+import { a as getPlacesConfig, b as getCreatableEntriesConfig, c as getQuickItems, d as getInitDestination, e as getPlaceSelectParameters, N as NavigationMinimal_default } from "./components/Navigation.js";
+import { a as YfmWrapperContent } from "./components/YfmWrapper.js";
+import { a as DatepickerControl } from "./components/common.js";
+import { P as PlaceholderIllustration } from "./components/PlaceholderIllustration.js";
+import { C as ChunkGroup, E as EmptyRow, a as CreateEntryActionType, b as CreateEntry, T as TAB_ALL } from "./pages/CollectionsNavigationPage.js";
+import { ChevronDown, ChevronUp, Plus, ChartColumn, Heading, TextAlignLeft, Picture, Sliders, CircleXmark, Database, Lock, ChartMixed, TriangleExclamationFill } from "@gravity-ui/icons";
+import { S as SmartLoader } from "./components/SmartLoader.js";
+import update from "immutability-helper";
+import { a as DialogEntryDescription } from "./components/DialogEntryDescription.js";
+import noop from "lodash/noop";
+import { C as Collapse } from "./components/Collapse.js";
+import { get } from "lodash";
+import { a as DialogTextWidget } from "./components/DialogTextWidget.js";
+import { m as getDashEntryUrl, n as getNewDashUrl$1, C as ControlButton, o as ControlCheckbox, p as ControlRangeDatepicker, q as ControlDatepicker, r as ControlTextArea, s as ControlInput, t as ControlSelect, v as isValidRequiredValue } from "./components/DashKit.js";
+import { g as getFieldEditorDocPath } from "./components/FieldEditor.js";
+import { E as EntryIcon } from "./components/EntryIcon.js";
+import { F as FieldWrapper } from "./components/FieldWrapper.js";
+import { compose } from "recompose";
+import { W as WorkbookNavigationMinimal } from "./components/WorkbookNavigationMinimal.js";
+import { E as EntityIcon } from "./components/EntityIcon.js";
+import isEmpty from "lodash/isEmpty";
+import _uniqBy from "lodash/uniqBy";
+import { I as Interpolate } from "./components/Interpolate.js";
+import isEqual from "lodash/isEqual";
+import { a8 as HOTKEYS_SCOPES } from "./components/DialogFilter.js";
+import "@gravity-ui/uikit/styles/styles.scss";
+/* empty css       */
+import { createHashHistory } from "history";
+const { theme, themeSettings } = getLocalTheme();
+function getUserState() {
+  return {
+    settings: {
+      data: DL.USER_SETTINGS,
+      error: null,
+      loading: false
+    },
+    theme,
+    themeSettings
+  };
+}
+function user(state = getUserState(), action) {
+  switch (action.type) {
+    case UPDATE_USER_SETTINGS: {
+      return {
+        ...state,
+        settings: {
+          ...state.settings,
+          data: { ...state.settings.data, ...action.payload.userSettings }
+        }
+      };
+    }
+    case SET_THEME: {
+      return {
+        ...state,
+        theme: action.payload.theme,
+        themeSettings: action.payload.themeSettings
+      };
+    }
+    default:
+      return state;
+  }
+}
+function getLandingNavigationSettings() {
+  const errorType = DL.LANDING_PAGE_ERROR_TYPE;
+  return {
+    withHelpCenter: !isHeaderWithoutHelpCenterError(errorType),
+    withNavigation: !isHeaderWithoutNavigationError(errorType)
+  };
+}
+const getInitialSettings = () => ({
+  withHelpCenter: true,
+  withNavigation: !DL.HIDE_NAVIGATION,
+  navigationType: "aside",
+  ...DL.IS_LANDING ? getLandingNavigationSettings() : {}
+});
+const getInitialState$1 = () => ({
+  startFromNavigation: "",
+  panelVisible: false,
+  place: "",
+  asideHeaderData: {
+    // This initial size is used in mobile version
+    size: 0
+  },
+  settings: getInitialSettings(),
+  currentPageEntry: null,
+  isHidden: false
+});
+const getAsideHeaderInitialState = () => {
+  const { getIsCompact: getIsCompact2 } = registry.common.functions.getAll();
+  return {
+    ...getInitialState$1(),
+    isCompact: getIsCompact2()
+  };
+};
+function asideHeader(state = getAsideHeaderInitialState(), action) {
+  switch (action.type) {
+    case OPEN_NAVIGATION: {
+      const { startFromNavigation, place } = action;
+      return {
+        ...state,
+        startFromNavigation: startFromNavigation || "",
+        place: place || "",
+        panelVisible: true
+      };
+    }
+    case CLOSE_NAVIGATION: {
+      return {
+        ...state,
+        panelVisible: false
+      };
+    }
+    case SET_ASIDE_HEADER_DATA: {
+      return {
+        ...state,
+        asideHeaderData: action.asideHeaderData
+      };
+    }
+    case SET_CURRENT_PAGE_ENTRY: {
+      return {
+        ...state,
+        currentPageEntry: action.currentPageEntry
+      };
+    }
+    case SET_ASIDE_HEADER_SETTINGS: {
+      return {
+        ...state,
+        settings: {
+          ...state.settings,
+          ...action.settings
+        }
+      };
+    }
+    case RESET_ASIDE_HEADER_SETTINGS: {
+      return {
+        ...state,
+        settings: getInitialSettings()
+      };
+    }
+    case SET_IS_COMPACT: {
+      return {
+        ...state,
+        isCompact: action.isCompact
+      };
+    }
+    case SET_IS_HIDDEN: {
+      return {
+        ...state,
+        isHidden: action.isHidden
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+}
+const initialState$b = {
+  getWorkbookEntries: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  getWorkbookSharedEntries: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  bindSharedEntryToWorkbook: {
+    isLoading: false,
+    error: null
+  },
+  items: [],
+  sharedItems: [],
+  getWorkbook: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  getWorkbookBreadcrumbs: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  createWorkbookEntry: {
+    type: null
+  },
+  renameEntry: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  changeFavoriteEntry: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  deleteEntry: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  filters: {
+    filterString: void 0,
+    orderField: "name",
+    orderDirection: "asc"
+  },
+  workbooksNames: {},
+  workbookPermissions: null,
+  entityBreadcrumbs: null
+};
+const workbooksReducer = (state = initialState$b, action) => {
+  switch (action.type) {
+    // Information about the workbook
+    case GET_WORKBOOK_LOADING: {
+      return {
+        ...state,
+        getWorkbook: {
+          ...state.getWorkbook,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_WORKBOOK_SUCCESS: {
+      return {
+        ...state,
+        getWorkbook: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_WORKBOOK_FAILED: {
+      return {
+        ...state,
+        getWorkbook: {
+          ...state.getWorkbook,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Bread crumbs of workbooks
+    case GET_WORKBOOK_BREADCRUMBS_LOADING: {
+      return {
+        ...state,
+        getWorkbookBreadcrumbs: {
+          ...state.getWorkbookBreadcrumbs,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_WORKBOOK_BREADCRUMBS_SUCCESS: {
+      return {
+        ...state,
+        getWorkbookBreadcrumbs: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_WORKBOOK_BREADCRUMBS_FAILED: {
+      return {
+        ...state,
+        getWorkbookBreadcrumbs: {
+          ...state.getWorkbookBreadcrumbs,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Entities in the workbook
+    case GET_WORKBOOK_ENTRIES_LOADING: {
+      return {
+        ...state,
+        getWorkbookEntries: {
+          ...state.getWorkbookEntries,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_WORKBOOK_ENTRIES_SUCCESS: {
+      const loadedIds = new Set(
+        state.items.map((item) => {
+          return item.entryId;
+        })
+      );
+      const newEntries = action.data.entries.filter((entry) => !loadedIds.has(entry.entryId));
+      return {
+        ...state,
+        getWorkbookEntries: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        },
+        items: [...state.items, ...newEntries]
+      };
+    }
+    case GET_ALL_WORKBOOK_ENTRIES_SEPARATELY_SUCCESS: {
+      const loadedIds = new Set(
+        state.items.map((item) => {
+          return item.entryId;
+        })
+      );
+      const newEntries = [];
+      action.data.forEach((workbookEntries) => {
+        return workbookEntries?.entries.forEach((entry) => {
+          if (!loadedIds.has(entry.entryId)) {
+            newEntries.push(entry);
+          }
+        });
+      });
+      return {
+        ...state,
+        getWorkbookEntries: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        },
+        items: [...state.items, ...newEntries]
+      };
+    }
+    case GET_WORKBOOK_ENTRIES_FAILED: {
+      return {
+        ...state,
+        getWorkbookEntries: {
+          ...state.getWorkbookEntries,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Shared entities in the workbook
+    case GET_WORKBOOK_SHARED_ENTRIES_LOADING: {
+      return {
+        ...state,
+        getWorkbookSharedEntries: {
+          ...state.getWorkbookSharedEntries,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_WORKBOOK_SHARED_ENTRIES_SUCCESS: {
+      const loadedIds = new Set(
+        state.sharedItems.map((item) => {
+          return item.entryId;
+        })
+      );
+      const newEntries = action.data.entries.filter((entry) => !loadedIds.has(entry.entryId));
+      return {
+        ...state,
+        getWorkbookSharedEntries: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        },
+        sharedItems: [...state.sharedItems, ...newEntries]
+      };
+    }
+    case GET_WORKBOOK_SHARED_ENTRIES_FAILED: {
+      return {
+        ...state,
+        getWorkbookSharedEntries: {
+          ...state.getWorkbookSharedEntries,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case BIND_SHARED_ENTRY_TO_WORKBOOK_LOADING: {
+      return {
+        ...state,
+        bindSharedEntryToWorkbook: {
+          ...state.bindSharedEntryToWorkbook,
+          isLoading: true
+        }
+      };
+    }
+    case BIND_SHARED_ENTRY_TO_WORKBOOK_SUCCESS: {
+      return {
+        ...state,
+        bindSharedEntryToWorkbook: {
+          isLoading: false,
+          error: null
+        }
+      };
+    }
+    case BIND_SHARED_ENTRY_TO_WORKBOOK_FAILED: {
+      return {
+        ...state,
+        bindSharedEntryToWorkbook: {
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Resetting information about the contents of the workbook
+    case RESET_WORKBOOK_ENTRIES: {
+      return {
+        ...state,
+        getWorkbookEntries: initialState$b.getWorkbookEntries,
+        items: initialState$b.items
+      };
+    }
+    // Resetting information about the shared entries of the workbook
+    case RESET_WORKBOOK_SHARED_ENTRIES: {
+      return {
+        ...state,
+        getWorkbookSharedEntries: initialState$b.getWorkbookSharedEntries,
+        sharedItems: initialState$b.sharedItems
+      };
+    }
+    case RESET_WORKBOOK_ENTRIES_BY_SCOPE: {
+      const entries = state.items.filter((entry) => entry.scope !== action.data);
+      return {
+        ...state,
+        getWorkbookEntries: {
+          ...state.getWorkbookEntries,
+          data: entries
+        },
+        items: entries
+      };
+    }
+    // Information about which entity to create in the workbook
+    case SET_CREATE_WORKBOOK_ENTRY_TYPE: {
+      return {
+        ...state,
+        createWorkbookEntry: {
+          type: action.data
+        }
+      };
+    }
+    case RESET_CREATE_WORKBOOK_ENTRY_TYPE: {
+      return {
+        ...state,
+        createWorkbookEntry: initialState$b.createWorkbookEntry
+      };
+    }
+    // Renaming the entry
+    case RENAME_ENTRY_LOADING: {
+      return {
+        ...state,
+        renameEntry: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case RENAME_ENTRY_SUCCESS: {
+      return {
+        ...state,
+        renameEntry: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case RENAME_ENTRY_FAILED: {
+      return {
+        ...state,
+        renameEntry: {
+          ...state.renameEntry,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case RENAME_ENTRY_INLINE: {
+      return {
+        ...state,
+        items: state.items.map((item) => {
+          const renamedEntry = action.data[0];
+          if (renamedEntry.entryId === item.entryId) {
+            const newItem = { ...item };
+            Object.keys(newItem).forEach((key) => {
+              const typedKey = key;
+              if (typedKey in renamedEntry) {
+                newItem[typedKey] = renamedEntry[typedKey];
+              }
+            });
+            return newItem;
+          }
+          return item;
+        })
+      };
+    }
+    // Change favorite the entry
+    case CHANGE_FAVORITE_ENTRY_LOADING: {
+      return {
+        ...state,
+        changeFavoriteEntry: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case CHANGE_FAVORITE_ENTRY_SUCCESS: {
+      return {
+        ...state,
+        changeFavoriteEntry: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case CHANGE_FAVORITE_ENTRY_FAILED: {
+      return {
+        ...state,
+        changeFavoriteEntry: {
+          ...state.changeFavoriteEntry,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case CHANGE_FAVORITE_ENTRY_INLINE: {
+      const changeFavoriteEntry = Array.isArray(action.data) ? action.data[0] : action.data;
+      const mapItemsCallback = (item) => {
+        if (changeFavoriteEntry.entryId === item.entryId) {
+          const newItem = { ...item };
+          newItem.isFavorite = !newItem.isFavorite;
+          return newItem;
+        }
+        return item;
+      };
+      return {
+        ...state,
+        sharedItems: state.sharedItems.map(mapItemsCallback),
+        items: state.items.map(mapItemsCallback)
+      };
+    }
+    // Deleting an entry
+    case DELETE_ENTRY_LOADING: {
+      return {
+        ...state,
+        deleteEntry: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case DELETE_ENTRY_SUCCESS: {
+      return {
+        ...state,
+        deleteEntry: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case DELETE_ENTRY_FAILED: {
+      return {
+        ...state,
+        deleteEntry: {
+          ...state.deleteEntry,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case DELETE_ENTRY_INLINE: {
+      return {
+        ...state,
+        items: state.items.filter((item) => {
+          if (action.data.entryId === item.entryId) {
+            return false;
+          }
+          return true;
+        })
+      };
+    }
+    case CHANGE_FILTERS: {
+      return {
+        ...state,
+        filters: {
+          ...state.filters,
+          ...action.data
+        }
+      };
+    }
+    case ADD_WORKBOOK_INFO: {
+      return {
+        ...state,
+        workbooksNames: {
+          ...state.workbooksNames,
+          [action.data.workbookId]: action.data.workbookName
+        },
+        workbookPermissions: action.data.workbookPermissions,
+        entityBreadcrumbs: action.data.workbookBreadcrumbs
+      };
+    }
+    case ADD_COLLECTION_BREADCRUMBS: {
+      return {
+        ...state,
+        entityBreadcrumbs: action.data
+      };
+    }
+    case RESET_WORKBOOK_PERMISSIONS: {
+      return {
+        ...state,
+        workbookPermissions: null
+      };
+    }
+    case SET_WORKBOOK: {
+      return {
+        ...state,
+        getWorkbook: {
+          isLoading: false,
+          data: action.data.workbook,
+          error: null
+        }
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+};
+const reducer$1 = (state, action) => {
+  if (action.type === RESET_WORKBOOK_STATE) {
+    return workbooksReducer(void 0, action);
+  }
+  return workbooksReducer(state, action);
+};
+const getInitialDialogState = () => ({
+  dialogs: []
+});
+function dialog(state = getInitialDialogState(), action) {
+  switch (action.type) {
+    case OPEN_DIALOG:
+      return {
+        ...state,
+        dialogs: [...state.dialogs, { id: action.id, props: action.props }]
+      };
+    case CLOSE_DIALOG: {
+      return {
+        ...state,
+        dialogs: state.dialogs.slice(0, -1)
+      };
+    }
+    case UPDATE_DIALOG_PROPS: {
+      const { id, props } = action;
+      const dialogToUpdateIndex = state.dialogs.findIndex((d) => d.id === id);
+      if (dialogToUpdateIndex !== -1) {
+        const dialogToUpdate = state.dialogs[dialogToUpdateIndex];
+        const updatedDialog = Object.assign(
+          { id: dialogToUpdate.id },
+          { props: dialogToUpdate.props },
+          { props }
+        );
+        const nextDialogs = state.dialogs.map((d) => {
+          if (d.id === id) {
+            return updatedDialog;
+          }
+          return d;
+        });
+        return {
+          ...state,
+          dialogs: nextDialogs
+        };
+      }
+      return state;
+    }
+    case PARTIAL_UPDATE_DIALOG_PROPS: {
+      const { id, props } = action;
+      const dialogToUpdateIndex = state.dialogs.findIndex((d) => d.id === id);
+      if (dialogToUpdateIndex !== -1) {
+        const dialogToUpdate = state.dialogs[dialogToUpdateIndex];
+        const updatedDialog = Object.assign(
+          { id: dialogToUpdate.id },
+          { props: { ...dialogToUpdate.props, ...props } }
+        );
+        return {
+          ...state,
+          dialogs: state.dialogs.map((d) => d.id === id ? updatedDialog : d)
+        };
+      }
+      return state;
+    }
+    default:
+      return state;
+  }
+}
+const initialState$a = {
+  isLanding: DL.IS_LANDING
+};
+const landing = (state = initialState$a, action) => {
+  switch (action.type) {
+    case SET_IS_LANDING: {
+      return {
+        isLanding: action.isLanding
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+};
+const getInitialEntryContentState = () => ({
+  revisionsMode: RevisionsMode.Closed,
+  revisionsListMode: RevisionsListMode.Expanded,
+  revisions: null,
+  currentRevId: null,
+  hasRevisionsNextPage: false,
+  revisionsLoadingStatus: "",
+  isRenameWithoutReload: false
+});
+function entryContent(state = getInitialEntryContentState(), action) {
+  switch (action.type) {
+    case SET_ENTRY: {
+      const newEntryId = action.payload.entryId;
+      const currentEntryRevisionsList = state.revisions;
+      const needCleanRevisionsList = currentEntryRevisionsList?.length && currentEntryRevisionsList[0].entryId !== newEntryId;
+      const revisions = needCleanRevisionsList ? [] : state.revisions;
+      return {
+        ...state,
+        ...action.payload,
+        revisions,
+        currentRevId: action.payload.revId
+      };
+    }
+    case SET_REVISIONS_MODE: {
+      const newState = {
+        ...state,
+        revisionsMode: action.payload
+      };
+      if (!action.payload) {
+        newState.revisionsListMode = RevisionsListMode.Expanded;
+      }
+      return newState;
+    }
+    case SET_REVISIONS_LIST_MODE:
+      return {
+        ...state,
+        revisionsListMode: action.payload
+      };
+    case TOGGLE_REVISIONS_MODE: {
+      const newRevisionsMode = state.revisionsMode === RevisionsMode.Opened ? RevisionsMode.Closed : RevisionsMode.Opened;
+      const newState = {
+        ...state,
+        revisionsMode: newRevisionsMode
+      };
+      return newState;
+    }
+    case SET_REVISIONS: {
+      const { revisions, currentRevId, hasRevisionsNextPage } = action.payload;
+      return {
+        ...state,
+        revisions,
+        currentRevId,
+        hasRevisionsNextPage
+      };
+    }
+    case CLEAN_REVISIONS: {
+      return {
+        ...state,
+        revisions: [],
+        hasRevisionsNextPage: false
+      };
+    }
+    case SET_ENTRY_CURRENT_REVID:
+      return {
+        ...state,
+        currentRevId: action.payload
+      };
+    case REVISIONS_LOADING_STATUS:
+      return {
+        ...state,
+        revisionsLoadingStatus: action.payload
+      };
+    case SET_IS_RENAME_WITHOUT_RELOAD: {
+      return {
+        ...state,
+        isRenameWithoutReload: action.isRenameWithoutReload
+      };
+    }
+    default:
+      return state;
+  }
+}
+const getInitialState = () => ({
+  colorPalettes: [],
+  currentColorPalette: void 0
+});
+function colorPaletteEditor(state = getInitialState(), action) {
+  switch (action.type) {
+    case SET_CURRENT_COLOR_PALETTE: {
+      return {
+        ...state,
+        currentColorPalette: action.colorPalette
+      };
+    }
+    case SET_COLOR_PALETTES: {
+      return {
+        ...state,
+        colorPalettes: action.colorPalettes
+      };
+    }
+    default:
+      return state;
+  }
+}
+const initialState$9 = {
+  getRootCollectionPermissions: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  getCollectionBreadcrumbs: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  getCollection: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  getStructureItems: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  items: [],
+  createCollection: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  copyTemplate: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  createWorkbook: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  moveCollection: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  moveCollections: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  moveWorkbook: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  moveWorkbooks: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  moveSharedEntry: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  copyWorkbook: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  updateWorkbook: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  updateCollection: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  deleteCollection: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  deleteCollections: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  deleteWorkbook: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  deleteWorkbooks: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  exportWorkbook: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  importWorkbook: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  getExportResult: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  getImportProgress: {
+    isLoading: false,
+    data: null,
+    error: null,
+    notificationEntries: null
+  },
+  getExportProgress: {
+    isLoading: false,
+    data: null,
+    error: null,
+    notificationEntries: null
+  }
+};
+const collectionsStructure = (state = initialState$9, action) => {
+  switch (action.type) {
+    case RESET_STATE: {
+      return initialState$9;
+    }
+    // Getting rights at the root of the structure
+    case GET_ROOT_COLLECTION_PERMISSIONS_LOADING: {
+      return {
+        ...state,
+        getRootCollectionPermissions: {
+          ...state.getRootCollectionPermissions,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_ROOT_COLLECTION_PERMISSIONS_SUCCESS: {
+      return {
+        ...state,
+        getRootCollectionPermissions: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_ROOT_COLLECTION_PERMISSIONS_FAILED: {
+      return {
+        ...state,
+        getRootCollectionPermissions: {
+          ...state.getRootCollectionPermissions,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Reset the collection bread crumbs
+    case RESET_COLLECTION_BREADCRUMBS: {
+      return {
+        ...state,
+        getCollectionBreadcrumbs: initialState$9.getCollectionBreadcrumbs
+      };
+    }
+    // Collections Bread Crumbs
+    case GET_COLLECTION_BREADCRUMBS_LOADING: {
+      return {
+        ...state,
+        getCollectionBreadcrumbs: {
+          ...state.getCollectionBreadcrumbs,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_COLLECTION_BREADCRUMBS_SUCCESS: {
+      return {
+        ...state,
+        getCollectionBreadcrumbs: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_COLLECTION_BREADCRUMBS_FAILED: {
+      return {
+        ...state,
+        getCollectionBreadcrumbs: {
+          ...state.getCollectionBreadcrumbs,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Information about the collection
+    case GET_COLLECTION_LOADING: {
+      return {
+        ...state,
+        getCollection: {
+          ...state.getCollection,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_COLLECTION_SUCCESS: {
+      return {
+        ...state,
+        getCollection: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_COLLECTION_FAILED: {
+      return {
+        ...state,
+        getCollection: {
+          ...state.getCollection,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Resetting Collection contents
+    case RESET_STRUCTURE_ITEMS: {
+      return {
+        ...state,
+        getStructureItems: initialState$9.getStructureItems,
+        items: initialState$9.items
+      };
+    }
+    // Contents of the collection
+    case GET_STRUCTURE_ITEMS_LOADING: {
+      return {
+        ...state,
+        getStructureItems: {
+          ...state.getStructureItems,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_STRUCTURE_ITEMS_SUCCESS: {
+      const loadedIds = state.items.map((item) => {
+        if ("workbookId" in item) {
+          return item.workbookId;
+        }
+        return item.collectionId;
+      });
+      const newItems = action.data.items.filter((item) => {
+        const id = "workbookId" in item ? item.workbookId : item.collectionId;
+        return !loadedIds.includes(id);
+      });
+      return {
+        ...state,
+        getStructureItems: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        },
+        items: [...state.items, ...newItems]
+      };
+    }
+    case GET_STRUCTURE_ITEMS_FAILED: {
+      return {
+        ...state,
+        getStructureItems: {
+          ...state.getStructureItems,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // copy template
+    case COPY_TEMPLATE_LOADING: {
+      return {
+        ...state,
+        copyTemplate: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case COPY_TEMPLATE_SUCCESS: {
+      return {
+        ...state,
+        copyTemplate: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case COPY_TEMPLATE_FAILED: {
+      return {
+        ...state,
+        copyTemplate: {
+          ...state.copyTemplate,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // collections creation
+    case CREATE_COLLECTION_LOADING: {
+      return {
+        ...state,
+        createCollection: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case CREATE_COLLECTION_SUCCESS: {
+      return {
+        ...state,
+        createCollection: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case CREATE_COLLECTION_FAILED: {
+      return {
+        ...state,
+        createCollection: {
+          ...state.createCollection,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case CREATE_WORKBOOK_LOADING: {
+      return {
+        ...state,
+        createWorkbook: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case CREATE_WORKBOOK_SUCCESS: {
+      return {
+        ...state,
+        createWorkbook: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case CREATE_WORKBOOK_FAILED: {
+      return {
+        ...state,
+        createWorkbook: {
+          ...state.createWorkbook,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Moving a collection
+    case MOVE_COLLECTION_LOADING: {
+      return {
+        ...state,
+        moveCollection: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case MOVE_COLLECTION_SUCCESS: {
+      return {
+        ...state,
+        moveCollection: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case MOVE_COLLECTION_FAILED: {
+      return {
+        ...state,
+        moveCollection: {
+          ...state.moveCollection,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Moving collections
+    case MOVE_COLLECTIONS_LOADING: {
+      return {
+        ...state,
+        moveCollections: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case MOVE_COLLECTIONS_SUCCESS: {
+      return {
+        ...state,
+        moveCollections: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case MOVE_COLLECTIONS_FAILED: {
+      return {
+        ...state,
+        moveCollections: {
+          ...state.moveCollections,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Moving the workbook
+    case MOVE_WORKBOOK_LOADING: {
+      return {
+        ...state,
+        moveWorkbook: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case MOVE_WORKBOOK_SUCCESS: {
+      return {
+        ...state,
+        moveWorkbook: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case MOVE_WORKBOOK_FAILED: {
+      return {
+        ...state,
+        moveWorkbook: {
+          ...state.moveWorkbook,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Moving workbooks
+    case MOVE_WORKBOOKS_LOADING: {
+      return {
+        ...state,
+        moveWorkbooks: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case MOVE_WORKBOOKS_SUCCESS: {
+      return {
+        ...state,
+        moveWorkbooks: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case MOVE_WORKBOOKS_FAILED: {
+      return {
+        ...state,
+        moveWorkbooks: {
+          ...state.moveWorkbooks,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Moving a shared entry
+    case MOVE_SHARED_ENTRY_LOADING: {
+      return {
+        ...state,
+        moveSharedEntry: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case MOVE_SHARED_ENTRY_SUCCESS: {
+      return {
+        ...state,
+        moveSharedEntry: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case MOVE_SHARED_ENTRY_FAILED: {
+      return {
+        ...state,
+        moveSharedEntry: {
+          ...state.moveSharedEntry,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Copying a workbook
+    case COPY_WORKBOOK_LOADING: {
+      return {
+        ...state,
+        copyWorkbook: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case COPY_WORKBOOK_SUCCESS: {
+      return {
+        ...state,
+        copyWorkbook: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case COPY_WORKBOOK_FAILED: {
+      return {
+        ...state,
+        copyWorkbook: {
+          ...state.copyWorkbook,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Workbook modification
+    case UPDATE_WORKBOOK_LOADING: {
+      return {
+        ...state,
+        updateWorkbook: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case UPDATE_WORKBOOK_SUCCESS: {
+      return {
+        ...state,
+        updateWorkbook: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case UPDATE_WORKBOOK_FAILED: {
+      return {
+        ...state,
+        updateWorkbook: {
+          ...state.updateWorkbook,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Collection modification
+    case UPDATE_COLLECTION_LOADING: {
+      return {
+        ...state,
+        updateCollection: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case UPDATE_COLLECTION_SUCCESS: {
+      return {
+        ...state,
+        updateCollection: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case UPDATE_COLLECTION_FAILED: {
+      return {
+        ...state,
+        updateCollection: {
+          ...state.updateCollection,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Deleting a collection
+    case DELETE_COLLECTION_LOADING: {
+      return {
+        ...state,
+        deleteCollection: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case DELETE_COLLECTION_SUCCESS: {
+      return {
+        ...state,
+        deleteCollection: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case DELETE_COLLECTION_FAILED: {
+      return {
+        ...state,
+        deleteCollection: {
+          ...state.deleteCollection,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Delete collections
+    case DELETE_COLLECTIONS_LOADING: {
+      return {
+        ...state,
+        deleteCollections: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case DELETE_COLLECTIONS_SUCCESS: {
+      return {
+        ...state,
+        deleteCollections: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case DELETE_COLLECTIONS_FAILED: {
+      return {
+        ...state,
+        deleteCollections: {
+          ...state.deleteCollections,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Deleting a workbook
+    case DELETE_WORKBOOK_LOADING: {
+      return {
+        ...state,
+        deleteWorkbook: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case DELETE_WORKBOOK_SUCCESS: {
+      return {
+        ...state,
+        deleteWorkbook: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case DELETE_WORKBOOK_FAILED: {
+      return {
+        ...state,
+        deleteWorkbook: {
+          ...state.deleteWorkbook,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Delete workbooks
+    case DELETE_WORKBOOKS_LOADING: {
+      return {
+        ...state,
+        deleteWorkbooks: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case DELETE_WORKBOOKS_SUCCESS: {
+      return {
+        ...state,
+        deleteWorkbooks: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case DELETE_WORKBOOKS_FAILED: {
+      return {
+        ...state,
+        deleteWorkbooks: {
+          ...state.deleteWorkbooks,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    // Export workbook file
+    case EXPORT_WORKBOOK_LOADING: {
+      return {
+        ...state,
+        exportWorkbook: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case EXPORT_WORKBOOK_SUCCESS: {
+      return {
+        ...state,
+        exportWorkbook: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case EXPORT_WORKBOOK_FAILED: {
+      return {
+        ...state,
+        exportWorkbook: {
+          isLoading: false,
+          data: null,
+          error: action.error
+        }
+      };
+    }
+    case RESET_EXPORT_WORKBOOK: {
+      return {
+        ...state,
+        exportWorkbook: {
+          isLoading: false,
+          data: null,
+          error: null
+        }
+      };
+    }
+    // Import workbook file
+    case IMPORT_WORKBOOK_LOADING: {
+      return {
+        ...state,
+        importWorkbook: {
+          isLoading: true,
+          data: null,
+          error: null
+        }
+      };
+    }
+    case IMPORT_WORKBOOK_SUCCESS: {
+      return {
+        ...state,
+        importWorkbook: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case IMPORT_WORKBOOK_FAILED: {
+      return {
+        ...state,
+        importWorkbook: {
+          isLoading: false,
+          data: null,
+          error: action.error
+        }
+      };
+    }
+    case RESET_IMPORT_WORKBOOK: {
+      return {
+        ...state,
+        importWorkbook: {
+          isLoading: false,
+          data: null,
+          error: null
+        }
+      };
+    }
+    // Getting workbook import progres
+    case GET_IMPORT_PROGRESS_LOADING: {
+      return {
+        ...state,
+        getImportProgress: {
+          ...state.getImportProgress,
+          isLoading: true,
+          error: null,
+          notificationEntries: null
+        }
+      };
+    }
+    case GET_IMPORT_PROGRESS_SUCCESS: {
+      return {
+        ...state,
+        getImportProgress: {
+          isLoading: false,
+          data: action.data,
+          error: null,
+          notificationEntries: action.notificationEntries
+        }
+      };
+    }
+    case GET_IMPORT_PROGRESS_FAILED: {
+      return {
+        ...state,
+        getImportProgress: {
+          ...state.getImportProgress,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case RESET_IMPORT_PROGRESS: {
+      return {
+        ...state,
+        getImportProgress: {
+          isLoading: false,
+          data: null,
+          error: null,
+          notificationEntries: null
+        }
+      };
+    }
+    // Getting workbook export progress
+    case GET_EXPORT_PROGRESS_LOADING: {
+      return {
+        ...state,
+        getExportProgress: {
+          ...state.getExportProgress,
+          isLoading: true,
+          error: null,
+          notificationEntries: null
+        }
+      };
+    }
+    case GET_EXPORT_PROGRESS_SUCCESS: {
+      return {
+        ...state,
+        getExportProgress: {
+          isLoading: false,
+          data: action.data,
+          error: null,
+          notificationEntries: action.notificationEntries
+        }
+      };
+    }
+    case GET_EXPORT_PROGRESS_FAILED: {
+      return {
+        ...state,
+        getExportProgress: {
+          ...state.getExportProgress,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case RESET_EXPORT_PROGRESS: {
+      return {
+        ...state,
+        getExportProgress: {
+          isLoading: false,
+          data: null,
+          error: null,
+          notificationEntries: null
+        }
+      };
+    }
+    // Getting export result
+    case GET_EXPORT_RESULT_LOADING: {
+      return {
+        ...state,
+        getExportResult: {
+          ...state.getExportResult,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_EXPORT_RESULT_SUCCESS: {
+      return {
+        ...state,
+        getExportResult: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_EXPORT_RESULT_FAILED: {
+      return {
+        ...state,
+        getExportResult: {
+          ...state.getExportResult,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case RESET_EXPORT_RESULT: {
+      return {
+        ...state,
+        getExportResult: initialState$9.getExportResult
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+};
+const initialState$8 = {
+  getEntry: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  getRelationsGraph: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  getRelations: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  migrateEntriesToWorkbook: {
+    isLoading: false,
+    data: null,
+    error: null
+  }
+};
+const migrationToWorkbook = (state = initialState$8, action) => {
+  switch (action.type) {
+    case RESET_STATE$1: {
+      return initialState$8;
+    }
+    case GET_ENTRY_LOADING: {
+      return {
+        ...state,
+        getEntry: {
+          ...state.getEntry,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_ENTRY_SUCCESS: {
+      return {
+        ...state,
+        getEntry: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_ENTRY_FAILED: {
+      return {
+        ...state,
+        getEntry: {
+          ...state.getEntry,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case GET_RELATIONS_GRAPH_LOADING: {
+      return {
+        ...state,
+        getRelationsGraph: {
+          ...state.getRelationsGraph,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_RELATIONS_GRAPH_SUCCESS: {
+      return {
+        ...state,
+        getRelationsGraph: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_RELATIONS_GRAPH_FAILED: {
+      return {
+        ...state,
+        getRelationsGraph: {
+          ...state.getRelationsGraph,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case GET_RELATIONS_LOADING: {
+      return {
+        ...state,
+        getRelations: {
+          ...state.getRelations,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_RELATIONS_SUCCESS: {
+      return {
+        ...state,
+        getRelations: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_RELATIONS_FAILED: {
+      return {
+        ...state,
+        getRelations: {
+          ...state.getRelations,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case MIGRATE_ENTRIES_TO_WORKBOOK_LOADING: {
+      return {
+        ...state,
+        migrateEntriesToWorkbook: {
+          ...state.migrateEntriesToWorkbook,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case MIGRATE_ENTRIES_TO_WORKBOOK_SUCCESS: {
+      return {
+        ...state,
+        migrateEntriesToWorkbook: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case MIGRATE_ENTRIES_TO_WORKBOOK_FAILED: {
+      return {
+        ...state,
+        migrateEntriesToWorkbook: {
+          ...state.migrateEntriesToWorkbook,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+};
+const initialState$7 = {
+  getEntry: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  getRelations: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  copyEntriesToWorkbook: {
+    isLoading: false,
+    data: null,
+    error: null
+  }
+};
+const copyEntriesToWorkbook = (state = initialState$7, action) => {
+  switch (action.type) {
+    case RESET_STATE$2: {
+      return initialState$7;
+    }
+    case GET_ENTRY_LOADING$1: {
+      return {
+        ...state,
+        getEntry: {
+          ...state.getEntry,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_ENTRY_SUCCESS$1: {
+      return {
+        ...state,
+        getEntry: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_ENTRY_FAILED$1: {
+      return {
+        ...state,
+        getEntry: {
+          ...state.getEntry,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case GET_RELATIONS_LOADING$1: {
+      return {
+        ...state,
+        getRelations: {
+          ...state.getRelations,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_RELATIONS_SUCCESS$1: {
+      return {
+        ...state,
+        getRelations: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_RELATIONS_FAILED$1: {
+      return {
+        ...state,
+        getRelations: {
+          ...state.getRelations,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case COPY_ENTRIES_TO_WORKBOOK_LOADING: {
+      return {
+        ...state,
+        copyEntriesToWorkbook: {
+          ...state.copyEntriesToWorkbook,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case COPY_ENTRIES_TO_WORKBOOK_SUCCESS: {
+      return {
+        ...state,
+        copyEntriesToWorkbook: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case COPY_ENTRIES_TO_WORKBOOK_FAILED: {
+      return {
+        ...state,
+        copyEntriesToWorkbook: {
+          ...state.copyEntriesToWorkbook,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+};
+const initialState$6 = {
+  units: {}
+};
+const cloneStateForHistory = (state, pathIgnoreList) => {
+  const deepOmitBy = (value, path, iteratee) => {
+    if (isObject(value) && !isSet(value) && !isFunction(value)) {
+      return transform(value, (result, item, key) => {
+        if (typeof item === "function") {
+          result[key] = item;
+        } else {
+          const itemPath = `${path}/${key}`;
+          if (!iteratee(itemPath)) {
+            result[key] = deepOmitBy(item, itemPath, iteratee);
+          }
+        }
+      });
+    } else {
+      return value;
+    }
+  };
+  return deepOmitBy(state, "", (path) => pathIgnoreList.includes(path));
+};
+function editHistory(state = initialState$6, action) {
+  switch (action.type) {
+    case INIT_EDIT_HISTORY_UNIT: {
+      const { unitId, setState, options } = action;
+      return {
+        units: {
+          ...state.units,
+          [unitId]: {
+            pointIndex: -1,
+            diffs: [],
+            setState,
+            options
+          }
+        }
+      };
+    }
+    case RESET_EDIT_HISTORY_UNIT: {
+      const { unitId } = action;
+      const unit = state.units[unitId];
+      return {
+        units: {
+          ...state.units,
+          [unitId]: {
+            ...unit,
+            pointIndex: -1,
+            diffs: []
+          }
+        }
+      };
+    }
+    case ADD_EDIT_HISTORY_POINT: {
+      const { unitId, diff, state: newState, stacked } = action;
+      const editHistoryUnit = state.units[unitId];
+      const { diffs, pointIndex } = editHistoryUnit;
+      const prevDiffs = diffs.slice(0, pointIndex + 1);
+      const storedNewState = cloneStateForHistory(
+        newState,
+        editHistoryUnit.options.pathIgnoreList
+      );
+      const nextPointIndex = pointIndex + (stacked ? 0 : 1);
+      let nextDiffs;
+      if (stacked) {
+        if (!Array.isArray(prevDiffs[prevDiffs.length - 1])) {
+          prevDiffs[prevDiffs.length - 1] = [prevDiffs[prevDiffs.length - 1]];
+        }
+        prevDiffs[prevDiffs.length - 1].push(diff);
+        nextDiffs = [...prevDiffs];
+      } else {
+        nextDiffs = [...prevDiffs, diff];
+      }
+      return {
+        units: {
+          ...state.units,
+          [unitId]: {
+            ...editHistoryUnit,
+            // Force current history point index to latest state
+            pointIndex: nextPointIndex,
+            diffs: nextDiffs,
+            pointState: storedNewState
+          }
+        }
+      };
+    }
+    case SET_EDIT_HISTORY_POINT_INDEX: {
+      const { unitId, pointIndex } = action;
+      const editHistoryUnit = state.units[unitId];
+      return {
+        units: {
+          ...state.units,
+          [unitId]: {
+            ...editHistoryUnit,
+            pointIndex
+          }
+        }
+      };
+    }
+    case SET_EDIT_HISTORY_CURRENT_STATE: {
+      const { unitId, pointState } = action;
+      const editHistoryUnit = state.units[unitId];
+      const storedPointState = cloneStateForHistory(
+        pointState,
+        editHistoryUnit.options.pathIgnoreList
+      );
+      return {
+        units: {
+          ...state.units,
+          [unitId]: {
+            ...editHistoryUnit,
+            pointState: storedPointState
+          }
+        }
+      };
+    }
+    default:
+      return state;
+  }
+}
+const initialState$5 = {};
+const localStorageFallback = (state = initialState$5, action) => {
+  switch (action.type) {
+    case SET_ITEM: {
+      const { payload } = action;
+      return {
+        ...state,
+        [payload.key]: payload.value
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+};
+const coreReducers = {
+  user,
+  asideHeader,
+  workbooks: reducer$1,
+  dialog,
+  landing,
+  entryContent,
+  colorPaletteEditor,
+  collectionsStructure,
+  controlDialog,
+  migrationToWorkbook,
+  copyEntriesToWorkbook,
+  editHistory,
+  localStorageFallback
+};
+const selectIsLanding = (state) => state.landing.isLanding;
+const locationChangeHandler = (location2, prevLocation) => {
+  if (location2.pathname !== prevLocation.pathname) {
+    fireMetricaHit(CounterName.Main, location2.pathname);
+    fireMetricaHit(CounterName.Cross, location2.pathname);
+  }
+};
+const useClearReloadedQuery = () => {
+  const isLanding = useSelector(selectIsLanding);
+  const { search } = useLocation();
+  const history = useHistory();
+  useEffectOnce(() => {
+    function clearQuery() {
+      const searchParams = new URLSearchParams(search);
+      if (searchParams.has(RELOADED_URL_QUERY)) {
+        searchParams.delete(RELOADED_URL_QUERY);
+        history.replace({ search: searchParams.toString() });
+      }
+    }
+    if (DL.AUTH_ENABLED && !isLanding && !DL.IS_AUTH_PAGE) {
+      clearQuery();
+    }
+  });
+};
+const initialState$4 = {
+  authPageInited: false,
+  rethPath: null
+};
+const commonReducer = (state = initialState$4, action) => {
+  switch (action.type) {
+    case SET_AUTH_PAGE_INITED: {
+      return {
+        ...state,
+        ...action.payload
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+};
+const UPDATE_FORM_VALUES = /* @__PURE__ */ Symbol("auth/signin/UPDATE_FORM_VALUES");
+const initialState$3 = {
+  login: "",
+  password: ""
+};
+const signinReducer = (state = initialState$3, action) => {
+  switch (action.type) {
+    case UPDATE_FORM_VALUES: {
+      return {
+        ...state,
+        ...action.payload
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+};
+const getInitialRoles = () => {
+  const rolesList = getUsersRoles();
+  const defaultRole = rolesList[rolesList.length - 1];
+  return [defaultRole];
+};
+const initialState$2 = {
+  values: {
+    login: "",
+    email: "",
+    firstName: "",
+    lastName: "",
+    password: "",
+    repeatPassword: "",
+    roles: getInitialRoles()
+  },
+  validation: {
+    login: void 0,
+    email: void 0,
+    firstName: void 0,
+    lastName: void 0,
+    password: void 0,
+    repeatPassword: void 0
+  }
+};
+const userInfoFormReducer = (state = initialState$2, action) => {
+  switch (action.type) {
+    case UPDATE_FORM_VALUES$1: {
+      return {
+        ...state,
+        values: {
+          ...state.values,
+          ...action.payload
+        }
+      };
+    }
+    case UPDATE_FORM_VALIDATION: {
+      return {
+        ...state,
+        validation: {
+          ...state.validation,
+          ...action.payload
+        }
+      };
+    }
+    case RESET_FORM_VALIDATION: {
+      return {
+        ...state,
+        validation: initialState$2.validation
+      };
+    }
+    case RESET_FORM: {
+      return initialState$2;
+    }
+    default: {
+      return state;
+    }
+  }
+};
+const initialState$1 = {
+  getProfile: {
+    isLoading: false,
+    data: null,
+    error: null
+  },
+  deleteProfile: {
+    isLoading: false,
+    error: null
+  },
+  updatePassword: {
+    isLoading: false,
+    error: null
+  },
+  updateRole: {
+    isLoading: false,
+    error: null
+  },
+  editProfile: {
+    isLoading: false,
+    error: null
+  }
+};
+const userProfileReducer = (state = initialState$1, action) => {
+  switch (action.type) {
+    case GET_USER_PROFILE_LOADING: {
+      return {
+        ...state,
+        getProfile: {
+          ...state.getProfile,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case GET_USER_PROFILE_SUCCESS: {
+      return {
+        ...state,
+        getProfile: {
+          isLoading: false,
+          data: action.data,
+          error: null
+        }
+      };
+    }
+    case GET_USER_PROFILE_FAILED: {
+      return {
+        ...state,
+        getProfile: {
+          ...state.getProfile,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case RESET_USER_PROFILE_STATE: {
+      return {
+        ...state,
+        getProfile: {
+          ...initialState$1.getProfile
+        }
+      };
+    }
+    case DELETE_USER_PROFILE_LOADING: {
+      return {
+        ...state,
+        deleteProfile: {
+          ...state.deleteProfile,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case DELETE_USER_PROFILE_SUCCESS: {
+      return {
+        ...state,
+        deleteProfile: {
+          ...state.deleteProfile,
+          isLoading: false,
+          error: null
+        }
+      };
+    }
+    case DELETE_USER_PROFILE_FAILED: {
+      return {
+        ...state,
+        deleteProfile: {
+          ...state.deleteProfile,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case EDIT_USER_PROFILE_LOADING: {
+      return {
+        ...state,
+        editProfile: {
+          ...state.editProfile,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case EDIT_USER_PROFILE_SUCCESS: {
+      return {
+        ...state,
+        editProfile: {
+          ...state.editProfile,
+          isLoading: false,
+          error: null
+        }
+      };
+    }
+    case EDIT_USER_PROFILE_FAILED: {
+      return {
+        ...state,
+        editProfile: {
+          ...state.editProfile,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case UPDATE_USER_PASSWORD_LOADING: {
+      return {
+        ...state,
+        updatePassword: {
+          ...state.updatePassword,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case UPDATE_USER_PASSWORD_SUCCESS: {
+      return {
+        ...state,
+        updatePassword: {
+          ...state.updatePassword,
+          isLoading: false,
+          error: null
+        }
+      };
+    }
+    case UPDATE_USER_PASSWORD_FAILED: {
+      return {
+        ...state,
+        updatePassword: {
+          ...state.updatePassword,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    case RESET_UPDATE_USER_PASSWORD_STATE: {
+      return {
+        ...state,
+        updatePassword: { ...initialState$1.updatePassword }
+      };
+    }
+    case UPDATE_USER_ROLE_LOADING: {
+      return {
+        ...state,
+        updateRole: {
+          ...state.updateRole,
+          isLoading: true,
+          error: null
+        }
+      };
+    }
+    case UPDATE_USER_ROLE_SUCCESS: {
+      return {
+        ...state,
+        updateRole: {
+          ...state.updateRole,
+          isLoading: false,
+          error: null
+        }
+      };
+    }
+    case UPDATE_USER_ROLE_FAILED: {
+      return {
+        ...state,
+        updateRole: {
+          ...state.updateRole,
+          isLoading: false,
+          error: action.error
+        }
+      };
+    }
+    default: {
+      return state;
+    }
+  }
+};
+const initialState = {
+  queue: [],
+  users: {
+    [SYSTEM_USER.UID]: {
+      loading: false,
+      error: null,
+      data: {
+        source: "system",
+        subject: {
+          uid: SYSTEM_USER.UID,
+          login: SYSTEM_USER.LOGIN
+        }
+      }
+    }
+  }
+};
+function usersByIdReducer(state = initialState, action) {
+  switch (action.type) {
+    case SET_QUEUE:
+      return {
+        ...state,
+        queue: [...action.payload.userIds]
+      };
+    case SET_USERS:
+      return {
+        ...state,
+        users: {
+          ...state.users,
+          ...action.payload.users
+        }
+      };
+    default:
+      return state;
+  }
+}
+const reducers = combineReducers({
+  common: commonReducer,
+  signin: signinReducer,
+  userInfoForm: userInfoFormReducer,
+  userProfile: userProfileReducer,
+  usersByIds: usersByIdReducer
+});
+const reducer = (state, action) => {
+  if (action.type === RESET_AUTH_STATE) {
+    return reducers(void 0, action);
+  }
+  return reducers(state, action);
+};
+const useIframeRender = () => {
+  const isIframeRendered = isIframe();
+  React__default.useEffect(() => {
+    if (isIframeRendered) {
+      document.body.classList?.add(DATALENS_IFRAME_CLASSNAME);
+    } else {
+      document.body.classList?.remove(DATALENS_IFRAME_CLASSNAME);
+    }
+  }, [isIframeRendered]);
+};
+const OPEN_SOURCE_INSTALLATION_INFO = "open source";
+reducerRegistry.register(coreReducers);
+reducerRegistry.register({ auth: reducer });
+reducerRegistry.register({ chartkitApi: chartkitApi.reducer });
+reducerRegistry.registerMiddleware(chartkitApi.middleware);
+const DatasetPage = React__default.lazy(() => import("./pages/DatasetPage.js"));
+const PreviewPage = React__default.lazy(() => import("./pages/PreviewPage.js"));
+const ConnectionsPage = React__default.lazy(
+  () => import(
+    /* webpackChunkName: "connections-page" */
+    "./pages/ConnectionsPage.js"
+  ).then((n) => n.C)
+);
+const CollectionsNavigtaionPage = React__default.lazy(
+  () => import("./pages/CollectionsNavigationPage.js").then((n) => n.c)
+);
+const ServiceSettings = React__default.lazy(() => import("./pages/ServiceSettingsPage.js").then((n) => n.i));
+const UserProfile = React__default.lazy(() => import("./pages/OwnUserProfilePage.js").then((n) => n.O));
+const LandingPage = React__default.lazy(() => import("./pages/LandingPage.js"));
+const AuthPage = React__default.lazy(
+  () => import(
+    /* webpackChunkName: "auth-page" */
+    "./pages/AuthPage.js"
+  ).then((n) => n.k)
+);
+const DatalensPageView = ({ homePathname = "/collections" }) => {
+  useClearReloadedQuery();
+  const capabilities2 = useCapabilities();
+  const isLanding = useSelector(selectIsLanding);
+  const location2 = useLocation();
+  if (isLanding) {
+    return /* @__PURE__ */ jsx(React__default.Suspense, { fallback: /* @__PURE__ */ jsx(FallbackPage, {}), children: /* @__PURE__ */ jsx(LandingPage, {}) });
+  }
+  if (DL.IS_AUTH_PAGE) {
+    return /* @__PURE__ */ jsx(React__default.Suspense, { fallback: /* @__PURE__ */ jsx(FallbackPage, {}), children: /* @__PURE__ */ jsx(AuthPage, {}) });
+  }
+  return /* @__PURE__ */ jsxs(React__default.Suspense, { fallback: /* @__PURE__ */ jsx(FallbackPage, {}), children: [
+    /* @__PURE__ */ jsxs(Switch, { children: [
+      DL.AUTH_ENABLED && /* @__PURE__ */ jsx(Route, { path: "/auth", component: AuthPage }),
+      /* @__PURE__ */ jsx(
+        Route,
+        {
+          path: ["/workbooks/:workbookId/datasets/new", "/datasets/:id"],
+          component: DatasetPage
+        }
+      ),
+      /* @__PURE__ */ jsx(Route, { path: "/preview", component: PreviewPage }),
+      /* @__PURE__ */ jsx(Route, { path: ["/connections/new/:type", "/connections/new"], children: /* @__PURE__ */ jsx(Redirect, { to: { pathname: homePathname, search: location2.search } }) }),
+      capabilities2[Capability.ManageableConnections] && /* @__PURE__ */ jsx(
+        Route,
+        {
+          path: [
+            "/connections/:id",
+            "/workbooks/:workbookId/connections/new/:type",
+            "/workbooks/:workbookId/connections/new"
+          ],
+          component: ConnectionsPage
+        }
+      ),
+      DL.AUTH_ENABLED && /* @__PURE__ */ jsx(Route, { path: "/profile", component: UserProfile }),
+      capabilities2[Capability.AccessibleSettings] && /* @__PURE__ */ jsx(Route, { path: "/settings", component: ServiceSettings }),
+      capabilities2[Capability.AccessibleCollectionsRoot] && /* @__PURE__ */ jsx(Route, { path: ["/collections"], component: CollectionsNavigtaionPage }),
+      /* @__PURE__ */ jsx(Route, { exact: true, path: dashAndWizardQLRoutes, component: DashAndWizardQLPages }),
+      /* @__PURE__ */ jsx(
+        Route,
+        {
+          path: capabilities2[Capability.ManageableConnections] ? ["/collections/:collectionId", "/workbooks/:workbookId"] : ["/workbooks/:workbookId"],
+          component: CollectionsNavigtaionPage
+        }
+      ),
+      /* @__PURE__ */ jsx(Route, { path: "/", children: /* @__PURE__ */ jsx(Redirect, { to: { pathname: homePathname, search: location2.search } }) })
+    ] }),
+    /* @__PURE__ */ jsx(LocationChange, { onLocationChanged: locationChangeHandler })
+  ] });
+};
+const DatalensPage = ({ homePathname = "/collections" }) => {
+  const showAsideHeaderAdapter = getIsAsideHeaderEnabled() && !isEmbeddedMode() && !isTvMode();
+  const showMobileHeader = !isEmbeddedMode() && DL.IS_MOBILE && !DL.IS_NOT_AUTHENTICATED && !DL.IS_AUTH_PAGE;
+  useIframeRender();
+  if (showMobileHeader) {
+    return /* @__PURE__ */ jsx(
+      MobileHeaderComponent,
+      {
+        renderContent: () => /* @__PURE__ */ jsx(DatalensPageView, { homePathname }),
+        logoTextProps: { installationInfo: OPEN_SOURCE_INSTALLATION_INFO }
+      }
+    );
+  }
+  if (showAsideHeaderAdapter) {
+    return /* @__PURE__ */ jsx(
+      AsideHeaderAdapter,
+      {
+        renderContent: () => /* @__PURE__ */ jsx(DatalensPageView, { homePathname }),
+        logoTextProps: { installationInfo: OPEN_SOURCE_INSTALLATION_INFO }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(DatalensPageView, { homePathname });
+};
+const registryLibsPlugins = (options = {}) => {
+  registry.libs.schematicSdk.register(
+    initSdk(options.sdk ?? {}),
+    options.sdk?.allowOverride ?? false
+  );
+};
+const updateFormValues = (payload) => ({
+  type: UPDATE_FORM_VALUES,
+  payload
+});
+const submitSigninForm = ({ onError }) => {
+  return (dispatch, getState) => {
+    const { sdk: sdk2 } = getSdk();
+    const { login, password } = getState().auth.signin;
+    const preparedLogin = login.trim();
+    return sdk2.auth.auth.signin({
+      login: preparedLogin,
+      password
+    }).then(() => {
+      const { rethPath } = getState().auth.common;
+      const url = new URL(rethPath || window.location.origin);
+      url.searchParams.delete(RELOADED_URL_QUERY);
+      window.location.href = url.toString();
+    }).catch((error) => {
+      if (!sdk2.isCancel(error)) {
+        logger$1.logError("auth/signin failed", error);
+        if (isSdkError(error)) {
+          onError?.(error);
+          return;
+        }
+        dispatch(
+          showToast({
+            title: error.message,
+            error
+          })
+        );
+      }
+    });
+  };
+};
+const selectLogin = (state) => state.auth.signin.login;
+const selectPassword = (state) => state.auth.signin.password;
+const selectFormData = (state) => state.auth.signin;
+const i18n$b = I18n.keyset("auth.sign-in");
+const Login = ({ qa }) => {
+  const dispatch = useDispatch();
+  const login = useSelector(selectLogin);
+  const handleUpdate = (value) => dispatch(updateFormValues({ login: value }));
+  return /* @__PURE__ */ jsx(
+    TextInput,
+    {
+      value: login,
+      onUpdate: handleUpdate,
+      placeholder: i18n$b("label_login-placeholder"),
+      size: "l",
+      autoComplete: "username",
+      autoFocus: true,
+      qa
+    }
+  );
+};
+const i18n$a = I18n.keyset("auth.sign-in");
+const Password = ({ qa }) => {
+  const dispatch = useDispatch();
+  const password = useSelector(selectPassword);
+  const handleUpdate = (value) => dispatch(updateFormValues({ password: value }));
+  return /* @__PURE__ */ jsx(
+    TextInput,
+    {
+      type: "password",
+      placeholder: i18n$a("label_password-placeholder"),
+      size: "l",
+      autoComplete: "current-password",
+      value: password,
+      onUpdate: handleUpdate,
+      qa
+    }
+  );
+};
+const darkLogo = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20width='179'%20height='24'%20fill='none'%20viewBox='0%200%20179%2024'%3e%3cpath%20fill='%23fff'%20d='M10.213%2020.8H7.116v-5.147L1.279%202.824h3.226L9.06%2012.86c.87%201.913%201.152%202.586%201.152%204.888zm2.022-9.285H9.087l3.788-8.69h3.149zm32.356%209.543c-2.867%200-4.863-2.38-4.863-6.673%200-4.345%202.047-6.854%204.991-6.854%201.331%200%202.458.621%203.225%201.785V2.824h3.047V20.8h-2.816l-.154-1.681c-.819%201.267-1.996%201.94-3.43%201.94m18.712-1.138c-.896.621-2.329%201.138-4.274%201.138-3.891%200-6.093-2.198-6.093-6.724%200-3.932%201.766-6.803%205.478-6.803%203.046%200%205.017%201.707%205.017%206.234v1.63h-7.346c.128%202.172.972%203.232%203.2%203.232%201.484%200%203.071-.569%204.018-1.215zm-38.32-7.992v5.69q0%201.59.154%203.182h-2.97a4%204%200%200%201-.23-1.035h-.128c-.589.62-1.357%201.216-3.149%201.216-2.355%200-3.942-1.449-3.942-3.957%200-2.716%202.074-4.242%206.733-4.242h.486v-.828c0-1.396-.666-1.914-2.125-1.914-1.715%200-3.2.931-4.172%201.733V9.11c.921-.672%202.534-1.526%204.53-1.526%203.226%200%204.813%201.19%204.813%204.345m5.53-.465V20.8h-3.047V7.79h2.97l.076%201.086h.154c.614-.62%201.69-1.293%203.507-1.293%202.483%200%203.507%201.138%203.507%203.725V20.8h-3.046v-9.182c0-.983-.487-1.448-1.562-1.448-1.1%200-1.997.595-2.56%201.293m42.16%209.337-2.74-4.397-2.585%204.397H64.25l4.044-6.777-3.89-6.233h3.43l2.457%203.931%202.201-3.93h3.046l-3.635%206.31%204.198%206.699zM45.486%209.963c-1.74%200-2.61%201.345-2.61%204.422%200%202.949.818%204.242%202.482%204.242%201.715%200%202.585-1.319%202.585-4.345%200-3-.819-4.32-2.457-4.32m12.876%200c-1.46%200-2.202%201.086-2.278%203.155h4.249v-.258c0-1.63-.46-2.897-1.971-2.897m-36.426%207.733v-2.87h-.435c-2.611%200-3.66.516-3.66%202.017%200%201.137.64%201.888%201.92%201.888%201.074%200%201.791-.466%202.175-1.035M84.32%202.824h4.306c4.834%200%208.452%202.276%208.452%208.897%200%205.872-3.645%209.079-8.716%209.079H84.32zm3.778%2015.545c3.46%200%205.731-2.25%205.731-6.7%200-4.836-2.245-6.414-5.467-6.414h-.846V18.37zM108.904%2011.928v5.69q0%201.59.158%203.182h-3.064a4%204%200%200%201-.238-1.035h-.132c-.607.62-1.4%201.216-3.249%201.216-2.43%200-4.067-1.475-4.067-4.113s2.139-4.19%206.947-4.19h.501v-.724c0-1.396-.686-1.914-2.192-1.914-1.611%200-3.46.673-4.305%201.294V8.773c.95-.543%202.588-1.19%204.675-1.19%203.328%200%204.966%201.19%204.966%204.345m-3.144%205.768v-2.974h-.449c-2.694%200-3.777.543-3.777%202.069%200%201.164.661%201.94%201.981%201.94%201.11%200%201.849-.466%202.245-1.035M110.117%207.79h1.664V4.945h3.143V7.79h3.302v2.431h-3.302v6.7c0%20.956.607%201.706%201.928%201.706%201.057%200%201.638-.414%201.638-.414v2.51s-.872.335-2.404.335c-2.905%200-4.305-1.732-4.305-4.164v-6.673h-1.664zM130.004%2011.928v5.69q0%201.59.159%203.182h-3.064a4%204%200%200%201-.238-1.035h-.132c-.608.62-1.4%201.216-3.249%201.216-2.43%200-4.068-1.475-4.068-4.113s2.14-4.19%206.947-4.19h.502v-.724c0-1.396-.687-1.914-2.192-1.914-1.612%200-3.461.673-4.306%201.294V8.773c.951-.543%202.589-1.19%204.675-1.19%203.329%200%204.966%201.19%204.966%204.345m-3.143%205.768v-2.974h-.449c-2.694%200-3.777.543-3.777%202.069%200%201.164.66%201.94%201.981%201.94%201.109%200%201.849-.466%202.245-1.035M132.532%202.824h3.196V18.37h6.418v2.43h-9.614zM153.767%2019.92c-.924.621-2.403%201.138-4.411%201.138-4.015%200-6.287-2.198-6.287-6.724%200-3.932%201.823-6.803%205.653-6.803%203.143%200%205.177%201.707%205.177%206.234v1.63h-7.581c.132%202.172%201.004%203.232%203.302%203.232%201.532%200%203.17-.569%204.147-1.215zm-5.098-9.957c-1.505%200-2.271%201.086-2.351%203.155h4.385v-.258c0-1.63-.475-2.897-2.034-2.897M159.149%2011.463V20.8h-3.144V7.79h3.064l.08%201.086h.158c.634-.62%201.743-1.293%203.619-1.293%202.562%200%203.619%201.138%203.619%203.725V20.8h-3.144v-9.182c0-.983-.502-1.448-1.611-1.448-1.136%200-2.06.595-2.641%201.293M173.152%2021.058c-3.064%200-4.543-1.215-4.543-1.215v-2.51c.264.13%201.743%201.294%204.041%201.294%201.796%200%202.615-.491%202.615-1.5%200-1.138-.977-1.63-2.8-1.862-2.589-.336-3.936-1.526-3.936-3.828%200-2.25%201.796-3.906%205.019-3.906%202.615%200%203.857.725%203.857.725v2.508c-.212-.155-1.506-.879-3.54-.879-1.479%200-2.272.44-2.272%201.423%200%201.241%201.11%201.396%202.43%201.577%202.668.362%204.28%201.552%204.28%203.828%200%203.078-2.034%204.345-5.151%204.345'/%3e%3c/svg%3e";
+const lightLogo = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20width='179'%20height='24'%20fill='none'%20viewBox='0%200%20179%2024'%3e%3cpath%20fill='%23000'%20fill-opacity='.85'%20d='M10.213%2020.8H7.116v-5.147L1.279%202.824h3.226L9.06%2012.86c.87%201.913%201.152%202.586%201.152%204.888zm2.022-9.285H9.087l3.788-8.69h3.149zm32.356%209.543c-2.867%200-4.863-2.38-4.863-6.673%200-4.345%202.047-6.854%204.991-6.854%201.331%200%202.458.621%203.225%201.785V2.824h3.047V20.8h-2.816l-.154-1.681c-.819%201.267-1.996%201.94-3.43%201.94m18.712-1.138c-.896.621-2.329%201.138-4.274%201.138-3.891%200-6.093-2.198-6.093-6.724%200-3.932%201.766-6.803%205.478-6.803%203.046%200%205.017%201.707%205.017%206.234v1.63h-7.346c.128%202.172.972%203.232%203.2%203.232%201.484%200%203.071-.569%204.018-1.215zm-38.32-7.992v5.69q0%201.59.154%203.182h-2.97a4%204%200%200%201-.23-1.035h-.128c-.589.62-1.357%201.216-3.149%201.216-2.355%200-3.942-1.449-3.942-3.957%200-2.716%202.074-4.242%206.733-4.242h.486v-.828c0-1.396-.666-1.914-2.125-1.914-1.715%200-3.2.931-4.172%201.733V9.11c.921-.672%202.534-1.526%204.53-1.526%203.226%200%204.813%201.19%204.813%204.345m5.53-.465V20.8h-3.047V7.79h2.97l.076%201.086h.154c.614-.62%201.69-1.293%203.507-1.293%202.483%200%203.507%201.138%203.507%203.725V20.8h-3.046v-9.182c0-.983-.487-1.448-1.562-1.448-1.1%200-1.997.595-2.56%201.293m42.16%209.337-2.74-4.397-2.585%204.397H64.25l4.044-6.777-3.89-6.233h3.43l2.457%203.931%202.201-3.93h3.046l-3.635%206.31%204.198%206.699zM45.486%209.963c-1.74%200-2.61%201.345-2.61%204.422%200%202.949.818%204.242%202.482%204.242%201.715%200%202.585-1.319%202.585-4.345%200-3-.819-4.32-2.457-4.32m12.876%200c-1.46%200-2.202%201.086-2.278%203.155h4.249v-.258c0-1.63-.46-2.897-1.971-2.897m-36.426%207.733v-2.87h-.435c-2.611%200-3.66.516-3.66%202.017%200%201.137.64%201.888%201.92%201.888%201.074%200%201.791-.466%202.175-1.035M84.32%202.824h4.306c4.834%200%208.452%202.276%208.452%208.897%200%205.872-3.645%209.079-8.716%209.079H84.32zm3.778%2015.545c3.46%200%205.731-2.25%205.731-6.7%200-4.836-2.245-6.414-5.467-6.414h-.846V18.37zM108.904%2011.928v5.69q0%201.59.158%203.182h-3.064a4%204%200%200%201-.238-1.035h-.132c-.607.62-1.4%201.216-3.249%201.216-2.43%200-4.067-1.475-4.067-4.113s2.139-4.19%206.947-4.19h.501v-.724c0-1.396-.686-1.914-2.192-1.914-1.611%200-3.46.673-4.305%201.294V8.773c.95-.543%202.588-1.19%204.675-1.19%203.328%200%204.966%201.19%204.966%204.345m-3.144%205.768v-2.974h-.449c-2.694%200-3.777.543-3.777%202.069%200%201.164.661%201.94%201.981%201.94%201.11%200%201.849-.466%202.245-1.035M110.117%207.79h1.664V4.945h3.143V7.79h3.302v2.431h-3.302v6.7c0%20.956.607%201.706%201.928%201.706%201.057%200%201.638-.414%201.638-.414v2.51s-.872.335-2.404.335c-2.905%200-4.305-1.732-4.305-4.164v-6.673h-1.664zM130.004%2011.928v5.69q0%201.59.159%203.182h-3.064a4%204%200%200%201-.238-1.035h-.132c-.608.62-1.4%201.216-3.249%201.216-2.43%200-4.068-1.475-4.068-4.113s2.14-4.19%206.947-4.19h.502v-.724c0-1.396-.687-1.914-2.192-1.914-1.612%200-3.461.673-4.306%201.294V8.773c.951-.543%202.589-1.19%204.675-1.19%203.329%200%204.966%201.19%204.966%204.345m-3.143%205.768v-2.974h-.449c-2.694%200-3.777.543-3.777%202.069%200%201.164.66%201.94%201.981%201.94%201.109%200%201.849-.466%202.245-1.035M132.532%202.824h3.196V18.37h6.418v2.43h-9.614zM153.767%2019.92c-.924.621-2.403%201.138-4.411%201.138-4.015%200-6.287-2.198-6.287-6.724%200-3.932%201.823-6.803%205.653-6.803%203.143%200%205.177%201.707%205.177%206.234v1.63h-7.581c.132%202.172%201.004%203.232%203.302%203.232%201.532%200%203.17-.569%204.147-1.215zm-5.098-9.957c-1.505%200-2.271%201.086-2.351%203.155h4.385v-.258c0-1.63-.475-2.897-2.034-2.897M159.149%2011.463V20.8h-3.144V7.79h3.064l.08%201.086h.158c.634-.62%201.743-1.293%203.619-1.293%202.562%200%203.619%201.138%203.619%203.725V20.8h-3.144v-9.182c0-.983-.502-1.448-1.611-1.448-1.136%200-2.06.595-2.641%201.293M173.152%2021.058c-3.064%200-4.543-1.215-4.543-1.215v-2.51c.264.13%201.743%201.294%204.041%201.294%201.796%200%202.615-.491%202.615-1.5%200-1.138-.977-1.63-2.8-1.862-2.589-.336-3.936-1.526-3.936-3.828%200-2.25%201.796-3.906%205.019-3.906%202.615%200%203.857.725%203.857.725v2.508c-.212-.155-1.506-.879-3.54-.879-1.479%200-2.272.44-2.272%201.423%200%201.241%201.11%201.396%202.43%201.577%202.668.362%204.28%201.552%204.28%203.828%200%203.078-2.034%204.345-5.151%204.345'/%3e%3c/svg%3e";
+const i18n$9 = I18n.keyset("auth.sign-in");
+const b$b = block("dl-signin");
+const Signin = ({ alternativeAuthOptions }) => {
+  const dispatch = useDispatch();
+  const [errorMessage, setErrorMessage] = React__default.useState(null);
+  const formData = useSelector(selectFormData);
+  const theme2 = useThemeType();
+  const logo = theme2 === "dark" ? darkLogo : lightLogo;
+  const handleSigninError = (error) => {
+    if (error.status === 403) {
+      setErrorMessage(i18n$9("label_error-incorrect-fields"));
+      return;
+    }
+    dispatch(showToast({ title: error.message, error }));
+  };
+  const handleSubmit = (event) => {
+    event.preventDefault();
+    if (!formData.login || !formData.password) {
+      setErrorMessage(i18n$9("label_error-required-fields"));
+      return;
+    }
+    dispatch(submitSigninForm({ onError: handleSigninError }));
+  };
+  const handleFormChange = React__default.useCallback(() => {
+    if (errorMessage) {
+      setErrorMessage(null);
+    }
+  }, [errorMessage]);
+  return /* @__PURE__ */ jsx(Flex, { className: b$b(), justifyContent: "center", alignItems: "center", children: /* @__PURE__ */ jsxs(
+    Flex,
+    {
+      className: b$b("form-container"),
+      direction: "column",
+      gap: "6",
+      as: "form",
+      qa: SignInQa.SIGN_IN_FORM,
+      onChange: handleFormChange,
+      onSubmit: handleSubmit,
+      children: [
+        /* @__PURE__ */ jsx(Icon, { data: logo, width: "100%" }),
+        /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 6, children: [
+          errorMessage && /* @__PURE__ */ jsx(Alert, { theme: "danger", message: errorMessage }),
+          /* @__PURE__ */ jsx(Login, { qa: SignInQa.INPUT_LOGIN }),
+          /* @__PURE__ */ jsx(Password, { qa: SignInQa.INPUT_PASSWORD }),
+          /* @__PURE__ */ jsx(Button, { size: "xl", view: "action", type: "submit", children: i18n$9("button_sign-in") }),
+          !DL.AUTH_SIGNUP_DISABLED && /* @__PURE__ */ jsxs(Flex, { gap: 1, children: [
+            i18n$9("label_sign-up-hint"),
+            /* @__PURE__ */ jsx(Link, { to: AUTH_ROUTE.SIGNUP, className: b$b("link"), children: i18n$9("label_sing-up-link") })
+          ] })
+        ] }),
+        alternativeAuthOptions
+      ]
+    }
+  ) });
+};
+const b$a = block("users-list-labels-list");
+const LabelsList = ({
+  items,
+  countVisibleElements = 1,
+  buttonTheme = "normal",
+  size = isEnabledFeature(Feature.EnableNewServiceSettings) ? "s" : "xs"
+}) => {
+  const [open, setOpen] = React__default.useState(false);
+  const anchorRef = React__default.useRef(null);
+  const toggleRolesPopup = React__default.useCallback(
+    (event) => {
+      event.stopPropagation();
+      setOpen(!open);
+    },
+    [open]
+  );
+  const handlePopupClose = React__default.useCallback(() => {
+    setOpen(false);
+  }, []);
+  const renderList = () => {
+    const visibleItems = items.slice(0, countVisibleElements);
+    const hiddenItems = items.slice(countVisibleElements);
+    const buttonText = `+${items.length - countVisibleElements}`;
+    return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+      visibleItems.map((item) => /* @__PURE__ */ jsx(UserRoleLabel, { role: item, size }, item)),
+      /* @__PURE__ */ jsx(
+        Label,
+        {
+          ref: anchorRef,
+          theme: buttonTheme,
+          onClick: toggleRolesPopup,
+          className: b$a("button"),
+          size,
+          children: buttonText
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Popup,
+        {
+          anchorElement: anchorRef.current,
+          open,
+          placement: ["bottom-end", "bottom", "top-end", "top"],
+          onOpenChange: (isOpened) => {
+            if (!isOpened) {
+              handlePopupClose();
+            }
+          },
+          children: /* @__PURE__ */ jsx("div", { className: b$a("popup"), children: /* @__PURE__ */ jsx("div", { className: b$a("popup-content"), children: hiddenItems.map((item) => /* @__PURE__ */ jsx(UserRoleLabel, { role: item, size }, item)) }) })
+        }
+      )
+    ] });
+  };
+  return /* @__PURE__ */ jsx(Flex, { className: b$a(), alignItems: "center", gap: 2, children: items.length > countVisibleElements ? renderList() : items.map((item) => /* @__PURE__ */ jsx(UserRoleLabel, { role: item, size }, item)) });
+};
+const b$9 = block("service-settings-users-list");
+const i18n$8 = I18n.keyset("service-settings.users-list.view");
+const newServiceSettingsEnabled = isEnabledFeature(Feature.EnableNewServiceSettings);
+const getUsersListColumns = () => newServiceSettingsEnabled ? [
+  {
+    id: "user",
+    // TODO: name: i18n('user'),
+    name: "Пользователь",
+    template: ({ firstName, lastName, email }) => /* @__PURE__ */ jsx(
+      User,
+      {
+        className: b$9("user"),
+        size: "m",
+        name: `${firstName ?? ""} ${lastName ?? ""}`.trim() || "—",
+        description: email
+      }
+    ),
+    width: "35%"
+  },
+  {
+    id: "role",
+    name: i18n$8("label_field-roles"),
+    template: ({ roles }) => /* @__PURE__ */ jsx(LabelsList, { items: roles, countVisibleElements: 1 })
+  },
+  {
+    id: "login",
+    name: i18n$8("label_field-login"),
+    template: ({ login }) => /* @__PURE__ */ jsx("div", { className: b$9("login"), children: login }),
+    meta: { copy: ({ login }) => login }
+  },
+  {
+    id: "userId",
+    name: i18n$8("label_field-id"),
+    meta: { copy: ({ userId }) => userId }
+  }
+] : [
+  {
+    id: "firstName",
+    name: i18n$8("label_field-first-name")
+  },
+  {
+    id: "lastName",
+    name: i18n$8("label_field-last-name")
+  },
+  {
+    id: "userId",
+    name: i18n$8("label_field-id"),
+    template: ({ userId }) => userId,
+    meta: { copy: ({ userId }) => userId }
+  },
+  {
+    id: "email",
+    name: i18n$8("label_field-email"),
+    template: ({ email }) => email,
+    meta: { copy: ({ email }) => email }
+  },
+  {
+    id: "role",
+    name: i18n$8("label_field-roles"),
+    template: ({ roles }) => /* @__PURE__ */ jsx(LabelsList, { items: roles, countVisibleElements: 1 })
+  },
+  {
+    id: "login",
+    name: i18n$8("label_field-login"),
+    meta: { copy: ({ login }) => login }
+  }
+];
+const registerAuthPlugins = () => {
+  registry.auth.functions.register({
+    getUsersListColumns
+  });
+  registry.auth.components.registerMany({
+    Signin
+  });
+};
+const exampleFunction = (arg) => {
+  return `${arg}`;
+};
+const AdvancedChartPlugin = {
+  type: "advanced-chart",
+  renderer: React__default.lazy(() => import("./AdvancedChartWidget.js"))
+};
+const HighchartsMapPlugin = {
+  type: "highchartsmap",
+  renderer: React__default.lazy(() => import("./HighchartsMapWidget.js"))
+};
+const MarkupPlugin = {
+  type: "markup",
+  renderer: React__default.lazy(() => import("./MarkupWidget.js"))
+};
+const MetricPlugin = {
+  type: "metric",
+  renderer: React__default.lazy(() => import("./MetricWidget.js"))
+};
+const TablePlugin = {
+  type: "table",
+  renderer: React__default.lazy(() => import("./pages/ConnectionsPage.js").then((n) => n.k))
+};
+const YandexMapPlugin = {
+  type: "yandexmap",
+  renderer: React__default.lazy(() => import("./YandexMapWidget.js"))
+};
+const getChartkitPlugins = () => [
+  YagrPlugin,
+  IndicatorPlugin,
+  MetricPlugin,
+  HighchartsMapPlugin,
+  YandexMapPlugin,
+  HighchartsPlugin,
+  GravityChartsPlugin,
+  MarkupPlugin,
+  TablePlugin,
+  AdvancedChartPlugin
+];
+const registerChartPlugins = () => {
+  registry.chart.functions.register({
+    [EXAMPLE_FUNCTION]: exampleFunction,
+    getWizardChartMenu,
+    getPanePreviewChartMenu,
+    getDefaultChartMenu,
+    getChartkitMenuByType,
+    getChartkitPlugins,
+    getChartkitType
+  });
+};
+const useCreateWorkbookDialogHandlers = () => {
+  const { collectionId = null } = useParams();
+  const dispatch = useDispatch();
+  const history = useHistory();
+  const handleOpenCreateDialog = React__default.useCallback(
+    (defaultView, options) => {
+      const { refreshPageAfterImport, initialImportStatus, ...restOptions } = options ?? {};
+      dispatch(
+        openDialog({
+          id: DIALOG_CREATE_WORKBOOK,
+          props: {
+            open: true,
+            collectionId,
+            onCreateWorkbook: ({ workbookId }) => {
+              if (workbookId) {
+                history.push(`${WORKBOOKS_PATH}/${workbookId}`);
+              }
+            },
+            onClose: () => {
+              dispatch(closeDialog());
+              if (refreshPageAfterImport && initialImportStatus !== void 0) {
+                refreshPageAfterImport(initialImportStatus);
+              }
+            },
+            defaultView,
+            showImport: true,
+            ...restOptions
+          }
+        })
+      );
+    },
+    [collectionId, dispatch, history]
+  );
+  const handleOpenCreateDialogWithConnection = React__default.useCallback(() => {
+    dispatch(
+      openDialog({
+        id: DIALOG_CREATE_WORKBOOK,
+        props: {
+          open: true,
+          collectionId,
+          onCreateWorkbook: ({ workbookId }) => {
+            if (workbookId) {
+              history.push(`${WORKBOOKS_PATH}/${workbookId}/connections/new`);
+            }
+          },
+          onClose: () => {
+            dispatch(closeDialog());
+          }
+        }
+      })
+    );
+  }, [collectionId, dispatch, history]);
+  return {
+    handleOpenCreateDialog,
+    handleOpenCreateDialogWithConnection
+  };
+};
+const customizeCollectionsActions = (_item, actions) => actions;
+const customizeWorkbooksActions = (_item, actions) => actions;
+const customizeEmptyPlaceholder = ({
+  title,
+  description,
+  actions
+}) => {
+  return { title, description, actions };
+};
+const customizeNoCreatePermissionDialog = ({ message }) => {
+  return {
+    message
+  };
+};
+const registerCollectionsPlugins = () => {
+  registry.collections.functions.register({
+    customizeWorkbooksActions,
+    customizeCollectionsActions,
+    customizeEmptyPlaceholder,
+    customizeNoCreatePermissionDialog,
+    useCreateWorkbookDialogHandlers
+  });
+};
+const getAdditionalChartkitErrorContent = () => {
+  return {};
+};
+const getIsCompact = () => {
+  const isCompactValue = localStorage.getItem("isCompact");
+  if (!isCompactValue) {
+    return false;
+  }
+  return JSON.parse(isCompactValue);
+};
+const updateIsCompact = (isCompact) => {
+  return () => {
+    localStorage.setItem("isCompact", JSON.stringify(isCompact));
+  };
+};
+const getLoginById = () => LoginById;
+const getRestrictedParamNames = () => RESTRICTED_PARAM_NAMES;
+const setEntryKey = async ({ scope, type, key, withRouting = true }) => {
+  const store = getStore();
+  if (withRouting) {
+    store.dispatch(setIsRenameWithoutReload(true));
+  }
+  switch (scope) {
+    case EntryScope.Dash:
+      store.dispatch(renameDash(key));
+      break;
+    case EntryScope.Connection:
+      store.dispatch(setConnectionKey(key));
+      break;
+    case EntryScope.Dataset:
+      store.dispatch(renameDataset(key));
+      break;
+    case EntryScope.Widget: {
+      if (ENTRY_TYPES.wizard.includes(type)) {
+        store.dispatch(setWizardWidgetKey(key));
+      } else if (ENTRY_TYPES.ql.includes(type)) {
+        store.dispatch(setQlEntryKey(key));
+      }
+      break;
+    }
+  }
+  if (withRouting) {
+    store.dispatch(setIsRenameWithoutReload(false));
+  }
+};
+const b$8 = block("dl-main-tab-content");
+const i18n$7 = I18n.keyset("new-workbooks");
+const MainTabContent = ({
+  workbook,
+  chunk,
+  onRenameEntry,
+  onDeleteEntry,
+  onDuplicateEntry,
+  onCopyEntry,
+  actionCreateText,
+  hasCreateButton = true,
+  title,
+  actionType,
+  isShowMoreBtn,
+  loadMoreEntries,
+  retryLoadEntries,
+  isErrorMessage,
+  isLoading,
+  createEntryBtn,
+  clearView,
+  onShowRelatedClick,
+  onCopyId,
+  onUpdateSharedEntryBindings
+}) => {
+  const [isOpen, setIsOpen] = React__default.useState(true);
+  const dispatch = useDispatch();
+  const handleCreateEntity = () => {
+    if (actionType) {
+      dispatch(setCreateWorkbookEntryType(actionType));
+    }
+  };
+  const getContentTab = () => {
+    if (isErrorMessage) {
+      return /* @__PURE__ */ jsx("div", { className: b$8("error-text"), children: i18n$7("label_error-load-entities") });
+    }
+    if (chunk && chunk.length > 0 && isOpen) {
+      return /* @__PURE__ */ jsx(
+        ChunkGroup,
+        {
+          workbook,
+          chunk,
+          onRenameEntry,
+          onDeleteEntry,
+          onDuplicateEntry,
+          onCopyEntry,
+          onShowRelatedClick,
+          onCopyId,
+          onUpdateSharedEntryBindings
+        },
+        chunk[0].key
+      );
+    }
+    if (isOpen) {
+      return /* @__PURE__ */ jsx(EmptyRow, { label: /* @__PURE__ */ jsx("div", { className: b$8("no-objects"), children: i18n$7("no_objects") }) });
+    }
+    return null;
+  };
+  const getActionBtn = () => {
+    const buttonSize = DL.IS_MOBILE ? MOBILE_SIZE.BUTTON : void 0;
+    if (isErrorMessage) {
+      return /* @__PURE__ */ jsx(
+        Button,
+        {
+          onClick: retryLoadEntries,
+          size: buttonSize,
+          className: b$8("retry-btn"),
+          view: "outlined",
+          children: i18n$7("action_retry")
+        }
+      );
+    }
+    if (isShowMoreBtn && isOpen) {
+      return /* @__PURE__ */ jsx(
+        Button,
+        {
+          onClick: loadMoreEntries,
+          size: buttonSize,
+          className: b$8("show-more-btn"),
+          view: "outlined",
+          children: i18n$7("action_show-more")
+        }
+      );
+    }
+    return null;
+  };
+  const showCreateButton = workbook.permissions.update && !DL.IS_MOBILE && hasCreateButton;
+  if (!isLoading && DL.IS_MOBILE && chunk.length === 0) {
+    return null;
+  }
+  const renderCreateButton = () => {
+    if (showCreateButton) {
+      return /* @__PURE__ */ jsx("div", { className: b$8("content"), children: /* @__PURE__ */ jsx("div", { className: b$8("create-btn"), children: createEntryBtn ?? /* @__PURE__ */ jsxs(Button, { onClick: handleCreateEntity, children: [
+        /* @__PURE__ */ jsx(Icon, { data: Plus }),
+        actionCreateText
+      ] }) }) });
+    }
+    return null;
+  };
+  return /* @__PURE__ */ jsxs("div", { className: b$8({ mobile: DL.IS_MOBILE }), children: [
+    !clearView && /* @__PURE__ */ jsxs("div", { className: b$8("header", { closed: !isOpen }), children: [
+      /* @__PURE__ */ jsx("div", { className: b$8("content"), children: /* @__PURE__ */ jsxs("div", { className: b$8("title"), onClick: () => setIsOpen(!isOpen), children: [
+        isOpen ? /* @__PURE__ */ jsx(ChevronDown, {}) : /* @__PURE__ */ jsx(ChevronUp, {}),
+        /* @__PURE__ */ jsx("div", { className: b$8("title-text"), children: title })
+      ] }) }),
+      renderCreateButton()
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: b$8("table"), children: [
+      /* @__PURE__ */ jsxs("div", { className: b$8("table-header"), children: [
+        /* @__PURE__ */ jsx("div", { className: b$8("table-header-cell", { title: true }) }),
+        !DL.IS_MOBILE && /* @__PURE__ */ jsx("div", { className: b$8("table-header-cell", { author: true }) }),
+        /* @__PURE__ */ jsx("div", { className: b$8("table-header-cell", { date: true }) }),
+        !DL.IS_MOBILE && /* @__PURE__ */ jsx("div", { className: b$8("table-header-cell", { controls: true }) })
+      ] }),
+      !isLoading && getContentTab()
+    ] }),
+    isLoading ? /* @__PURE__ */ jsx(SmartLoader, { size: "m", showAfter: 0 }) : getActionBtn()
+  ] });
+};
+const i18n$6 = I18n.keyset("new-workbooks");
+const b$7 = block("dl-workbook-entries-table");
+const WorkbookEntriesTableTabs = ({
+  workbook,
+  retryLoadEntries,
+  loadMoreEntries,
+  scope,
+  mapTokens,
+  mapErrors,
+  mapLoaders,
+  chunks,
+  onRenameEntry,
+  onDeleteEntry,
+  onDuplicateEntry,
+  onCopyEntry,
+  onShowRelated,
+  onCopyId
+}) => {
+  const capabilities2 = useCapabilities();
+  if (scope) {
+    return null;
+  }
+  const [dashChunk = [], widgetChunk = [], datasetChunk = [], connChunk = []] = chunks ?? [];
+  const isWidgetEmpty = widgetChunk.length === 0;
+  const isDashEmpty = dashChunk.length === 0;
+  const clearViewDash = DL.IS_MOBILE && isWidgetEmpty;
+  const clearViewWidget = DL.IS_MOBILE && isDashEmpty;
+  const showDataEntities = workbook.permissions.view && !DL.IS_MOBILE;
+  if (DL.IS_MOBILE && isWidgetEmpty && isDashEmpty) {
+    return /* @__PURE__ */ jsx(PlaceholderIllustration, { name: "template", title: i18n$6("label_empty-mobile-workbook") });
+  }
+  return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      MainTabContent,
+      {
+        chunk: dashChunk,
+        actionCreateText: i18n$6("action_create-dashboard"),
+        title: i18n$6("title_dashboards"),
+        actionType: CreateEntryActionType.Dashboard,
+        isShowMoreBtn: Boolean(!isDashEmpty && mapTokens?.[EntryScope.Dash]),
+        loadMoreEntries: () => loadMoreEntries?.(EntryScope.Dash),
+        retryLoadEntries: () => retryLoadEntries?.(EntryScope.Dash),
+        isErrorMessage: mapErrors?.[EntryScope.Dash],
+        isLoading: mapLoaders?.[EntryScope.Dash],
+        workbook,
+        onRenameEntry,
+        onDeleteEntry,
+        onDuplicateEntry,
+        onCopyEntry,
+        clearView: clearViewDash,
+        onShowRelatedClick: onShowRelated,
+        onCopyId
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      MainTabContent,
+      {
+        chunk: widgetChunk,
+        actionCreateText: i18n$6("action_create-chart"),
+        title: i18n$6("title_charts"),
+        actionType: CreateEntryActionType.Wizard,
+        isShowMoreBtn: Boolean(!isWidgetEmpty && mapTokens?.[EntryScope.Widget]),
+        loadMoreEntries: () => loadMoreEntries?.(EntryScope.Widget),
+        retryLoadEntries: () => retryLoadEntries?.(EntryScope.Widget),
+        isErrorMessage: mapErrors?.[EntryScope.Widget],
+        isLoading: mapLoaders?.[EntryScope.Widget],
+        workbook,
+        onRenameEntry,
+        onDeleteEntry,
+        onDuplicateEntry,
+        onCopyEntry,
+        createEntryBtn: /* @__PURE__ */ jsx(CreateEntry, { className: b$7("controls"), scope: EntryScope.Widget }),
+        clearView: clearViewWidget,
+        onShowRelatedClick: onShowRelated,
+        onCopyId
+      }
+    ),
+    showDataEntities && /* @__PURE__ */ jsx(
+      MainTabContent,
+      {
+        chunk: datasetChunk,
+        actionCreateText: i18n$6("action_create-dataset"),
+        title: i18n$6("title_datasets"),
+        actionType: CreateEntryActionType.Dataset,
+        isShowMoreBtn: Boolean(
+          datasetChunk?.length > 0 && mapTokens?.[EntryScope.Dataset]
+        ),
+        loadMoreEntries: () => loadMoreEntries?.(EntryScope.Dataset),
+        retryLoadEntries: () => retryLoadEntries?.(EntryScope.Dataset),
+        isErrorMessage: mapErrors?.[EntryScope.Dataset],
+        isLoading: mapLoaders?.[EntryScope.Dataset],
+        workbook,
+        onRenameEntry,
+        onDeleteEntry,
+        onDuplicateEntry,
+        onCopyEntry,
+        onShowRelatedClick: onShowRelated,
+        onCopyId
+      }
+    ),
+    showDataEntities && capabilities2[Capability.ManageableConnections] && /* @__PURE__ */ jsx(
+      MainTabContent,
+      {
+        chunk: connChunk,
+        actionCreateText: i18n$6("action_create-connection"),
+        title: i18n$6("title_connections"),
+        actionType: CreateEntryActionType.Connection,
+        isShowMoreBtn: Boolean(
+          connChunk?.length > 0 && mapTokens?.[EntryScope.Connection]
+        ),
+        loadMoreEntries: () => loadMoreEntries?.(EntryScope.Connection),
+        retryLoadEntries: () => retryLoadEntries?.(EntryScope.Connection),
+        isErrorMessage: mapErrors?.[EntryScope.Connection],
+        isLoading: mapLoaders?.[EntryScope.Connection],
+        workbook,
+        onRenameEntry,
+        onDeleteEntry,
+        onDuplicateEntry,
+        onCopyEntry,
+        onShowRelatedClick: onShowRelated,
+        onCopyId
+      }
+    )
+  ] });
+};
+const getAllEntryScopes = () => {
+  return Object.values(EntryScope);
+};
+const bEditPanelItem = block("edit-panel-item");
+const DASHKIT_BASIC_ACTION_PANEL_ITEM = {
+  [DashTabItemType.GroupControl]: {
+    id: "group-selector",
+    icon: /* @__PURE__ */ jsx(Icon, { data: Sliders }),
+    get title() {
+      return i18n$c("dash.main.view", "button_edit-panel-selector");
+    },
+    className: bEditPanelItem(),
+    qa: DashboardAddWidgetQa.AddGroupControl,
+    dragProps: {
+      type: DashTabItemType.GroupControl
+    }
+  },
+  [DashTabItemType.Image]: {
+    id: DashTabItemType.Image,
+    icon: /* @__PURE__ */ jsx(Icon, { data: Picture }),
+    get title() {
+      return i18n$c("dash.main.view", "button_edit-panel-image");
+    },
+    className: bEditPanelItem(),
+    qa: DashboardAddWidgetQa.AddImage,
+    dragProps: {
+      type: DashTabItemType.Image
+    }
+  },
+  [DashTabItemType.Text]: {
+    id: "text",
+    icon: /* @__PURE__ */ jsx(Icon, { data: TextAlignLeft }),
+    get title() {
+      return i18n$c("dash.main.view", "button_edit-panel-text");
+    },
+    className: bEditPanelItem(),
+    qa: DashboardAddWidgetQa.AddText,
+    dragProps: {
+      type: DashTabItemType.Text
+    }
+  },
+  [DashTabItemType.Title]: {
+    id: "header",
+    icon: /* @__PURE__ */ jsx(Icon, { data: Heading }),
+    get title() {
+      return i18n$c("dash.main.view", "button_edit-panel-title");
+    },
+    className: bEditPanelItem(),
+    qa: DashboardAddWidgetQa.AddTitle,
+    dragProps: {
+      type: DashTabItemType.Title
+    }
+  },
+  [DashTabItemType.Widget]: {
+    id: "chart",
+    icon: /* @__PURE__ */ jsx(Icon, { data: ChartColumn }),
+    get title() {
+      return i18n$c("dash.main.view", "button_edit-panel-chart");
+    },
+    className: bEditPanelItem(),
+    qa: DashboardAddWidgetQa.AddWidget,
+    dragProps: {
+      type: DashTabItemType.Widget
+    }
+  }
+};
+const getBasicActionPanelItems = () => {
+  return [
+    DASHKIT_BASIC_ACTION_PANEL_ITEM[DashTabItemType.Widget],
+    DASHKIT_BASIC_ACTION_PANEL_ITEM[DashTabItemType.GroupControl],
+    DASHKIT_BASIC_ACTION_PANEL_ITEM[DashTabItemType.Text],
+    DASHKIT_BASIC_ACTION_PANEL_ITEM[DashTabItemType.Title]
+  ];
+};
+function getCurrentUserRights() {
+  if (!DL.AUTH_ENABLED) {
+    return {
+      admin: true
+    };
+  }
+  return {
+    admin: Boolean(DL.IS_NATIVE_AUTH_ADMIN)
+  };
+}
+const i18n$5 = I18n.keyset("component.revisions-panel.view");
+const ENTRY_SCOPE_TEXTS = {
+  connection: {
+    scopeText: i18n$5("label_connection"),
+    panelText: i18n$5("label_of-connection")
+  },
+  dataset: {
+    scopeText: i18n$5("label_dataset"),
+    panelText: i18n$5("label_of-dataset")
+  },
+  dash: {
+    scopeText: i18n$5("label_dash"),
+    panelText: i18n$5("label_of-dash")
+  },
+  widget: {
+    scopeText: i18n$5("label_chart"),
+    panelText: i18n$5("label_of-chart")
+  },
+  editor: {
+    scopeText: i18n$5("label_editor"),
+    panelText: i18n$5("label_of-editor")
+  }
+};
+const getRevisionsPanelEntryScopesTexts = () => ENTRY_SCOPE_TEXTS;
+const getScopeTypeIcon = (scope) => {
+  switch (scope) {
+    case EntryScope.Folder:
+      return "folder";
+    case EntryScope.Widget:
+    case "chart":
+      return "chart-wizard";
+    case EntryScope.Dataset:
+      return "dataset";
+    case EntryScope.Dash:
+    case "dashboard":
+      return "dashboard";
+    case "monitoring":
+      return "editor";
+    case "broken":
+      return "broken";
+    default:
+      return null;
+  }
+};
+const getTopLevelEntryScopes = () => {
+  return [EntryScope.Dash];
+};
+const migrateItemDataOnPaste = ({
+  itemData
+}) => {
+  const migratedItemData = {
+    ...itemData,
+    data: update(itemData.data, { $unset: ["id"] })
+  };
+  if (itemData.type === ITEM_TYPE.WIDGET) {
+    migratedItemData.data.tabs = itemData.data.tabs && itemData.data.tabs.map((tab) => {
+      return update(tab, {
+        $unset: ["id"]
+      });
+    });
+  }
+  if (itemData.type === ITEM_TYPE.GROUP_CONTROL) {
+    migratedItemData.data.group = itemData.data.group?.map((item) => {
+      return update(item, { $unset: ["id"] });
+    });
+  }
+  return migratedItemData;
+};
+const registerCommonPlugins = () => {
+  registry.common.components.registerMany({
+    MobileHeaderComponent,
+    PlaceholderIllustrationImage: Illustration,
+    UserAvatarById,
+    EntryBreadcrumbs,
+    YfmWrapperContent,
+    DatepickerControl,
+    MarkdownControl,
+    WorkbookEntriesTableTabs,
+    DialogEntryDescription
+  });
+  registry.common.functions.register({
+    [EXAMPLE_FUNCTION]: exampleFunction,
+    getEntryMenuConfig,
+    getMenuGroupConfig,
+    getIconDataById,
+    getIllustrationStore,
+    getIsCompact,
+    updateIsCompact,
+    getPlaceSelectParameters,
+    getLoginById,
+    getEntryName,
+    getInitDestination,
+    getNavigationQuickItems: getQuickItems,
+    getNavigationCreatableEntriesConfig: getCreatableEntriesConfig,
+    getNavigationPlacesConfig: getPlacesConfig,
+    setEntryKey,
+    getUpdatedUserSettings,
+    getUIEntryRoute,
+    getFormatNumber: formatNumber,
+    getAdditionalEntryDialoguesMap,
+    getAdditionalEntryContextMenuItems,
+    isEntryId,
+    extractEntryId,
+    getAdditionalMarkdownPlugins: async () => [],
+    fetchRenderedMarkdown,
+    fetchBatchRenderedMarkdown,
+    fetchDistinctsByApi,
+    requestCollectDashStats,
+    requestCollectChartkitStats,
+    migrateItemDataOnPaste,
+    checkCreateEntryButtonVisibility: () => true,
+    getBasicActionPanelItems,
+    getListMembersFilter: () => null,
+    getAllEntryScopes,
+    getTopLevelEntryScopes,
+    getScopeTypeIcon,
+    getEntryScopesWithRevisionsList,
+    getRevisionsPanelEntryScopesTexts,
+    getRestrictedParamNames,
+    getAdditionalChartkitErrorContent,
+    getCurrentUserRights,
+    getNotAuthenticatedErrorContentTypes: () => [],
+    getHeaderWithoutHelpCenterErrorContentTypes: () => [],
+    getHeaderWithoutNavigationErrorContentTypes: () => [],
+    getImageNameFromErrorContentType: () => null
+  });
+  if (DL.AUTH_ENABLED) {
+    registry.common.functions.register({ resolveUsersByIds });
+  }
+};
+const i18n$4 = I18n.keyset("connections.form");
+const CACHE_TTL_MIN = 0;
+const CACHE_TTL_MAX = 24 * 60 * 60;
+const CACHE_TTL_MODE = {
+  DEFAULT: "default",
+  CUSTOMIZABLE: "customizable"
+};
+const getInitialCacheTtlMode = (value) => {
+  return value ? CACHE_TTL_MODE.CUSTOMIZABLE : CACHE_TTL_MODE.DEFAULT;
+};
+const getPreparedCacheValue = (value) => {
+  if (value === "") {
+    return null;
+  }
+  let result = Number(value);
+  if (result < CACHE_TTL_MIN) {
+    result = CACHE_TTL_MIN;
+  } else if (result > CACHE_TTL_MAX) {
+    result = CACHE_TTL_MAX;
+  }
+  return String(result);
+};
+const CacheTtlRowComponent = (props) => {
+  const { actions, form, innerForm, labelText, disabled, name } = props;
+  const value = form[name];
+  const cacheTtlMode = innerForm[InnerFieldKey.CacheTtlMode];
+  const radioButtonBeforeUpdateHandler = (nextCacheTtlMode) => {
+    const nextCacheTtlSec = nextCacheTtlMode === CACHE_TTL_MODE.DEFAULT ? null : "0";
+    actions.changeForm({ [name]: nextCacheTtlSec });
+  };
+  React__default.useEffect(() => {
+    const initialCacheTtlMode = getInitialCacheTtlMode(value);
+    actions.changeInnerForm({ [InnerFieldKey.CacheTtlMode]: initialCacheTtlMode });
+  }, []);
+  return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+    /* @__PURE__ */ jsx(Label$1, { text: labelText || i18n$4("field_cache-ttl-sec") }),
+    /* @__PURE__ */ jsx(
+      RadioButton,
+      {
+        name: InnerFieldKey.CacheTtlMode,
+        options: [
+          { text: i18n$4("value_default"), value: CACHE_TTL_MODE.DEFAULT },
+          {
+            text: i18n$4("value_customizable-cache-ttl"),
+            value: CACHE_TTL_MODE.CUSTOMIZABLE
+          }
+        ],
+        inner: true,
+        controlProps: { disabled },
+        beforeUpdate: radioButtonBeforeUpdateHandler
+      }
+    ),
+    cacheTtlMode === CACHE_TTL_MODE.CUSTOMIZABLE && /* @__PURE__ */ jsx(
+      Input,
+      {
+        name,
+        width: "s",
+        controlProps: {
+          disabled,
+          type: "number",
+          controlProps: { min: CACHE_TTL_MIN, max: CACHE_TTL_MAX }
+        },
+        prepareValue: getPreparedCacheValue
+      }
+    )
+  ] });
+};
+const mapStateToProps$1 = (state) => {
+  return {
+    form: state.connections.form,
+    innerForm: state.connections.innerForm
+  };
+};
+const mapDispatchToProps$2 = (dispatch) => {
+  return {
+    actions: bindActionCreators(
+      {
+        changeForm,
+        changeInnerForm
+      },
+      dispatch
+    )
+  };
+};
+const CacheTtlRow = connect(mapStateToProps$1, mapDispatchToProps$2)(CacheTtlRowComponent);
+const b$6 = block("conn-form-collapse");
+const COLLAPSE_MODE = {
+  OPENED: "opened",
+  CLOSED: "closed"
+};
+const CollapseRowComponent = (props) => {
+  const { actions, innerForm, name, text } = props;
+  const componentProps = get(props, "componentProps", {});
+  const defaultIsExpand = get(componentProps, "defaultIsExpand", false);
+  const clickHandler = React__default.useCallback(() => {
+    const currentMode = innerForm[name] || COLLAPSE_MODE.CLOSED;
+    const nextMode = currentMode === COLLAPSE_MODE.CLOSED ? COLLAPSE_MODE.OPENED : COLLAPSE_MODE.CLOSED;
+    actions.changeInnerForm({ [name]: nextMode });
+  }, [actions, innerForm, name]);
+  React__default.useEffect(() => {
+    const initialMode = defaultIsExpand ? COLLAPSE_MODE.OPENED : COLLAPSE_MODE.CLOSED;
+    actions.changeInnerForm({ [name]: initialMode });
+  }, []);
+  return /* @__PURE__ */ jsx("div", { className: b$6(), onClick: clickHandler, children: /* @__PURE__ */ jsx(Collapse, { ...componentProps, className: b$6("component"), title: text, children: /* @__PURE__ */ jsx("div", {}) }) });
+};
+const mapStateToProps = (state) => {
+  return {
+    innerForm: state.connections.innerForm
+  };
+};
+const mapDispatchToProps$1 = (dispatch) => {
+  return {
+    actions: bindActionCreators(
+      {
+        changeInnerForm
+      },
+      dispatch
+    )
+  };
+};
+const CollapseRow = connect(mapStateToProps, mapDispatchToProps$1)(CollapseRowComponent);
+const b$5 = block("conn-form-raw-sql-level");
+function RawSQLLevelRow(props) {
+  const { name, label, switchOffValue, radioGroup, disabled } = props;
+  const dispatch = useDispatch();
+  const form = useSelector(formSelector);
+  const value = form[name] || "";
+  const switchChecked = Boolean(value && value !== switchOffValue);
+  const handleSwitchUpdate = (checked) => {
+    const nextValue = checked && radioGroup?.options[0]?.value ? radioGroup.options[0].value : switchOffValue;
+    dispatch(changeForm({ [name]: nextValue }));
+  };
+  return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+    /* @__PURE__ */ jsx(Label$1, { ...label }),
+    /* @__PURE__ */ jsxs("div", { className: b$5("control"), children: [
+      /* @__PURE__ */ jsx(Switch$1, { checked: switchChecked, onUpdate: handleSwitchUpdate, disabled }),
+      switchChecked && /* @__PURE__ */ jsx(
+        RadioGroup,
+        {
+          name,
+          options: radioGroup?.options,
+          controlProps: {
+            ...radioGroup?.controlProps,
+            disabled: disabled || radioGroup?.controlProps?.disabled
+          }
+        }
+      )
+    ] })
+  ] });
+}
+const PreparedRowItem = (props) => {
+  switch (props.type) {
+    case "cache_ttl_sec": {
+      const { type: _type, ...rowProps } = props;
+      return /* @__PURE__ */ jsx(CacheTtlRow, { ...rowProps });
+    }
+    case "collapse": {
+      const { type: _type, ...rowProps } = props;
+      return /* @__PURE__ */ jsx(CollapseRow, { ...rowProps });
+    }
+    case "raw_sql_level": {
+      const { type: _type, ...rowProps } = props;
+      return /* @__PURE__ */ jsx(RawSQLLevelRow, { ...rowProps });
+    }
+    default: {
+      logger$1.logError(`FormItem (conn): unknown row type "${props.type}"`);
+      return null;
+    }
+  }
+};
+const listItemRender = ({ data, components }) => {
+  const { ListItemWrapper, ListItemLink, ListItemTitle, ListItemIcon } = components;
+  const { to, iconData, title } = data;
+  return /* @__PURE__ */ jsx(ListItemWrapper, { children: /* @__PURE__ */ jsxs(ListItemLink, { to, children: [
+    /* @__PURE__ */ jsx(ListItemIcon, { iconData }),
+    /* @__PURE__ */ jsx(ListItemTitle, { title })
+  ] }) });
+};
+const registerConnectionsPlugins = () => {
+  registry.connections.components.registerMany({
+    CreateEditorChartButton: () => null,
+    PreparedRowItem
+  });
+  registry.connections.functions.register({
+    getFakeEntry,
+    getNewConnectionDestination,
+    beforeConnectorFormUnmount: noop,
+    getConnectionItemRender: listItemRender,
+    getIsShowCreateConnectionButton
+  });
+};
+const getMinAutoupdateInterval = () => {
+  return 30;
+};
+const LazyBody = React__default.lazy(() => import("./Body.js"));
+const registerDashPlugins = () => {
+  registry.dash.components.registerMany({
+    DashBody: LazyBody,
+    DialogTextWidget
+  });
+  registry.dash.functions.register({
+    [EXAMPLE_FUNCTION]: exampleFunction,
+    getCaptionText,
+    getNewDashUrl: getNewDashUrl$1,
+    getDashEntryUrl,
+    getMinAutoupdateInterval,
+    getExtendedItemData
+  });
+};
+const b$4 = block("rls-dialog");
+const i18n$3 = I18n.keyset("dataset.rls.modify");
+const _RLSDialog = class _RLSDialog extends React__default.Component {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      visible: false,
+      rlsField: ""
+    };
+    this.saveRls = () => {
+      const { field, onSave, onClose } = this.props;
+      const { rlsField } = this.state;
+      if (field) {
+        const { guid } = field;
+        onSave({
+          [guid]: rlsField
+        });
+        onClose();
+      }
+    };
+    this.changeRlsSettings = (rlsField) => {
+      this.setState({ rlsField });
+    };
+  }
+  static getDerivedStateFromProps(nextProps, nextState) {
+    const { rlsField, visible } = nextProps;
+    const { visible: visibleState } = nextState;
+    if (visible === visibleState) {
+      return null;
+    }
+    return {
+      rlsField,
+      visible
+    };
+  }
+  render() {
+    const { visible, onClose, field } = this.props;
+    const { rlsField } = this.state;
+    if (!field) {
+      return null;
+    }
+    const { title } = field;
+    return /* @__PURE__ */ jsxs(Dialog, { open: visible, onClose, children: [
+      /* @__PURE__ */ jsx(Dialog.Header, { caption: i18n$3("label_row-level-security") }),
+      /* @__PURE__ */ jsxs(Dialog.Body, { className: b$4(), children: [
+        /* @__PURE__ */ jsx("div", { className: b$4("field-name"), children: /* @__PURE__ */ jsx("span", { children: title }) }),
+        /* @__PURE__ */ jsx(
+          TextArea,
+          {
+            rows: 5,
+            placeholder: i18n$3("field_placeholder-row-level-security"),
+            value: rlsField,
+            autoFocus: true,
+            onUpdate: this.changeRlsSettings
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx(
+        Dialog.Footer,
+        {
+          preset: "default",
+          onClickButtonCancel: onClose,
+          onClickButtonApply: this.saveRls,
+          textButtonCancel: i18n$3("button_cancel"),
+          textButtonApply: i18n$3("button_save"),
+          propsButtonApply: {
+            disabled: this.isSaveBtnDisabled
+          }
+        }
+      )
+    ] });
+  }
+  get isSaveBtnDisabled() {
+    const { rlsField } = this.props;
+    const { rlsField: rlsFieldState } = this.state;
+    return rlsField === rlsFieldState;
+  }
+};
+_RLSDialog.defaultProps = {
+  visible: false
+};
+let RLSDialog = _RLSDialog;
+const renderRLSDialog = (props) => {
+  return /* @__PURE__ */ jsx(RLSDialog, { ...props });
+};
+const registerDatasetPlugins = () => {
+  registry.datasets.functions.register({
+    renderRLSDialog
+  });
+};
+const registerDocsPlugins = () => {
+  registry.docs.functions.register({ getFieldEditorDocPath });
+};
+const registerMainPlugins = () => {
+  registry.main.components.registerMany({});
+};
+const b$3 = block("ql-view-setup");
+class ViewSetupComponent extends React__default.PureComponent {
+  constructor(props) {
+    super(props);
+    this.defaultMonitoringQLConnection = null;
+    this.onChartTypeUpdate = (newChartType) => {
+      this.setState({
+        chartType: newChartType
+      });
+      if (newChartType === QLChartType.Monitoringql && isEnabledFeature(Feature.EnableCustomMonitoring)) {
+        if (this.defaultMonitoringQLConnection === null) {
+          const getDefaultMonitoringQLConnectionId = registry.ql.functions.get(
+            "getDefaultMonitoringQLConnectionId"
+          );
+          const defaultMonitoringQLConnectionId = getDefaultMonitoringQLConnectionId(DL.ENV);
+          this.fetchConnection(defaultMonitoringQLConnectionId).then(
+            (connection) => {
+              if (connection) {
+                this.defaultMonitoringQLConnection = connection;
+                this.setState({
+                  connection,
+                  showConnectionError: false
+                });
+              }
+            }
+          );
+        } else {
+          this.setState({
+            connection: this.defaultMonitoringQLConnection,
+            showConnectionError: false
+          });
+        }
+      } else {
+        this.setState({
+          connection: null,
+          showConnectionError: false
+        });
+      }
+    };
+    this.onCreateClick = () => {
+      const { connection, chartType } = this.state;
+      if (!connection || !chartType) {
+        this.setState({
+          showConnectionError: true
+        });
+      } else {
+        this.props.performManualConfiguration({ connection, chartType });
+      }
+    };
+    this.toggleNavigation = (value) => {
+      const isNavigationVisible = value || !this.state.isNavigationVisible;
+      this.setState({
+        isNavigationVisible
+      });
+    };
+    this.onNavigationEntryClick = async (newConnection) => {
+      const connection = {
+        ...newConnection,
+        data: null,
+        public: false,
+        revId: "",
+        tenantId: "",
+        unversionedData: null
+      };
+      this.toggleNavigation(false);
+      this.setState({
+        connection
+      });
+    };
+    this.onNavigationClose = () => {
+      const { isNavigationVisible } = this.state;
+      if (isNavigationVisible) {
+        this.toggleNavigation(false);
+      }
+    };
+    this.navigationButtonRef = React__default.createRef();
+    let initialChartType = QLChartType.Sql;
+    const urlChartType = location.href.match(/\/new\/([^?]+)(\?.+)?/);
+    if (urlChartType) {
+      initialChartType = decodeURIComponent(urlChartType[1]);
+    }
+    if (![QLChartType.Sql, QLChartType.Promql, QLChartType.Monitoringql].includes(
+      initialChartType
+    )) {
+      initialChartType = QLChartType.Sql;
+    }
+    if (initialChartType === QLChartType.Monitoringql && isEnabledFeature(Feature.EnableCustomMonitoring)) {
+      const getDefaultMonitoringQLConnectionId = registry.ql.functions.get(
+        "getDefaultMonitoringQLConnectionId"
+      );
+      const defaultMonitoringQLConnectionId = getDefaultMonitoringQLConnectionId(DL.ENV);
+      this.fetchConnection(defaultMonitoringQLConnectionId).then(
+        (connection) => {
+          if (connection) {
+            this.defaultMonitoringQLConnection = connection;
+            this.setState({
+              connection,
+              showConnectionError: false
+            });
+          }
+        }
+      );
+    }
+    this.state = {
+      isNavigationVisible: false,
+      title: "",
+      chartType: initialChartType,
+      connection: null,
+      showConnectionError: false
+    };
+  }
+  render() {
+    const { defaultPath, entry } = this.props;
+    const { chartType, connection, showConnectionError } = this.state;
+    const workbookId = entry?.workbookId || null;
+    const chartTypesList = [{ value: QLChartType.Sql, text: "SQL", key: "SQL" }];
+    if (isEnabledFeature(Feature.QLPrometheus)) {
+      chartTypesList.push({ value: QLChartType.Promql, text: "Prometheus", key: "Prometheus" });
+    }
+    if (isEnabledFeature(Feature.QLMonitoring)) {
+      chartTypesList.push({
+        value: QLChartType.Monitoringql,
+        text: "Monitoring",
+        key: "Monitoring"
+      });
+    }
+    const { getPlaceSelectParameters: getPlaceSelectParameters2 } = registry.common.functions.getAll();
+    const { getConnectionsByChartType: getConnectionsByChartType2 } = registry.ql.functions.getAll();
+    return /* @__PURE__ */ jsx("div", { className: b$3(), children: /* @__PURE__ */ jsxs("div", { className: b$3("form"), children: [
+      /* @__PURE__ */ jsx("span", { className: b$3("form-header"), children: i18n$c("sql", "label_create-ql-chart") }),
+      /* @__PURE__ */ jsxs("div", { className: b$3("form-row"), children: [
+        /* @__PURE__ */ jsx("span", { className: b$3("form-label"), children: i18n$c("sql", "label_chart-type") }),
+        /* @__PURE__ */ jsx(
+          SegmentedRadioGroup,
+          {
+            value: chartType,
+            onUpdate: this.onChartTypeUpdate,
+            className: b$3("chart-type-select"),
+            children: chartTypesList.map((chartTypeConfig) => {
+              return /* @__PURE__ */ jsx(
+                SegmentedRadioGroup.Option,
+                {
+                  value: chartTypeConfig.value,
+                  children: /* @__PURE__ */ jsx("span", { children: chartTypeConfig.text })
+                },
+                chartTypeConfig.key
+              );
+            })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: b$3("form-row"), ref: this.navigationButtonRef, children: [
+        /* @__PURE__ */ jsx("span", { className: b$3("form-label"), children: i18n$c("sql", "label_connection") }),
+        connection ? /* @__PURE__ */ jsx("div", { className: b$3("connection-select-btn-wrapper"), children: /* @__PURE__ */ jsx(
+          Button,
+          {
+            className: b$3("connection-select-btn"),
+            width: "auto",
+            onClick: () => {
+              this.toggleNavigation();
+            },
+            disabled: chartType === QLChartType.Monitoringql && isEnabledFeature(Feature.EnableCustomMonitoring),
+            children: /* @__PURE__ */ jsxs("div", { className: b$3("connection-select-btn-content"), children: [
+              /* @__PURE__ */ jsx(
+                EntryIcon,
+                {
+                  entry: connection,
+                  size: 24,
+                  className: b$3("entry-icon")
+                }
+              ),
+              connection.name
+            ] })
+          }
+        ) }) : /* @__PURE__ */ jsx(
+          FieldWrapper,
+          {
+            error: showConnectionError ? i18n$c("sql", "error_select-connection") : void 0,
+            className: b$3("connection-select-btn-wrapper", { error: true }),
+            children: /* @__PURE__ */ jsx(
+              Button,
+              {
+                onClick: () => {
+                  this.toggleNavigation();
+                },
+                disabled: chartType === QLChartType.Monitoringql && isEnabledFeature(Feature.EnableCustomMonitoring),
+                qa: ViewSetupQA.SelectConnection,
+                className: b$3("connection-select-btn"),
+                children: i18n$c("sql", "label_select-connection")
+              }
+            )
+          }
+        ),
+        workbookId ? /* @__PURE__ */ jsx(
+          WorkbookNavigationMinimal,
+          {
+            anchor: this.navigationButtonRef,
+            visible: this.state.isNavigationVisible,
+            onClose: this.onNavigationClose,
+            onEntryClick: this.onNavigationEntryClick,
+            workbookId,
+            scope: EntryScope.Connection,
+            includeClickableType: getConnectionsByChartType2(chartType)
+          }
+        ) : /* @__PURE__ */ jsx(
+          NavigationMinimal_default,
+          {
+            sdk,
+            anchor: this.navigationButtonRef,
+            visible: this.state.isNavigationVisible,
+            onClose: this.onNavigationClose,
+            onEntryClick: this.onNavigationEntryClick,
+            clickableScope: "connection",
+            scope: "connection",
+            startFrom: defaultPath,
+            ignoreWorkbookEntries: true,
+            ignoreSharedEntries: true,
+            placeSelectParameters: getPlaceSelectParameters2([
+              PLACE.ROOT,
+              PLACE.FAVORITES,
+              PLACE.CONNECTIONS
+            ]),
+            includeClickableType: getConnectionsByChartType2(chartType)
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: b$3("form-buttons"), children: /* @__PURE__ */ jsx(
+        Button,
+        {
+          className: b$3("create-btn"),
+          view: "action",
+          size: "l",
+          qa: ViewSetupQA.ViewSetupCreate,
+          onClick: this.onCreateClick,
+          children: i18n$c("sql", "label_create")
+        }
+      ) })
+    ] }) });
+  }
+  fetchConnection(connectionId) {
+    return getSdk().sdk.us.getEntry({ entryId: connectionId }).then((loadedConnectionEntry) => {
+      if (!loadedConnectionEntry) {
+        throw new Error(i18n$c("sql", "error_failed-to-load-default-connection"));
+      }
+      const connection = loadedConnectionEntry;
+      connection.name = Utils.getEntryNameFromKey(connection.key);
+      return connection;
+    }).catch((error) => {
+      logger$1.logError("ql: setup failed", error);
+      this.props.setError({
+        error
+      });
+      this.props.setStatus(AppStatus.Failed);
+    });
+  }
+}
+const makeMapStateToProps = (state) => {
+  return {
+    defaultPath: getDefaultPath(state),
+    entry: getEntry(state)
+  };
+};
+const mapDispatchToProps = {
+  performManualConfiguration,
+  setStatus,
+  setError
+};
+const ViewSetupComponentConnected = connect(
+  makeMapStateToProps,
+  mapDispatchToProps
+)(compose(withRouter)(ViewSetupComponent));
+const ViewSetup = () => {
+  return /* @__PURE__ */ jsx(ViewSetupComponentConnected, {});
+};
+const getConnectionsByChartType = (chartType) => {
+  return AVAILABLE_CONNECTION_TYPES_BY_CHART_TYPE[chartType];
+};
+const registerQlPlugins = () => {
+  registry.ql.components.registerMany({
+    QlUnconfiguredChartView: ViewSetup
+  });
+  registry.ql.functions.register({
+    getConnectionsByChartType
+  });
+};
+const i18n$2 = I18n.keyset("new-workbooks");
+const b$2 = block("dl-workbook-create-entry");
+const ChartQlItem = () => /* @__PURE__ */ jsxs("div", { className: b$2("dropdown-item"), children: [
+  /* @__PURE__ */ jsx(EntityIcon, { type: "chart-ql" }),
+  /* @__PURE__ */ jsx("div", { className: b$2("dropdown-text"), children: i18n$2("menu_ql-chart") })
+] });
+const ChartWizardItem = () => /* @__PURE__ */ jsxs("div", { className: b$2("dropdown-item"), children: [
+  /* @__PURE__ */ jsx(EntityIcon, { type: "chart-wizard" }),
+  /* @__PURE__ */ jsx("div", { className: b$2("dropdown-text"), children: i18n$2("menu_wizard-chart") })
+] });
+const ConnectionItem = () => /* @__PURE__ */ jsxs("div", { className: b$2("dropdown-item"), children: [
+  /* @__PURE__ */ jsx(EntityIcon, { type: "connection" }),
+  /* @__PURE__ */ jsx("div", { className: b$2("dropdown-text"), children: i18n$2("menu_connection") })
+] });
+const DashboardItem = () => /* @__PURE__ */ jsxs("div", { className: b$2("dropdown-item"), children: [
+  /* @__PURE__ */ jsx(EntityIcon, { type: "dashboard" }),
+  /* @__PURE__ */ jsx("div", { className: b$2("dropdown-text"), children: i18n$2("menu_dashboard") })
+] });
+const DatasetItem = () => /* @__PURE__ */ jsxs("div", { className: b$2("dropdown-item"), children: [
+  /* @__PURE__ */ jsx(EntityIcon, { type: "dataset" }),
+  /* @__PURE__ */ jsx("div", { className: b$2("dropdown-text"), children: i18n$2("menu_dataset") })
+] });
+const defineOptions = (options) => ({
+  buttonText: options.text,
+  hasMenu: Number(options.items?.length) > 0,
+  handleClick: options.onClick,
+  items: options.items ?? []
+});
+const useCreateEntryOptions = ({
+  scope,
+  handleAction
+}) => {
+  const defineAction = (type) => () => handleAction(type);
+  if (scope === EntryScope.Dash) {
+    return defineOptions({
+      text: i18n$2("action_create-dashboard"),
+      onClick: defineAction(CreateEntryActionType.Dashboard)
+    });
+  }
+  if (scope === EntryScope.Dataset) {
+    return defineOptions({
+      text: i18n$2("action_create-dataset"),
+      onClick: defineAction(CreateEntryActionType.Dataset)
+    });
+  }
+  if (scope === EntryScope.Connection && capabilities.has(Capability.ManageableConnections)) {
+    return defineOptions({
+      text: i18n$2("action_create-connection"),
+      onClick: defineAction(CreateEntryActionType.Connection)
+    });
+  }
+  if (scope === EntryScope.Widget) {
+    return defineOptions({
+      text: i18n$2("action_create-chart"),
+      items: [
+        { text: /* @__PURE__ */ jsx(ChartWizardItem, {}), action: defineAction(CreateEntryActionType.Wizard) },
+        { text: /* @__PURE__ */ jsx(ChartQlItem, {}), action: defineAction(CreateEntryActionType.QL) }
+      ]
+    });
+  }
+  return defineOptions({
+    text: i18n$2("action_create"),
+    items: [
+      [{ text: /* @__PURE__ */ jsx(DashboardItem, {}), action: defineAction(CreateEntryActionType.Dashboard) }],
+      [
+        { text: /* @__PURE__ */ jsx(ChartWizardItem, {}), action: defineAction(CreateEntryActionType.Wizard) },
+        { text: /* @__PURE__ */ jsx(ChartQlItem, {}), action: defineAction(CreateEntryActionType.QL) }
+      ],
+      [
+        { text: /* @__PURE__ */ jsx(DatasetItem, {}), action: defineAction(CreateEntryActionType.Dataset) },
+        { text: /* @__PURE__ */ jsx(ConnectionItem, {}), action: defineAction(CreateEntryActionType.Connection) }
+      ]
+    ]
+  });
+};
+const getWorkbookDashboardEntryUrl = (response) => {
+  return `/${response.data?.entryId}`;
+};
+const getNewDashUrl = (workbookId) => {
+  return `/workbooks/${workbookId}/dashboards`;
+};
+const i18n$1 = I18n.keyset("new-workbooks.empty-table");
+function getText(scope) {
+  let title;
+  let description = "";
+  switch (scope) {
+    case EntryScope.Dash: {
+      title = i18n$1("section_empty-scope-dashboard");
+      break;
+    }
+    case EntryScope.Widget: {
+      title = i18n$1("section_empty-scope-widget");
+      break;
+    }
+    case EntryScope.Dataset: {
+      title = i18n$1("section_empty-scope-dataset");
+      break;
+    }
+    case EntryScope.Connection: {
+      title = i18n$1("section_empty-scope-connection");
+      break;
+    }
+    default: {
+      title = i18n$1("section_empty-scope-all");
+      description = i18n$1("label_empty-scope-all-description");
+    }
+  }
+  return { title, description };
+}
+const useAdditionalWorkbookEntryActions = () => {
+  return [];
+};
+const getWorkbookEntryUrl = (workbookEntry, workbook) => {
+  if (workbookEntry.scope === EntryScope.Widget && !workbook.permissions.view && workbook.permissions.limitedView) {
+    return `/preview/${workbookEntry.entryId}`;
+  }
+  return new URL(navigateHelper_default.redirectUrlSwitcher(workbookEntry), window.location.origin).pathname;
+};
+const useAdditionalWorkbookActions = () => {
+  return [];
+};
+const i18n = I18n.keyset("new-workbooks.table-filters");
+const getWorkbookTabs = (workbook) => {
+  const tabs = [
+    { id: TAB_ALL, title: i18n("switch_filter-by-scope-all") },
+    { id: EntryScope.Dash, title: i18n("switch_filter-by-scope-dash") },
+    { id: EntryScope.Widget, title: i18n("switch_filter-by-scope-widget") }
+  ];
+  if (!DL.IS_MOBILE && (!DL.IAM_RESOURCES?.workbook.roles.limitedViewer || workbook.permissions.view)) {
+    tabs.push({ id: EntryScope.Dataset, title: i18n("switch_filter-by-scope-dataset") });
+    if (capabilities.has(Capability.ManageableConnections)) {
+      tabs.push({
+        id: EntryScope.Connection,
+        title: i18n("switch_filter-by-scope-connection")
+      });
+    }
+  }
+  return tabs;
+};
+const checkWbCreateEntryButtonVisibility = (workbook) => {
+  return workbook.permissions.update && !DL.IS_MOBILE;
+};
+const registerWorkbooksPlugins = () => {
+  registry.workbooks.functions.register({
+    checkWbCreateEntryButtonVisibility,
+    getWorkbookTabs,
+    getWorkbookEntryUrl,
+    getWorkbookDashboardEntryUrl,
+    getNewDashUrl,
+    useAdditionalWorkbookEntryActions,
+    useAdditionalWorkbookActions,
+    useCreateEntryOptions,
+    getWorkbookEmptyStateTexts: getText
+  });
+};
+const registerAppPlugins = (options = {}) => {
+  registerChartPlugins();
+  registerConnectionsPlugins();
+  registerCommonPlugins();
+  registerDatasetPlugins();
+  registerDashPlugins();
+  registerQlPlugins();
+  registerWorkbooksPlugins();
+  registerMainPlugins();
+  registerDocsPlugins();
+  registerCollectionsPlugins();
+  registerAuthPlugins();
+  registryLibsPlugins(options.libs);
+};
+const b$1 = block(CHARTKIT_ERROR_NODE_CLASSNAME);
+const logger = logger$1.get(CHARTKIT_LOGGER);
+function getEndpointForScope(scopeName) {
+  if (scopeName === "dataset") {
+    return DL.ENDPOINTS.dataset;
+  } else if (scopeName === "connection") {
+    return DL.ENDPOINTS.connections;
+  } else {
+    return null;
+  }
+}
+const InterpolatedErrorMessage = (props) => {
+  const { text, href } = props;
+  return /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(
+    Interpolate,
+    {
+      text,
+      matches: {
+        link(match) {
+          return /* @__PURE__ */ jsx(Link$1, { href, target: "_blank", rel: "noopener noreferrer", children: match });
+        }
+      }
+    }
+  ) });
+};
+const ChartKitError = (props) => {
+  const dispatch = useDispatch();
+  const location2 = useLocation();
+  const { error, onAction } = props;
+  React__default.useEffect(() => {
+    logger.logError("ChartKitError", error);
+  }, [error]);
+  const {
+    code,
+    message: title,
+    details = {},
+    debug: { requestId = DL.REQUEST_ID, traceId = null } = {}
+  } = error;
+  const extraParams = error.extra;
+  const { hideDebugInfo, hideRetry, openedMore, actionText, actionData, showErrorMessage } = extraParams;
+  const { noControls } = React__default.useMemo(
+    () => Utils.getOptionsFromSearch(location2.search),
+    [location2]
+  );
+  const more = isEmpty(details) ? null : details;
+  const showMore = more || extraParams.showMore;
+  const showRetry = !hideRetry;
+  const showControls = !noControls && !isEmbeddedEntry() && (showMore || showRetry);
+  let showSourceDetails = true;
+  const expandMore = more && (openedMore || noControls);
+  let detailsString = "";
+  const notEmptyDetails = !isEmpty(details);
+  if (notEmptyDetails) {
+    const values = Object.values(details);
+    if (values.length === 1 && typeof values[0] === "string") {
+      detailsString = values[0];
+    } else {
+      detailsString = JSON.stringify(details, null, 4);
+    }
+  }
+  let iconData = CircleXmark;
+  let detailedTitle = title;
+  const sourceErrorDetails = [];
+  const uniqDetails = _uniqBy(Object.keys(details) || [], (key) => {
+    const source = details[key];
+    const errorCode = source.code || source.status;
+    if (source.details) {
+      return `${errorCode}-${source.details.entry_id}`;
+    }
+    return null;
+  });
+  uniqDetails.forEach((key) => {
+    const source = details[key];
+    if (source.message || source.code) {
+      sourceErrorDetails.push({ message: source.message, code: source.code });
+    }
+  });
+  const iconModes = {
+    "no-data": false
+  };
+  switch (code) {
+    case ERROR_CODE.NO_DATA:
+      iconModes["no-data"] = true;
+      break;
+    case ERROR_CODE.TOO_MANY_LINES:
+    case ERROR_CODE.UI_SANDBOX_EXECUTION_TIMEOUT:
+    case ERROR_CODE.UI_SANDBOX_FN_EXECUTION_TIMEOUT: {
+      iconData = ChartMixed;
+      break;
+    }
+    case ERROR_CODE.DATA_PROVIDER_ERROR:
+      iconData = Database;
+      break;
+    case CHARTS_ERROR_CODE.CONFIG_LOADING_ERROR:
+      if (error?.debug?.code === 403) {
+        iconData = Lock;
+        const entryId = error?.debug?.entryId;
+        if (entryId) {
+          const text = i18n$c("component.chartkit-error.codes", code);
+          const href = `/navigate/${entryId}`;
+          const message = /* @__PURE__ */ jsx(InterpolatedErrorMessage, { text, href });
+          detailedTitle = [message];
+        }
+      }
+      break;
+    case CHARTS_ERROR_CODE.DATA_FETCHING_ERROR: {
+      const errorDetails = [];
+      uniqDetails.forEach((key) => {
+        const source = details[key];
+        const errorCode = source.code || source.status;
+        iconData = Database;
+        if ([
+          ErrorCode.UsAccessDenied,
+          ErrorCode.ReferencedEntryAccessDenied,
+          ErrorCode.WorkbookIsolationInterruptionDenied
+        ].includes(errorCode) && source.details && source.details.scope) {
+          const { scope } = source.details;
+          if (scope === "dataset" || scope === "connection") {
+            const endpoint = getEndpointForScope(scope);
+            const detailKey = `${errorCode}_${scope.toUpperCase()}`;
+            const text = i18n$c("component.chartkit-error.codes", detailKey);
+            const href = `${endpoint}/${source.details.entry_id}`;
+            const message = /* @__PURE__ */ jsx(InterpolatedErrorMessage, { text, href });
+            errorDetails.push(message);
+          }
+        } else if ([
+          ErrorCode.DBError,
+          ErrorCode.DBQueryError,
+          ErrorCode.DBSourceDoesntExist
+        ].includes(errorCode) && source.debug && source.debug.db_message) {
+          errorDetails.push(i18n$c("component.chartkit-error.codes", errorCode));
+          detailsString = source.debug.db_message;
+        } else if (source.status === 409) {
+          errorDetails.push(i18n$c("common.errors", "label_error-outdated-message"));
+          iconData = CircleXmark;
+          showSourceDetails = false;
+        } else if (I18n.has("component.chartkit-error.codes", errorCode)) {
+          errorDetails.push(i18n$c("component.chartkit-error.codes", errorCode));
+          detailsString = "";
+        }
+      });
+      detailedTitle = errorDetails.length ? errorDetails : detailedTitle;
+      break;
+    }
+    case ErrorCode.EntryForbidden: {
+      detailedTitle = i18n$c("common.errors", "label_error-access-message");
+      break;
+    }
+    case ErrorCode.InvalidTokenFormat: {
+      detailedTitle = i18n$c("common.errors", "label_error-invalid-format-token-message");
+      break;
+    }
+    case ErrorCode.TokenNotFound: {
+      detailedTitle = i18n$c("common.errors", "label_error-token-not-found-message");
+      break;
+    }
+    case ErrorCode.InvalidToken: {
+      detailedTitle = i18n$c("common.errors", "label_error-invalid-token-message");
+      break;
+    }
+    case ErrorCode.OutdatedDependencies: {
+      detailedTitle = i18n$c("common.errors", "label_error-outdated-message");
+      break;
+    }
+  }
+  const getAdditionalChartkitErrorContent2 = registry.common.functions.get(
+    "getAdditionalChartkitErrorContent"
+  );
+  const additionalContent = getAdditionalChartkitErrorContent2({ code });
+  if (additionalContent.detailedTitle) {
+    detailedTitle = additionalContent.detailedTitle;
+  }
+  if (additionalContent.iconData) {
+    iconData = additionalContent.iconData;
+  }
+  const renderSourceErrorDetails = () => {
+    return sourceErrorDetails.map((sourceErrorDetail) => /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+      showErrorMessage && sourceErrorDetail.message && /* @__PURE__ */ jsx("div", { className: b$1("message"), children: sourceErrorDetail.message }),
+      !sourceErrorDetail.message && sourceErrorDetail.code && /* @__PURE__ */ jsx("div", { className: b$1("code-block"), children: sourceErrorDetail.code })
+    ] }, sourceErrorDetail.message));
+  };
+  return /* @__PURE__ */ jsxs("div", { className: b$1(), "data-qa": ChartkitMenuDialogsQA.chartError, children: [
+    /* @__PURE__ */ jsxs("div", { "data-qa": code, className: b$1("title", { mobile: DL.IS_MOBILE }), children: [
+      /* @__PURE__ */ jsx(Icon, { data: iconData, size: 20, className: b$1("icon", iconModes) }),
+      Array.isArray(detailedTitle) ? /* @__PURE__ */ jsx("div", { children: detailedTitle.map((str) => /* @__PURE__ */ jsx("div", { children: str }, str)) }) : detailedTitle
+    ] }),
+    showSourceDetails && renderSourceErrorDetails(),
+    expandMore && detailsString && /* @__PURE__ */ jsx("div", { className: b$1("code-block"), children: detailsString }),
+    showControls && /* @__PURE__ */ jsxs("div", { className: b$1("actions"), children: [
+      showRetry && /* @__PURE__ */ jsx(
+        Button,
+        {
+          className: b$1("action"),
+          onClick: () => onAction(actionData),
+          qa: ChartkitMenuDialogsQA.errorButtonRetry,
+          children: actionText
+        }
+      ),
+      showMore && /* @__PURE__ */ jsx(
+        Button,
+        {
+          view: "flat",
+          className: b$1("action"),
+          onClick: () => dispatch(openDialogErrorWithTabs({ error, title: error.message })),
+          children: i18n$c("component.chartkit-error.view", "button_details")
+        }
+      )
+    ] }),
+    !hideDebugInfo && /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+      requestId && /* @__PURE__ */ jsx("div", { className: b$1("request-id"), children: `Request-ID: ${requestId}` }),
+      traceId && /* @__PURE__ */ jsx("div", { className: b$1("request-id"), children: `Trace-ID: ${traceId}` })
+    ] })
+  ] });
+};
+const Error$1 = React__default.memo(ChartKitError);
+function isNotSingleParam(control) {
+  return "paramFrom" in control && "paramTo" in control;
+}
+const STATUS = {
+  LOADING: "loading",
+  DONE: "done",
+  ERROR: "error"
+};
+const b = block("chartkit-control");
+const dashI18n = I18n.keyset("dash.dashkit-plugin-control.view");
+const controlI18n = I18n.keyset("chartkit.control");
+class Control extends React__default.PureComponent {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      status: STATUS.LOADING,
+      data: this.props.data,
+      savedData: this.props.data,
+      params: this.props.data.params,
+      statePriority: false,
+      validationErrors: {},
+      loading: false
+    };
+    this.renderControl = (control, index) => {
+      if (!control) {
+        return null;
+      }
+      if (control.type === "line-break") {
+        return /* @__PURE__ */ jsx("br", {}, index);
+      }
+      const { label, param } = control;
+      const notSingleParam = isNotSingleParam(control);
+      const value = isNotSingleParam(control) ? {
+        from: unwrapFromArrayAndSkipOperation(this.params[control.paramFrom]),
+        to: unwrapFromArrayAndSkipOperation(this.params[control.paramTo])
+      } : unwrapFromArrayAndSkipOperation(this.params[param]);
+      let props = {
+        ...control,
+        className: b("item"),
+        key: index + (param || isNotSingleParam(control) && control.paramFrom || label),
+        value: control.disabled ? "" : value,
+        onChange: (value2) => this.onChange(control, value2, index),
+        loading: this.state.loading
+      };
+      if ("required" in control) {
+        props = { ...props, ...this.getValidationProps(control, value, index) };
+      }
+      switch (control.type) {
+        case CONTROL_TYPE.SELECT:
+          return /* @__PURE__ */ jsx(ControlSelect, { ...props });
+        case CONTROL_TYPE.INPUT:
+          return /* @__PURE__ */ jsx(ControlInput, { ...props });
+        case CONTROL_TYPE.TEXTAREA:
+          return /* @__PURE__ */ jsx(ControlTextArea, { ...props, className: b("item", { button: true }) });
+        case CONTROL_TYPE.DATEPICKER:
+          return /* @__PURE__ */ jsx(ControlDatepicker, { ...props });
+        case CONTROL_TYPE.RANGE_DATEPICKER:
+          return /* @__PURE__ */ jsx(ControlRangeDatepicker, { returnInterval: !notSingleParam, ...props });
+        case CONTROL_TYPE.CHECKBOX:
+          return /* @__PURE__ */ jsx(ControlCheckbox, { ...props, className: b("item", { checkbox: true }) });
+        case CONTROL_TYPE.BUTTON:
+          return /* @__PURE__ */ jsx(ControlButton, { ...props, className: b("item", { button: true }) });
+      }
+      return null;
+    };
+    this.getChangedParams = (control, value) => {
+      let newParams = { ...this.params };
+      let callExternalOnChange = this.isStandalone;
+      let callChangeByClick = false;
+      if (control.type === "range-datepicker" && control.paramFrom && control.paramTo && typeof value === "object" && !Array.isArray(value)) {
+        newParams[control.paramFrom] = [value.from];
+        newParams[control.paramTo] = [value.to];
+      } else if (control.type === "button" && control.onClick && control.onClick.action === CLICK_ACTION_TYPE.SET_PARAMS && control.onClick.args) {
+        newParams = control.onClick.args;
+        callExternalOnChange = true;
+        callChangeByClick = true;
+      } else if (control.type === "button" && control.onClick && control.onClick.action === CLICK_ACTION_TYPE.SET_INITIAL_PARAMS && this.props.initialParams?.params) {
+        newParams = this.props.initialParams?.params;
+        callExternalOnChange = true;
+        callChangeByClick = true;
+      } else {
+        newParams[control.param] = wrapToArray(value).map(
+          (value2) => addOperationForValue({ value: value2, operation: control.operation })
+        );
+      }
+      return { newParams, callExternalOnChange, callChangeByClick };
+    };
+    this.getValidationProps = (control, value, index) => {
+      const validationProps = {};
+      const initialValidationError = isValidRequiredValue({
+        required: control.required,
+        value
+      }) ? dashI18n("value_required") : null;
+      const validationError = initialValidationError || this.state.validationErrors[index];
+      validationProps.required = control.required;
+      validationProps.hasValidationError = Boolean(validationError);
+      if (control.label && control.required) {
+        validationProps.label = `${control.label}*`;
+      }
+      if ("innerLabel" in control && !control.label && control.innerLabel && control.required) {
+        validationProps.innerLabel = `${control.innerLabel}*`;
+      }
+      if (control.type === "input" || control.type === "select") {
+        validationProps.placeholder = validationError || control.placeholder;
+      }
+      return validationProps;
+    };
+  }
+  static getDerivedStateFromProps(nextProps, prevState) {
+    const resultState = {
+      ...prevState,
+      savedData: nextProps.data,
+      statePriority: false
+    };
+    const propsDataEqual = isEqual(nextProps.data, prevState.savedData);
+    if (!prevState.statePriority && !propsDataEqual) {
+      return {
+        ...resultState,
+        data: nextProps.data,
+        params: nextProps.data.params
+      };
+    }
+    return resultState;
+  }
+  static getDerivedStateFromError() {
+    return { status: STATUS.ERROR };
+  }
+  get params() {
+    return { ...this.props.data.params, ...this.state.params };
+  }
+  componentDidMount() {
+    this.setStatePriority({ status: STATUS.DONE });
+    if (this.isStandalone) {
+      this.props.onLoad();
+    }
+  }
+  get isStandalone() {
+    return this.props.data.type === "control";
+  }
+  setStatePriority(state, callback) {
+    this.setState(Object.assign({ statePriority: true }, state), callback);
+  }
+  async run(prevParams, callOnChange) {
+    this.setStatePriority({ status: STATUS.LOADING });
+    let loadedData;
+    try {
+      loadedData = await this.props.getControls(prevParams);
+    } catch (error) {
+      console.error("CHARTKIT_CONTROL_RUN_FAILED", error);
+      this.setStatePriority({ status: STATUS.ERROR });
+      return;
+    }
+    if (!loadedData) {
+      return;
+    }
+    const newParams = loadedData.params;
+    this.setStatePriority(
+      {
+        status: STATUS.DONE,
+        data: loadedData,
+        params: newParams
+      },
+      () => {
+        if (callOnChange) {
+          this.props.onChange(
+            { type: "PARAMS_CHANGED", data: { params: newParams } },
+            { forceUpdate: !this.isStandalone },
+            callOnChange
+          );
+        }
+      }
+    );
+  }
+  async onChange(control, value, index) {
+    const { type, updateControlsOnChange, updateOnChange, postUpdateOnChange } = control;
+    const { newParams, callExternalOnChange, callChangeByClick } = this.getChangedParams(
+      control,
+      value
+    );
+    const hasError = "required" in control ? isValidRequiredValue({
+      required: control.required,
+      value
+    }) : false;
+    this.setValidationError(String(index), hasError);
+    if (hasError) {
+      return;
+    }
+    if (type === "button" && control.onClick?.action === CLICK_ACTION_TYPE.RUN_ACTIVITY) {
+      this.setState({ loading: true });
+      try {
+        await this.props.runActivity?.({ params: { ...newParams, ...control.onClick.args } });
+      } catch (e) {
+      } finally {
+        this.setState({ loading: false });
+      }
+      return;
+    }
+    if (!isEqual(newParams, this.params) || type === CONTROL_TYPE.BUTTON) {
+      if (postUpdateOnChange) {
+        this.run(newParams, true);
+      } else if (updateOnChange) {
+        this.setStatePriority({ params: newParams }, () => {
+          this.props.onChange(
+            { type: "PARAMS_CHANGED", data: { params: newParams } },
+            { forceUpdate: true },
+            callExternalOnChange,
+            callChangeByClick
+          );
+        });
+      } else if (updateControlsOnChange) {
+        this.run(newParams);
+      } else {
+        this.setStatePriority({ params: newParams }, () => {
+          this.props.onUpdate?.({ type: "PARAMS_CHANGED", data: { params: newParams } });
+        });
+      }
+    }
+  }
+  renderBody() {
+    const { status } = this.state;
+    if (status === STATUS.ERROR) {
+      return /* @__PURE__ */ jsxs("div", { className: b("error"), children: [
+        controlI18n("label_error"),
+        /* @__PURE__ */ jsx(Icon, { data: TriangleExclamationFill, className: b("error-icon") })
+      ] });
+    }
+    return /* @__PURE__ */ jsx("div", { className: b("controls", { hidden: status === STATUS.LOADING }), children: this.state.data.controls?.controls.map(this.renderControl) });
+  }
+  renderLoader() {
+    return this.state.status === STATUS.LOADING ? /* @__PURE__ */ jsx("div", { className: b("loader"), children: /* @__PURE__ */ jsx(Loader, { size: "s" }) }) : null;
+  }
+  render() {
+    if (this.state.data.controls) {
+      const { lineBreaks = "nowrap" } = this.state.data.controls;
+      const standalone = this.isStandalone;
+      const classNameMix = standalone ? CHARTKIT_SCROLLABLE_NODE_CLASSNAME : "";
+      return /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: b(
+            { "line-breaks": lineBreaks, standalone, mobile: DL.IS_MOBILE },
+            classNameMix
+          ),
+          children: [
+            this.renderLoader(),
+            this.renderBody()
+          ]
+        }
+      );
+    }
+    return null;
+  }
+  setValidationError(index, hasError) {
+    if (hasError) {
+      this.setState({
+        validationErrors: {
+          ...this.state.validationErrors,
+          [index]: dashI18n("value_required")
+        }
+      });
+      return;
+    }
+    if (this.state.validationErrors[index]) {
+      this.setState({
+        validationErrors: {
+          ...this.state.validationErrors,
+          [index]: null
+        }
+      });
+    }
+  }
+}
+var control_default = {
+  key: "control",
+  value: Control
+};
+var markdown_default = {
+  key: CHARTKIT_WIDGET_TYPE.MARKDOWN,
+  value: Markdown
+};
+var table_default = {
+  key: CHARTKIT_WIDGET_TYPE.TABLE,
+  value: Table
+};
+const X_CSRF_TOKEN_HEADER = "X-CSRF-Token";
+const DATALENS_DEBUG_MODE_KEY = "datalens-debug-mode";
+ChartKitWithCharts.registerPlugins(table_default, control_default, markdown_default);
+ChartKitWithCharts.setGeneralSettings({
+  lang: DL.USER_LANG,
+  isMobile: DL.IS_MOBILE,
+  theme: "common",
+  config: isEnabledFeature(Feature.UseConfigurableChartkit),
+  requestIdPrefix: DL.REQUEST_ID_PREFIX,
+  ErrorComponent: Error$1
+});
+ChartKitWithCharts.setDataProviderSettings({
+  endpoint: DL.ENDPOINTS.charts,
+  lang: DL.USER_LANG,
+  includeUnresolvedParams: true,
+  requestDecorator: (request) => {
+    const CSRFToken = Utils.getCSRFToken();
+    request.headers[ACCEPT_LANGUAGE_HEADER] = DL.USER_LANG;
+    if (CSRFToken) {
+      request.headers[X_CSRF_TOKEN_HEADER] = CSRFToken;
+    }
+    if (DL.CURRENT_TENANT_ID) {
+      request.headers[TENANT_ID_HEADER] = DL.CURRENT_TENANT_ID;
+    }
+    let dispayMode = "basic";
+    if (isEmbeddedEntry()) {
+      dispayMode = "secure-embedded";
+    } else if (isIframe()) {
+      dispayMode = "embedded";
+    }
+    request.headers[DISPLAY_MODE_HEADER] = dispayMode;
+    if (DL.DISPLAY_SUPERUSER_SWITCH) {
+      const cookieValue = Utils.getCookie(SUPERUSER_SWITCH_MODE_COOKIE_NAME);
+      const headerValue = cookieValue === ENABLE;
+      if (cookieValue) {
+        request.headers[SuperuserHeader.XDlAllowSuperuser] = headerValue;
+        request.headers[SuperuserHeader.XDlSudo] = headerValue;
+      }
+    }
+    const datalensDebugMode = Utils.restore(DATALENS_DEBUG_MODE_KEY);
+    if (datalensDebugMode === 1) {
+      request.data.datalensDebugMode = 1;
+    }
+    return request;
+  },
+  noJsonFn: isEnabledFeature(Feature.NoJsonFn) || Utils.getCookie(DISABLE_JSONFN_SWITCH_MODE_COOKIE_NAME) === DISABLE
+});
+var DatalensChartKitOld_default = ChartKitWithCharts;
+const initChartKitSettings = () => {
+  DatalensChartKitOld_default.registerPlugins(table_default, control_default, markdown_default);
+  DatalensChartKitOld_default.setGeneralSettings({
+    lang: DL.USER_LANG,
+    isMobile: DL.IS_MOBILE,
+    theme: "common",
+    config: isEnabledFeature(Feature.UseConfigurableChartkit),
+    requestIdPrefix: DL.REQUEST_ID_PREFIX,
+    ErrorComponent: Error$1,
+    menu: getChartkitMenu({ chartsDataProvider })
+  });
+  DatalensChartKitOld_default.setDataProviderSettings?.({
+    endpoint: DL.ENDPOINTS.charts,
+    lang: DL.USER_LANG,
+    includeUnresolvedParams: true,
+    requestDecorator: (request) => {
+      if (!request.headers) {
+        request.headers = {};
+      }
+      const CSRFToken = Utils.getCSRFToken();
+      request.headers[ACCEPT_LANGUAGE_HEADER] = DL.USER_LANG;
+      if (CSRFToken) {
+        request.headers[X_CSRF_TOKEN_HEADER$1] = CSRFToken;
+      }
+      if (DL.CURRENT_TENANT_ID) {
+        request.headers[TENANT_ID_HEADER] = DL.CURRENT_TENANT_ID;
+      }
+      let dispayMode = "basic";
+      if (isEmbeddedEntry()) {
+        dispayMode = "secure-embedded";
+      } else if (isIframe()) {
+        dispayMode = "embedded";
+      }
+      request.headers[DISPLAY_MODE_HEADER] = dispayMode;
+      if (DL.DISPLAY_SUPERUSER_SWITCH) {
+        const cookieValue = Utils.getCookie(SUPERUSER_SWITCH_MODE_COOKIE_NAME);
+        const headerValue = cookieValue === ENABLE;
+        if (cookieValue) {
+          request.headers[SuperuserHeader.XDlAllowSuperuser] = headerValue;
+          request.headers[SuperuserHeader.XDlSudo] = headerValue;
+        }
+      }
+      const datalensDebugMode = Utils.restore(DATALENS_DEBUG_MODE_KEY$1);
+      if (datalensDebugMode === 1) {
+        request.data.datalensDebugMode = 1;
+      }
+      return request;
+    },
+    noJsonFn: isEnabledFeature(Feature.NoJsonFn) || Utils.getCookie(DISABLE_JSONFN_SWITCH_MODE_COOKIE_NAME) === DISABLE
+  });
+};
+const renderDatalens = (render, config) => {
+  registerAppPlugins(config.pluginsConfig);
+  const { registerPlugins } = config;
+  if (registerPlugins) {
+    registerPlugins();
+  }
+  initChartKitSettings();
+  render();
+};
+const getOverridedTheme = (defaultTheme) => {
+  const queryTheme = Utils.getOptionsFromSearch(getLocation().search).theme;
+  return ALLOW_THEMES.includes(queryTheme) ? queryTheme : defaultTheme;
+};
+let currentRootElement = null;
+function mount(rootElement, homePathname) {
+  setHistory(createHashHistory());
+  currentRootElement = rootElement;
+  const Content = () => {
+    const theme2 = getOverridedTheme("light");
+    const themeSettings2 = useSelector(selectThemeSettings);
+    return /* @__PURE__ */ jsx(
+      ThemeProvider,
+      {
+        theme: theme2,
+        systemLightTheme: themeSettings2?.systemLightTheme,
+        systemDarkTheme: themeSettings2?.systemDarkTheme,
+        children: /* @__PURE__ */ jsx(MobileProvider, { mobile: DL.IS_MOBILE, children: /* @__PURE__ */ jsx(HotkeysProvider, { initiallyActiveScopes: [HOTKEYS_SCOPES.GLOBAL], children: /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+          /* @__PURE__ */ jsx(DialogManagerContainer, {}),
+          /* @__PURE__ */ jsx(DatalensPage, { homePathname })
+        ] }) }) })
+      }
+    );
+  };
+  const renderApp = () => {
+    Utils.setup();
+    const history = getHistory();
+    const store = getStore();
+    registerSDKDispatch(store.dispatch);
+    ReactDOM.render(
+      /* @__PURE__ */ jsx(Router, { history, children: /* @__PURE__ */ jsx(Provider, { store, children: /* @__PURE__ */ jsx(Content, {}) }) }),
+      rootElement
+    );
+  };
+  renderDatalens(renderApp, {});
+}
+function unmount(rootElement) {
+  const targetElement = rootElement || currentRootElement;
+  if (targetElement) {
+    try {
+      ReactDOM.unmountComponentAtNode(targetElement);
+      if (targetElement === currentRootElement) {
+        currentRootElement = null;
+      }
+      resetStore();
+    } catch (error) {
+      console.error("Error unmounting DataLens main.tsx:", error);
+    }
+  }
+}
+export {
+  bEditPanelItem as b,
+  mount as m,
+  unmount as u
+};